diff --git a/.gitignore b/.gitignore
index e6d44a024..9fc713587 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,6 +60,7 @@ checksum
 /doc/dynare.info
 /doc/dynare.info-1
 /doc/dynare.info-2
+/doc/dynare.info-3
 /doc/dynare.cp
 /doc/dynare.fn
 /doc/dynare.fns
@@ -212,3 +213,6 @@ tests/julia/rbc/rbc*.jl
 
 # Octave variables saved when Octave crashes
 octave-workspace
+
+# VERSION generated file
+VERSION
\ No newline at end of file
diff --git a/NEWS b/NEWS
index 500f3e325..71e9b45d4 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,800 @@
+Announcement for Dynare 4.5.0 (on 2013-12-16)
+=============================================
+
+We are pleased to announce the release of Dynare 4.5.0.
+
+This major release adds new features and fixes various bugs.
+
+The Windows packages are already available for download at:
+
+ http://www.dynare.org/download/dynare-stable
+
+The Mac and Debian/Ubuntu packages should follow soon.
+
+All users are strongly encouraged to upgrade.
+
+This release is compatible with MATLAB versions ranging from 7.3 (R2006b) to
+9.2 (R2017a) and with GNU Octave version 4.2.
+
+Here is the list of major user-visible changes:
+
+
+
+Dynare 4.5
+==========
+
+
+ - Ramsey policy
+
+   + Added command `ramsey_model` that builds the expanded model with
+     FOC conditions for the planner's problem but doesn't perform any
+     computation. Usefull to compute Ramsey policy in a perfect
+     foresight model,
+
+   + `ramsey_policy` accepts multipliers in its variable list and
+     displays results for them.
+
+
+ - Perfect foresight models
+
+   + New commands `perfect_foresight_setup` (for preparing the
+     simulation) and `perfect_foresight_solver` (for computing it). The
+     old `simul` command still exist and is now an alias for
+     `perfect_foresight_setup` + `perfect_foresight_solver`. It is no
+     longer possible to manipulate by hand the contents of
+     `oo_.exo_simul` when using `simul`. People who want to do
+     it must first call `perfect_foresight_setup`, then do the
+     manipulations, then call `perfect_foresight_solver`,
+
+   + By default, the perfect foresight solver will try a homotopy
+     method if it fails to converge at the first try. The old behavior
+     can be restored with the `no_homotopy` option,
+
+   + New option `stack_solve_algo=7` that allows specifying a
+     `solve_algo` solver for solving the model,
+
+   + New option `solve_algo` that allows specifying a solver for
+     solving the model when using `stack_solve_algo=7`,
+
+   + New option `lmmcp` that solves the model via a Levenberg-Marquardt
+     mixed complementarity problem (LMMCP) solver,
+
+   + New option `robust_lin_solve` that triggers the use of a robust
+     linear solver for the default `solve_algo=4`,
+
+   + New options `tolf` and `tolx` to control termination criteria of
+     solvers,
+
+   + New option `endogenous_terminal_period` to `simul`,
+
+   + Added the possibility to set the initial condition of the
+     (stochastic) extended path simulations with the histval block.
+
+
+ - Optimal simple rules
+
+   + Saves the optimal value of parameters to `oo_.osr.optim_params`,
+
+   + New block `osr_params_bounds` allows specifying bounds for the
+     estimated parameters,
+
+   + New option `opt_algo` allows selecting different optimizers while
+     the new option `optim` allows specifying the optimizer options,
+
+   + The `osr` command now saves the names, bounds, and indices for the
+     estimated parameters as well as the indices and weights of the
+     variables entering the objective function into `M_.osr`.
+
+
+ - Forecasts and Smoothing
+
+   + The smoother and forecasts take uncertainty about trends and means
+     into account,
+
+   + Forecasts accounting for measurement error are now saved in fields
+     of the form `HPDinf_ME` and `HPDsup_ME`,
+
+   + New fields `oo_.Smoother.Trend` and `oo_.Smoother.Constant` that
+     save the trend and constant parts of the smoothed variables,
+
+   + new field `oo_.Smoother.TrendCoeffs` that stores the trend
+     coefficients.
+
+   + Rolling window forecasts allowed in `estimation` command by
+     passing a vector to `first_obs`,
+
+   + The `calib_smoother` command now accepts the `loglinear`,
+     `prefilter`, `first_obs` and `filter_decomposition` options.
+
+
+ - Estimation
+
+   + New options: `logdata`, `consider_all_endogenous`,
+     `consider_only_observed`, `posterior_max_subsample_draws`,
+     `mh_conf_sig`, `diffuse_kalman_tol`, `dirname`, `nodecomposition`
+
+   + `load_mh_file` and `mh_recover` now try to load chain's proposal density,
+
+   + New option `load_results_after_load_mh` that allows loading some
+     posterior results from a previous run if no new MCMC draws are
+     added,
+
+   + New option `posterior_nograph` that suppresses the generation of
+     graphs associated with Bayesian IRFs, posterior smoothed objects,
+     and posterior forecasts,
+
+   + Saves the posterior density at the mode in
+     `oo_.posterior.optimization.log_density`,
+
+   + The `filter_covariance` option now also works with posterior
+     sampling like Metropolis-Hastings,
+
+   + New option `no_posterior_kernel_density` to suppress computation
+     of kernel density of posterior objects,
+
+   + Recursive estimation and forecasting now provides the individual
+     `oo_` structures for each sample in `oo_recursive_`,
+
+   + The `trace_plot` command can now plot the posterior density,
+
+   + New command `generate_trace_plots` allows generating all trace
+     plots for one chain,
+
+   + New commands `prior_function` and `posterior_function` that
+     execute a user-defined function on parameter draws from the
+     prior/posterior distribution,
+
+   + New option `huge_number` for replacement of infinite bounds with
+     large number during `mode_compute`,
+
+   + New option `posterior_sampling_method` allows selecting the new
+     posterior sampling options:
+     `tailored_random_block_metropolis_hastings` (Tailored randomized
+     block (TaRB) Metropolis-Hastings), `slice` (Slice sampler),
+     `independent_metropolis_hastings` (Independent
+     Metropolis-Hastings),
+
+   + New option `posterior_sampler_options` that allow controlling the
+     options of the `posterior_sampling_method`, its `scale_file`-option
+     pair allows loading the `_mh_scale.mat`-file storing the tuned
+     scale factor from a previous run of `mode_compute=6`,
+
+   + New option `raftery_lewis_diagnostics` that computes Raftery/Lewis
+     (1992) convergence diagnostics,
+
+   + New option `fast_kalman_filter` that provides fast Kalman filter
+     using Chandrasekhar recursions as described in Ed Herbst (2015),
+
+   + The `dsge_var` option now saves results at the posterior mode into
+     `oo_.dsge_var`,
+
+   + New option `smoothed_state_uncertainty` to provide the uncertainty
+     estimate for the smoothed state estimate from the Kalman smoother,
+
+   + New prior density: generalized Weibull distribution,
+
+   + Option `mh_recover` now allows continuing a crashed chain at the
+     last save mh-file,
+
+   + New option `nonlinear_filter_initialization` for the
+     `estimation` command. Controls the initial covariance matrix
+     of the state variables in nonlinear filters.
+
+   + The `conditional_variance_decomposition` option now displays
+     output and stores it as a LaTeX-table when the `TeX` option is
+     invoked,
+
+   + The `use_calibration` to `estimated_params_init` now also works
+     with ML,
+
+   + Improved initial estimation checks.
+
+
+ - Steady state
+
+   + The default solver for finding the steady state is now a
+     trust-region solver (can be triggered explicitly with option
+     `solve_algo=4`),
+
+   + New options `tolf` and `tolx` to control termination criteria of
+     solver,
+
+   + The debugging mode now provides the termination values in steady
+     state finding.
+
+
+ - Stochastic simulations
+
+   + New options `nodecomposition`,
+
+   + New option `bandpass_filter` to compute bandpass-filtered
+     theoretical and simulated moments,
+
+   + New option `one_sided_hp_filter` to compute one-sided HP-filtered
+     simulated moments,
+
+   + `stoch_simul` displays a simulated variance decomposition when
+     simulated moments are requested,
+
+   + `stoch_simul` saves skewness and kurtosis into respective fields
+     of `oo_` when simulated moments have been requested,
+
+   + `stoch_simul` saves the unconditional variance decomposition in
+     `oo_.variance_decomposition`,
+
+   + New option `dr_display_tol` that governs omission of small terms
+     in display of decision rules,
+
+   + The `stoch_simul` command now prints the displayed tables as LaTeX
+     code when the new `TeX` option is enabled,
+
+   + The `loglinear` option now works with lagged and leaded exogenous
+     variables like news shocks,
+
+   + New option `spectral_density` that allows displaying the spectral
+     density of (filtered) endogenous variables,
+
+   + New option `contemporaneous_correlation` that allows saving
+     contemporaneous correlations in addition to the covariances.
+
+
+ - Identification
+
+   + New options `diffuse_filter` and `prior_trunc`,
+
+   + The `identification` command now supports correlations via
+     simulated moments,
+
+
+ - Sensitivity analysis
+
+   + New blocks `irf_calibration` and `moment_calibration`,
+
+   + Outputs LaTeX tables if the new `TeX` option is used,
+
+   + New option `relative_irf` to `irf_calibration` block.
+
+
+ - Conditional forecast
+
+   + Command `conditional_forecast` now takes into account `histval`
+     block if present.
+
+
+ - Shock decomposition
+
+   + New option `colormap` to `shocks_decomposition` for controlling
+     the color map used in the shocks decomposition graphs,
+
+   + `shocks_decomposition` now accepts the `nograph` option,
+
+   + New command `realtime_shock_decomposition` that for each period `T= [presample,...,nobs]`
+     allows computing the:
+
+     * realtime historical shock decomposition `Y(t|T)`, i.e. without observing data in `[T+1,...,nobs]`
+
+     * forecast shock decomposition `Y(T+k|T)`
+
+     * realtime conditional shock decomposition `Y(T+k|T+k)-Y(T+k|T)`
+
+   + New block `shock_groups` that allows grouping shocks for the
+     `shock_decomposition` and `realtime_shock_decomposition` commands,
+
+   + New command `plot_shock_decomposition` that allows plotting the
+     results from `shock_decomposition` and
+     `realtime_shock_decomposition` for different vintages and shock
+     groupings.
+
+
+ - Macroprocessor
+
+   + Can now pass a macro-variable to the `@#include` macro directive,
+
+   + New preprocessor flag `-I`, macro directive `@#includepath`, and
+     dynare config file block `[paths]` to pass a search path to the
+     macroprocessor to be used for file inclusion via `@#include`.
+
+
+ - Command line
+
+   + New option `onlyclearglobals` (do not clear JIT compiled functions
+     with recent versions of Matlab),
+
+   + New option `minimal_workspace` to use fewer variables in the
+     current workspace,
+
+   + New option `params_derivs_order` allows limiting the order of the
+     derivatives with respect to the parameters that are calculated by
+     the preprocessor,
+
+   + New command line option `mingw` to support the MinGW-w64 C/C++
+     Compiler from TDM-GCC for `use_dll`.
+
+
+ - dates/dseries/reporting classes
+
+   + New methods `abs`, `cumprod` and `chain`,
+
+   + New option `tableRowIndent` to `addTable`,
+
+   + Reporting system revamped and made more efficient, dependency on
+     matlab2tikz has been dropped.
+
+
+ - Optimization algorithms
+
+   + `mode_compute=2` Uses the simulated annealing as described by
+     Corana et al. (1987),
+
+   + `mode_compute=101` Uses SOLVEOPT as described by Kuntsevich and
+     Kappel (1997),
+
+   + `mode_compute=102` Uses `simulannealbnd` from Matlab's Global
+     Optimization Toolbox (if available),
+
+   + New option `silent_optimizer` to shut off output from mode
+     computing/optimization,
+
+   + New options `verbosity` and `SaveFiles` to control output and
+     saving of files during mode computing/optimization.
+
+
+ - LaTeX output
+
+   + New command `write_latex_original_model`,
+
+   + New option `write_equation_tags` to `write_latex_dynamic_model`
+     that allows printing the specified equation tags to the generate
+     LaTeX code,
+
+   + New command `write_latex_parameter_table` that writes the names and
+     values of model parameters to a LaTeX table,
+
+   + New command `write_latex_prior_table` that writes the descriptive
+     statistics about the prior distribution to a LaTeX table,
+
+   + New command `collect_latex_files` that creates one compilable LaTeX
+     file containing all TeX-output.
+
+
+ - Misc.
+
+   + Provides 64bit preprocessor,
+
+   + Introduces new path management to avoid conflicts with other
+     toolboxes,
+
+   + Full compatibility with Matlab 2014b's new graphic interface,
+
+   + When using `model(linear)`, Dynare automatically checks
+     whether the model is truly linear,
+
+   + `usedll`, the `msvc` option now supports `normcdf`, `acosh`,
+     `asinh`, and `atanh`,
+
+   + New parallel option `NumberOfThreadsPerJob` for Windows nodes that
+     sets the number of threads assigned to each remote MATLAB/Octave
+     run,
+
+   + Improved numerical performance of
+     `schur_statespace_transformation` for very large models,
+
+   + The `all_values_required` option now also works with `histval`,
+
+   + Add missing `horizon` option to `ms_forecast`,
+
+   + BVAR now saves the marginal data density in
+     `oo_.bvar.log_marginal_data_density` and stores prior and
+     posterior information in `oo_.bvar.prior` and
+     `oo_.bvar.posterior`.
+
+
+
+* Bugs and problems identified in version 4.4.3 and that have been fixed in version 4.5.0:
+
+
+ - BVAR models
+
+   + `bvar_irf` could display IRFs in an unreadable way when they moved from
+     negative to positive values,
+
+   + In contrast to what is stated in the documentation, the confidence interval
+     size `conf_sig` was 0.6 by default instead of 0.9.
+
+
+ - Conditional forecasts
+
+   + The `conditional_forecast` command produced wrong results in calibrated
+     models when used at initial values outside of the steady state (given with
+     `initval`),
+
+   + The `plot_conditional_forecast` option could produce unreadable figures if
+     the areas overlap,
+
+   + The `conditional_forecast` command after MLE crashed,
+
+   + In contrast to what is stated in the manual, the confidence interval size
+     `conf_sig` was 0.6 by default instead of 0.8.
+
+   + Conditional forecasts were wrong when the declaration of endogenous
+     variables was not preceeding the declaration of the exogenous
+     variables and parameters.
+
+
+ - Discretionary policy
+
+   + Dynare allowed running models where the number of instruments did not match
+     the number of omitted equations,
+
+   + Dynare could crash in some cases when trying to display the solution,
+
+   + Parameter dependence embedded via a `steady_state` was not taken into
+     account, typically resulting in crashes.
+
+ - dseries class
+
+   + When subtracting a dseries object from a number, the number was instead
+     subtracted from the dseries object.
+
+
+ - DSGE-VAR models
+
+   + Dynare crashed when estimation encountered non-finite values in the Jacobian
+     at the steady state,
+
+   + The presence of a constant was not considered for degrees of freedom
+     computation of the Gamma function used during the posterior computation; due
+     to only affecting the constant term, results should be be unaffected, except
+     for model_comparison when comparing models with and without.
+
+
+ - Estimation command
+
+   + In contrast to what was stated in the manual, the confidence interval size
+     `conf_sig` for `forecast` without MCMC was 0.6 by default instead of 0.9,
+
+   + Calling estimation after identification could lead to crashes,
+
+   + When using recursive estimation/forecasting and setting some elements of
+     `nobs` to be larger than the number of observations T in the data,
+     `oo_recursive_` contained additional cell entries that simply repeated the
+     results obtained for `oo_recursive_T`,
+
+   + Computation of Bayesian smoother could crash for larger models when
+     requesting `forecast` or `filtered_variables`,
+
+   + Geweke convergence diagnostics were not computed on the full MCMC chain when
+     the `load_mh_file` option was used,
+
+   + The Geweke convergence diagnostics always used the default `taper_steps` and
+   `geweke_interval`,
+
+   + Bayesian IRFs (`bayesian_irfs` option) could be displayed in an unreadable
+     way when they move from negative to positive values,
+
+   + If `bayesian_irfs` was requested when `mh_replic` was too low to compute
+     HPDIs, plotting was crashing,
+
+   + The x-axis value in `oo_.prior_density` for the standard deviation and
+     correlation of measurement errors was written into a field
+     `mearsurement_errors_*` instead of `measurement_errors_*`,
+
+   + Using a user-defined `mode_compute` crashed estimation,
+
+   + Option `mode_compute=10` did not work with infinite prior bounds,
+
+   + The posterior variances and covariances computed by `moments_varendo` were
+     wrong for very large models due to a matrix erroneously being filled up with
+     zeros,
+
+   + Using the `forecast` option with `loglinear` erroneously added the unlogged
+     steady state,
+
+   + When using the `loglinear` option the check for the presence of a constant
+     was erroneously based on the unlogged steady state,
+
+   + Estimation of `observation_trends` was broken as the trends specified as a
+     function of deep parameters were not correctly updated during estimation,
+
+   + When using `analytic_derivation`, the parameter values were not set before
+     testing whether the steady state file changes parameter values, leading to
+     subsequent crashes,
+
+   + If the steady state of an initial parameterization did not solve, the
+     observation equation could erroneously feature no constant when the
+     `use_calibration` option was used,
+
+   + When computing posterior moments, Dynare falsely displayed that moment
+     computations are skipped, although the computation was performed correctly,
+
+   + If `conditional_variance_decomposition` was requested, although all
+     variables contain unit roots, Dynare crashed instead of providing an error
+     message,
+
+   + Computation of the posterior parameter distribution was erroneously based
+     on more draws than specified (there was one additional draw for every Markov
+     chain),
+
+   + The estimation option `lyapunov=fixed_point` was broken,
+
+   + Computation of `filtered_vars` with only one requested step crashed Dynare,
+
+   + Option `kalman_algo=3` was broken with non-diagonal measurement error,
+
+   + When using the diffuse Kalman filter with missing observations, an additive
+     factor log(2*pi) was missing in the last iteration step,
+
+   + Passing of the `MaxFunEvals` and `InitialSimplexSize` options to
+     `mode_compute=8` was broken,
+
+   + Bayesian forecasts contained initial conditions and had the wrong length in
+     both plots and stored variables,
+
+   + Filtered variables obtained with `mh_replic=0`, ML, or
+     `calibrated_smoother` were padded with zeros at the beginning and end and
+     had the wrong length in stored variables,
+
+   + Computation of smoothed measurement errors in Bayesian estimation was broken,
+
+   + The `selected_variables_only` option (`mh_replic=0`, ML, or
+     `calibrated_smoother`) returned wrong results for smoothed, updated, and
+     filtered variables,
+
+   + Combining the `selected_variables_only` option with forecasts obtained
+     using `mh_replic=0`, ML, or `calibrated_smoother` leaded to crashes,
+
+   + `oo_.UpdatedVariables` was only filled when the `filtered_vars` option was specified,
+
+   + When using Bayesian estimation with `filtered_vars`, but without
+     `smoother`, then `oo_.FilteredVariables` erroneously also contained filtered
+     variables at the posterior mean as with `mh_replic=0`,
+
+   + Running an MCMC a second time in the same folder with a different number of
+     iterations could result in crashes due to the loading of stale files,
+
+   + Results displayed after Bayesian estimation when not specifying
+     the `smoother` option were based on the parameters at the mode
+     from mode finding instead of the mean parameters from the
+     posterior draws. This affected the smoother results displayed, but
+     also calls to subsequent command relying on the parameters stored
+     in `M_.params` like `stoch_simul`,
+
+   + The content of `oo_.posterior_std` after Bayesian estimation was based on
+     the standard deviation at the posterior mode, not the one from the MCMC, this
+     was not consistent with the reference manual,
+
+   + When the initialization of an MCMC run failed, the metropolis.log file was
+     locked, requiring a restart of Matlab to restart estimation,
+
+   + If the posterior mode was right at the corner of the prior bounds, the
+     initialization of the MCMC erroneously crashed,
+
+   + If the number of dropped draws via `mh_drop` coincided with the number of
+     draws in a `_mh'-file`, `oo_.posterior.metropolis.mean` and
+     `oo_.posterior.metropolis.Variance` were NaN.
+
+
+ - Estimation and calibrated smoother
+
+   + When using `observation_trends` with the `prefilter` option, the mean shift
+     due to the trend was not accounted for,
+
+   + When using `first_obs`>1, the higher trend starting point of
+     `observation_trends` was not taken into account, leading, among other things,
+     to problems in recursive forecasting,
+
+   + The diffuse Kalman smoother was crashing if the forecast error variance
+     matrix becomes singular,
+
+   + The multivariate Kalman smoother provided incorrect state estimates when
+     all data for one observation are missing,
+
+   + The multivariate diffuse Kalman smoother provided incorrect state estimates
+     when the `Finf` matrix becomes singular,
+
+   + The univariate diffuse Kalman filter was crashing if the initial covariance
+     matrix of the nonstationary state vector is singular,
+
+
+ - Forecats
+
+   + In contrast to what is stated in the manual, the confidence interval size
+     `conf_sig` was 0.6 by default instead of 0.9.
+
+   + Forecasting with exogenous deterministic variables provided wrong decision
+     rules, yielding wrong forecasts.
+
+   + Forecasting with exogenous deterministic variables crashed when the
+     `periods` option was not explicitly specified,
+
+   + Option `forecast` when used with `initval` was using the initial values in
+     the `initval` block and not the steady state computed from these initial
+     values as the starting point of forecasts.
+
+
+ - Global Sensitivity Analysis
+
+   + Sensitivity with ML estimation could result in crashes,
+
+   + Option `mc` must be forced if `neighborhood_width` is used,
+
+   + Fixed dimension of `stock_logpo` and `stock_ys`,
+
+   + Incomplete variable initialization could lead to crashes with `prior_range=1`.
+
+
+ - Indentification
+
+   + Identification did not correctly pass the `lik_init` option,
+     requiring the manual setting of `options_.diffuse_filter=1` in
+     case of unit roots,
+
+   + Testing identification of standard deviations as the only
+     parameters to be estimated with ML leaded to crashes,
+
+   + Automatic increase of the lag number for autocovariances when the
+     number of parameters is bigger than the number of non-zero moments
+     was broken,
+
+   + When using ML, the asymptotic Hessian was not computed,
+
+   + Checking for singular values when the eigenvectors contained only
+     one column did not work correctly,
+
+
+ - Model comparison
+
+   + Selection of the `modifiedharmonicmean` estimator was broken,
+
+
+ - Optimal Simple Rules
+
+   + When covariances were specified, variables that only entered with
+     their variance and no covariance term obtained a wrong weight,
+     resulting in wrong results,
+
+   + Results reported for stochastic simulations after `osr` were based
+     on the last parameter vector encountered during optimization,
+     which does not necessarily coincide with the optimal parameter
+     vector,
+
+   + Using only one (co)variance in the objective function resulted in crashes,
+
+   + For models with non-stationary variables the objective function was computed wrongly.
+
+
+ - Ramsey policy
+
+   + If a Lagrange multiplier appeared in the model with a lead or a lag
+     of more than one period, the steady state could be wrong.
+
+   + When using an external steady state file, incorrect steady states
+     could be accepted,
+
+   + When using an external steady state file with more than one
+     instrument, Dynare crashed,
+
+   + When using an external steady state file and running `stoch_simul`
+     after `ramsey_planner`, an incorrect steady state was used,
+
+   + When the number of instruments was not equal to the number of
+     omitted equations, Dynare crashed with a cryptic message,
+
+   + The `planner_objective` accepted `varexo`, but ignored them for computations,
+
+
+ - Shock decomposition
+
+   + Did not work with the `parameter_set=calibration` option if an
+     `estimated_params` block is present,
+
+   + Crashed after MLE.
+
+
+ - Perfect foresight models
+
+   + The perfect foresight solver could accept a complex solution
+     instead of continuing to look for a real-valued one,
+
+   + The `initval_file` command only accepted column and not row vectors,
+
+   + The `initval_file` command did not work with Excel files,
+
+   + Deterministic simulations with one boundary condition crashed in
+     `solve_one_boundary` due to a missing underscore when passing
+     `options_.simul.maxit`,
+
+   + Deterministic simulation with exogenous variables lagged by more
+     than one period crashed,
+
+   + Termination criterion `maxit` was hard-coded for `solve_algo=0`
+     and could no be changed,
+
+   + When using `block`/`bytecode`, relational operators could not be enforced,
+
+   + When using `block` some exceptions were not properly handled,
+     leading to code crashes,
+
+   + Using `periods=1` crashed the solver (bug only partially fixed).
+
+
+ - Smoothing
+
+   + The univariate Kalman smoother returned wrong results when used
+     with correlated measurement error,
+
+   + The diffuse smoother sometimes returned linear combinations of the
+     smoothed stochastic trend estimates instead of the original trend
+     estimates.
+
+ - Perturbation reduced form
+
+   + In contrast to what is stated in the manual, the results of the
+     unconditional variance decomposition were only stored in
+     `oo_.gamma_y(nar+2)`, not in `oo_.variance_decomposition`,
+
+   + Dynare could crash when the steady state could not be computed
+     when using the `loglinear` option,
+
+   + Using `bytcode` when declared exogenous variables were not
+     used in the model leaded to crashes in stochastic simulations,
+
+   + Displaying decision rules involving lags of auxiliary variables of
+     type 0 (leads>1) crashed.
+
+   + The `relative_irf` option resulted in wrong output at `order>1` as
+     it implicitly relies on linearity.
+
+
+ - Displaying of the MH-history with the `internals` command crashed
+   if parameter names did not have same length.
+
+ - Dynare crashed when the user-defined steady state file returned an
+   error code, but not an conformable-sized steady state vector.
+
+ - Due to a bug in `mjdgges.mex` unstable parameter draws with
+   eigenvalues up to 1+1e-6 could be accepted as stable for the
+   purpose of the Blanchard-Kahn conditions, even if `qz_criterium<1`.
+
+ - The `use_dll` option on Octave for Windows required to pass a
+   compiler flag at the command line, despite the manual stating this
+   was not necessary.
+
+ - Dynare crashed for models with `block` option if the Blanchard-Kahn
+   conditions were not satisfied instead of generating an error
+   message.
+
+ - The `verbose` option did not work with `model(block)`.
+
+ - When falsely specifying the `model(linear)` for nonlinear models,
+   incorrect steady states were accepted instead of aborting.
+
+ - The `STEADY_STATE` operator called on model local variables
+   (so-called pound variables) did not work as expected.
+
+ - The substring operator in macro-processor was broken. The
+   characters of the substring could be mixed with random characters
+   from the memory space.
+
+ - Block decomposition could sometimes cause the preprocessor to crash.
+
+ - A bug when external functions were used in model local variables
+   that were contained in equations that required auxiliary
+   variable/equations led to crashes of Matlab.
+
+ - Sampling from the prior distribution for an inverse gamma II
+   distribution when `prior_trunc>0` could result in incorrect
+   sampling.
+
+ - Sampling from the prior distribution for a uniform distribution
+   when `prior_trunc>0` was ignoring the prior truncation.
+
+ - Conditional forecasts were wrong when the declaration of endogenous
+   variables was not preceeding the declaration of the exogenous
+   variables and parameters.
+
+
+
 Announcement for Dynare 4.4.3 (on 2014-07-31)
 =============================================
 
@@ -988,7 +1785,7 @@ Here is a list of the main bugfixes since version 4.2.0:
 
  * Option `conditional_variance_decomposition' of `stoch_simul' and
    `estimation' has been fixed
- 
+
  * Automatic detrending now works in conjunction with the `EXPECTATION'
    operator
 
@@ -1029,7 +1826,7 @@ This release is compatible with MATLAB versions ranging from 6.5 (R13) to 7.11
 
 Here is the list of major user-visible changes:
 
-* New solution algorithms: 
+* New solution algorithms:
 
   - Pruning for second order simulations has been added, as described in Kim,
     Kim, Schaumburg and Sims (2008) [1,2]
@@ -1066,7 +1863,7 @@ Here is the list of major user-visible changes:
 
   - Syntax of deterministic shocks has changed: after the values keyword,
     arbitrary expressions must be enclosed within parentheses (but numeric
-    constants are still accepted as is) 
+    constants are still accepted as is)
 
 * Various improvements:
 
@@ -1095,7 +1892,7 @@ Here is the list of major user-visible changes:
     from the console, it will replace graphical waitbars by text waitbars for
     long computations
 
-  - Steady option "solve_algo=0" (uses fsolve()) now works under Octave 
+  - Steady option "solve_algo=0" (uses fsolve()) now works under Octave
 
 * For Emacs users:
 
diff --git a/README.md b/README.md
index 202ed7d5b..0a19dc997 100644
--- a/README.md
+++ b/README.md
@@ -91,7 +91,7 @@ If you have downloaded the sources from an official source archive or the source
 
 If you want to use Git, do the following from a terminal:
 
-    git clone --recursive http://github.com/DynareTeam/dynare.git
+    git clone --recursive https://github.com/DynareTeam/dynare.git
     cd dynare
     autoreconf -si
 
@@ -303,7 +303,7 @@ After this, prepare the source and configure the build tree as described for Lin
 - **NB**: If not compiling Dynare mex files for Octave, add ```--without-octave``` to the installation command
 - **NB**: To compile the latest stable version of dynare, follow the same instructions as above, omitting the ```--HEAD``` argument
 - **NB**: To update a ```--HEAD``` install of dynare you need to uninstall it then install it again: ```brew uninstall dynare; brew install dynare --HEAD```.
-- **NB**: If you want to maintain a separate git directory of dynare, you can do a ```--HEAD``` install of dynare, then uninstall it. This will have the effect of bringing in all the dependencies you will need to then compile dynare from your git directory. Then, change to the git directory and type:
+- **NB**: If you want to maintain a separate git directory of dynare, you can do a ```--HEAD``` install of dynare, then uninstall it. This will have the effect of bringing in all the dependencies you will need to then compile dynare from your git directory. (For `flex` and `bison` it may be necessary to symlink them via `brew link bison --force` and `brew link flex --force` as they are keg-only). Then, change to the git directory and type:
     - ```autoreconf -si; ./configure --with-matlab=/Applications/MATLAB_R2015a.app MATLAB_VERSION=R2015a```, adjusting the Matlab path and version to accord with your version
 - Once compilation is done, open Matlab and type the last line shown when you type ```brew info dynare``` in the Terminal window. With the typical Homebrew setup, this is:
     - ```addpath /usr/local/opt/dynare/lib/dynare/matlab```
diff --git a/VERSION.in b/VERSION.in
new file mode 100644
index 000000000..7b4f3f3a0
--- /dev/null
+++ b/VERSION.in
@@ -0,0 +1 @@
+@PACKAGE_VERSION@
\ No newline at end of file
diff --git a/configure.ac b/configure.ac
index a29888519..4ddf92682 100755
--- a/configure.ac
+++ b/configure.ac
@@ -18,7 +18,7 @@ dnl You should have received a copy of the GNU General Public License
 dnl along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 AC_PREREQ([2.62])
-AC_INIT([dynare], [4.5-unstable])
+AC_INIT([dynare], [4.6-unstable])
 AC_CONFIG_SRCDIR([preprocessor/DynareMain.cc])
 AM_INIT_AUTOMAKE([1.11 -Wall -Wno-portability foreign no-dist-gzip dist-xz tar-pax])
 
@@ -172,6 +172,7 @@ esac
 AX_PTHREAD
 
 AC_CONFIG_FILES([Makefile
+                 VERSION
                  preprocessor/macro/Makefile
                  preprocessor/Makefile
                  doc/Makefile
diff --git a/doc/bvar-a-la-sims.tex b/doc/bvar-a-la-sims.tex
index 07af9fb77..b58b83b75 100644
--- a/doc/bvar-a-la-sims.tex
+++ b/doc/bvar-a-la-sims.tex
@@ -12,7 +12,7 @@
 \begin{document}
 
 \title{BVAR models ``\`a la Sims'' in Dynare\thanks{Copyright \copyright~2007--2015 S\'ebastien
-    Villemot; \copyright~2016 S\'ebastien
+    Villemot; \copyright~2016--2017 S\'ebastien
     Villemot and Johannes Pfeifer. Permission is granted to copy, distribute and/or modify
     this document under the terms of the GNU Free Documentation
     License, Version 1.3 or any later version published by the Free
@@ -26,8 +26,8 @@
   }}
 
 \author{S\'ebastien Villemot\thanks{Paris School of Economics and
-    CEPREMAP.} \and Johannes Pfeifer\thanks{University of Mannheim. E-mail: \href{mailto:pfeifer@uni-mannheim.de}{\texttt{pfeifer@uni-mannheim.de}}.}}
-\date{First version: September 2007 \hspace{1cm} This version: October 2016}
+    CEPREMAP.} \and Johannes Pfeifer\thanks{University of Cologne. E-mail: \href{mailto:jpfeifer@uni-koeln.de}{\texttt{jpfeifer@uni-koeln.de}}.}}
+\date{First version: September 2007 \hspace{1cm} This version: May 2017}
 
 \maketitle
 
@@ -545,7 +545,7 @@ Most results are stored for future use:
 The syntax for computing impulse response functions is:
 
 \medskip
-\texttt{bvar\_irf(}\textit{number\_of\_periods},\textit{identification\_scheme}\texttt{);}
+\texttt{bvar\_irf(}\textit{number\_of\_lags},\textit{identification\_scheme}\texttt{);}
 \medskip
 
 The \textit{identification\_scheme} option has two potential values
@@ -556,7 +556,25 @@ The \textit{identification\_scheme} option has two potential values
 
 Keep in mind that the first factorization of the covariance matrix is sensible to the ordering of the variables (as declared in the mod file with \verb+var+). This is not the case of the second factorization, but its structural interpretation is, at best, unclear (the Matrix square root of a covariance matrix, $\Sigma$, is the unique symmetric matrix $A$ such that $\Sigma = AA$).\newline
 
-The mean, median, variance and confidence intervals for IRFs are saved in \texttt{oo\_.bvar.irf}
+If you want to change the length of the IRFs plotted by the command, you can put\\
+
+\medskip
+\texttt{options\_.irf=40;}\\
+\medskip
+
+before the \texttt{bvar\_irf}-command. Similarly, to change the coverage of the highest posterior density intervals to e.g. 60\% you can put the command\\
+
+\medskip
+\texttt{options\_.bvar.conf\_sig=0.6;}\\
+\medskip
+
+there.\newline
+
+
+The mean, median, variance, and confidence intervals for IRFs are saved in \texttt{oo\_.bvar.irf}
+
+
+
 
 \section{Examples}
 
diff --git a/doc/dynare.texi b/doc/dynare.texi
index 0dc42dacf..e244eafb2 100644
--- a/doc/dynare.texi
+++ b/doc/dynare.texi
@@ -2,6 +2,8 @@
 @c %**start of header
 @setfilename dynare.info
 @documentencoding UTF-8
+@set txicodequoteundirected
+
 @settitle Dynare Reference Manual
 @afourwide
 @dircategory Math
@@ -112,8 +114,8 @@ A copy of the license can be found at @uref{http://www.gnu.org/licenses/fdl.txt}
 @subtitle Reference Manual, version @value{VERSION}
 @author Stéphane Adjemian
 @author Houtan Bastani
-@author Frédéric Karamé
 @author Michel Juillard
+@author Frédéric Karamé
 @author Junior Maih
 @author Ferhat Mihoubi
 @author George Perendia
@@ -169,14 +171,14 @@ Installation of Dynare
 
 * On Windows::
 * On Debian GNU/Linux and Ubuntu::
-* On Mac OS X::
+* On macOS::
 * For other systems::
 
 Compiler installation
 
 * Prerequisites on Windows::
 * Prerequisites on Debian GNU/Linux and Ubuntu::
-* Prerequisites on Mac OS X::
+* Prerequisites on macOS::
 
 Configuration
 
@@ -206,6 +208,9 @@ The Model file
 * Deterministic simulation::
 * Stochastic solution and simulation::
 * Estimation::
+* Model Comparison::
+* Shock Decomposition::
+* Calibrated Smoother::
 * Forecasting::
 * Optimal policy::
 * Sensitivity and identification analysis::
@@ -345,23 +350,21 @@ as a support tool for forecasting exercises. In the academic world,
 Dynare is used for research and teaching purposes in postgraduate
 macroeconomics courses.
 
-Dynare is a free software, which means that it can be downloaded free
-of charge, that its source code is freely available, and that it can
-be used for both non-profit and for-profit purposes. Most of the
-source files are covered by the GNU General Public Licence (GPL)
-version 3 or later (there are some exceptions to this, see the file
-@file{license.txt} in Dynare distribution). It is available for the
-Windows, Mac and Linux platforms and is fully documented through a
-user guide and a reference manual. Part of Dynare is programmed in
-C++, while the rest is written using the
-@uref{http://www.mathworks.com/products/matlab/, MATLAB} programming
-language.  The latter implies that commercially-available MATLAB
-software is required in order to run Dynare. However, as an
-alternative to MATLAB, Dynare is also able to run on top of
-@uref{http://www.octave.org, GNU Octave} (basically a free clone of
-MATLAB): this possibility is particularly interesting for students or
-institutions who cannot afford, or do not want to pay for, MATLAB and
-are willing to bear the concomitant performance loss.
+Dynare is a free software, which means that it can be downloaded free of
+charge, that its source code is freely available, and that it can be used for
+both non-profit and for-profit purposes. Most of the source files are covered
+by the GNU General Public Licence (GPL) version 3 or later (there are some
+exceptions to this, see the file @file{license.txt} in Dynare distribution). It
+is available for the Windows, macOS, and Linux platforms and is fully
+documented through a user guide and a reference manual. Part of Dynare is
+programmed in C++, while the rest is written using the
+@uref{http://www.mathworks.com/products/matlab/, MATLAB} programming language.
+The latter implies that commercially-available MATLAB software is required in
+order to run Dynare. However, as an alternative to MATLAB, Dynare is also able
+to run on top of @uref{http://www.octave.org, GNU Octave} (basically a free
+clone of MATLAB): this possibility is particularly interesting for students or
+institutions who cannot afford, or do not want to pay for, MATLAB and are
+willing to bear the concomitant performance loss.
 
 The development of Dynare is mainly done at
 @uref{http://www.cepremap.fr, Cepremap} by a core team of
@@ -371,7 +374,7 @@ Adjemian (Université du Maine, Gains and Cepremap), Houtan Bastani
 (Cepremap), Michel Juillard (Banque de France), Frédéric Karamé
 (Université du Maine, Gains and Cepremap), Junior Maih (Norges Bank),
 Ferhat Mihoubi (Université Paris-Est Créteil, Epee and Cepremap), George
-Perendia, Johannes Pfeifer (University of Mannheim), Marco Ratto (European Commission, Joint Research Centre - JRC)
+Perendia, Johannes Pfeifer (University of Cologne), Marco Ratto (European Commission, Joint Research Centre - JRC)
 and Sébastien Villemot (OFCE – Sciences Po).
 Increasingly, the developer base is expanding, as tools developed by
 researchers outside of Cepremap are integrated into Dynare. Financial
@@ -439,7 +442,7 @@ If you want to give a URL, use the address of the Dynare website:
 
 Packaged versions of Dynare are available for Windows XP/Vista/7/8,
 @uref{http://www.debian.org,Debian GNU/Linux},
-@uref{http://www.ubuntu.com/,Ubuntu} and Mac OS X 10.8 or later.  Dynare should
+@uref{http://www.ubuntu.com/,Ubuntu} and macOS 10.8 or later.  Dynare should
 work on other systems, but some compilation steps are necessary in that case.
 
 In order to run Dynare, you need one of the following:
@@ -447,7 +450,7 @@ In order to run Dynare, you need one of the following:
 @itemize
 
 @item
-MATLAB version 7.5 (R2007b) or above (MATLAB R2009b 64-bit for Mac OS X);
+MATLAB version 7.5 (R2007b) or above (MATLAB R2009b 64-bit for macOS);
 
 @item
 GNU Octave version 3.6 or above.
@@ -470,10 +473,6 @@ If under GNU Octave, the following
 @uref{http://octave.sourceforge.net/,Octave-Forge} packages: optim,
 io, statistics, control.
 
-@item 
-Mac OS X Octave users will also need to install
-gnuplot if they want graphing capabilities.
-
 @end itemize
 
 
@@ -490,7 +489,7 @@ about your own files.
 @menu
 * On Windows::
 * On Debian GNU/Linux and Ubuntu::
-* On Mac OS X::
+* On macOS::
 * For other systems::
 @end menu
 
@@ -521,25 +520,29 @@ Wiki} for detailed instructions.
 Dynare will be installed under @file{/usr/lib/dynare}. Documentation will be
 under @file{/usr/share/doc/dynare-doc}.
 
-@node On Mac OS X
-@subsection On Mac OS X
+@node On macOS
+@subsection On macOS
 
-Execute the automated installer called
-@file{dynare-4.@var{x}.@var{y}.pkg} (where
-4.@var{x}.@var{y} is the version number), and follow the
-instructions. The default installation directory is
-@file{/Applications/Dynare/4.@var{x}.@var{y}}.
-
-Please refer to the
+To install Dynare for use with Matlab, execute the automated installer called
+@file{dynare-4.@var{x}.@var{y}.pkg} (where 4.@var{x}.@var{y} is the version
+number), and follow the instructions. The default installation directory is
+@file{/Applications/Dynare/4.@var{x}.@var{y}} (please refer to the
 @uref{http://www.dynare.org/DynareWiki/InstallOnMacOSX,Dynare Wiki} for
-detailed instructions.
+detailed instructions).
 
 After installation, this directory will contain several sub-directories,
 among which are @file{matlab}, @file{mex} and @file{doc}.
 
-Note that you can have several versions of Dynare coexisting (for
-example in @file{/Applications/Dynare}), as long as you correctly
-adjust your path settings (@pxref{Some words of warning}).
+Note that several versions of Dynare can coexist (by default in
+@file{/Applications/Dynare}), as long as you correctly adjust your path
+settings (@pxref{Some words of warning}).
+
+To install Dynare for Octave, first install Homebrew following the instructions
+on their site: @uref{https://brew.sh/}. Then install Octave, issuing the
+command @code{brew install octave} at the Terminal prompt. You can then install
+the latest stable version of Dynare by typing @code{brew install dynare} at the
+Terminal prompt. You can also pass options to the installation command. These
+options can be viewed by typing @code{brew info dynare} at the Terminal prompt.
 
 @node For other systems
 @subsection For other systems
@@ -568,7 +571,7 @@ Octave comes with built-in functionality for compiling mex-files.
 @menu
 * Prerequisites on Windows::
 * Prerequisites on Debian GNU/Linux and Ubuntu::
-* Prerequisites on Mac OS X::
+* Prerequisites on macOS::
 @end menu
 
 @node Prerequisites on Windows
@@ -596,9 +599,9 @@ it can be installed via @code{apt-get install build-essential}.
 Users of Octave under Linux should install the package for MEX file compilation 
 (under Debian or Ubuntu, it is called @file{liboctave-dev}).
 
-@node Prerequisites on Mac OS X
-@subsection Prerequisites on Mac OS X
-If you are using MATLAB under Mac OS X, you should install the latest
+@node Prerequisites on macOS
+@subsection Prerequisites on macOS
+If you are using MATLAB under macOS, you should install the latest
 version of XCode: see
 @uref{http://www.dynare.org/DynareWiki/InstallOnMacOSX,instructions on
 the Dynare wiki}.
@@ -638,7 +641,7 @@ Under Debian GNU/Linux or Ubuntu, type:
 addpath /usr/lib/dynare/matlab
 @end example
 
-Under Mac OS X, assuming that you have installed Dynare in the standard
+Under macOS, assuming that you have installed Dynare in the standard
 location, and replacing @code{4.@var{x}.@var{y}} with the correct version
 number, type:
 
@@ -653,7 +656,7 @@ will have to do it again.
 Via the menu entries:
 
 Select the ``Set Path'' entry in the ``File'' menu, then click on
-``Add Folder@dots{}'', and select the @file{matlab} subdirectory of your
+``Add Folder@dots{}'', and select the @file{matlab} subdirectory of `your
 Dynare installation. Note that you @emph{should not} use ``Add with
 Subfolders@dots{}''. Apply the settings by clicking on ``Save''. Note that
 MATLAB will remember this setting next time you run it.
@@ -677,18 +680,16 @@ addpath c:\dynare\4.@var{x}.@var{y}\matlab
 Under Debian GNU/Linux or Ubuntu, there is no need to use the
 @code{addpath} command; the packaging does it for you.
 
-Under Mac OS X, assuming that you have installed Dynare in the
-standard location, and replacing ``4.@var{x}.@var{y}'' with the correct
-version number, type:
+Under macOS, assuming that you have installed Dynare and Octave via Homebrew, type:
 
 @example
-addpath /Applications/Dynare/4.@var{x}.@var{y}/matlab
+addpath /usr/local/opt/dynare/lib/dynare/matlab
 @end example
 
 If you don't want to type this command every time you run Octave, you
 can put it in a file called @file{.octaverc} in your home directory
 (under Windows this will generally be @file{c:\Documents and
-Settings\USERNAME\} while under Mac OS X it is @file{/Users/USERNAME/}).
+Settings\USERNAME\} while under macOS it is @file{/Users/USERNAME/}).
 This file is run by Octave at every startup.
 
 @node Some words of warning
@@ -1065,6 +1066,9 @@ end of line one and the parser would continue processing.
 * Deterministic simulation::
 * Stochastic solution and simulation::
 * Estimation::
+* Model Comparison::
+* Shock Decomposition::
+* Calibrated Smoother::
 * Forecasting::
 * Optimal policy::
 * Sensitivity and identification analysis::
@@ -1104,6 +1108,10 @@ mutually exclusive arguments are separated by vertical bars: @samp{|};
 @item
 @var{INTEGER} indicates an integer number;
 
+@item
+@var{INTEGER_VECTOR} indicates a vector of integer numbers separated by spaces,
+enclosed by square brackets;
+
 @item
 @var{DOUBLE} indicates a double precision number. The following syntaxes
 are valid: @code{1.1e3}, @code{1.1E3}, @code{1.1d3}, @code{1.1D3}. In
@@ -2085,6 +2093,7 @@ Compiling the @TeX{} file requires the following @LaTeX{} packages:
 @anchor{write_latex_dynamic_model}
 
 @deffn Command write_latex_dynamic_model ;
+@deffnx Command write_latex_dynamic_model (@var{OPTIONS}) ;
 
 @descriptionhead
 
@@ -2131,6 +2140,16 @@ also have been replaced by new auxiliary variables and equations.
 
 For the required @LaTeX{} packages, @pxref{write_latex_original_model}.
 
+@optionshead
+
+@table @code
+
+@item write_equation_tags
+Write the equation tags in the @LaTeX{} output. NB: the equation tags will be
+interpreted with @LaTeX{} markups.
+
+@end table
+
 @end deffn
 
 @deffn Command write_latex_static_model ;
@@ -2303,7 +2322,7 @@ necessary for lagged/leaded variables, while feasible starting values are requir
 It is important to be aware that if some variables, endogenous or exogenous, are not mentioned in the
 @code{initval} block, a zero value is assumed. It is particularly important to keep 
 this in mind when specifying exogenous variables using @code{varexo} that are not allowed 
-to take on the value of zero, like e.g. TFP. 
+to take on the value of zero, like @i{e.g.} TFP.
 
 Note that if the @code{initval} block is immediately followed by a
 @code{steady} command, its semantics are slightly changed. 
@@ -2549,7 +2568,7 @@ equilibrium values.
 The fact that @code{c} at @math{t=0} and @code{k} at @math{t=201} specified in
 @code{initval} and @code{endval} are taken as given has an important
 implication for plotting the simulated vector for the endogenous
-variables, i.e. the rows of @code{oo_.endo_simul}: this vector will 
+variables, @i{i.e.} the rows of @code{oo_.endo_simul}: this vector will
 also contain the initial and terminal
 conditions and thus is 202 periods long in the example. When you specify
 arbitrary values for the initial and terminal conditions for forward- and
@@ -2626,13 +2645,18 @@ Moreover, as only states enter the recursive policy functions, all values specif
 @itemize
 
 @item
-in @ref{stoch_simul}, if the @code{periods} option is specified. Note that this only affects the starting point for the simulation, but not for the impulse response functions.
+in @ref{stoch_simul}, if the @code{periods} option is specified. Note that this
+only affects the starting point for the simulation, but not for the impulse
+response functions. When using the @ref{loglinear} option, the
+@code{histval}-block nevertheless takes the unlogged starting values.
 
 @item
-in @ref{forecast} as the initial point at which the forecasts are computed
+in @ref{forecast} as the initial point at which the forecasts are computed. When using the @ref{loglinear} option, 
+the @code{histval}-block nevertheless takes the unlogged starting values.
 
 @item
-in @ref{conditional_forecast} for a calibrated model as the initial point at which the conditional forecasts are computed
+in @ref{conditional_forecast} for a calibrated model as the initial point at which the conditional forecasts are computed.
+When using the @ref{loglinear} option, the @code{histval}-block nevertheless takes the unlogged starting values.
 
 @item 
 in @ref{Ramsey} policy, where it also specifies the values of the endogenous states at 
@@ -3463,6 +3487,7 @@ end;
 
 @deffn Command check ;
 @deffnx Command check (solve_algo = @var{INTEGER}) ;
+@anchor{check}
 
 @descriptionhead
 
@@ -3983,6 +4008,12 @@ moments. If theoretical moments are requested, the spectrum of the model solutio
 following the approach outlined in @cite{Uhlig (2001)}.
 Default: no filter.
 
+@item one_sided_hp_filter = @var{DOUBLE}
+Uses the one-sided HP filter with @math{\lambda} = @var{DOUBLE} described in @cite{Stock and Watson (1999)}
+before computing moments. This option is only available with simulated moments.
+Default: no filter.
+
+
 @item hp_ngrid = @var{INTEGER}
 Number of points in the grid for the discrete Inverse Fast Fourier
 Transform used in the HP filter computation. It may be necessary to
@@ -3997,7 +4028,7 @@ Default: no filter.
 
 @item bandpass_filter = @var{[HIGHEST_PERIODICITY LOWEST_PERIODICITY]}
 Uses a bandpass filter before computing moments. The passband is set to a periodicity of @code{HIGHEST_PERIODICITY} 
-to @code{LOWEST_PERIODICITY}, e.g. 6 to 32 quarters if the model frequency is quarterly.
+to @code{LOWEST_PERIODICITY}, @i{e.g.} @math{6} to @math{32} quarters if the model frequency is quarterly.
 Default: @code{[6,32]}.
 
 @item irf = @var{INTEGER}
@@ -4139,7 +4170,7 @@ period(s). The periods must be strictly positive. Conditional variances are give
 decomposition provides the decomposition of the effects of shocks upon
 impact. The results are stored in
 @code{oo_.conditional_variance_decomposition}
-(@pxref{oo_.conditional_variance_decomposition}). The variance decomposition is only conducted, if theoretical moments are requested, i.e. using the @code{periods=0}-option. In case of @code{order=2}, Dynare provides a second-order accurate approximation to the true second moments based on the linear terms of the second-order solution (see @cite{Kim, Kim, Schaumburg and Sims (2008)}). Note that the unconditional variance decomposition (i.e. at horizon infinity) is automatically conducted if theoretical moments are requested and if @code{nodecomposition} is not set (@pxref{oo_.variance_decomposition})
+(@pxref{oo_.conditional_variance_decomposition}). The variance decomposition is only conducted, if theoretical moments are requested, @i{i.e.} using the @code{periods=0}-option. In case of @code{order=2}, Dynare provides a second-order accurate approximation to the true second moments based on the linear terms of the second-order solution (see @cite{Kim, Kim, Schaumburg and Sims (2008)}). Note that the unconditional variance decomposition (@i{i.e.} at horizon infinity) is automatically conducted if theoretical moments are requested and if @code{nodecomposition} is not set (@pxref{oo_.variance_decomposition})
 
 @item pruning
 Discard higher order terms when iteratively computing simulations of
@@ -4367,7 +4398,7 @@ accurate approximation of the true second moments, see @code{conditional_varianc
 @anchor{oo_.variance_decomposition}
 @defvr {MATLAB/Octave variable} oo_.variance_decomposition
 After a run of @code{stoch_simul} when requesting theoretical moments (@code{periods=0}), 
-contains a matrix with the result of the unconditional variance decomposition (i.e. at horizon infinity). 
+contains a matrix with the result of the unconditional variance decomposition (@i{i.e.} at horizon infinity).
 The first dimension corresponds to the endogenous variables (in the order of declaration) and 
 the second dimension corresponds to exogenous variables (in the order of declaration). 
 Numbers are in percent and sum up to 100 across columns.
@@ -4755,7 +4786,7 @@ varobs
 
 This block specifies @emph{linear} trends for observed variables as
 functions of model parameters. In case the @code{loglinear}-option is used,
-this corresponds to a linear trend in the logged observables, i.e. an exponential
+this corresponds to a linear trend in the logged observables, @i{i.e.} an exponential
 trend in the level of the observables.
 
 Each line inside of the block should be of the form:
@@ -5091,7 +5122,7 @@ convergence is  then checked using  the @cite{Brooks and  Gelman (1998)}
 univariate convergence diagnostic.
 
 The inefficiency factors are computed as in @cite{Giordano et al. (2011)} based on 
-Parzen windows as in e.g. @cite{Andrews (1991)}.
+Parzen windows as in @i{e.g.} @cite{Andrews (1991)}.
 
 @optionshead
 
@@ -5154,9 +5185,10 @@ first observation of the rolling window.
 
 
 @item prefilter = @var{INTEGER}
-@anchor{prefilter}
-A value of @code{1} means that the estimation procedure will demean
-each data series by its empirical mean. If the (@ref{loglinear}) option without the (@ref{logdata}) option is requested, the data will first be logged and then demeaned. Default: @code{0}, @i{i.e.} no prefiltering
+@anchor{prefilter} A value of @code{1} means that the estimation procedure will
+demean each data series by its empirical mean. If the @ref{loglinear} option
+without the @ref{logdata} option is requested, the data will first be logged
+and then demeaned. Default: @code{0}, @i{i.e.} no prefiltering
 
 @item presample = @var{INTEGER}
 @anchor{presample}
@@ -5265,8 +5297,8 @@ smoothed shocks,  forecast, moments,  IRF).  The  draws used  to compute
 these posterior moments are sampled uniformly in the estimated empirical
 posterior  distribution (@i{ie}  draws of  the MCMC).   @code{sub_draws}
 should  be  smaller than  the  total  number  of MCMC  draws  available.
-Default:  @code{min(posterior_max_subsample_draws,0.25*Total  number  of
-draws)}
+Default:  @code{min(posterior_max_subsample_draws,(Total  number  of
+draws)*(number of chains))}
 
 @item posterior_max_subsample_draws = @var{INTEGER}
 @anchor{posterior_max_subsample_draws} maximum number  of draws from the
@@ -5305,11 +5337,11 @@ The scale to be used for drawing the initial value of the
 Metropolis-Hastings chain. Generally, the starting points should be overdispersed
 for the @cite{Brooks and Gelman (1998)}-convergence diagnostics to be meaningful. Default: 2*@code{mh_jscale}. 
 It is important to keep in mind that @code{mh_init_scale} is set at the beginning of 
-Dynare execution, i.e. the default will not take into account potential changes in
+Dynare execution, @i{i.e.} the default will not take into account potential changes in
 @ref{mh_jscale} introduced by either @code{mode_compute=6} or the 
 @code{posterior_sampler_options}-option @ref{scale_file}. 
 If @code{mh_init_scale} is too wide during initalization of the posterior sampler so that 100 tested draws 
-are inadmissible (e.g. Blanchard-Kahn conditions are always violated), Dynare will request user input 
+are inadmissible (@i{e.g.} Blanchard-Kahn conditions are always violated), Dynare will request user input 
 of a new @code{mh_init_scale} value with which the next 100 draws will be drawn and tested. 
 If the @ref{nointeractive}-option has been invoked, the program will instead automatically decrease 
 @code{mh_init_scale} by 10 percent after 100 futile draws and try another 100 draws. This iterative 
@@ -5507,7 +5539,7 @@ generator state of the already present draws is currently not supported.
 
 @item load_results_after_load_mh
 @anchor{load_results_after_load_mh} This option is available when loading a previous MCMC run without
-adding additional draws, i.e. when @code{load_mh_file} is specified with @code{mh_replic=0}. It tells Dynare 
+adding additional draws, @i{i.e.} when @code{load_mh_file} is specified with @code{mh_replic=0}. It tells Dynare 
 to load the previously computed convergence diagnostics, marginal data density, and posterior statistics from an
 existing @code{_results}-file instead of recomputing them.
 
@@ -5834,7 +5866,7 @@ Note that @code{'slice'} is incompatible with
 @anchor{posterior_sampler_options}
 A list of @var{NAME} and @var{VALUE} pairs. Can be used to set options for the posterior sampling methods.
 The set of available options depends on the selected posterior sampling routine 
-(i.e. on the value of option @ref{posterior_sampling_method}):
+(@i{i.e.} on the value of option @ref{posterior_sampling_method}):
 
 @table @code
 
@@ -5904,7 +5936,7 @@ mode to perform rotated slice iterations. Default: 0
 
 @item 'initial_step_size'
 Sets the initial size of the interval in the stepping-out procedure as fraction of the prior support
-i.e. the size will be initial_step_size*(UB-LB). @code{initial_step_size} must be a real number in the interval [0, 1]. 
+@i{i.e.} the size will be initial_step_size*(UB-LB). @code{initial_step_size} must be a real number in the interval [0, 1]. 
 Default: 0.8
 
 @item 'use_mh_covariance_matrix'
@@ -5976,13 +6008,13 @@ option @code{moments_varendo} to be specified.
 
 @item filtered_vars
 @anchor{filtered_vars} Triggers the computation of the posterior
-distribution of filtered endogenous variables/one-step ahead forecasts, i.e. @math{E_{t}{y_{t+1}}}. Results are
+distribution of filtered endogenous variables/one-step ahead forecasts, @i{i.e.} @math{E_{t}{y_{t+1}}}. Results are
 stored in @code{oo_.FilteredVariables} (see below for a description of
 this variable)
 
 @item smoother
 @anchor{smoother} Triggers the computation of the posterior distribution
-of smoothed endogenous variables and shocks, i.e. the expected value of variables and shocks given the information available in all observations up to the @emph{final} date (@math{E_{T}{y_t}}). Results are stored in
+of smoothed endogenous variables and shocks, @i{i.e.} the expected value of variables and shocks given the information available in all observations up to the @emph{final} date (@math{E_{T}{y_t}}). Results are stored in
 @code{oo_.SmoothedVariables}, @code{oo_.SmoothedShocks} and
 @code{oo_.SmoothedMeasurementErrors}.  Also triggers the computation of
 @code{oo_.UpdatedVariables}, which contains the estimation of the expected value of variables given the information available at the @emph{current} date (@math{E_{t}{y_t}}).  See below for a description of all these
@@ -6024,9 +6056,9 @@ Use the Univariate Diffuse Kalman Filter
 
 @end table
 @noindent
-Default value is @code{0}. In case of missing observations of single or all series, Dynare treats those missing values as unobserved states and uses the Kalman filter to infer their value (see e.g. @cite{Durbin and Koopman (2012), Ch. 4.10})
+Default value is @code{0}. In case of missing observations of single or all series, Dynare treats those missing values as unobserved states and uses the Kalman filter to infer their value (see @i{e.g.} @cite{Durbin and Koopman (2012), Ch. 4.10})
 This procedure has the advantage of being capable of dealing with observations where the forecast error variance matrix becomes singular for some variable(s).
-If this happens, the respective observation enters with a weight of zero in the log-likelihood, i.e. this observation for the respective variable(s) is dropped
+If this happens, the respective observation enters with a weight of zero in the log-likelihood, @i{i.e.} this observation for the respective variable(s) is dropped
 from the likelihood computations (for details see @cite{Durbin and Koopman (2012), Ch. 6.4 and 7.2.5} and @cite{Koopman and Durbin (2000)}). If the use of a multivariate Kalman filter is specified and a
 singularity is encountered, Dynare by default automatically switches to the univariate Kalman filter for this parameter draw. This behavior can be changed via the
 @ref{use_univariate_filters_if_singularity_is_detected} option.
@@ -6036,7 +6068,7 @@ singularity is encountered, Dynare by default automatically switches to the univ
 recursions as described by @cite{Herbst, 2015}. This setting is only used with
 @code{kalman_algo=1} or @code{kalman_algo=3}. In case of using the diffuse Kalman 
 filter (@code{kalman_algo=3/lik_init=3}), the observables must be stationary. This option 
-is not yet compatible with @code{analytical_derivation}.
+is not yet compatible with @ref{analytic_derivation}.
 
 @item kalman_tol = @var{DOUBLE}
 @anchor{kalman_tol} Numerical tolerance for determining the singularity of the covariance matrix of the prediction errors during the Kalman filter (minimum allowed reciprocal of the matrix condition number). Default value is @code{1e-10}
@@ -6047,23 +6079,25 @@ is not yet compatible with @code{analytical_derivation}.
 @item filter_covariance
 @anchor{filter_covariance} Saves the series of one step ahead error of
 forecast covariance matrices. With Metropolis, they are saved in @ref{oo_.FilterCovariance},
-otherwise in @ref{oo_.Smoother.Variance}.
+otherwise in @ref{oo_.Smoother.Variance}. Saves also k-step ahead error of
+forecast covariance matrices if @code{filter_step_ahead} is set.
 
 @item filter_step_ahead = [@var{INTEGER1}:@var{INTEGER2}]
 See below.
 
 @item filter_step_ahead = [@var{INTEGER1} @var{INTEGER2}  @dots{}]
 @anchor{filter_step_ahead}
-Triggers the computation k-step ahead filtered values, i.e. @math{E_{t}{y_{t+k}}}. Stores results in
-@code{oo_.FilteredVariablesKStepAhead} and
-@code{oo_.FilteredVariablesKStepAheadVariances}.
+Triggers the computation k-step ahead filtered values, @i{i.e.} @math{E_{t}{y_{t+k}}}. Stores results in
+@code{oo_.FilteredVariablesKStepAhead}. Also stores 1-step ahead values in @code{oo_.FilteredVariables}. 
+@code{oo_.FilteredVariablesKStepAheadVariances} is stored if @code{filter_covariance}.
+ 
 
 @item filter_decomposition
 @anchor{filter_decomposition} Triggers the computation of the shock
 decomposition of the above k-step ahead filtered values. Stores results in @code{oo_.FilteredVariablesShockDecomposition}.
 
 @item smoothed_state_uncertainty
-@anchor{smoothed_state_uncertainty} Triggers the computation of the variance of smoothed estimates, i.e.
+@anchor{smoothed_state_uncertainty} Triggers the computation of the variance of smoothed estimates, @i{i.e.}
 @code{Var_T(y_t)}. Stores results in @code{oo_.Smoother.State_uncertainty}.
 
 @item diffuse_filter
@@ -6180,9 +6214,10 @@ where the model is ill-behaved. By default the original objective function is
 used.
 
 @item analytic_derivation
+@anchor{analytic_derivation}
 Triggers estimation with analytic gradient. The final hessian is also
 computed analytically. Only works for stationary models without
-missing observations.
+missing observations, i.e. for @code{kalman_algo<3}.
 
 @item ar = @var{INTEGER}
 @xref{ar}. Only useful in conjunction with option @code{moments_varendo}.
@@ -6213,10 +6248,14 @@ such a singularity is encountered. Default: @code{1}.
 With the default @ref{use_univariate_filters_if_singularity_is_detected}=1, Dynare will switch 
 to the univariate Kalman filter when it encounters a singular forecast error variance
 matrix during Kalman filtering. Upon encountering such a singularity for the first time, all subsequent
-parameter draws and computations will automatically rely on univariate filter, i.e. Dynare will never try 
+parameter draws and computations will automatically rely on univariate filter, @i{i.e.} Dynare will never try 
 the multivariate filter again. Use the @code{keep_kalman_algo_if_singularity_is_detected} option to have the 
 @code{use_univariate_filters_if_singularity_is_detected} only affect the behavior for the current draw/computation.
 
+@item rescale_prediction_error_covariance
+@anchor{rescale_prediction_error_covariance}
+Rescales the prediction error covariance in the Kalman filter to avoid badly scaled matrix and reduce the probability of a switch to univariate Kalman filters (which are slower). By default no rescaling is done.
+
 @item qz_zero_threshold = @var{DOUBLE}
 @xref{qz_zero_threshold}.
 
@@ -6325,6 +6364,22 @@ Sets the method for approximating the particle distribution. Possible values for
 @item cpf_weights = @var{OPTION}
 @anchor{cpf_weights} Controls the method used to update the weights in conditional particle filter, possible values are @code{amisanotristani} (@cite{Amisano et al (2010)}) or @code{murrayjonesparslow} (@cite{Murray et al. (2013)}). Default value is @code{amisanotristani}.
 
+@item nonlinear_filter_initialization = @var{INTEGER}
+@anchor{nonlinear_filter_initialization} Sets the initial condition of the
+nonlinear filters. By default the nonlinear filters are initialized with the
+unconditional covariance matrix of the state variables, computed with the
+reduced form solution of the first order approximation of the model. If
+@code{nonlinear_filter_initialization=2}, the nonlinear filter is instead
+initialized with a covariance matrix estimated with a stochastic simulation of
+the reduced form solution of the second order approximation of the model. Both
+these initializations assume that the model is stationary, and cannot be used
+if the model has unit roots (which can be seen with the @ref{check} command
+prior to estimation). If the model has stochastic trends, user must use
+@code{nonlinear_filter_initialization=3}, the filters are then initialized with
+an identity matrix for the covariance matrix of the state variables. Default
+value is @code{nonlinear_filter_initialization=1} (initialization based on the
+first order approximation of the model).
+
 @end table
 
 
@@ -6343,7 +6398,7 @@ It is also possible to impose implicit ``endogenous'' priors about IRFs and mome
 estimation. For example, one can specify that all valid parameter draws for the model must generate fiscal multipliers that are
 bigger than 1 by specifying how the IRF to a government spending shock must look like. The prior restrictions can be imposed
 via @code{irf_calibration} and @code{moment_calibration} blocks (@pxref{IRF/Moment calibration}). The way it works internally is that 
-any parameter draw that is inconsistent with the ``calibration'' provided in these blocks is discarded, i.e. assigned a prior density of 0. 
+any parameter draw that is inconsistent with the ``calibration'' provided in these blocks is discarded, @i{i.e.} assigned a prior density of 0. 
 When specifying these blocks, it is important to keep in mind that one won't be able to easily do @code{model_comparison} in this case, 
 because the prior density will not integrate to 1.
 
@@ -6387,7 +6442,7 @@ Upper bound of a 90% HPD interval
 @item HPDinf_ME
 Lower bound of a 90% HPD interval@footnote{See option @ref{conf_sig}
 to change the size of the HPD interval} for observables when taking 
-measurement error into account (see e.g. @cite{Christoffel et al. (2010), p.17}).
+measurement error into account (see @i{e.g.} @cite{Christoffel et al. (2010), p.17}).
 
 @item HPDsup_ME
 Upper bound of a 90% HPD interval for observables when taking 
@@ -6520,7 +6575,7 @@ indicate the respective variables. The third dimension of the array provides the
 observation for which the forecast has been made. For example, if @code{filter_step_ahead=[1 2 4]} 
 and @code{nobs=200}, the element (3,5,204) stores the four period ahead filtered 
 value of variable 5 computed at time t=200 for time t=204. The periods at the beginning 
-and end of the sample for which no forecasts can be made, e.g. entries (1,5,1) and 
+and end of the sample for which no forecasts can be made, @i{e.g.} entries (1,5,1) and 
 (1,5,204) in the example, are set to zero. Note that in case of Bayesian estimation 
 the variables will be ordered in the order of declaration after the estimation 
 command (or in general declaration order if no variables are specified here). In case 
@@ -6556,7 +6611,7 @@ The fourth dimension of the array provides the
 observation for which the forecast has been made. For example, if @code{filter_step_ahead=[1 2 4]} 
 and @code{nobs=200}, the element (3,5,2,204) stores the contribution of the second shock to the 
 four period ahead filtered value of variable 5 (in deviations from the mean) computed at time t=200 for time t=204. The periods at the beginning 
-and end of the sample for which no forecasts can be made, e.g. entries (1,5,1) and 
+and end of the sample for which no forecasts can be made, @i{e.g.} entries (1,5,1) and 
 (1,5,204) in the example, are set to zero. Padding with zeros and variable ordering is analogous to 
 @code{oo_.FilteredVariablesKStepAhead}. 
 @end defvr
@@ -6706,7 +6761,7 @@ Fields are of the form:
 Variable set by the @code{estimation} command (if used with the
 @code{smoother} option), or by the @code{calib_smoother} command.
 Contains the constant part of the endogenous variables used in the
-smoother, accounting e.g. for the data mean when using the @code{prefilter}
+smoother, accounting @i{e.g.} for the data mean when using the @code{prefilter}
 option.
 
 Fields are of the form:
@@ -6715,6 +6770,11 @@ Fields are of the form:
 @end example
 @end defvr
 
+@defvr {MATLAB/Octave variable} oo_.Smoother.loglinear
+Indicator keeping track of whether the smoother was run with the @ref{loglinear} option 
+and thus whether stored smoothed objects are in logs.
+@end defvr
+
 @defvr {MATLAB/Octave variable} oo_.PosteriorTheoreticalMoments
 @anchor{oo_.PosteriorTheoreticalMoments}
 Variable set by the @code{estimation} command, if it is used with the
@@ -6737,7 +6797,7 @@ Auto- and cross-correlation of endogenous variables. Fields are vectors with cor
 
 
 @item VarianceDecomposition
-Decomposition of variance (unconditional variance, i.e. at horizon infinity)@footnote{When the shocks are correlated, it
+Decomposition of variance (unconditional variance, @i{i.e.} at horizon infinity)@footnote{When the shocks are correlated, it
 is the decomposition of orthogonalized shocks via Cholesky
 decomposition according to the order of declaration of shocks
 (@pxref{Variable declarations})}
@@ -6903,7 +6963,7 @@ Upper/lower bound of the 90% HPD interval taking into account both parameter and
 
 @end table
 
-@var{VARIABLE_NAME} contains a matrix of the following size: number of time periods for which forecasts are requested using the nobs = [@var{INTEGER1}:@var{INTEGER2}] option times the number of forecast horizons requested by the @code{forecast} option. I.e., the row indicates the period at which the forecast is performed and the column the respective k-step ahead forecast. The starting periods are sorted in ascending order, not in declaration order.
+@var{VARIABLE_NAME} contains a matrix of the following size: number of time periods for which forecasts are requested using the nobs = [@var{INTEGER1}:@var{INTEGER2}] option times the number of forecast horizons requested by the @code{forecast} option. @i{i.e.}, the row indicates the period at which the forecast is performed and the column the respective k-step ahead forecast. The starting periods are sorted in ascending order, not in declaration order.
 
 @end defvr
 
@@ -6957,13 +7017,31 @@ estimates using a higher tapering are usually more reliable.
 @end table
 @end defvr
 
+@deffn Command unit_root_vars @var{VARIABLE_NAME}@dots{};
+
+This command is deprecated. Use @code{estimation} option @code{diffuse_filter} instead for estimating a model with non-stationary observed variables or @code{steady} option @code{nocheck} to prevent @code{steady} to check the steady state returned by your steady state file.
+@end deffn
+
+Dynare also has the ability to estimate Bayesian VARs:
+
+@deffn Command bvar_density ;
+Computes the marginal density of an estimated BVAR model, using
+Minnesota priors.
+
+See @file{bvar-a-la-sims.pdf}, which comes with Dynare distribution,
+for more information on this command.
+@end deffn
+
+@node Model Comparison
+@section Model Comparison
+
 @deffn Command model_comparison @var{FILENAME}[(@var{DOUBLE})]@dots{};
 @deffnx Command model_comparison (marginal_density = laplace | modifiedharmonicmean) @var{FILENAME}[(@var{DOUBLE})]@dots{};
 @anchor{model_comparison}
 @descriptionhead
 
 This command computes odds ratios and estimate a posterior density over a
-collection of models (see e.g. @cite{Koop (2003), Ch. 1}). The priors over
+collection of models (see @i{e.g.} @cite{Koop (2003), Ch. 1}). The priors over
 models can be specified as the @var{DOUBLE} values, otherwise a uniform prior
 over all models is assumed.  In contrast to frequentist econometrics, the
 models to be compared do not need to be nested.  However, as the computation of
@@ -7032,14 +7110,17 @@ Posterior probability of the respective model
 
 @end defvr
 
+@node Shock Decomposition
+@section Shock Decomposition
 
 @deffn Command shock_decomposition [@var{VARIABLE_NAME}]@dots{};
 @deffnx Command shock_decomposition (@var{OPTIONS}@dots{}) [@var{VARIABLE_NAME}]@dots{};
+@anchor{shock_decomposition}
 
 @descriptionhead
 
 This command computes the historical shock decomposition for a given sample based on 
-the Kalman smoother, i.e. it decomposes the historical deviations of the endogenous 
+the Kalman smoother, @i{i.e.} it decomposes the historical deviations of the endogenous 
 variables from their respective steady state values into the contribution coming 
 from the various shocks. The @code{variable_names} provided govern for which 
 variables the decomposition is plotted.
@@ -7052,16 +7133,14 @@ model).
 
 @table @code
 
-@item parameter_set = @var{PARAMETER_SET}
-Specify the parameter set to use for running the smoother. The
-@var{PARAMETER_SET} can take one of the following seven values:
-@code{calibration}, @code{prior_mode}, @code{prior_mean},
-@code{posterior_mode}, @code{posterior_mean},
-@code{posterior_median}, @code{mle_mode}. Default value: @code{posterior_mean} if
+@item parameter_set = @code{calibration} | @code{prior_mode} | @code{prior_mean} | @code{posterior_mode} | @code{posterior_mean} | @code{posterior_median} | @code{mle_mode}
+@anchor{parameter_set} Specify the parameter set to use for running the smoother. Note that the
+parameter set used in subsequent commands like @code{stoch_simul} will be set
+to the specified @code{parameter_set}. Default value: @code{posterior_mean} if
 Metropolis has been run, @code{mle_mode} if MLE has been run.
 
 @item datafile = @var{FILENAME}
-@xref{datafile}. Useful when computing the shock decomposition on a
+@anchor{datafile_shock_decomp} @xref{datafile}. Useful when computing the shock decomposition on a
 calibrated model.
 
 @item first_obs = @var{INTEGER}
@@ -7070,31 +7149,43 @@ calibrated model.
 @item nobs = @var{INTEGER}
 @xref{nobs}.
 
-@item use_shock_groups [= @var{SHOCK_GROUPS_NAME}]
-@anchor{use_shock_groups}. Uses groups of shocks instead of individual shocks in
-the decomposition. Groups of shocks are defined in @xref{shock_groups} block.
+@item use_shock_groups [= @var{STRING}]
+@anchor{use_shock_groups} Uses shock grouping defined by the string instead of individual shocks in
+the decomposition. The groups of shocks are defined in the @ref{shock_groups} block.
 
-@item colormap = @var{COLORMAP_NAME}
-@anchor{colormap}. Controls the colormap used for the shocks decomposition
-graphs. See @code{colormap} in Matlab/Octave manual.
+@item colormap = @var{STRING}
+@anchor{colormap} Controls the colormap used for the shocks decomposition
+graphs. See @code{colormap} in Matlab/Octave manual for valid arguments.
 
 @item nograph
-@xref{nograph}. Suppresses the display and creation only within the @code{shock_decomposition}-command
-but does not affect other commands.
+@xref{nograph}. Suppresses the display and creation only within the
+@code{shock_decomposition}-command, but does not affect other commands.
+@xref{plot_shock_decomposition} for plotting graphs.
 
+@item init_state = @var{BOOLEAN}
+@anchor{init_state} If equal to @math{0}, the shock decomposition is computed conditional on the smoothed state
+variables in period @math{0}, @i{i.e.} the smoothed shocks starting in period
+@math{1} are used.  If equal to @math{1}, the shock decomposition is computed
+conditional on the smoothed state variables in period @math{1}. Default:
+@math{0}
 @end table
 
+@outputhead
+
+@defvr {MATLAB/Octave variable} oo_.shock_decomposition
 @vindex oo_.shock_decomposition
+@anchor{oo_.shock_decomposition}
 The results are stored in the field @code{oo_.shock_decomposition}, which is a three
 dimensional array. The first dimension contains the @code{M_.endo_nbr} endogenous variables. 
-The second dimension stores
+The second dimension stores 
 in the first @code{M_.exo_nbr} columns the contribution of the respective shocks.
 Column @code{M_.exo_nbr+1} stores the contribution of the initial conditions,
 while column @code{M_.exo_nbr+2} stores the smoothed value of the respective
-endogenous variable in deviations from their steady state, i.e. the mean and trends are
+endogenous variable in deviations from their steady state, @i{i.e.} the mean and trends are
 subtracted. The third dimension stores the time periods. Both the variables 
-and shocks are stored in the order of declaration, i.e. @code{M_.endo_names} and 
+and shocks are stored in the order of declaration, @i{i.e.} @code{M_.endo_names} and 
 @code{M_.exo_names}, respectively.
+@end defvr
 
 @end deffn
 
@@ -7105,11 +7196,11 @@ and shocks are stored in the order of declaration, i.e. @code{M_.endo_names} and
 of the shock groups is written in a block delimited by @code{shock_groups} and
 @code{end}.
 
-Each line defines a group of shock as a list of exogenous variables:
+Each line defines a group of shocks as a list of exogenous variables:
 
 @example
 SHOCK_GROUP_NAME   = VARIABLE_1 [[,] VARIABLE_2 [,]@dots{}];
-`SHOCK GROUP NAME' = VARIABLE_1 [[,] VARIABLE_2 [,]@dots{}];
+'SHOCK GROUP NAME' = VARIABLE_1 [[,] VARIABLE_2 [,]@dots{}];
 @end example
 
 @optionshead
@@ -7120,7 +7211,7 @@ SHOCK_GROUP_NAME   = VARIABLE_1 [[,] VARIABLE_2 [,]@dots{}];
 Specifies a name for the following definition of shock groups. It is possible
 to use several @code{shock_groups} blocks in a model file, each grouping being
 identified by a different name. This name must in turn be used in the
-@code{shocks_decomposition} command.
+@code{shock_decomposition} command.
 
 @end table
 
@@ -7133,28 +7224,275 @@ varexo e_a, e_b, e_c, e_d;
 
 shock_groups(name=group1);
 supply = e_a, e_b;
-`aggregate demand' = e_c, e_d;
+'aggregate demand' = e_c, e_d;
 end;
 
-shocks_decomposition(use_shock_groups=group1);
+shock_decomposition(use_shock_groups=group1);
 @end example
+This example defines a shock grouping with the name @code{group1}, containing a set of supply and demand shocks 
+and conducts the shock decomposition for these two groups.
+@end deffn
+
+@deffn Command realtime_shock_decomposition [@var{VARIABLE_NAME}]@dots{};
+@deffnx Command realtime_shock_decomposition (@var{OPTIONS}@dots{}) [@var{VARIABLE_NAME}]@dots{};
+@anchor{realtime_shock_decomposition}
+
+@descriptionhead
+
+This command computes the realtime historical shock decomposition for a given
+sample based on the Kalman smoother. For each period
+@math{T=[@code{presample},@dots{},@code{nobs}]}, it recursively computes three objects:
+@itemize @bullet
+@item
+realtime historical shock decomposition @math{Y(t|T)} for @math{t=[1,@dots{},T]},
+@i{i.e.} without observing data in @math{[T+1,@dots{},@code{nobs}]}. This results in a standard 
+shock decomposition being computed for each additional datapoint becoming available after @code{presample}.
+@item
+forecast shock decomposition @math{Y(T+k|T)} for @math{k=[1,@dots{},forecast]}, @i{i.e.} the @math{k}-step 
+ahead forecast made for every @math{T} is decomposed in its shock contributions.
+@item
+realtime conditional shock decomposition of the difference between the realtime historical shock decomposition and the 
+forecast shock decomposition. If @ref{vintage} is equal to @math{0}, it computes the effect of shocks realizing in period 
+@math{T}, @i{i.e.} decomposes @math{Y(T|T)-Y(T|T-1)}. Put differently it conducts a @math{1}-period ahead shock decomposition from 
+@math{T-1} to @math{T}, by decomposing the update step of the Kalman filter. If @code{vintage>0} and smaller than @code{nobs},
+the decomposition is conducted of the forecast revision @math{Y(T+k|T+k)-Y(T+k|T)}.
+
+@end itemize
+
+Like @ref{shock_decomposition} it decomposes the historical deviations of the endogenous 
+variables from their respective steady state values into the contribution coming 
+from the various shocks. The @code{variable_names} provided govern for which 
+variables the decomposition is plotted.
+
+Note that this command must come after either @code{estimation} (in case
+of an estimated model) or @code{stoch_simul} (in case of a calibrated
+model).
+
+@optionshead
+
+@table @code
+
+@item parameter_set = @code{calibration} | @code{prior_mode} | @code{prior_mean} | @code{posterior_mode} | @code{posterior_mean} | @code{posterior_median} | @code{mle_mode}
+@xref{parameter_set}.
+
+@item datafile = @var{FILENAME}
+@xref{datafile_shock_decomp}.
+
+@item first_obs = @var{INTEGER}
+@xref{first_obs}.
+
+@item nobs = @var{INTEGER}
+@xref{nobs}.
+
+@item use_shock_groups [= @var{STRING}]
+@xref{use_shock_groups}.
+
+@item colormap = @var{STRING}
+@xref{colormap}.
+
+@item nograph
+@xref{nograph}. Only shock decompositions are computed and stored in @code{oo_.realtime_shock_decomposition},
+@code{oo_.conditional_shock_decomposition} and @code{oo_.realtime_forecast_shock_decomposition} but no plot is made 
+(@xref{plot_shock_decomposition}).
+
+@item presample = @var{INTEGER}
+@anchor{presample_shock_decomposition} First data point from which recursive
+realtime shock decompositions are computed, @i{i.e.} for
+@math{T=[@code{presample}@dots{}@code{nobs}]}.
+
+@item forecast = @var{INTEGER}
+@anchor{forecast_shock_decomposition} Compute shock decompositions up to
+@math{T+k} periods, @i{i.e.} get shock contributions to k-step ahead forecasts.
+
+@item save_realtime = @var{INTEGER_VECTOR}
+@anchor{save_realtime} Choose for which vintages to save the full realtime
+shock decomposition. Default: @math{0}.
+@end table
+
+@outputhead
+
+@defvr {MATLAB/Octave variable} oo_.realtime_shock_decomposition
+@vindex oo_.realtime_shock_decomposition
+Structure storing the results of realtime historical decompositions. Fields are three-dimensional arrays with 
+the first two dimension equal to the ones of @ref{oo_.shock_decomposition}. The third dimension stores the time 
+periods and is therefore of size @code{T+forecast}. Fields are of the form:
+@example
+@code{oo_.realtime_shock_decomposition.@var{OBJECT}}
+@end example
+where @var{OBJECT} is one of the following:
+
+@table @code
+
+@item pool
+Stores the pooled decomposition, @i{i.e.} for every realtime shock decomposition terminal period
+@math{T=[@code{presample},@dots{},@code{nobs}]} it collects the last period's decomposition @math{Y(T|T)}
+(see also @ref{plot_shock_decomposition}). The third dimension of the array will have size 
+@code{nobs+forecast}.
+
+@item time_*
+Stores the vintages of realtime historical shock decompositions if @code{save_realtime} is used. For example, if
+@code{save_realtime=[5]} and @code{forecast=8}, the third dimension will be of size 13.
+
+@end table
+@end defvr
+
+@defvr {MATLAB/Octave variable} oo_.realtime_conditional_shock_decomposition
+@vindex oo_.realtime_conditional_shock_decomposition
+Structure storing the results of realtime conditional decompositions. Fields are of the form:
+@example
+@code{oo_.realtime_conditional_shock_decomposition.@var{OBJECT}}
+@end example
+where @var{OBJECT} is one of the following:
+
+@table @code
+
+@item pool
+Stores the pooled realtime conditional shock decomposition, @i{i.e.} collects the decompositions of 
+@math{Y(T|T)-Y(T|T-1)} for the terminal periods @math{T=[@code{presample},@dots{},@code{nobs}]}. 
+The third dimension is of size @code{nobs}.
+
+@item time_*
+Store the vintages of @math{k}-step conditional forecast shock decompositions @math{Y(t|T+k)}, for
+@math{t=[T@dots{}T+k]}. @xref{vintage}. The third dimension is of size @code{1+forecast}.
+
+@end table
+@end defvr
+
+@defvr {MATLAB/Octave variable} oo_.realtime_forecast_shock_decomposition
+@vindex oo_.realtime_forecast_shock_decomposition
+Structure storing the results of realtime forecast decompositions. Fields are of the form:
+@example
+@code{oo_.realtime_forecast_shock_decomposition.@var{OBJECT}}
+@end example
+where @var{OBJECT} is one of the following:
+
+@table @code
+
+@item pool
+Stores the pooled realtime forecast decomposition of the @math{1}-step ahead effect of shocks
+on the @math{1}-step ahead prediction, @i{i.e.} @math{Y(T|T-1)}. 
+
+@item time_*
+Stores the vintages of @math{k}-step out-of-sample forecast shock
+decompositions, @i{i.e.} @math{Y(t|T)}, for @math{t=[T@dots{}T+k]}. @xref{vintage}.
+@end table
+@end defvr
 
 @end deffn
 
-@deffn Command unit_root_vars @var{VARIABLE_NAME}@dots{};
+@deffn Command plot_shock_decomposition [@var{VARIABLE_NAME}]@dots{};
+@deffnx Command plot_shock_decomposition (@var{OPTIONS}@dots{}) [@var{VARIABLE_NAME}]@dots{};
+@anchor{plot_shock_decomposition}
+
+@descriptionhead
+
+This command plots the historical shock decomposition already computed by
+@code{shock_decomposition} or @code{realtime_shock_decomposition}. For that reason,
+it must come after one of these commands. The @code{variable_names} provided govern which
+variables the decomposition is plotted for.
+
+Further note that, unlike the majority of Dynare commands, the options
+specified below are overwritten with their defaults before every call to
+@code{plot_shock_decomposition}. Hence, if you want to reuse an option in a
+subsequent call to @code{plot_shock_decomposition}, you must pass it to the
+command again.
+
+@optionshead
+
+@table @code
+
+@item use_shock_groups [= @var{STRING}]
+@xref{use_shock_groups}.
+
+@item colormap = @var{STRING}
+@xref{colormap}.
+
+@item nodisplay
+@xref{nodisplay}.
+
+@item graph_format = @var{FORMAT}
+@itemx graph_format = ( @var{FORMAT}, @var{FORMAT}@dots{} )
+@xref{graph_format}.
+
+@item detail_plot
+Plots shock contributions using subplots, one per shock (or group of
+shocks). Default: not activated
+
+@item interactive
+Under MATLAB, add uimenus for detailed group plots. Default: not activated
+
+@item screen_shocks
+@anchor{screen_shcoks} For large models (@i{i.e.} for models with more than @math{16}
+shocks), plots only the shocks that have the largest historical contribution
+for chosen selected @code{variable_names}.  Historical contribution is ranked
+by the mean absolute value of all historical contributions.
+
+@item steadystate
+@anchor{steadystate} If passed, the the @math{y}-axis value of the zero line in
+the shock decomposition plot is translated to the steady state level. Default:
+not activated
+
+@item type = @code{qoq} | @code{yoy} | @code{aoa}
+@anchor{type} For quarterly data, valid arguments are: @code{qoq} for
+quarter-on-quarter plots, @code{yoy} for year-on-year plots of growth rates,
+@code{aoa} for annualized variables, @i{i.e.} the value in the last quarter for
+each year is plotted.  Default value: @code{empty}, @i{i.e.} standard
+period-on-period plots (@code{qoq} for quarterly data).
+
+@item fig_name = @var{STRING}
+@anchor{fig_name} Specifies a user-defined keyword to be appended to the
+default figure name set by @code{plot_shock_decomposition}.  This can avoid to
+overwrite plots in case of sequential calls to @code{plot_shock_decomposition}.
+
+@item write_xls 
+@anchor{write_xls} Saves shock decompositions to Excel-file in the main directory, named 
+@code{FILENAME_shock_decomposition_TYPE_FIG_NAME.xls}. This option requires your system to be
+configured to be able to write Excel files.@footnote{In case of Excel not being installed, 
+@url{https://mathworks.com/matlabcentral/fileexchange/38591-xlwrite--generate-xls-x--files-without-excel-on-mac-linux-win} may be helpful.}
+
+@item realtime = @var{INTEGER}
+@anchor{realtime} Which kind of shock decomposition to plot. @var{INTEGER} can take following values:
+@itemize @bullet
+@item
+@code{0}: standard historical shock decomposition. @xref{shock_decomposition}.
+@item
+@code{1}: realtime historical shock decomposition. @xref{realtime_shock_decomposition}.
+@item
+@code{2}: conditional realtime shock decomposition. @xref{realtime_shock_decomposition}.
+@item
+@code{3}: realtime forecast shock decomposition. @xref{realtime_shock_decomposition}.
+@end itemize
+If no @ref{vintage} is requested, @i{i.e.} @code{vintage=0} then the pooled objects from @ref{realtime_shock_decomposition}
+will be plotted and the respective vintage otherwise.
+Default: @math{0}
+
+@item vintage = @var{INTEGER}
+@anchor{vintage} Selects a particular data vintage in @math{[presample,@dots{},nobs]} for which to plot the results from
+@ref{realtime_shock_decomposition} selected via the @ref{realtime} option. If the standard 
+historical shock decomposition is selected (@code{realtime=0}), @code{vintage} will have no effect. If @code{vintage=0}
+the pooled objects from @ref{realtime_shock_decomposition} will be plotted. If @code{vintage>0}, it plots the shock
+decompositions for vintage @math{T=@code{vintage}} under the following scenarios:
+@itemize @bullet
+@item
+@code{realtime=1}: the full vintage shock decomposition @math{Y(t|T)} for
+@math{t=[1,@dots{},T]}
+@item
+@code{realtime=2}: the conditional forecast shock decomposition from @math{T},
+@i{i.e.} plots @math{Y(T+j|T+j)} and the shock contributions needed to get to
+the data @math{Y(T+j)} conditional on @math{T=}@code{vintage}, with
+@math{j=[0,@dots{},@code{forecast}]}.
+@item
+@code{realtime=3}: plots unconditional forecast shock decomposition from
+@math{T}, @i{i.e.} @math{Y(T+j|T)}, where @math{T=@code{vintage}} and
+@math{j=[0,@dots{},@code{forecast}]}.
+@end itemize
+Default: @math{0}
+@end table
 
-This command is deprecated. Use @code{estimation} option @code{diffuse_filter} instead for estimating a model with non-stationary observed variables or @code{steady} option @code{nocheck} to prevent @code{steady} to check the steady state returned by your steady state file.
 @end deffn
 
-Dynare also has the ability to estimate Bayesian VARs:
-
-@deffn Command bvar_density ;
-Computes the marginal density of an estimated BVAR model, using
-Minnesota priors.
-
-See @file{bvar-a-la-sims.pdf}, which comes with Dynare distribution,
-for more information on this command.
-@end deffn
+@node Calibrated Smoother
+@section Calibrated Smoother
 
 Dynare can also run the smoother on a calibrated model:
 
@@ -7552,8 +7890,8 @@ is not specified, a value of 0 is assumed. That is, if you specify only
 values for periods 1 and 3, the values for period 2 will be 0. Currently, it is not 
 possible to have uncontrolled intermediate periods.
 In case of the presence of @code{observation_trends}, the specified controlled path for 
-these variables needs to include the trend component.
-
+these variables needs to include the trend component. When using the @ref{loglinear} option, 
+it is necessary to specify the logarithm of the controlled variables.
 
 @end deffn
 
@@ -7753,7 +8091,7 @@ where:
 
 @item
 @math{\gamma} are parameters to be optimized. They must be elements
-of the matrices @math{A_1}, @math{A_2}, @math{A_3}, i.e. be specified as
+of the matrices @math{A_1}, @math{A_2}, @math{A_3}, @i{i.e.} be specified as
 parameters in the @code{params}-command and be entered in the
 @code{model}-block;
 
@@ -7775,7 +8113,7 @@ parameters to minimize the weighted (co)-variance of a specified subset
 of endogenous variables, subject to a linear law of motion implied by the
 first order conditions of the model. A few things are worth mentioning.
 First, @math{y} denotes the selected endogenous variables' deviations
-from their steady state, i.e. in case they are not already mean 0 the
+from their steady state, @i{i.e.} in case they are not already mean 0 the
 variables entering the loss function are automatically demeaned so that
 the centered second moments are minimized. Second, @code{osr} only solves
 linear quadratic problems of the type resulting from combining the
@@ -7812,7 +8150,7 @@ by listing them after the command, as @code{stoch_simul}
 Specifies the optimizer for minimizing the objective function. The same solvers as for @code{mode_compute} (@pxref{mode_compute}) are available, except for 5,6, and 10. 
 
 @item optim = (@var{NAME}, @var{VALUE}, ...)
-A list of @var{NAME} and @var{VALUE} pairs. Can be used to set options for the optimization routines. The set of available options depends on the selected optimization routine (i.e. on the value of option @ref{opt_algo}). @xref{optim}.
+A list of @var{NAME} and @var{VALUE} pairs. Can be used to set options for the optimization routines. The set of available options depends on the selected optimization routine (@i{i.e.} on the value of option @ref{opt_algo}). @xref{optim}.
 
 @item maxit = @var{INTEGER} 
 Determines the maximum number of iterations used in @code{opt_algo=4}.  This option is now deprecated and will be 
@@ -7924,7 +8262,7 @@ Each line has the following syntax:
 PARAMETER_NAME, LOWER_BOUND, UPPER_BOUND;
 @end example
 
-Note that the use of this block requires the use of a constrained optimizer, i.e. setting @ref{opt_algo} to 
+Note that the use of this block requires the use of a constrained optimizer, @i{i.e.} setting @ref{opt_algo} to 
 1,2,5, or 9.
 
 @examplehead
@@ -8069,7 +8407,7 @@ maximizes the policy maker's objective function subject to the
 constraints provided by the equilibrium path of the private economy and under 
 commitment to this optimal policy. The Ramsey policy is computed
 by approximating the equilibrium system around the perturbation point where the 
-Lagrange multipliers are at their steady state, i.e. where the Ramsey planner acts 
+Lagrange multipliers are at their steady state, @i{i.e.} where the Ramsey planner acts 
 as if the initial multipliers had 
 been set to 0 in the distant past, giving them time to converge to their steady 
 state value. Consequently, the optimal decision rules are computed around this steady state 
@@ -8132,7 +8470,7 @@ multipliers associated with the planner's problem are set to their steady state
 values (@pxref{ramsey_policy}).
 
 In contrast, the second entry stores the value of the planner objective with 
-initial Lagrange multipliers of the planner's problem set to 0, i.e. it is assumed 
+initial Lagrange multipliers of the planner's problem set to 0, @i{i.e.} it is assumed 
 that the planner exploits its ability to surprise private agents in the first
 period of implementing Ramsey policy. This is the value of implementating
 optimal policy for the first time and committing not to re-optimize in the future.
@@ -8251,7 +8589,7 @@ This command triggers sensitivity analysis on a DSGE model.
 @anchor{Sampling Options}
 @table @code
 
-@item nsam = @var{INTEGER}
+@item Nsam = @var{INTEGER}
 Size of the Monte-Carlo sample. Default: @code{2048}
 
 @item ilptau = @var{INTEGER}
@@ -8308,11 +8646,7 @@ If equal to @code{0}, generate a new sample. Default: @code{0}
 @item alpha2_stab = @var{DOUBLE}
 Critical value for correlations @math{\rho} in filtered samples:
 plot couples of parmaters with @math{\left|\rho\right|>} @code{alpha2_stab}.
-Default: @code{0.3}
-
-@item ksstat = @var{DOUBLE}
-Critical value for Smirnov statistics @math{d}: plot parameters with
-@math{d>} @code{ksstat}. Default: @code{0.1}
+Default: @code{0}
 
 @item pvalue_ks = @var{DOUBLE}
 The threshold @math{pvalue} for significant Kolmogorov-Smirnov test (@i{i.e.} plot parameters with
@@ -8345,7 +8679,7 @@ An empty vector indicates that these entries will not be filtered. Default: @cod
 
 @item ksstat_redform = @var{DOUBLE}
 Critical value for Smirnov statistics @math{d} when reduced form entries
-are filtered. Default: @code{0.1}
+are filtered. Default: @code{0.001}
 
 @item alpha2_redform = @var{DOUBLE}
 Critical value for correlations @math{\rho}  when reduced form entries
@@ -8392,7 +8726,7 @@ error). Default: @code{presample+1}
 
 @item alpha_rmse = @var{DOUBLE}
 Critical value for Smirnov statistics @math{d}: plot parameters with
-@math{d>} @code{alpha_rmse}. Default: @code{0.002}
+@math{d>} @code{alpha_rmse}. Default: @code{0.001}
 
 @item alpha2_rmse = @var{DOUBLE}
 Critical value for correlation @math{\rho}: plot couples of parmaters with
@@ -8475,7 +8809,7 @@ Maximum number of lags for moments in identification analysis. Default: @code{1}
 
 The @code{irf_calibration} and @code{moment_calibration} blocks allow imposing implicit ``endogenous'' priors 
 about IRFs and moments on the model. The way it works internally is that 
-any parameter draw that is inconsistent with the ``calibration'' provided in these blocks is discarded, i.e. assigned a prior density of 0. 
+any parameter draw that is inconsistent with the ``calibration'' provided in these blocks is discarded, @i{i.e.} assigned a prior density of @math{0}. 
 In the context of @code{dynare_sensitivity}, these restrictions allow tracing out which parameters are driving the model to
 satisfy or violate the given restrictions.
 
@@ -10586,7 +10920,7 @@ related to the model (and hence not placed in the model file). At the
 moment, it is only used when using Dynare to run parallel
 computations.
 
-On Linux and Mac OS X, the default location of the configuration file
+On Linux and macOS, the default location of the configuration file
 is @file{$HOME/.dynare}, while on Windows it is
 @file{%APPDATA%\dynare.ini} (typically @file{C:\Documents and
 Settings\@var{USERNAME}\Application Data\dynare.ini} under Windows XP,
@@ -10847,7 +11181,7 @@ If just one integer is passed, the number of processors to use. If a
 range of integers is passed, the specific processors to use (processor
 counting is defined to begin at one as opposed to zero). Note that
 using specific processors is only possible under Windows; under Linux
-and Mac OS X, if a range is passed the same number of processors will
+and macOS, if a range is passed the same number of processors will
 be used but the range will be adjusted to begin at one.
 
 @item ComputerName = @var{COMPUTER_NAME}
@@ -10934,7 +11268,7 @@ This section outlines the steps necessary on most Windows systems to set up Dyna
 
 @enumerate
 @item Write a configuration file containing the options you want. A mimimum working 
-    example setting up a cluster consisting of two local CPU cores that allows for e.g. running
+    example setting up a cluster consisting of two local CPU cores that allows for @i{e.g.} running
     two Monte Carlo Markov Chains in parallel is shown below.
 @item Save the configuration file somwhere. The name and file ending do not matter 
     if you are providing it with the @code{conffile} command line option. The only restrictions are that the 
@@ -10942,8 +11276,8 @@ This section outlines the steps necessary on most Windows systems to set up Dyna
     For the configuration file to be accessible without providing an explicit path at the command line, you must save it 
     under the name @file{dynare.ini} into your user account's @code{Application Data} folder.
 @item Install the @file{PSTools} from @uref{https://technet.microsoft.com/sysinternals/pstools.aspx} 
-    to your system, e.g. into @file{C:\PSTools}.
-@item Set the Windows System Path to the @file{PSTools}-folder (e.g. using something along the line of pressing Windows Key+Pause to 
+    to your system, @i{e.g.} into @file{C:\PSTools}.
+@item Set the Windows System Path to the @file{PSTools}-folder (@i{e.g.} using something along the line of pressing Windows Key+Pause to 
     open the System Configuration, then go to Advanced -> Environment Variables -> Path, see also @uref{https://technet.microsoft.com/sysinternals/pstools.aspx}).
 @item Restart your computer to make the path change effective.
 @item Open Matlab and type into the command window 
@@ -11905,7 +12239,7 @@ plot(ts2.data,'--r');           % Plot of the filtered y.
 hold off
 axis tight
 id = get(gca,'XTick');
-set(gca,'XTickLabel',strings(ts.dates(id)));
+set(gca,'XTickLabel',strings(ts1.dates(id)));
 @end example
 
 @iftex
@@ -13269,7 +13603,7 @@ Instantiates a @code{Report} object.
 The full path to the @LaTeX{} compiler on your system. If this option
 is not provided, Dynare will try to find the appropriate program to
 compile @LaTeX{} on your system. Default is system dependent: Windows:
-the result of @code{findtexmf --file-type=exe pdflatex}, Mac OS X and
+the result of @code{findtexmf --file-type=exe pdflatex}, macOS and
 Linux: the result of @code{which pdflatex}
 
 @item showDate, @code{BOOLEAN}
@@ -13838,7 +14172,7 @@ Print the compiler output to the screen. Useful for debugging your code as the
 @ref{showOutput}
 
 @item showReport, @code{BOOLEAN}
-Open the compiled report (works on Windows and OS X on Matlab). Default:
+Open the compiled report (works on Windows and macOS on Matlab). Default:
 @code{true}
 
 @end table
@@ -14402,6 +14736,10 @@ Smets, Frank and Rafael Wouters (2003): ``An Estimated Dynamic
 Stochastic General Equilibrium Model of the Euro Area,'' @i{Journal of
 the European Economic Association}, 1(5), 1123--1175
 
+@item
+Stock, James H. and Mark W. Watson (1999). ``Forecasting Inflation,'', @i{Journal of Monetary
+Economics}, 44(2), 293--335.
+
 @item
 Uhlig, Harald (2001): ``A Toolkit for Analysing Nonlinear Dynamic Stochastic Models Easily,''
 in @i{Computational Methods for the Study of Dynamic
diff --git a/dynare++/kord/journal.cweb b/dynare++/kord/journal.cweb
index b43b27bcc..3fb666bb7 100644
--- a/dynare++/kord/journal.cweb
+++ b/dynare++/kord/journal.cweb
@@ -101,7 +101,11 @@ void SystemResources::getRUS(double& load_avg, long int& pg_avail,
 	majflt = -1;
 #endif
 
-#if !defined(__MINGW32__) && !defined(__CYGWIN32__) && !defined(__CYGWIN__) && !defined(__MINGW64__) && !defined(__CYGWIN64__)
+
+#define MINGCYGTMP (!defined(__MINGW32__) && !defined(__CYGWIN32__) && !defined(__CYGWIN__))
+#define MINGCYG (MINGCYGTMP && !defined(__MINGW64__) && !defined(__CYGWIN64__))
+
+#if MINGCYG
 	getloadavg(&load_avg, 1);
 #else
 	load_avg = -1.0;
diff --git a/dynare++/parser/cc/atom_assignings.h b/dynare++/parser/cc/atom_assignings.h
index 2151f9bcc..14f11b2cb 100644
--- a/dynare++/parser/cc/atom_assignings.h
+++ b/dynare++/parser/cc/atom_assignings.h
@@ -12,114 +12,126 @@
 #include <vector>
 #include <map>
 
-namespace ogp {
+namespace ogp
+{
 
-	class AtomAsgnEvaluator;
+  class AtomAsgnEvaluator;
 
-	/** This class represents atom assignments used in parameters
-	 * settings and initval initialization. It maintains atoms of the
-	 * all expressions on the right hand side, the parsed formulas of
-	 * the right hand sides, and the information about the left hand
-	 * sides. See documentation to the order member below. */
-	class AtomAssignings {
-		friend class AtomAsgnEvaluator;
-	protected:
-		typedef std::map<const char*, int, ltstr> Tvarintmap;
-		/** All atoms which should be sufficient for formulas at the
-		 * right hand sides. The atoms should be filled with names
-		 * (preregistered). This is a responsibility of the caller. */
-		StaticAtoms& atoms;
-		/** The formulas of right hand sides. */
-		FormulaParser expr;
-		/** Name storage of the names from left hand sides. */
-		NameStorage left_names;
-		/** Information on left hand sides. This maps a name to the
-		 * index of its assigned expression in expr. More than one
-		 * name may reference to the same expression. */
-		Tvarintmap lname2expr;
-		/** Information on left hand sides. If order[i] >= 0, then it
-		 * says that i-th expression in expr is assigned to atom with
-		 * order[i] tree index. */
-		std::vector<int> order;
-	public:
-		/** Construct the object using the provided static atoms. */
-		AtomAssignings(StaticAtoms& a) : atoms(a), expr(atoms)
-			{}
-		/** Make a copy with provided reference to (posibly different)
-		 * static atoms. */
-		AtomAssignings(const AtomAssignings& aa, StaticAtoms& a);
-		virtual ~AtomAssignings()
-			{}
-		/** Parse the assignments from the given string. */
-		void parse(int length, const char* stream);
-		/** Process a syntax error from bison. */
-		void error(const char* mes);
-		/** Add an assignment of the given name to the given
-		 * double. Can be called by a user, anytime. */
-		void add_assignment_to_double(const char* name, double val);
-		/** Add an assignment. Called from assign.y. */
-		void add_assignment(int asgn_off, const char* str, int name_len,
-							int right_off, int right_len);
-		/** This applies old2new map (possibly from atom
-		 * substitutions) to this object. It registers new variables
-		 * in the atoms, and adds the expressions to expr, and left
-		 * names to lname2expr. The information about dynamical part
-		 * of substitutions is ignored, since we are now in the static
-		 * world. */
-		void apply_subst(const AtomSubstitutions::Toldnamemap& mm);
-		/** Debug print. */
-		void print() const;
-	};
+  /** This class represents atom assignments used in parameters
+   * settings and initval initialization. It maintains atoms of the
+   * all expressions on the right hand side, the parsed formulas of
+   * the right hand sides, and the information about the left hand
+   * sides. See documentation to the order member below. */
+  class AtomAssignings
+  {
+    friend class AtomAsgnEvaluator;
+  protected:
+    typedef std::map<const char *, int, ltstr> Tvarintmap;
+    /** All atoms which should be sufficient for formulas at the
+     * right hand sides. The atoms should be filled with names
+     * (preregistered). This is a responsibility of the caller. */
+    StaticAtoms &atoms;
+    /** The formulas of right hand sides. */
+    FormulaParser expr;
+    /** Name storage of the names from left hand sides. */
+    NameStorage left_names;
+    /** Information on left hand sides. This maps a name to the
+     * index of its assigned expression in expr. More than one
+     * name may reference to the same expression. */
+    Tvarintmap lname2expr;
+    /** Information on left hand sides. If order[i] >= 0, then it
+     * says that i-th expression in expr is assigned to atom with
+     * order[i] tree index. */
+    std::vector<int> order;
+  public:
+    /** Construct the object using the provided static atoms. */
+    AtomAssignings(StaticAtoms &a) : atoms(a), expr(atoms)
+    {
+    }
+    /** Make a copy with provided reference to (posibly different)
+     * static atoms. */
+    AtomAssignings(const AtomAssignings &aa, StaticAtoms &a);
+    virtual ~AtomAssignings()
+    {
+    }
+    /** Parse the assignments from the given string. */
+    void parse(int length, const char *stream);
+    /** Process a syntax error from bison. */
+    void error(const char *mes);
+    /** Add an assignment of the given name to the given
+     * double. Can be called by a user, anytime. */
+    void add_assignment_to_double(const char *name, double val);
+    /** Add an assignment. Called from assign.y. */
+    void add_assignment(int asgn_off, const char *str, int name_len,
+                        int right_off, int right_len);
+    /** This applies old2new map (possibly from atom
+     * substitutions) to this object. It registers new variables
+     * in the atoms, and adds the expressions to expr, and left
+     * names to lname2expr. The information about dynamical part
+     * of substitutions is ignored, since we are now in the static
+     * world. */
+    void apply_subst(const AtomSubstitutions::Toldnamemap &mm);
+    /** Debug print. */
+    void print() const;
+  };
 
-	/** This class basically evaluates the atom assignments
-	 * AtomAssignings, so it inherits from ogp::FormulaEvaluator. It
-	 * is also a storage for the results of the evaluation stored as a
-	 * vector, so the class inherits from std::vector<double> and
-	 * ogp::FormulaEvalLoader. As the expressions for atoms are
-	 * evaluated, the results are values for atoms which will be
-	 * used in subsequent evaluations. For this reason, the class
-	 * inherits also from AtomValues. */
-	class AtomAsgnEvaluator : public FormulaEvalLoader,
-							  public AtomValues,
-							  protected FormulaEvaluator,
-							  public std::vector<double> {
-	protected:
-		typedef std::map<int, double> Tusrvalmap;
-		Tusrvalmap user_values;
-		const AtomAssignings& aa;
-	public:
-		AtomAsgnEvaluator(const AtomAssignings& a)
-			: FormulaEvaluator(a.expr),
-			  std::vector<double>(a.expr.nformulas()), aa(a) {}
-		virtual ~AtomAsgnEvaluator() {}
-		/** This sets all initial values to NaNs, all constants and
-		 * all values set by user by call set_value. This is called by
-		 * FormulaEvaluator::eval() method, which is called by eval()
-		 * method passing this argument as AtomValues. So the
-		 * ogp::EvalTree will be always this->etree. */
-		void setValues(EvalTree& et) const;
-		/** User setting of the values. For example in initval,
-		 * parameters are known and should be set to their values. In
-		 * constrast endogenous variables are set initially to NaNs by
-		 * AtomValues::setValues. */
-		void set_user_value(const char* name, double val);
-		/** This sets the result of i-th expression in aa to res, and
-		 * also checks whether the i-th expression is an atom. If so,
-		 * it sets the value of the atom in ogp::EvalTree
-		 * this->etree. */
-		void load(int i, double res);
-		/** After the user values have been set, the assignments can
-		 * be evaluated. For this purpose we have eval() method. The
-		 * result is that this object as std::vector<double> will
-		 * contain the values. It is ordered given by formulas in
-		 * expr. */
-		void eval()
-			{FormulaEvaluator::eval(*this, *this);}
-		/** This returns a value for a given name. If the name is not
-		 * found among atoms, or there is no assignment for the atom,
-		 * NaN is returned. */
-		double get_value(const char* name) const;
-	};
+  /** This class basically evaluates the atom assignments
+   * AtomAssignings, so it inherits from ogp::FormulaEvaluator. It
+   * is also a storage for the results of the evaluation stored as a
+   * vector, so the class inherits from std::vector<double> and
+   * ogp::FormulaEvalLoader. As the expressions for atoms are
+   * evaluated, the results are values for atoms which will be
+   * used in subsequent evaluations. For this reason, the class
+   * inherits also from AtomValues. */
+  class AtomAsgnEvaluator : public FormulaEvalLoader,
+                            public AtomValues,
+                            protected FormulaEvaluator,
+                            public std::vector<double>
+  {
+  protected:
+    typedef std::map<int, double> Tusrvalmap;
+    Tusrvalmap user_values;
+    const AtomAssignings &aa;
+  public:
+    AtomAsgnEvaluator(const AtomAssignings &a)
+      : FormulaEvaluator(a.expr),
+        std::vector<double>(a.expr.nformulas()), aa(a)
+    {
+    }
+    virtual ~AtomAsgnEvaluator()
+    {
+    }
+    /** This sets all initial values to NaNs, all constants and
+     * all values set by user by call set_value. This is called by
+     * FormulaEvaluator::eval() method, which is called by eval()
+     * method passing this argument as AtomValues. So the
+     * ogp::EvalTree will be always this->etree. */
+    void setValues(EvalTree &et) const;
+    /** User setting of the values. For example in initval,
+     * parameters are known and should be set to their values. In
+     * constrast endogenous variables are set initially to NaNs by
+     * AtomValues::setValues. */
+    void set_user_value(const char *name, double val);
+    /** This sets the result of i-th expression in aa to res, and
+     * also checks whether the i-th expression is an atom. If so,
+     * it sets the value of the atom in ogp::EvalTree
+     * this->etree. */
+    void load(int i, double res);
+    /** After the user values have been set, the assignments can
+     * be evaluated. For this purpose we have eval() method. The
+     * result is that this object as std::vector<double> will
+     * contain the values. It is ordered given by formulas in
+     * expr. */
+    void
+    eval()
+    {
+      FormulaEvaluator::eval(*this, *this);
+    }
+    /** This returns a value for a given name. If the name is not
+     * found among atoms, or there is no assignment for the atom,
+     * NaN is returned. */
+    double get_value(const char *name) const;
+  };
 
 };
 
diff --git a/dynare++/parser/cc/atom_substitutions.h b/dynare++/parser/cc/atom_substitutions.h
index 82c99946b..a0e060960 100644
--- a/dynare++/parser/cc/atom_substitutions.h
+++ b/dynare++/parser/cc/atom_substitutions.h
@@ -9,148 +9,185 @@
 
 #include <string>
 
-namespace ogp {
+namespace ogp
+{
 
-	using std::string;
-	using std::map;
-	using std::pair;
+  using std::string;
+  using std::map;
+  using std::pair;
 
-	/** This class tracts an information about the performed
-	 * substitutions. In fact, there is only one number to keep track
-	 * about, this is a number of substitutions. */
-	struct SubstInfo {
-		int num_substs;
-		SubstInfo() : num_substs(0) {}
-	};
+  /** This class tracts an information about the performed
+   * substitutions. In fact, there is only one number to keep track
+   * about, this is a number of substitutions. */
+  struct SubstInfo
+  {
+    int num_substs;
+    SubstInfo() : num_substs(0)
+    {
+    }
+  };
 
-	/** This class tracks all atom substitutions during the job and
-	 * then builds structures when all substitutions are finished. */
-	class AtomSubstitutions {
-	public:
-		typedef pair<const char*, int> Tshiftname;
-		typedef map<const char*, Tshiftname, ltstr> Tshiftmap;
-		typedef set<Tshiftname> Tshiftnameset;
-		typedef map<const char*, Tshiftnameset, ltstr> Toldnamemap;
-	protected:
-		/** This maps a new name to a shifted old name. This is, one
-		 * entry looks as "a_m3 ==> a(-3)", saying that a variable
-		 * "a_m3" corresponds to a variable "a" lagged by 3. */
-		Tshiftmap new2old;
-		/** This is inverse to new2old, which is not unique. For old
-		 * name, say "a", it says what new names are derived with what
-		 * shifts from the "a". For example, it can map "a" to a two
-		 * element set {["a_m3", +3], ["a_p2", -2]}. This says that
-		 * leading "a_m3" by 3 one gets old "a" and lagging "a_p2" by
-		 * 2 one gets also old "a". */
-		Toldnamemap old2new;
-		/** This is a reference to old atoms with multiple leads and
-		 * lags. They are supposed to be used with parsing finished
-		 * being had called, so that the external ordering is
-		 * available. */
-		const FineAtoms& old_atoms;
-		/** This is a reference to new atoms. All name pointers point
-		 * to storage of these atoms. */
-		FineAtoms& new_atoms;
-		/** Substitutions information. */
-		SubstInfo info;
-	public:
-		/** Create the object with reference to the old and new
-		 * atoms. In the beginning, old atoms are supposed to be with
-		 * parsing_finished() called, and new atoms a simple copy of
-		 * old atoms. The new atoms will be an instance of SAtoms. All
-		 * substitution job is done by a substitution method of the
-		 * new atoms. */
-		AtomSubstitutions(const FineAtoms& oa, FineAtoms& na)
-			: old_atoms(oa), new_atoms(na) {}
-		/** Construct a copy of the object using a different instances
-		 * of old atoms and new atoms, which are supposed to be
-		 * semantically same as the atoms from as. */
-		AtomSubstitutions(const AtomSubstitutions& as, const FineAtoms& oa, FineAtoms& na);
-		virtual ~AtomSubstitutions() {}
-		/** This is called during the substitution job from the
-		 * substitution method of the new atoms. This says that the
-		 * new name, say "a_m3" is a substitution of old name "a"
-		 * shifted by -3. */
-		void add_substitution(const char* newname, const char* oldname, int tshift);
-		/** This is called when all substitutions are finished. This
-		 * forms the new external ordering of the new atoms and calls
-		 * parsing_finished() for the new atoms with the given ordering type. */
-		void substitutions_finished(VarOrdering::ord_type ot);
-		/** Returns a new name for old name and given tshift. For "a"
-		 * and tshift=-3, it returns "a_m3". If there is no such
-		 * substitution, it returns NULL. */
-		const char* get_new4old(const char* oldname, int tshift) const;
-		/** Return new2old. */
-		const Tshiftmap& get_new2old() const
-			{return new2old;}
-		/** Return old2new. */
-		const Toldnamemap& get_old2new() const
-			{return old2new;}
-		/** Return substitution info. */
-		const SubstInfo& get_info() const
-			{return info;}
-		/** Return old atoms. */
-		const FineAtoms& get_old_atoms() const
-			{return old_atoms;}
-		/** Return new atoms. */
-		const FineAtoms& get_new_atoms() const
-			{return new_atoms;}
-		/** Debug print. */
-		void print() const;
-	};
+  /** This class tracks all atom substitutions during the job and
+   * then builds structures when all substitutions are finished. */
+  class AtomSubstitutions
+  {
+  public:
+    typedef pair<const char *, int> Tshiftname;
+    typedef map<const char *, Tshiftname, ltstr> Tshiftmap;
+    typedef set<Tshiftname> Tshiftnameset;
+    typedef map<const char *, Tshiftnameset, ltstr> Toldnamemap;
+  protected:
+    /** This maps a new name to a shifted old name. This is, one
+     * entry looks as "a_m3 ==> a(-3)", saying that a variable
+     * "a_m3" corresponds to a variable "a" lagged by 3. */
+    Tshiftmap new2old;
+    /** This is inverse to new2old, which is not unique. For old
+     * name, say "a", it says what new names are derived with what
+     * shifts from the "a". For example, it can map "a" to a two
+     * element set {["a_m3", +3], ["a_p2", -2]}. This says that
+     * leading "a_m3" by 3 one gets old "a" and lagging "a_p2" by
+     * 2 one gets also old "a". */
+    Toldnamemap old2new;
+    /** This is a reference to old atoms with multiple leads and
+     * lags. They are supposed to be used with parsing finished
+     * being had called, so that the external ordering is
+     * available. */
+    const FineAtoms &old_atoms;
+    /** This is a reference to new atoms. All name pointers point
+     * to storage of these atoms. */
+    FineAtoms &new_atoms;
+    /** Substitutions information. */
+    SubstInfo info;
+  public:
+    /** Create the object with reference to the old and new
+     * atoms. In the beginning, old atoms are supposed to be with
+     * parsing_finished() called, and new atoms a simple copy of
+     * old atoms. The new atoms will be an instance of SAtoms. All
+     * substitution job is done by a substitution method of the
+     * new atoms. */
+    AtomSubstitutions(const FineAtoms &oa, FineAtoms &na)
+      : old_atoms(oa), new_atoms(na)
+    {
+    }
+    /** Construct a copy of the object using a different instances
+     * of old atoms and new atoms, which are supposed to be
+     * semantically same as the atoms from as. */
+    AtomSubstitutions(const AtomSubstitutions &as, const FineAtoms &oa, FineAtoms &na);
+    virtual ~AtomSubstitutions()
+    {
+    }
+    /** This is called during the substitution job from the
+     * substitution method of the new atoms. This says that the
+     * new name, say "a_m3" is a substitution of old name "a"
+     * shifted by -3. */
+    void add_substitution(const char *newname, const char *oldname, int tshift);
+    /** This is called when all substitutions are finished. This
+     * forms the new external ordering of the new atoms and calls
+     * parsing_finished() for the new atoms with the given ordering type. */
+    void substitutions_finished(VarOrdering::ord_type ot);
+    /** Returns a new name for old name and given tshift. For "a"
+     * and tshift=-3, it returns "a_m3". If there is no such
+     * substitution, it returns NULL. */
+    const char *get_new4old(const char *oldname, int tshift) const;
+    /** Return new2old. */
+    const Tshiftmap &
+    get_new2old() const
+    {
+      return new2old;
+    }
+    /** Return old2new. */
+    const Toldnamemap &
+    get_old2new() const
+    {
+      return old2new;
+    }
+    /** Return substitution info. */
+    const SubstInfo &
+    get_info() const
+    {
+      return info;
+    }
+    /** Return old atoms. */
+    const FineAtoms &
+    get_old_atoms() const
+    {
+      return old_atoms;
+    }
+    /** Return new atoms. */
+    const FineAtoms &
+    get_new_atoms() const
+    {
+      return new_atoms;
+    }
+    /** Debug print. */
+    void print() const;
+  };
 
-	class SAtoms : public FineAtoms {
-	public:
-		SAtoms()
-			: FineAtoms() {}
-		SAtoms(const SAtoms& sa)
-			: FineAtoms(sa) {}
-		virtual ~SAtoms() {}
-		/** This substitutes all lags and leads for all exogenous and
-		 * all lags and leads greater than 1 for all endogenous
-		 * variables. This is useful for perfect foresight problems
-		 * where we can do that. */
-		void substituteAllLagsAndLeads(FormulaParser& fp, AtomSubstitutions& as);
-		/** This substitutes all lags of all endo and exo and one step
-		 * leads of all exo variables. This is useful for stochastic
-		 * models where we cannot solve leads more than 1. */
-		void substituteAllLagsAndExo1Leads(FormulaParser& fp, AtomSubstitutions& as);
-	protected:
-		/** This finds an endogenous variable name which occurs between
-		 * ll1 and ll2 included. */
-		const char* findEndoWithLeadInInterval(int ll1, int ll2) const
-			{return findNameWithLeadInInterval(get_endovars(), ll1, ll2);}
-		/** This finds an exogenous variable name which occurs between
-		 * ll1 and ll2 included. */
-		const char* findExoWithLeadInInterval(int ll1, int ll2) const
-			{return findNameWithLeadInInterval(get_exovars(), ll1, ll2);}
+  class SAtoms : public FineAtoms
+  {
+  public:
+    SAtoms()
+      : FineAtoms()
+    {
+    }
+    SAtoms(const SAtoms &sa)
+      : FineAtoms(sa)
+    {
+    }
+    virtual ~SAtoms()
+    {
+    }
+    /** This substitutes all lags and leads for all exogenous and
+     * all lags and leads greater than 1 for all endogenous
+     * variables. This is useful for perfect foresight problems
+     * where we can do that. */
+    void substituteAllLagsAndLeads(FormulaParser &fp, AtomSubstitutions &as);
+    /** This substitutes all lags of all endo and exo and one step
+     * leads of all exo variables. This is useful for stochastic
+     * models where we cannot solve leads more than 1. */
+    void substituteAllLagsAndExo1Leads(FormulaParser &fp, AtomSubstitutions &as);
+  protected:
+    /** This finds an endogenous variable name which occurs between
+     * ll1 and ll2 included. */
+    const char *
+    findEndoWithLeadInInterval(int ll1, int ll2) const
+    {
+      return findNameWithLeadInInterval(get_endovars(), ll1, ll2);
+    }
+    /** This finds an exogenous variable name which occurs between
+     * ll1 and ll2 included. */
+    const char *
+    findExoWithLeadInInterval(int ll1, int ll2) const
+    {
+      return findNameWithLeadInInterval(get_exovars(), ll1, ll2);
+    }
 
-		/** This attempts to find a non registered name of the form
-		 * <str>_m<abs(ll)> or <str>_p<abs(ll)>. A letter 'p' is
-		 * chosen if ll is positive, 'm' if negative. If a name of
-		 * such form is already registered, one more character (either
-		 * 'p' or 'm') is added and the test is performed again. The
-		 * resulting name is returned in a string out. */ 
-		void attemptAuxName(const char* str, int ll, string& out) const;
+    /** This attempts to find a non registered name of the form
+     * <str>_m<abs(ll)> or <str>_p<abs(ll)>. A letter 'p' is
+     * chosen if ll is positive, 'm' if negative. If a name of
+     * such form is already registered, one more character (either
+     * 'p' or 'm') is added and the test is performed again. The
+     * resulting name is returned in a string out. */
+    void attemptAuxName(const char *str, int ll, string &out) const;
 
-		/** This makes auxiliary variables to eliminate all leads/lags
-		 * greater/less than or equal to start up to the limit_lead
-		 * for a variable with the given name. If the limit_lead is
-		 * greater/less than the maxlead/minlag of the variable, than
-		 * maxlead/minlag is used. This process is recorded in
-		 * AtomSubstitutions. The new auxiliary variables and their
-		 * atoms are created in this object. The auxiliary equations
-		 * are created in the given FormulaParser. The value of step
-		 * is allowed to be either -1 (lags) or +1 (leads). */
-		void makeAuxVariables(const char* name, int step, int start, int limit_lead,
-							  FormulaParser& fp, AtomSubstitutions& as);
-	private:
-		/** This is a worker routine for findEndoWithLeadInInterval
-		 * and findExoWithLeadInInterval. */
-		const char* findNameWithLeadInInterval(const vector<const char*>& names,
-											   int ll1, int ll2) const;
+    /** This makes auxiliary variables to eliminate all leads/lags
+     * greater/less than or equal to start up to the limit_lead
+     * for a variable with the given name. If the limit_lead is
+     * greater/less than the maxlead/minlag of the variable, than
+     * maxlead/minlag is used. This process is recorded in
+     * AtomSubstitutions. The new auxiliary variables and their
+     * atoms are created in this object. The auxiliary equations
+     * are created in the given FormulaParser. The value of step
+     * is allowed to be either -1 (lags) or +1 (leads). */
+    void makeAuxVariables(const char *name, int step, int start, int limit_lead,
+                          FormulaParser &fp, AtomSubstitutions &as);
+  private:
+    /** This is a worker routine for findEndoWithLeadInInterval
+     * and findExoWithLeadInInterval. */
+    const char *findNameWithLeadInInterval(const vector<const char *> &names,
+                                           int ll1, int ll2) const;
 
-	};
+  };
 
 };
 
diff --git a/dynare++/parser/cc/csv_parser.h b/dynare++/parser/cc/csv_parser.h
index 3edc52a4e..95b12354e 100644
--- a/dynare++/parser/cc/csv_parser.h
+++ b/dynare++/parser/cc/csv_parser.h
@@ -5,38 +5,58 @@
 #ifndef OGP_CSV_PARSER
 #define OGP_CSV_PARSER
 
-namespace ogp {
+namespace ogp
+{
 
-	class CSVParserPeer {
-	public:
-		virtual ~CSVParserPeer() {}
-		virtual void item(int irow, int icol, const char* str, int length) = 0;
-	};
+  class CSVParserPeer
+  {
+  public:
+    virtual ~CSVParserPeer()
+    {
+    }
+    virtual void item(int irow, int icol, const char *str, int length) = 0;
+  };
 
-	class CSVParser {
-	private:
-		CSVParserPeer& peer;
-		int row;
-		int col;
-		const char* parsed_string;
-	public:
-		CSVParser(CSVParserPeer& p)
-			: peer(p), row(0), col(0), parsed_string(0) {}
-		CSVParser(const CSVParser& csvp)
-			: peer(csvp.peer), row(csvp.row),
-			  col(csvp.col), parsed_string(csvp.parsed_string) {}
-		virtual ~CSVParser() {}
+  class CSVParser
+  {
+  private:
+    CSVParserPeer &peer;
+    int row;
+    int col;
+    const char *parsed_string;
+  public:
+    CSVParser(CSVParserPeer &p)
+      : peer(p), row(0), col(0), parsed_string(0)
+    {
+    }
+    CSVParser(const CSVParser &csvp)
+      : peer(csvp.peer), row(csvp.row),
+        col(csvp.col), parsed_string(csvp.parsed_string)
+    {
+    }
+    virtual ~CSVParser()
+    {
+    }
 
-		void csv_error(const char* mes);
-		void csv_parse(int length, const char* str);
+    void csv_error(const char *mes);
+    void csv_parse(int length, const char *str);
 
-		void nextrow()
-			{row++; col = 0;}
-		void nextcol()
-			{col++;}
-		void item(int off, int length)
-			{peer.item(row, col, parsed_string+off, length);}
-	};
+    void
+    nextrow()
+    {
+      row++; col = 0;
+    }
+    void
+    nextcol()
+    {
+      col++;
+    }
+    void
+    item(int off, int length)
+    {
+      peer.item(row, col, parsed_string+off, length);
+    }
+  };
 };
 
 #endif
diff --git a/dynare++/parser/cc/dynamic_atoms.h b/dynare++/parser/cc/dynamic_atoms.h
index 7d44d6dcc..cf28da2ef 100644
--- a/dynare++/parser/cc/dynamic_atoms.h
+++ b/dynare++/parser/cc/dynamic_atoms.h
@@ -13,389 +13,462 @@
 #include <string>
 #include <cstring>
 
-namespace ogp {
-	using std::vector;
-	using std::map;
-	using std::set;
-	using std::string;
+namespace ogp
+{
+  using std::vector;
+  using std::map;
+  using std::set;
+  using std::string;
 
-	struct ltstr {
-		bool operator()(const char* a1, const char* a2) const
-			{ return strcmp(a1, a2) < 0; }
-	};
+  struct ltstr
+  {
+    bool
+    operator()(const char *a1, const char *a2) const
+    {
+      return strcmp(a1, a2) < 0;
+    }
+  };
 
-	/** Class storing names. We will keep names of variables in
-	 * various places, and all these pointers will point to one
-	 * storage, which will be responsible for allocation and
-	 * deallocation. The main function of the class is to allocate
-	 * space for names, and return a pointer of the stored name if
-	 * required. */
-	class NameStorage {
-	protected:
-		/** Vector of names allocated, this is the storage. */
-		vector<char*> name_store;
-		/** Map useful to quickly decide if the name is already
-		 * allocated or not. */
-		set<const char*, ltstr> name_set;
-	public:
-		NameStorage() {}
-		NameStorage(const NameStorage& stor);
-		virtual ~NameStorage();
-		/** Query for the name. If the name has been stored, it
-		 * returns its address, otherwise 0. */
-		const char* query(const char* name) const;
-		/** Insert the name if it has not been inserted yet, and
-		 * return its new or old allocation. */
-		const char* insert(const char* name);
-		int num() const
-			{return (int)name_store.size();}
-		const char* get_name(int i) const
-			{return name_store[i];}
-		/** Debug print. */
-		void print() const;
-	};
+  /** Class storing names. We will keep names of variables in
+   * various places, and all these pointers will point to one
+   * storage, which will be responsible for allocation and
+   * deallocation. The main function of the class is to allocate
+   * space for names, and return a pointer of the stored name if
+   * required. */
+  class NameStorage
+  {
+  protected:
+    /** Vector of names allocated, this is the storage. */
+    vector<char *> name_store;
+    /** Map useful to quickly decide if the name is already
+     * allocated or not. */
+    set<const char *, ltstr> name_set;
+  public:
+    NameStorage()
+    {
+    }
+    NameStorage(const NameStorage &stor);
+    virtual
+    ~NameStorage();
+    /** Query for the name. If the name has been stored, it
+     * returns its address, otherwise 0. */
+    const char *query(const char *name) const;
+    /** Insert the name if it has not been inserted yet, and
+     * return its new or old allocation. */
+    const char *insert(const char *name);
+    int
+    num() const
+    {
+      return (int) name_store.size();
+    }
+    const char *
+    get_name(int i) const
+    {
+      return name_store[i];
+    }
+    /** Debug print. */
+    void print() const;
+  };
 
-	class Constants : public AtomValues {
-	public:
-		/** Type for a map mapping tree indices to double values. */
-		typedef map<int,double> Tconstantmap;
-		typedef map<int,int> Tintintmap;
-	protected:
-		/** Map mapping a tree index of a constant to its double value. */ 
-		Tconstantmap cmap;
-	public:
-		Constants() {}
-		/** Copy constructor. */
-		Constants(const Constants& c)
-			: cmap(c.cmap), cinvmap(c.cinvmap) {}
-		/** Copy constructor registering the constants in the given
-		 * tree. The mapping from old tree indices to new ones is
-		 * traced in tmap. */
-		Constants(const Constants& c, OperationTree& otree, Tintintmap& tmap)
-			{import_constants(c, otree, tmap);}
-		/** Import constants registering their tree indices in the
-		 * given tree. The mapping form old tree indices to new ones
-		 * is traced in tmap. */
-		void import_constants(const Constants& c, OperationTree& otree, Tintintmap& tmap);
-		/** Implements AtomValues interface. This sets the values to
-		 * the evaluation tree EvalTree. */
-		void setValues(EvalTree& et) const;
-		/** This adds a constant with the given tree index. The
-		 * constant must be checked previously and asserted that it
-		 * does not exist. */
-		void add_constant(int t, double val);
-		/** Returns true if the tree index is either an hardwired
-		 * constant (initial number OperationTree:num_constants in
-		 * OperationTree) or the tree index is a registered constant
-		 * by add_constant method. */
-		bool is_constant(int t) const;
-		double get_constant_value(int t) const;
-		/** Return -1 if the given string representation of a constant
-		 * is not among the constants (double represenations). If it
-		 * is, its tree index is returned. */ 
-		int check(const char* str) const;
-		/** Debug print. */
-		void print() const;
-		const Tconstantmap& get_constantmap() const
-			{return cmap;}
-	private:
-		/** Inverse map to Tconstantmap. */
-		typedef map<double,int> Tconstantinvmap;
-		/** This is an inverse map to cmap. This is only used for fast
-		 * queries for the existing double constants in check
-		 * method and add_constant. */
-		Tconstantinvmap cinvmap;
-	};
+  class Constants : public AtomValues
+  {
+  public:
+    /** Type for a map mapping tree indices to double values. */
+    typedef map<int, double> Tconstantmap;
+    typedef map<int, int> Tintintmap;
+  protected:
+    /** Map mapping a tree index of a constant to its double value. */
+    Tconstantmap cmap;
+  public:
+    Constants()
+    {
+    }
+    /** Copy constructor. */
+    Constants(const Constants &c)
+      : cmap(c.cmap), cinvmap(c.cinvmap)
+    {
+    }
+    /** Copy constructor registering the constants in the given
+     * tree. The mapping from old tree indices to new ones is
+     * traced in tmap. */
+    Constants(const Constants &c, OperationTree &otree, Tintintmap &tmap)
+    {
+      import_constants(c, otree, tmap);
+    }
+    /** Import constants registering their tree indices in the
+     * given tree. The mapping form old tree indices to new ones
+     * is traced in tmap. */
+    void import_constants(const Constants &c, OperationTree &otree, Tintintmap &tmap);
+    /** Implements AtomValues interface. This sets the values to
+     * the evaluation tree EvalTree. */
+    void setValues(EvalTree &et) const;
+    /** This adds a constant with the given tree index. The
+     * constant must be checked previously and asserted that it
+     * does not exist. */
+    void add_constant(int t, double val);
+    /** Returns true if the tree index is either an hardwired
+     * constant (initial number OperationTree:num_constants in
+     * OperationTree) or the tree index is a registered constant
+     * by add_constant method. */
+    bool is_constant(int t) const;
+    double get_constant_value(int t) const;
+    /** Return -1 if the given string representation of a constant
+     * is not among the constants (double represenations). If it
+     * is, its tree index is returned. */
+    int check(const char *str) const;
+    /** Debug print. */
+    void print() const;
+    const Tconstantmap &
+    get_constantmap() const
+    {
+      return cmap;
+    }
+  private:
+    /** Inverse map to Tconstantmap. */
+    typedef map<double, int> Tconstantinvmap;
+    /** This is an inverse map to cmap. This is only used for fast
+     * queries for the existing double constants in check
+     * method and add_constant. */
+    Tconstantinvmap cinvmap;
+  };
 
-    /** This class is a parent to Atoms classes which distinguish between
-	 * constants (numerical literals), and variables with lags and
-	 * leads. This abstraction does not distinguish between a parameter
-	 * and a variable without lag or lead. In this sense, everything is a
-	 * variable.*/
-	class DynamicAtoms : public Atoms, public Constants {
-	public:
-		/** Definition of a type mapping lags to the indices of the variables. */
-		typedef map<int,int> Tlagmap;
-	protected:
-		/** Definition of a type mapping names of the atoms to Tlagmap. */
-		typedef map<const char*, Tlagmap, ltstr> Tvarmap;
-		/** Definition of a type mapping indices of variables to the variable names. */
-		typedef map<int, const char*> Tindexmap;
-		/** This is just a storage for variable names, since all other
-		 * instances of a variable name just point to the memory
-		 * allocated by this object. */
-		NameStorage varnames;
-		/** This is the map for variables. Each variable name is
-		 * mapped to the Tlagmap, which maps lags/leads to the nulary
-		 * term indices in the tree. */
-		Tvarmap vars;
-		/** This is almost inverse map to the vars. It maps variable
-		 * indices to the names. A returned name can be in turn used
-		 * as a key in vars. */
-		Tindexmap indices;
+  /** This class is a parent to Atoms classes which distinguish between
+   * constants (numerical literals), and variables with lags and
+   * leads. This abstraction does not distinguish between a parameter
+   * and a variable without lag or lead. In this sense, everything is a
+   * variable.*/
+  class DynamicAtoms : public Atoms, public Constants
+  {
+  public:
+    /** Definition of a type mapping lags to the indices of the variables. */
+    typedef map<int, int> Tlagmap;
+  protected:
+    /** Definition of a type mapping names of the atoms to Tlagmap. */
+    typedef map<const char *, Tlagmap, ltstr> Tvarmap;
+    /** Definition of a type mapping indices of variables to the variable names. */
+    typedef map<int, const char *> Tindexmap;
+    /** This is just a storage for variable names, since all other
+     * instances of a variable name just point to the memory
+     * allocated by this object. */
+    NameStorage varnames;
+    /** This is the map for variables. Each variable name is
+     * mapped to the Tlagmap, which maps lags/leads to the nulary
+     * term indices in the tree. */
+    Tvarmap vars;
+    /** This is almost inverse map to the vars. It maps variable
+     * indices to the names. A returned name can be in turn used
+     * as a key in vars. */
+    Tindexmap indices;
 
-		/** Number of variables. */
-		int nv;
-		/** Minimum lag, if there is at least one lag, than this is a negative number. */
-		int minlag;
-		/** Maximum lead, if there is at least one lead, than this is a positive number. */
-		int maxlead;
-	public:
-		/** Construct empty DynamicAtoms. */
-		DynamicAtoms();
-		DynamicAtoms(const DynamicAtoms& da);
-		virtual ~DynamicAtoms() {}
-		/** Check the nulary term identified by its string
-		 * representation. The nulary term can be either a constant or
-		 * a variable. If constant, -1 is returned so that it could be
-		 * assigned regardless if the same constant has already
-		 * appeared or not. If variable, then -1 is returned only if
-		 * the variable has not been assigned an index, otherwise the
-		 * assigned index is returned. */ 
-		int check(const char* name) const;
-		/** Assign the nulary term identified by its string
-		 * representation. This method should be called when check()
-		 * returns -1. */
-		void assign(const char* name, int t);
-		/** Return a number of all variables. */
-		int nvar() const
-			{ return nv; }
-		/** Return the vector of variable indices. */
-		vector<int> variables() const;
-		/** Return max lead and min lag for a variable given by the
-		 * index. If a variable cannot be found, the method retursn
-		 * the smallest integer as maxlead and the largest integer as
-		 * minlag. */
-		void varspan(int t, int& mlead, int& mlag) const;
-		/** Return max lead and min lag for a variable given by the
-		 * name (without lead, lag). The same is valid if the variable
-		 * name cannot be found. */
-		void varspan(const char* name, int& mlead, int& mlag) const;
-		/** Return max lead and min lag for a vector of variables given by the names. */
-		void varspan(const vector<const char*>& names, int& mlead, int& mlag) const;
-		/** Return true for all tree indices corresponding to a
-		 * variable in the sense of this class. (This is parameters,
-		 * exo and endo). Since the semantics of 'variable' will be
-		 * changed in subclasses, we use name 'named atom'. These are
-		 * all atoms but constants. */
-		bool is_named_atom(int t) const;
-		/** Return index of the variable described by the variable
-		 * name and lag/lead. If it doesn't exist, return -1. */
-		int index(const char* name, int ll) const;
-		/** Return true if a variable is referenced, i.e. it has lag
-		 * map. */
-		bool is_referenced(const char* name) const;
-		/** Return the lag map for the variable name. */
-		const Tlagmap& lagmap(const char* name) const;
-		/** Return the variable name for the tree index. It throws an
-		 * exception if the tree index t is not a named atom. */
-		const char* name(int t) const;
-		/** Return the lead/lag for the tree index. It throws an
-		 * exception if the tree index t is not a named atom. */
-		int lead(int t) const;
-		/** Return maximum lead. */
-		int get_maxlead() const
-			{return maxlead;}
-		/** Return minimum lag. */
-		int get_minlag() const
-			{return minlag;}
-		/** Return the name storage to allow querying to other
-		 * classes. */
-		const NameStorage& get_name_storage() const
-			{return varnames;}
-		/** Assign the variable with a given lead. The varname must be
-		 * from the varnames storage. The method checks if the
-		 * variable iwht the given lead/lag is not assigned. If so, an
-		 * exception is thrown. */
-		void assign_variable(const char* varname, int ll, int t);
-		/** Unassign the variable with a given lead and given tree
-		 * index. The tree index is only provided as a check. An
-		 * exception is thrown if the name, ll, and the tree index t
-		 * are not consistent. The method also updates nv, indices,
-		 * maxlead and minlag. The varname must be from the varnames
-		 * storage. */
-		void unassign_variable(const char* varname, int ll, int t);
-		/** Debug print. */
-		void print() const;
-	protected:
-		/** Do the check for the variable. A subclass may need to
-		 * reimplement this so that it could raise an error if the
-		 * variable is not among a given list. */
-		virtual int check_variable(const char* name) const;
-		/** Assign the constant. */
-		void assign_constant(const char* name, int t);
-		/** Assign the variable. */
-		void assign_variable(const char* name, int t);
-		/** The method just updates minlag or/and maxlead. Note that
-		 * when assigning variables, the update is done when inserting
-		 * to the maps, however, if removing a variable, we need to
-		 * call this method. */
-		void update_minmaxll();
-		/** The method parses the string to recover a variable name
-		 * and lag/lead ll. The variable name doesn't contain a lead/lag. */
-		virtual void parse_variable(const char* in, string& out, int& ll) const = 0;
-	public:
-		/** Return true if the str represents a double.*/ 
-		static bool is_string_constant(const char* str);
-	};
+    /** Number of variables. */
+    int nv;
+    /** Minimum lag, if there is at least one lag, than this is a negative number. */
+    int minlag;
+    /** Maximum lead, if there is at least one lead, than this is a positive number. */
+    int maxlead;
+  public:
+    /** Construct empty DynamicAtoms. */
+    DynamicAtoms();
+    DynamicAtoms(const DynamicAtoms &da);
+    virtual ~DynamicAtoms()
+    {
+    }
+    /** Check the nulary term identified by its string
+     * representation. The nulary term can be either a constant or
+     * a variable. If constant, -1 is returned so that it could be
+     * assigned regardless if the same constant has already
+     * appeared or not. If variable, then -1 is returned only if
+     * the variable has not been assigned an index, otherwise the
+     * assigned index is returned. */
+    int check(const char *name) const;
+    /** Assign the nulary term identified by its string
+     * representation. This method should be called when check()
+     * returns -1. */
+    void assign(const char *name, int t);
+    /** Return a number of all variables. */
+    int
+    nvar() const
+    {
+      return nv;
+    }
+    /** Return the vector of variable indices. */
+    vector<int> variables() const;
+    /** Return max lead and min lag for a variable given by the
+     * index. If a variable cannot be found, the method retursn
+     * the smallest integer as maxlead and the largest integer as
+     * minlag. */
+    void varspan(int t, int &mlead, int &mlag) const;
+    /** Return max lead and min lag for a variable given by the
+     * name (without lead, lag). The same is valid if the variable
+     * name cannot be found. */
+    void varspan(const char *name, int &mlead, int &mlag) const;
+    /** Return max lead and min lag for a vector of variables given by the names. */
+    void varspan(const vector<const char *> &names, int &mlead, int &mlag) const;
+    /** Return true for all tree indices corresponding to a
+     * variable in the sense of this class. (This is parameters,
+     * exo and endo). Since the semantics of 'variable' will be
+     * changed in subclasses, we use name 'named atom'. These are
+     * all atoms but constants. */
+    bool is_named_atom(int t) const;
+    /** Return index of the variable described by the variable
+     * name and lag/lead. If it doesn't exist, return -1. */
+    int index(const char *name, int ll) const;
+    /** Return true if a variable is referenced, i.e. it has lag
+     * map. */
+    bool is_referenced(const char *name) const;
+    /** Return the lag map for the variable name. */
+    const Tlagmap&lagmap(const char *name) const;
+    /** Return the variable name for the tree index. It throws an
+     * exception if the tree index t is not a named atom. */
+    const char *name(int t) const;
+    /** Return the lead/lag for the tree index. It throws an
+     * exception if the tree index t is not a named atom. */
+    int lead(int t) const;
+    /** Return maximum lead. */
+    int
+    get_maxlead() const
+    {
+      return maxlead;
+    }
+    /** Return minimum lag. */
+    int
+    get_minlag() const
+    {
+      return minlag;
+    }
+    /** Return the name storage to allow querying to other
+     * classes. */
+    const NameStorage &
+    get_name_storage() const
+    {
+      return varnames;
+    }
+    /** Assign the variable with a given lead. The varname must be
+     * from the varnames storage. The method checks if the
+     * variable iwht the given lead/lag is not assigned. If so, an
+     * exception is thrown. */
+    void assign_variable(const char *varname, int ll, int t);
+    /** Unassign the variable with a given lead and given tree
+     * index. The tree index is only provided as a check. An
+     * exception is thrown if the name, ll, and the tree index t
+     * are not consistent. The method also updates nv, indices,
+     * maxlead and minlag. The varname must be from the varnames
+     * storage. */
+    void unassign_variable(const char *varname, int ll, int t);
+    /** Debug print. */
+    void print() const;
+  protected:
+    /** Do the check for the variable. A subclass may need to
+     * reimplement this so that it could raise an error if the
+     * variable is not among a given list. */
+    virtual int check_variable(const char *name) const;
+    /** Assign the constant. */
+    void assign_constant(const char *name, int t);
+    /** Assign the variable. */
+    void assign_variable(const char *name, int t);
+    /** The method just updates minlag or/and maxlead. Note that
+     * when assigning variables, the update is done when inserting
+     * to the maps, however, if removing a variable, we need to
+     * call this method. */
+    void update_minmaxll();
+    /** The method parses the string to recover a variable name
+     * and lag/lead ll. The variable name doesn't contain a lead/lag. */
+    virtual void parse_variable(const char *in, string &out, int &ll) const = 0;
+  public:
+    /** Return true if the str represents a double.*/
+    static bool is_string_constant(const char *str);
+  };
 
-
-	/** This class is a parent of all orderings of the dynamic atoms
-	 * of variables which can appear before t, at t, or after t. It
-	 * encapsulates the ordering, and the information about the number
-	 * of static (appearing only at time t) predetermined (appearing
-	 * before t and possibly at t), both (appearing before t and after
-	 * t and possibly at t) and forward looking (appearing after t and
-	 * possibly at t).
-	 *
-	 * The constructor takes a list of variable names. The class also
-	 * provides mapping from the ordering of the variables in the list
-	 * (outer) to the new ordering (at time t) and back.
-	 *
-	 * The user of the subclass must call do_ordering() after
-	 * initialization.
-	 *
-	 * The class contains a few preimplemented methods for
-	 * ordering. The class is used in this way: Make a subclass, and
-	 * implement pure virtual do_ordering() by just plugging a
-	 * preimplemented method, or plugging your own implementation. The
-	 * method do_ordering() is called by the user after the constructor.
-	 */
-	class VarOrdering {
-	protected:
-		/** Number of static variables. */
-		int n_stat;
-		/** Number of predetermined variables. */
-		int n_pred;
-		/** Number of both variables. */
-		int n_both;
-		/** Number of forward looking variables. */
-		int n_forw;
-		/** This is a set of tree indices corresponding to the
-		 * variables at all times as they occur in the formulas. In
-		 * fact, since this is used only for derivatives, the ordering
-		 * of this vector is only important for ordering of the
-		 * derivatives, in other contexts the ordering is not
-		 * important, so it is rather a set of indices.*/
-		vector<int> der_atoms;
-		/** This maps tree index of the variable to the position in
-		 * the row of the ordering. One should be careful with making
-		 * space in the positions for variables not appearing at time
-		 * t. For instance in the pred(t-1), both(t-1), stat(t),
-		 * pred(t), both(t), forw(t), both(t+1), forw(t+1) ordering,
-		 * the variables x(t-1), y(t-1), x(t+1), z(t-1), z(t), and
-		 * z(t+1) having tree indices 6,5,4,3,2,1 will be ordered as
-		 * follows: y(t-1), x(t-1), z(t-1), [y(t)], [x(t)], z(t),
-		 * x(t+1), where a bracketed expresion means non-existent by
-		 * occupying a space. The map thus will look as follows:
-		 * {5->0, 6->1, 3->2, 2->5, 3->6}. Note that nothing is mapped
-		 * to positions 3 and 4. */ 
-		map<int,int> positions;
-		/** This maps an ordering of the list of variables in
-		 * constructor to the new ordering (at time t). The length is
-		 * the number of variables. */
-		vector<int> outer2y;
-		/** This maps a new ordering to the ordering of the list of
-		 * variables in constructor (at time t). The length is the
-		 * number of variables. */
-		vector<int> y2outer;
-		/** This is just a reference for variable names to keep it
-		 * from constructor to do_ordering() implementations. */
-		const vector<const char*>& varnames;
-		/** This is just a reference to atoms to keep it from
-		 * constructor to do_ordering() implementations. */
-		const DynamicAtoms& atoms;
-	public:
-		/** This is an enum type for an ordering type implemented by
-		 * do_general. */
-		enum ord_type {pbspbfbf, bfspbfpb};
-		/** Construct the ordering of the variables given by the names
-		 * with their dynamic occurrences defined by the atoms. It
-		 * calls the virtual method do_ordering which can be
-		 * reimplemented. */
-		VarOrdering(const vector<const char*>& vnames, const DynamicAtoms& a)
-			: n_stat(0), n_pred(0), n_both(0), n_forw(0), varnames(vnames), atoms(a)
-			{}
-		VarOrdering(const VarOrdering& vo, const vector<const char*>& vnames,
-					const DynamicAtoms& a);
-		virtual VarOrdering* clone(const vector<const char*>& vnames,
-								   const DynamicAtoms& a) const = 0;
-		/** Destructor does nothing here. */
-		virtual ~VarOrdering() {}
-		/** This is the method setting the ordering and the map. A
-		 * subclass must reimplement it, possibly using a
-		 * preimplemented ordering. This method must be called by the
-		 * user after the class has been created. */
-		virtual void do_ordering() = 0;
-		/** Return number of static. */
-		int nstat() const
-			{return n_stat;}
-		/** Return number of predetermined. */
-		int npred() const
-			{return n_pred;}
-		/** Return number of both. */
-		int nboth() const
-			{return n_both;}
-		/** Return number of forward looking. */
-		int nforw() const
-			{return n_forw;}
-		/** Return the set of tree indices for derivatives. */
-		const vector<int>& get_der_atoms() const
-			{return der_atoms;}
-		/** Return the y2outer. */
-		const vector<int>& get_y2outer() const
-			{return y2outer;}
-		/** Return the outer2y. */
-		const vector<int>& get_outer2y() const
-			{return outer2y;}
-		/** Query the atom given by the tree index. True is returned
-		 * if the atom is one of the variables in the object. */
-		bool check(int t) const;
-		/** Return the position of the atom (nulary term) given by a
-		 * tree index. It is a lookup to the map. If the atom cannot
-		 * be found, the exception is raised. */
-		int get_pos_of(int t) const;
-		/** This returns a length of ordered row of atoms. In all
-		 * cases so far, it does not depend on the ordering and it is
-		 * as follows. */
-		int length() const
-			{return n_stat+2*n_pred+3*n_both+2*n_forw;}
-		/** Debug print. */
-		void print() const;
-	protected:
-		/** This is a general ordering method which orders the
-		 * variables by the given ordering ord_type. See documentation
-		 * for respective do_ methods. */
-		void do_general(ord_type ordering);
-		/** This is a preimplemented ordering for do_ordering()
-		 * method. It assumes that the variables appear only at time
-		 * t-1, t, t+1. It orders the atoms as pred(t-1), both(t-1),
-		 * stat(t), pred(t), both(t), forw(t), both(t+1),
-		 * forw(t+1). It builds the der_atoms, the map of positions,
-		 * as well as y2outer and outer2y. */
-		void do_pbspbfbf()
-			{do_general(pbspbfbf);}
-		/** This is a preimplemented ordering for do_ordering()
-		 * method. It assumes that the variables appear only at time
-		 * t-1, t, t+1. It orders the atoms as both(t+1), forw(t+1),
-		 * stat(t), pred(t), both(t), forw(t), pred(t-1),
-		 * both(t-1). It builds the der_atoms, the map of positions,
-		 * as well as y2outer and outer2y. */
-		void do_bfspbfpb()
-			{do_general(bfspbfpb);}
-		/** This is a preimplemented ordering for do_ordering()
-		 * method. It makes no assumptions about occurences of
-		 * variables at different times. It orders the atoms with
-		 * increasing time keeping the given ordering within one
-		 * time. This implies that y2outer and outer2y will be
-		 * identities. The der_atoms will be just a sequence of atoms
-		 * from the least to the most time preserving the order of atoms
-		 * within one time. */
-		void do_increasing_time();
-	private:
-		/** Declare this copy constructor as private to hide it. */
-		VarOrdering(const VarOrdering& vo);
-	};
+  /** This class is a parent of all orderings of the dynamic atoms
+   * of variables which can appear before t, at t, or after t. It
+   * encapsulates the ordering, and the information about the number
+   * of static (appearing only at time t) predetermined (appearing
+   * before t and possibly at t), both (appearing before t and after
+   * t and possibly at t) and forward looking (appearing after t and
+   * possibly at t).
+   *
+   * The constructor takes a list of variable names. The class also
+   * provides mapping from the ordering of the variables in the list
+   * (outer) to the new ordering (at time t) and back.
+   *
+   * The user of the subclass must call do_ordering() after
+   * initialization.
+   *
+   * The class contains a few preimplemented methods for
+   * ordering. The class is used in this way: Make a subclass, and
+   * implement pure virtual do_ordering() by just plugging a
+   * preimplemented method, or plugging your own implementation. The
+   * method do_ordering() is called by the user after the constructor.
+   */
+  class VarOrdering
+  {
+  protected:
+    /** Number of static variables. */
+    int n_stat;
+    /** Number of predetermined variables. */
+    int n_pred;
+    /** Number of both variables. */
+    int n_both;
+    /** Number of forward looking variables. */
+    int n_forw;
+    /** This is a set of tree indices corresponding to the
+     * variables at all times as they occur in the formulas. In
+     * fact, since this is used only for derivatives, the ordering
+     * of this vector is only important for ordering of the
+     * derivatives, in other contexts the ordering is not
+     * important, so it is rather a set of indices.*/
+    vector<int> der_atoms;
+    /** This maps tree index of the variable to the position in
+     * the row of the ordering. One should be careful with making
+     * space in the positions for variables not appearing at time
+     * t. For instance in the pred(t-1), both(t-1), stat(t),
+     * pred(t), both(t), forw(t), both(t+1), forw(t+1) ordering,
+     * the variables x(t-1), y(t-1), x(t+1), z(t-1), z(t), and
+     * z(t+1) having tree indices 6,5,4,3,2,1 will be ordered as
+     * follows: y(t-1), x(t-1), z(t-1), [y(t)], [x(t)], z(t),
+     * x(t+1), where a bracketed expresion means non-existent by
+     * occupying a space. The map thus will look as follows:
+     * {5->0, 6->1, 3->2, 2->5, 3->6}. Note that nothing is mapped
+     * to positions 3 and 4. */
+    map<int, int> positions;
+    /** This maps an ordering of the list of variables in
+     * constructor to the new ordering (at time t). The length is
+     * the number of variables. */
+    vector<int> outer2y;
+    /** This maps a new ordering to the ordering of the list of
+     * variables in constructor (at time t). The length is the
+     * number of variables. */
+    vector<int> y2outer;
+    /** This is just a reference for variable names to keep it
+     * from constructor to do_ordering() implementations. */
+    const vector<const char *> &varnames;
+    /** This is just a reference to atoms to keep it from
+     * constructor to do_ordering() implementations. */
+    const DynamicAtoms &atoms;
+  public:
+    /** This is an enum type for an ordering type implemented by
+     * do_general. */
+    enum ord_type {pbspbfbf, bfspbfpb};
+    /** Construct the ordering of the variables given by the names
+     * with their dynamic occurrences defined by the atoms. It
+     * calls the virtual method do_ordering which can be
+     * reimplemented. */
+    VarOrdering(const vector<const char *> &vnames, const DynamicAtoms &a)
+      : n_stat(0), n_pred(0), n_both(0), n_forw(0), varnames(vnames), atoms(a)
+    {
+    }
+    VarOrdering(const VarOrdering &vo, const vector<const char *> &vnames,
+                const DynamicAtoms &a);
+    virtual VarOrdering *clone(const vector<const char *> &vnames,
+                               const DynamicAtoms &a) const = 0;
+    /** Destructor does nothing here. */
+    virtual ~VarOrdering()
+    {
+    }
+    /** This is the method setting the ordering and the map. A
+     * subclass must reimplement it, possibly using a
+     * preimplemented ordering. This method must be called by the
+     * user after the class has been created. */
+    virtual void do_ordering() = 0;
+    /** Return number of static. */
+    int
+    nstat() const
+    {
+      return n_stat;
+    }
+    /** Return number of predetermined. */
+    int
+    npred() const
+    {
+      return n_pred;
+    }
+    /** Return number of both. */
+    int
+    nboth() const
+    {
+      return n_both;
+    }
+    /** Return number of forward looking. */
+    int
+    nforw() const
+    {
+      return n_forw;
+    }
+    /** Return the set of tree indices for derivatives. */
+    const vector<int> &
+    get_der_atoms() const
+    {
+      return der_atoms;
+    }
+    /** Return the y2outer. */
+    const vector<int> &
+    get_y2outer() const
+    {
+      return y2outer;
+    }
+    /** Return the outer2y. */
+    const vector<int> &
+    get_outer2y() const
+    {
+      return outer2y;
+    }
+    /** Query the atom given by the tree index. True is returned
+     * if the atom is one of the variables in the object. */
+    bool check(int t) const;
+    /** Return the position of the atom (nulary term) given by a
+     * tree index. It is a lookup to the map. If the atom cannot
+     * be found, the exception is raised. */
+    int get_pos_of(int t) const;
+    /** This returns a length of ordered row of atoms. In all
+     * cases so far, it does not depend on the ordering and it is
+     * as follows. */
+    int
+    length() const
+    {
+      return n_stat+2*n_pred+3*n_both+2*n_forw;
+    }
+    /** Debug print. */
+    void print() const;
+  protected:
+    /** This is a general ordering method which orders the
+     * variables by the given ordering ord_type. See documentation
+     * for respective do_ methods. */
+    void do_general(ord_type ordering);
+    /** This is a preimplemented ordering for do_ordering()
+     * method. It assumes that the variables appear only at time
+     * t-1, t, t+1. It orders the atoms as pred(t-1), both(t-1),
+     * stat(t), pred(t), both(t), forw(t), both(t+1),
+     * forw(t+1). It builds the der_atoms, the map of positions,
+     * as well as y2outer and outer2y. */
+    void
+    do_pbspbfbf()
+    {
+      do_general(pbspbfbf);
+    }
+    /** This is a preimplemented ordering for do_ordering()
+     * method. It assumes that the variables appear only at time
+     * t-1, t, t+1. It orders the atoms as both(t+1), forw(t+1),
+     * stat(t), pred(t), both(t), forw(t), pred(t-1),
+     * both(t-1). It builds the der_atoms, the map of positions,
+     * as well as y2outer and outer2y. */
+    void
+    do_bfspbfpb()
+    {
+      do_general(bfspbfpb);
+    }
+    /** This is a preimplemented ordering for do_ordering()
+     * method. It makes no assumptions about occurences of
+     * variables at different times. It orders the atoms with
+     * increasing time keeping the given ordering within one
+     * time. This implies that y2outer and outer2y will be
+     * identities. The der_atoms will be just a sequence of atoms
+     * from the least to the most time preserving the order of atoms
+     * within one time. */
+    void do_increasing_time();
+  private:
+    /** Declare this copy constructor as private to hide it. */
+    VarOrdering(const VarOrdering &vo);
+  };
 
 };
 
diff --git a/dynare++/parser/cc/fine_atoms.h b/dynare++/parser/cc/fine_atoms.h
index 7cc825608..27e5a3841 100644
--- a/dynare++/parser/cc/fine_atoms.h
+++ b/dynare++/parser/cc/fine_atoms.h
@@ -10,337 +10,417 @@
 #include <vector>
 #include <string>
 
-namespace ogp {
+namespace ogp
+{
 
-	using std::vector;
-	using std::string;
+  using std::vector;
+  using std::string;
 
-	/** This is just ordering used for endogenous variables. It
-	 * assumes that we have only time t-1, t, and t+1, orders them as
-	 * pred(t-1), both(t-1), stat(t), pred(t), both(t), forw(t),
-	 * both(t+1), forw(t+1). */
-	class EndoVarOrdering1 : public VarOrdering {
-	public:
-		EndoVarOrdering1(const vector<const char*>& vnames, const DynamicAtoms& a)
-			: VarOrdering(vnames, a) {}
-		EndoVarOrdering1(const EndoVarOrdering1& vo, const vector<const char*>& vnames,
-						 const DynamicAtoms& a)
-			: VarOrdering(vo, vnames, a) {}
-		VarOrdering* clone(const vector<const char*>& vnames, const DynamicAtoms& a) const
-			{return new EndoVarOrdering1(*this, vnames, a);}
-		void do_ordering()
-			{do_pbspbfbf();}
-	};
+  /** This is just ordering used for endogenous variables. It
+   * assumes that we have only time t-1, t, and t+1, orders them as
+   * pred(t-1), both(t-1), stat(t), pred(t), both(t), forw(t),
+   * both(t+1), forw(t+1). */
+  class EndoVarOrdering1 : public VarOrdering
+  {
+  public:
+    EndoVarOrdering1(const vector<const char *> &vnames, const DynamicAtoms &a)
+      : VarOrdering(vnames, a)
+    {
+    }
+    EndoVarOrdering1(const EndoVarOrdering1 &vo, const vector<const char *> &vnames,
+                     const DynamicAtoms &a)
+      : VarOrdering(vo, vnames, a)
+    {
+    }
+    VarOrdering *
+    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const
+    {
+      return new EndoVarOrdering1(*this, vnames, a);
+    }
+    void
+    do_ordering()
+    {
+      do_pbspbfbf();
+    }
+  };
 
-	/** This is just another ordering used for endogenous
-	 * variables. It assumes that we have only time t-1, t, and t+1,
-	 * orders them as both(t+1), forw(t+1), pred(t-1), both(t-1),
-	 * stat(t), pred(t), both(t), forw(t). */
-	class EndoVarOrdering2 : public VarOrdering {
-	public:
-		EndoVarOrdering2(const vector<const char*>& vnames, const DynamicAtoms& a)
-			: VarOrdering(vnames, a) {}
-		EndoVarOrdering2(const EndoVarOrdering2& vo, const vector<const char*>& vnames,
-						 const DynamicAtoms& a)
-			: VarOrdering(vo, vnames, a) {}
-		VarOrdering* clone(const vector<const char*>& vnames, const DynamicAtoms& a) const
-			{return new EndoVarOrdering2(*this, vnames, a);}
-		void do_ordering()
-			{do_bfspbfpb();}
-	};
+  /** This is just another ordering used for endogenous
+   * variables. It assumes that we have only time t-1, t, and t+1,
+   * orders them as both(t+1), forw(t+1), pred(t-1), both(t-1),
+   * stat(t), pred(t), both(t), forw(t). */
+  class EndoVarOrdering2 : public VarOrdering
+  {
+  public:
+    EndoVarOrdering2(const vector<const char *> &vnames, const DynamicAtoms &a)
+      : VarOrdering(vnames, a)
+    {
+    }
+    EndoVarOrdering2(const EndoVarOrdering2 &vo, const vector<const char *> &vnames,
+                     const DynamicAtoms &a)
+      : VarOrdering(vo, vnames, a)
+    {
+    }
+    VarOrdering *
+    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const
+    {
+      return new EndoVarOrdering2(*this, vnames, a);
+    }
+    void
+    do_ordering()
+    {
+      do_bfspbfpb();
+    }
+  };
 
-	/** This is just ordering used for exogenous variables. It makes
-	 * no assumptions about their timing. It orders them from the
-	 * least time to the latest time. */
-	class ExoVarOrdering : public VarOrdering {
-	public:
-		ExoVarOrdering(const vector<const char*>& vnames, const DynamicAtoms& a)
-			: VarOrdering(vnames, a) {}
-		ExoVarOrdering(const ExoVarOrdering& vo, const vector<const char*>& vnames,
-					   const DynamicAtoms& a)
-			: VarOrdering(vo, vnames, a) {}
-		VarOrdering* clone(const vector<const char*>& vnames, const DynamicAtoms& a) const
-			{return new ExoVarOrdering(*this, vnames, a);}
-		void do_ordering()
-			{do_increasing_time();}
-	};
+  /** This is just ordering used for exogenous variables. It makes
+   * no assumptions about their timing. It orders them from the
+   * least time to the latest time. */
+  class ExoVarOrdering : public VarOrdering
+  {
+  public:
+    ExoVarOrdering(const vector<const char *> &vnames, const DynamicAtoms &a)
+      : VarOrdering(vnames, a)
+    {
+    }
+    ExoVarOrdering(const ExoVarOrdering &vo, const vector<const char *> &vnames,
+                   const DynamicAtoms &a)
+      : VarOrdering(vo, vnames, a)
+    {
+    }
+    VarOrdering *
+    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const
+    {
+      return new ExoVarOrdering(*this, vnames, a);
+    }
+    void
+    do_ordering()
+    {
+      do_increasing_time();
+    }
+  };
 
-	class FineAtoms;
+  class FineAtoms;
 
-	/** This class provides an outer ordering of all variables (endo
-	 * and exo). It maps the ordering to the particular outer
-	 * orderings of endo and exo. It works tightly with the FineAtoms
-	 * class. */
-	class AllvarOuterOrdering {
-	protected:
-		/** Type for a map mapping a variable name to an integer. */
-		typedef map<const char*, int, ltstr> Tvarintmap;
-		/** Reference to atoms. */
-		const FineAtoms& atoms;
-		/** The vector of all endo and exo variables in outer
-		 * ordering. The pointers point to storage in atoms. */
-		vector<const char*> allvar;
-		/** The mapping from outer endogenous to outer all. For
-		 * example endo2all[0] is the order of the first outer
-		 * endogenous variable in the allvar ordering. */
-		vector<int> endo2all;
-		/** The mapping from outer exogenous to outer all. For example
-		 * exo2all[0] is the order of the first outer exogenous
-		 * variables in the allvar ordering. */
-		vector<int> exo2all;
-	public:
-		/** Construct the allvar outer ordering from the provided
-		 * sequence of endo and exo names. The names can have an
-		 * arbitrary storage, the storage is transformed to the atoms
-		 * storage. An exception is thrown if either the list is not
-		 * exhaustive, or some string is not a variable. */
-		AllvarOuterOrdering(const vector<const char*>& allvar_outer, const FineAtoms& a);
-		/** Copy constructor using the storage of provided atoms. */
-		AllvarOuterOrdering(const AllvarOuterOrdering& allvar_outer, const FineAtoms& a);
-		/** Return endo2all mapping. */
-		const vector<int>& get_endo2all() const
-			{return endo2all;}
-		/** Return exo2all mapping. */
-		const vector<int>& get_exo2all() const
-			{return exo2all;}
-		/** Return the allvar ordering. */
-		const vector<const char*>& get_allvar() const
-			{return allvar;}
-	};
+  /** This class provides an outer ordering of all variables (endo
+   * and exo). It maps the ordering to the particular outer
+   * orderings of endo and exo. It works tightly with the FineAtoms
+   * class. */
+  class AllvarOuterOrdering
+  {
+  protected:
+    /** Type for a map mapping a variable name to an integer. */
+    typedef map<const char *, int, ltstr> Tvarintmap;
+    /** Reference to atoms. */
+    const FineAtoms &atoms;
+    /** The vector of all endo and exo variables in outer
+     * ordering. The pointers point to storage in atoms. */
+    vector<const char *> allvar;
+    /** The mapping from outer endogenous to outer all. For
+     * example endo2all[0] is the order of the first outer
+     * endogenous variable in the allvar ordering. */
+    vector<int> endo2all;
+    /** The mapping from outer exogenous to outer all. For example
+     * exo2all[0] is the order of the first outer exogenous
+     * variables in the allvar ordering. */
+    vector<int> exo2all;
+  public:
+    /** Construct the allvar outer ordering from the provided
+     * sequence of endo and exo names. The names can have an
+     * arbitrary storage, the storage is transformed to the atoms
+     * storage. An exception is thrown if either the list is not
+     * exhaustive, or some string is not a variable. */
+    AllvarOuterOrdering(const vector<const char *> &allvar_outer, const FineAtoms &a);
+    /** Copy constructor using the storage of provided atoms. */
+    AllvarOuterOrdering(const AllvarOuterOrdering &allvar_outer, const FineAtoms &a);
+    /** Return endo2all mapping. */
+    const vector<int> &
+    get_endo2all() const
+    {
+      return endo2all;
+    }
+    /** Return exo2all mapping. */
+    const vector<int> &
+    get_exo2all() const
+    {
+      return exo2all;
+    }
+    /** Return the allvar ordering. */
+    const vector<const char *> &
+    get_allvar() const
+    {
+      return allvar;
+    }
+  };
 
-	/** This class refines the DynamicAtoms by distinguishing among
-	 * parameters (no lag and leads) and endogenous and exogenous
-	 * variables (with lags and leads). For parameters, endogenous and
-	 * exogenous, it defines outer orderings and internal
-	 * orderings. The internal orderings are created by
-	 * parsing_finished() method when it is sure that no new variables
-	 * would be registered. The outer orderings are given by the order
-	 * of calls of registering methods.
-     * 
-     * In addition, the class also defines outer ordering of
-     * endogenous and exogenous variables. This is input as a
-     * parameter to parsing_finished(). By default, this whole outer
-     * ordering is just a concatenation of outer ordering of
-     * endogenous and exogenous variables.
-	 *
-	 * The internal ordering of all endo and exo variables is just a
-	 * concatenation of endo and exo variables in their internal
-	 * orderings. This is the ordering with respect to which all
-	 * derivatives are taken. */
-	class FineAtoms : public DynamicAtoms {
-		friend class AllvarOuterOrdering;
-	protected:
-		typedef map<const char*, int, ltstr> Tvarintmap;
-	private:
-		/** The vector of parameters names. The order gives the order
-		 * the data is communicated with outside world. */
-		vector<const char*> params;
-		/** A map mapping a name of a parameter to an index in the outer
-		 * ordering. */
-		Tvarintmap param_outer_map;
-		/** The vector of endogenous variables. This defines the order
-		 * like parameters. */
-		vector<const char*> endovars;
-		/** A map mapping a name of an endogenous variable to an index
-		 * in the outer ordering. */
-		Tvarintmap endo_outer_map;
-		/** The vector of exogenous variables. Also defines the order
-		 * like parameters and endovars. */
-		vector<const char*> exovars;
-		/** A map mapping a name of an exogenous variable to an index
-		 * in the outer ordering. */
-		Tvarintmap exo_outer_map;
+  /** This class refines the DynamicAtoms by distinguishing among
+   * parameters (no lag and leads) and endogenous and exogenous
+   * variables (with lags and leads). For parameters, endogenous and
+   * exogenous, it defines outer orderings and internal
+   * orderings. The internal orderings are created by
+   * parsing_finished() method when it is sure that no new variables
+   * would be registered. The outer orderings are given by the order
+   * of calls of registering methods.
+   *
+   * In addition, the class also defines outer ordering of
+   * endogenous and exogenous variables. This is input as a
+   * parameter to parsing_finished(). By default, this whole outer
+   * ordering is just a concatenation of outer ordering of
+   * endogenous and exogenous variables.
+   *
+   * The internal ordering of all endo and exo variables is just a
+   * concatenation of endo and exo variables in their internal
+   * orderings. This is the ordering with respect to which all
+   * derivatives are taken. */
+  class FineAtoms : public DynamicAtoms
+  {
+    friend class AllvarOuterOrdering;
+  protected:
+    typedef map<const char *, int, ltstr> Tvarintmap;
+  private:
+    /** The vector of parameters names. The order gives the order
+     * the data is communicated with outside world. */
+    vector<const char *> params;
+    /** A map mapping a name of a parameter to an index in the outer
+     * ordering. */
+    Tvarintmap param_outer_map;
+    /** The vector of endogenous variables. This defines the order
+     * like parameters. */
+    vector<const char *> endovars;
+    /** A map mapping a name of an endogenous variable to an index
+     * in the outer ordering. */
+    Tvarintmap endo_outer_map;
+    /** The vector of exogenous variables. Also defines the order
+     * like parameters and endovars. */
+    vector<const char *> exovars;
+    /** A map mapping a name of an exogenous variable to an index
+     * in the outer ordering. */
+    Tvarintmap exo_outer_map;
 
-	protected:
-		/** This is the internal ordering of all atoms corresponding
-		 * to endogenous variables. It is constructed by
-		 * parsing_finished() method, which should be called after all
-		 * parsing jobs have been finished. */ 
-		VarOrdering* endo_order;
-		/** This is the internal ordering of all atoms corresponding
-		 * to exogenous variables. It has the same handling as
-		 * endo_order. */
-		VarOrdering* exo_order;
-		/** This is the all variables outer ordering. It is
-		 * constructed by parsing finished. */
-		AllvarOuterOrdering* allvar_order;
-		/** This vector defines a set of atoms as tree indices used
-		 * for differentiation. The order of the atoms in this vector
-		 * defines ordering of the derivative tensors. The ordering is
-		 * a concatenation of atoms from endo_order and then
-		 * exo_order. This vector is setup by parsing_finished() and
-		 * is returned by variables(). */
-		vector<int> der_atoms;
-		/** This is a mapping from endogenous atoms to all atoms in
-		 * der_atoms member. The mapping maps index in endogenous atom
-		 * ordering to index (not value) in der_atoms. It is useful if
-		 * one wants to evaluate derivatives wrt only endogenous
-		 * variables. It is set by parsing_finished(). By definition,
-		 * it is monotone. */
-		vector<int> endo_atoms_map;
-		/** This is a mapping from exogenous atoms to all atoms in
-		 * der_atoms member. It is the same as endo_atoms_map for
-		 * atoms of exogenous variables. */
-		vector<int> exo_atoms_map;
-	public:
-		FineAtoms()
-			: endo_order(NULL), exo_order(NULL), allvar_order(NULL) {}
-		FineAtoms(const FineAtoms& fa);
-		/** Deletes endo_order and exo_order. */
-		virtual ~FineAtoms()
-			{
-				if (endo_order) delete endo_order;
-				if (exo_order) delete exo_order;
-				if (allvar_order) delete allvar_order;
-			}
-		/** Overrides DynamicAtoms::check_variable so that the error
-		 * would be raised if the variable name is not declared. A
-		 * variable is declared by inserting it to
-		 * DynamicAtoms::varnames. This is a responsibility of a
-		 * subclass. */
-		int check_variable(const char* name) const;
-		/** This calculates min lag and max lead of endogenous variables. */
-		void endovarspan(int& mlead, int& mlag) const
-			{varspan(endovars, mlead, mlag);}
-		/** This calculates mim lag and max lead of exogenous variables. */
-		void exovarspan(int& mlead, int& mlag) const
-			{varspan(exovars, mlead, mlag);}
-		/** This calculates the number of periods in which at least
-		 * one exogenous variable occurs. */
-		int num_exo_periods() const;
-		/** Return an (external) ordering of parameters. */
-		const vector<const char*>& get_params() const
-			{return params;}
-		/** Return an external ordering of endogenous variables. */
-		const vector<const char*>& get_endovars() const
-			{return endovars;}
-		/** Return an external ordering of exogenous variables. */
-		const vector<const char*>& get_exovars() const
-			{return exovars;}
-		/** This constructs internal orderings and makes the indices
-		 * returned by variables method available. Further it
-		 * constructs outer ordering of all variables by a simple
-		 * concatenation of outer endogenous and outer exogenous. In
-		 * addition, it makes nstat, npred, nboth, nforw available. */
-		void parsing_finished(VarOrdering::ord_type ot);
-		/** This does the same thing as
-		 * parsing_finished(VarOrdering::ord_type) plus it allows for
-		 * inputing a different outer ordering of all variables. The
-		 * ordering is input as a list of strings, their storage can
-		 * be arbitrary. */
-		void parsing_finished(VarOrdering::ord_type ot, const vector<const char*> avo);
-		/** Return the external ordering of all variables (endo and
-		 * exo). This is either the second argument to
-		 * parsing_finished or the default external ordering. This
-		 * must be called only after parsing_finished. */
-		const vector<const char*>& get_allvar() const;
-		/** Return the map from outer ordering of endo variables to
-		 * the allvar ordering. This must be called only after
-		 * parsing_finished. */
-		const vector<int>& outer_endo2all() const;
-		/** Return the map from outer ordering of exo variables to
-		 * the allvar ordering. This must be called only after
-		 * parsing_finished. */
-		const vector<int>& outer_exo2all() const;
-		/** Return the atoms with respect to which we are going to
-		 * differentiate. This must be called after
-		 * parsing_finished. */
-		vector<int> variables() const;
-		/** Return the number of static. */
-		int nstat() const;
-		/** Return the number of predetermined. */
-		int npred() const;
-		/** Return the number of both. */
-		int nboth() const;
-		/** Return the number of forward looking. */
-		int nforw() const;
-		/** Return the index of an endogenous atom given by tree index in
-		 * the endo ordering. This must be also called only after
-		 * parsing_finished(). */
-		int get_pos_of_endo(int t) const;
-		/** Return the index of an exogenous atom given by tree index in
-		 * the exo ordering. This must be also called only after
-		 * parsing_finished(). */
-		int get_pos_of_exo(int t) const;
-		/** Return the index of either endogenous or exogenous atom
-		 * given by tree index in the concatenated ordering of
-		 * endogenous and exogenous atoms. This must be also called
-		 * only after parsing_finished(). */
-		int get_pos_of_all(int t) const;
-		/** Return the mapping from endogenous at time t to outer
-		 * ordering of endogenous. */
-		const vector<int>& y2outer_endo() const;
-		/** Return the mapping from the outer ordering of endogenous to endogenous
-		 * at time t. */
-		const vector<int>& outer2y_endo() const;
-		/** Return the mapping from exogenous at time t to outer
-		 * ordering of exogenous. */
-		const vector<int>& y2outer_exo() const;
-		/** Return the mapping from the outer ordering of exogenous to exogenous
-		 * at time t. */
-		const vector<int>& outer2y_exo() const;
-		/** Return the endo_atoms_map. */
-		const vector<int>& get_endo_atoms_map() const;
-		/** Return the exo_atoms_map. */
-		const vector<int>& get_exo_atoms_map() const;
-		/** Return an index in the outer ordering of a given
-		 * parameter. An exception is thrown if the name is not a
-		 * parameter. */
-		int name2outer_param(const char* name) const;
-		/** Return an index in the outer ordering of a given
-		 * endogenous variable. An exception is thrown if the name is not a
-		 * and endogenous variable. */
-		int name2outer_endo(const char* name) const;
-		/** Return an index in the outer ordering of a given
-		 * exogenous variable. An exception is thrown if the name is not a
-		 * and exogenous variable. */
-		int name2outer_exo(const char* name) const;
-		/** Return an index in the outer ordering of all variables
-		 * (endo and exo) for a given name. An exception is thrown if
-		 * the name is not a variable. This must be called only after
-		 * parsing_finished(). */
-		int name2outer_allvar(const char* name) const;
-		/** Return the number of endogenous variables at time t-1, these are state
-		 * variables. */
-		int nys() const
-			{return npred()+nboth();}
-		/** Return the number of endogenous variables at time t+1. */
-		int nyss() const
-			{return nboth()+nforw();}
-		/** Return the number of endogenous variables. */
-		int ny() const
-			{return endovars.size();}
-		/** Return the number of exogenous variables. */
-		int nexo() const
-			{return (int)exovars.size();}
-		/** Return the number of parameters. */
-		int np() const
-			{return (int)(params.size());}
-		/** Register unique endogenous variable name. The order of
-		 * calls defines the endo outer ordering. The method is
-		 * virtual, since a superclass may want to do some additional
-		 * action. */
-		virtual void register_uniq_endo(const char* name);
-		/** Register unique exogenous variable name. The order of
-		 * calls defines the exo outer ordering. The method is
-		 * virtual, since a superclass may want to do somem additional
-		 * action. */
-		virtual void register_uniq_exo(const char* name);
-		/** Register unique parameter name. The order of calls defines
-		 * the param outer ordering. The method is
-		 * virtual, since a superclass may want to do somem additional
-		 * action. */
-		virtual void register_uniq_param(const char* name);
-		/** Debug print. */
-		void print() const;
-	private:
-		/** This performs the common part of parsing_finished(), which
-		 * is a construction of internal orderings. */
-		void make_internal_orderings(VarOrdering::ord_type ot);
-	protected:
-		/** This remembers the ordering type of the last call make_internal_ordering. */
-		VarOrdering::ord_type order_type;
-	};
+  protected:
+    /** This is the internal ordering of all atoms corresponding
+     * to endogenous variables. It is constructed by
+     * parsing_finished() method, which should be called after all
+     * parsing jobs have been finished. */
+    VarOrdering *endo_order;
+    /** This is the internal ordering of all atoms corresponding
+     * to exogenous variables. It has the same handling as
+     * endo_order. */
+    VarOrdering *exo_order;
+    /** This is the all variables outer ordering. It is
+     * constructed by parsing finished. */
+    AllvarOuterOrdering *allvar_order;
+    /** This vector defines a set of atoms as tree indices used
+     * for differentiation. The order of the atoms in this vector
+     * defines ordering of the derivative tensors. The ordering is
+     * a concatenation of atoms from endo_order and then
+     * exo_order. This vector is setup by parsing_finished() and
+     * is returned by variables(). */
+    vector<int> der_atoms;
+    /** This is a mapping from endogenous atoms to all atoms in
+     * der_atoms member. The mapping maps index in endogenous atom
+     * ordering to index (not value) in der_atoms. It is useful if
+     * one wants to evaluate derivatives wrt only endogenous
+     * variables. It is set by parsing_finished(). By definition,
+     * it is monotone. */
+    vector<int> endo_atoms_map;
+    /** This is a mapping from exogenous atoms to all atoms in
+     * der_atoms member. It is the same as endo_atoms_map for
+     * atoms of exogenous variables. */
+    vector<int> exo_atoms_map;
+  public:
+    FineAtoms()
+      : endo_order(NULL), exo_order(NULL), allvar_order(NULL)
+    {
+    }
+    FineAtoms(const FineAtoms &fa);
+    /** Deletes endo_order and exo_order. */
+    virtual ~FineAtoms()
+    {
+      if (endo_order)
+        delete endo_order;
+      if (exo_order)
+        delete exo_order;
+      if (allvar_order)
+        delete allvar_order;
+    }
+    /** Overrides DynamicAtoms::check_variable so that the error
+     * would be raised if the variable name is not declared. A
+     * variable is declared by inserting it to
+     * DynamicAtoms::varnames. This is a responsibility of a
+     * subclass. */
+    int check_variable(const char *name) const;
+    /** This calculates min lag and max lead of endogenous variables. */
+    void
+    endovarspan(int &mlead, int &mlag) const
+    {
+      varspan(endovars, mlead, mlag);
+    }
+    /** This calculates mim lag and max lead of exogenous variables. */
+    void
+    exovarspan(int &mlead, int &mlag) const
+    {
+      varspan(exovars, mlead, mlag);
+    }
+    /** This calculates the number of periods in which at least
+     * one exogenous variable occurs. */
+    int num_exo_periods() const;
+    /** Return an (external) ordering of parameters. */
+    const vector<const char *> &
+    get_params() const
+    {
+      return params;
+    }
+    /** Return an external ordering of endogenous variables. */
+    const vector<const char *> &
+    get_endovars() const
+    {
+      return endovars;
+    }
+    /** Return an external ordering of exogenous variables. */
+    const vector<const char *> &
+    get_exovars() const
+    {
+      return exovars;
+    }
+    /** This constructs internal orderings and makes the indices
+     * returned by variables method available. Further it
+     * constructs outer ordering of all variables by a simple
+     * concatenation of outer endogenous and outer exogenous. In
+     * addition, it makes nstat, npred, nboth, nforw available. */
+    void parsing_finished(VarOrdering::ord_type ot);
+    /** This does the same thing as
+     * parsing_finished(VarOrdering::ord_type) plus it allows for
+     * inputing a different outer ordering of all variables. The
+     * ordering is input as a list of strings, their storage can
+     * be arbitrary. */
+    void parsing_finished(VarOrdering::ord_type ot, const vector<const char *> avo);
+    /** Return the external ordering of all variables (endo and
+     * exo). This is either the second argument to
+     * parsing_finished or the default external ordering. This
+     * must be called only after parsing_finished. */
+    const vector<const char *>&get_allvar() const;
+    /** Return the map from outer ordering of endo variables to
+     * the allvar ordering. This must be called only after
+     * parsing_finished. */
+    const vector<int>&outer_endo2all() const;
+    /** Return the map from outer ordering of exo variables to
+     * the allvar ordering. This must be called only after
+     * parsing_finished. */
+    const vector<int>&outer_exo2all() const;
+    /** Return the atoms with respect to which we are going to
+     * differentiate. This must be called after
+     * parsing_finished. */
+    vector<int> variables() const;
+    /** Return the number of static. */
+    int nstat() const;
+    /** Return the number of predetermined. */
+    int npred() const;
+    /** Return the number of both. */
+    int nboth() const;
+    /** Return the number of forward looking. */
+    int nforw() const;
+    /** Return the index of an endogenous atom given by tree index in
+     * the endo ordering. This must be also called only after
+     * parsing_finished(). */
+    int get_pos_of_endo(int t) const;
+    /** Return the index of an exogenous atom given by tree index in
+     * the exo ordering. This must be also called only after
+     * parsing_finished(). */
+    int get_pos_of_exo(int t) const;
+    /** Return the index of either endogenous or exogenous atom
+     * given by tree index in the concatenated ordering of
+     * endogenous and exogenous atoms. This must be also called
+     * only after parsing_finished(). */
+    int get_pos_of_all(int t) const;
+    /** Return the mapping from endogenous at time t to outer
+     * ordering of endogenous. */
+    const vector<int>&y2outer_endo() const;
+    /** Return the mapping from the outer ordering of endogenous to endogenous
+     * at time t. */
+    const vector<int>&outer2y_endo() const;
+    /** Return the mapping from exogenous at time t to outer
+     * ordering of exogenous. */
+    const vector<int>&y2outer_exo() const;
+    /** Return the mapping from the outer ordering of exogenous to exogenous
+     * at time t. */
+    const vector<int>&outer2y_exo() const;
+    /** Return the endo_atoms_map. */
+    const vector<int>&get_endo_atoms_map() const;
+    /** Return the exo_atoms_map. */
+    const vector<int>&get_exo_atoms_map() const;
+    /** Return an index in the outer ordering of a given
+     * parameter. An exception is thrown if the name is not a
+     * parameter. */
+    int name2outer_param(const char *name) const;
+    /** Return an index in the outer ordering of a given
+     * endogenous variable. An exception is thrown if the name is not a
+     * and endogenous variable. */
+    int name2outer_endo(const char *name) const;
+    /** Return an index in the outer ordering of a given
+     * exogenous variable. An exception is thrown if the name is not a
+     * and exogenous variable. */
+    int name2outer_exo(const char *name) const;
+    /** Return an index in the outer ordering of all variables
+     * (endo and exo) for a given name. An exception is thrown if
+     * the name is not a variable. This must be called only after
+     * parsing_finished(). */
+    int name2outer_allvar(const char *name) const;
+    /** Return the number of endogenous variables at time t-1, these are state
+     * variables. */
+    int
+    nys() const
+    {
+      return npred()+nboth();
+    }
+    /** Return the number of endogenous variables at time t+1. */
+    int
+    nyss() const
+    {
+      return nboth()+nforw();
+    }
+    /** Return the number of endogenous variables. */
+    int
+    ny() const
+    {
+      return endovars.size();
+    }
+    /** Return the number of exogenous variables. */
+    int
+    nexo() const
+    {
+      return (int) exovars.size();
+    }
+    /** Return the number of parameters. */
+    int
+    np() const
+    {
+      return (int) (params.size());
+    }
+    /** Register unique endogenous variable name. The order of
+     * calls defines the endo outer ordering. The method is
+     * virtual, since a superclass may want to do some additional
+     * action. */
+    virtual void register_uniq_endo(const char *name);
+    /** Register unique exogenous variable name. The order of
+     * calls defines the exo outer ordering. The method is
+     * virtual, since a superclass may want to do somem additional
+     * action. */
+    virtual void register_uniq_exo(const char *name);
+    /** Register unique parameter name. The order of calls defines
+     * the param outer ordering. The method is
+     * virtual, since a superclass may want to do somem additional
+     * action. */
+    virtual void register_uniq_param(const char *name);
+    /** Debug print. */
+    void print() const;
+  private:
+    /** This performs the common part of parsing_finished(), which
+     * is a construction of internal orderings. */
+    void make_internal_orderings(VarOrdering::ord_type ot);
+  protected:
+    /** This remembers the ordering type of the last call make_internal_ordering. */
+    VarOrdering::ord_type order_type;
+  };
 };
 
 #endif
diff --git a/dynare++/parser/cc/formula_parser.h b/dynare++/parser/cc/formula_parser.h
index 0f5c965c6..5cd4476e5 100644
--- a/dynare++/parser/cc/formula_parser.h
+++ b/dynare++/parser/cc/formula_parser.h
@@ -5,408 +5,492 @@
 
 #include "tree.h"
 
-namespace ogp {
-	using std::vector;
+namespace ogp
+{
+  using std::vector;
 
-	/** Pure virtual class defining a minimal interface for
-	 * representation of nulary terms within FormulaParser. */
-	class Atoms {
-	public:
-		Atoms() {}
-		virtual ~Atoms() {}
-		/** This returns previously assigned internal index to the
-		 * given atom, or returns -1 if the atom has not been assigned
-		 * yet. The method can raise an exception, if the Atoms
-		 * implementation is strict and the name is not among
-		 * prescribed possible values. */
-		virtual int check(const char* name) const = 0;
-		/** This method assigns an internal index to the nulary term
-		 * described by the name. The internal index is allocated by
-		 * OperationTree class. */
-		virtual void assign(const char* name, int t) = 0;
-		/** Returns a number of variables which will be used for
-		 * differentiations. */
-		virtual int nvar() const = 0;
-		/** Returns a vector of variable's internal indices which will
-		 * be used for differentiations. */
-		virtual vector<int> variables() const = 0;
-		/** Debug print. */
-		virtual void print() const = 0;
-	};
+  /** Pure virtual class defining a minimal interface for
+   * representation of nulary terms within FormulaParser. */
+  class Atoms
+  {
+  public:
+    Atoms()
+    {
+    }
+    virtual ~Atoms()
+    {
+    }
+    /** This returns previously assigned internal index to the
+     * given atom, or returns -1 if the atom has not been assigned
+     * yet. The method can raise an exception, if the Atoms
+     * implementation is strict and the name is not among
+     * prescribed possible values. */
+    virtual int check(const char *name) const = 0;
+    /** This method assigns an internal index to the nulary term
+     * described by the name. The internal index is allocated by
+     * OperationTree class. */
+    virtual void assign(const char *name, int t) = 0;
+    /** Returns a number of variables which will be used for
+     * differentiations. */
+    virtual int nvar() const = 0;
+    /** Returns a vector of variable's internal indices which will
+     * be used for differentiations. */
+    virtual vector<int> variables() const = 0;
+    /** Debug print. */
+    virtual void print() const = 0;
+  };
 
-	/** Pure virtual class defining interface for all classes able to
-	 * set nulary terms to evaluation tree EvalTree. The
-	 * implementations of this class will have to be connected with
-	 * Atoms to have knowledge about the atoms and their indices in
-	 * the tree, and will call EvalTree::set_nulary. */
-	class AtomValues {
-	public:
-		virtual ~AtomValues() {}
-		virtual void setValues(EvalTree& et) const = 0;
-	};
+  /** Pure virtual class defining interface for all classes able to
+   * set nulary terms to evaluation tree EvalTree. The
+   * implementations of this class will have to be connected with
+   * Atoms to have knowledge about the atoms and their indices in
+   * the tree, and will call EvalTree::set_nulary. */
+  class AtomValues
+  {
+  public:
+    virtual ~AtomValues()
+    {
+    }
+    virtual void setValues(EvalTree &et) const = 0;
+  };
 
-	class FormulaDerEvaluator;
-	class FoldMultiIndex;
-	/** For ordering FoldMultiIndex in the std::map. */
-	struct ltfmi {
-		bool operator()(const FoldMultiIndex& i1, const FoldMultiIndex& i2) const;
-	};
+  class FormulaDerEvaluator;
+  class FoldMultiIndex;
+  /** For ordering FoldMultiIndex in the std::map. */
+  struct ltfmi
+  {
+    bool operator()(const FoldMultiIndex &i1, const FoldMultiIndex &i2) const;
+  };
 
-	/** This class stores derivatives (tree indices) of one formula
-	 * for all orders upto a given one. It stores the derivatives as a
-	 * sequence (vector) of these tree indices and sequence of the
-	 * multidimensional indices of variables wrt which the derivatives
-	 * were taken. In order to speed up querying for a derivative
-	 * given the variables, we have a map mapping the multidimensional
-	 * index to the order of the derivative in the sequence.
-	 * 
-	 * The only reason we do not have only this map is that the
-	 * iterators of the map do not survive the insertions to the map,
-	 * and implementation of the constructor has to be very difficult.
-	 */
-	class FormulaDerivatives {
-		friend class FormulaDerEvaluator;
-	protected:
-		/** Vector of derivatives. This is a list of derivatives (tree
-		 * indices), the ordering is given by the algorithm used to
-		 * create it. Currently, it starts with zero-th derivative,
-		 * the formula itself and carries with first order, second,
-		 * etc. */
-		vector<int> tder;
-		/** Vector of multiindices corresponding to the vector of
-		 * derivatives. */
-		vector<FoldMultiIndex> indices;
-		/** For retrieving derivatives via a multiindex, we have a map
-		 * mapping a multiindex to a derivative in the tder
-		 * ordering. This means that indices[ind2der[index]] == index. */
-		typedef map<FoldMultiIndex, int, ltfmi> Tfmiintmap;
-		Tfmiintmap ind2der;
-		/** The number of variables. */
-		int nvar;
-		/** The maximum order of derivatives. */
-		int order;
-	public:
-		/** The constructor allocates and fills the sequence of the
-		 * indices of derivatives for a formula.
-		 * @param otree the OperationTree for which all work is done
-		 * and to which the derivatives are added.
-		 * @param vars the vector of nulary terms in the tree; the
-		 * derivatives are taken with respect to these variables in
-		 * the ordering given by the vector.
-		 * @param f the index of the formula being differentiated. The
-		 * zero derivative is set to f.
-		 * @param max_order the maximum order of differentiation.
-		 */ 
-		FormulaDerivatives(OperationTree& otree, const vector<int>& vars, int f, int max_order);
-		/** Copy constructor. */
-		FormulaDerivatives(const FormulaDerivatives& fd);
-		virtual ~FormulaDerivatives(){}
-		/** Random access to the derivatives via multiindex. */
-		int derivative(const FoldMultiIndex& mi) const;
-		/** Return the order. */
-		int get_order() const
-			{return order;}
-		/** Debug print. */
-		void print(const OperationTree& otree) const;
-	};
+  /** This class stores derivatives (tree indices) of one formula
+   * for all orders upto a given one. It stores the derivatives as a
+   * sequence (vector) of these tree indices and sequence of the
+   * multidimensional indices of variables wrt which the derivatives
+   * were taken. In order to speed up querying for a derivative
+   * given the variables, we have a map mapping the multidimensional
+   * index to the order of the derivative in the sequence.
+   *
+   * The only reason we do not have only this map is that the
+   * iterators of the map do not survive the insertions to the map,
+   * and implementation of the constructor has to be very difficult.
+   */
+  class FormulaDerivatives
+  {
+    friend class FormulaDerEvaluator;
+  protected:
+    /** Vector of derivatives. This is a list of derivatives (tree
+     * indices), the ordering is given by the algorithm used to
+     * create it. Currently, it starts with zero-th derivative,
+     * the formula itself and carries with first order, second,
+     * etc. */
+    vector<int> tder;
+    /** Vector of multiindices corresponding to the vector of
+     * derivatives. */
+    vector<FoldMultiIndex> indices;
+    /** For retrieving derivatives via a multiindex, we have a map
+     * mapping a multiindex to a derivative in the tder
+     * ordering. This means that indices[ind2der[index]] == index. */
+    typedef map<FoldMultiIndex, int, ltfmi> Tfmiintmap;
+    Tfmiintmap ind2der;
+    /** The number of variables. */
+    int nvar;
+    /** The maximum order of derivatives. */
+    int order;
+  public:
+    /** The constructor allocates and fills the sequence of the
+     * indices of derivatives for a formula.
+     * @param otree the OperationTree for which all work is done
+     * and to which the derivatives are added.
+     * @param vars the vector of nulary terms in the tree; the
+     * derivatives are taken with respect to these variables in
+     * the ordering given by the vector.
+     * @param f the index of the formula being differentiated. The
+     * zero derivative is set to f.
+     * @param max_order the maximum order of differentiation.
+     */
+    FormulaDerivatives(OperationTree &otree, const vector<int> &vars, int f, int max_order);
+    /** Copy constructor. */
+    FormulaDerivatives(const FormulaDerivatives &fd);
+    virtual ~FormulaDerivatives()
+    {
+    }
+    /** Random access to the derivatives via multiindex. */
+    int derivative(const FoldMultiIndex &mi) const;
+    /** Return the order. */
+    int
+    get_order() const
+    {
+      return order;
+    }
+    /** Debug print. */
+    void print(const OperationTree &otree) const;
+  };
 
-	class FormulaEvaluator;
+  class FormulaEvaluator;
 
-	/** This class is able to parse a number of formulas and
-	 * differentiate them. The life cycle of the object is as follows:
-	 * After it is created, a few calls to parse will add formulas
-	 * (zero derivatives) to the object. Then a method differentiate()
-	 * can be called and a vector of pointers to derivatives for each
-	 * formula is created. After this, no one should call other
-	 * parse() or differentiate(). A const reference of the object can
-	 * be used in constructors of FormulaEvaluator and
-	 * FormulaDerEvaluator in order to evaluate formulas (zero
-	 * derivatives) and higher derivatives resp. */
-	class FormulaParser {
-		friend class FormulaCustomEvaluator;
-		friend class FormulaDerEvaluator;
-	protected:
-		/** The OperationTree of all formulas, including derivatives. */
-		OperationTree otree;
-		/** Reference to Atoms. The Atoms are filled with nulary terms
-		 * during execution of parse(). */
-		Atoms& atoms;
-		/** Vector of formulas (zero derivatives) in the order as they
-		 * have been parsed. */
-		vector<int> formulas;
-		/** The vector to derivatives, each vector corresponds to a
-		 * formula in the vector formulas. */
-		vector<FormulaDerivatives*> ders;
-	public:
-		/** Construct an empty formula parser. */
-		FormulaParser(Atoms& a)
-			: atoms(a) {}
-		/** Copy constructor using a different instance of Atoms. */
-		FormulaParser(const FormulaParser& fp, Atoms& a);
-		virtual ~FormulaParser();
+  /** This class is able to parse a number of formulas and
+   * differentiate them. The life cycle of the object is as follows:
+   * After it is created, a few calls to parse will add formulas
+   * (zero derivatives) to the object. Then a method differentiate()
+   * can be called and a vector of pointers to derivatives for each
+   * formula is created. After this, no one should call other
+   * parse() or differentiate(). A const reference of the object can
+   * be used in constructors of FormulaEvaluator and
+   * FormulaDerEvaluator in order to evaluate formulas (zero
+   * derivatives) and higher derivatives resp. */
+  class FormulaParser
+  {
+    friend class FormulaCustomEvaluator;
+    friend class FormulaDerEvaluator;
+  protected:
+    /** The OperationTree of all formulas, including derivatives. */
+    OperationTree otree;
+    /** Reference to Atoms. The Atoms are filled with nulary terms
+     * during execution of parse(). */
+    Atoms &atoms;
+    /** Vector of formulas (zero derivatives) in the order as they
+     * have been parsed. */
+    vector<int> formulas;
+    /** The vector to derivatives, each vector corresponds to a
+     * formula in the vector formulas. */
+    vector<FormulaDerivatives *> ders;
+  public:
+    /** Construct an empty formula parser. */
+    FormulaParser(Atoms &a)
+      : atoms(a)
+    {
+    }
+    /** Copy constructor using a different instance of Atoms. */
+    FormulaParser(const FormulaParser &fp, Atoms &a);
+    virtual
+    ~FormulaParser();
 
-		/** Requires an addition of the formula; called from the
-		 * parser. */
-		void add_formula(int t);
-		/** Requires an addition of the binary operation; called from
-		 * the parser. */
-		int add_binary(code_t code, int t1, int t2);
-		/** Requires an addition of the unary operation; called from
-		 * the parser. */
-		int add_unary(code_t code, int t);
-		/** Requires an addition of the nulary operation given by the
-		 * string. The Atoms are consulted for uniquness and are given
-		 * an internal index generated by the OperationTree. This is
-		 * the channel through which the Atoms are filled. */
-		int add_nulary(const char* str);
+    /** Requires an addition of the formula; called from the
+     * parser. */
+    void add_formula(int t);
+    /** Requires an addition of the binary operation; called from
+     * the parser. */
+    int add_binary(code_t code, int t1, int t2);
+    /** Requires an addition of the unary operation; called from
+     * the parser. */
+    int add_unary(code_t code, int t);
+    /** Requires an addition of the nulary operation given by the
+     * string. The Atoms are consulted for uniquness and are given
+     * an internal index generated by the OperationTree. This is
+     * the channel through which the Atoms are filled. */
+    int add_nulary(const char *str);
 
-		/** Adds a derivative to the tree. This just calls
-		 * OperationTree::add_derivative. */
-		int add_derivative(int t, int v)
-			{return otree.add_derivative(t, v);}
-		/** Adds a substitution. This just calls
-		 * OperationTree::add_substitution. */
-		int add_substitution(int t, const map<int,int>& subst)
-			{return otree.add_substitution(t, subst);}
-		/** Add the substitution given by the map where left sides of
-		 * substitutions come from another parser. The right sides are
-		 * from this object. The given t is from the given parser fp. */
-		int add_substitution(int t, const map<int,int>& subst,
-							 const FormulaParser& fp)
-			{return otree.add_substitution(t, subst, fp.otree);}
-		/** This adds formulas from the given parser with (possibly)
-		 * different atoms applying substitutions from the given map
-		 * mapping atoms from fp to atoms of the object. */
-		void add_subst_formulas(const map<int,int>& subst, const FormulaParser& fp);
-		/** Substitute formulas. For each i from 1 through all
-		 * formulas, it adds a substitution of the i-th formula and
-		 * make it to be i-th formula.*/
-		void substitute_formulas(const std::map<int,int>& subst);
-		/** This method turns the given term to nulary operation. It
-		 * should be used with caution, since this method does not
-		 * anything do with atoms, but usually some action is also
-		 * needed (at leat to assign the tree index t to some
-		 * atom). */
-		void nularify(int t)
-			{otree.nularify(t);}
-		/** Returns a set of nulary terms of the given term. Just
-		 * calls OperationTree::nulary_of_term. */
-		const unordered_set<int>& nulary_of_term(int t) const
-			{return otree.nulary_of_term(t);}
+    /** Adds a derivative to the tree. This just calls
+     * OperationTree::add_derivative. */
+    int
+    add_derivative(int t, int v)
+    {
+      return otree.add_derivative(t, v);
+    }
+    /** Adds a substitution. This just calls
+     * OperationTree::add_substitution. */
+    int
+    add_substitution(int t, const map<int, int> &subst)
+    {
+      return otree.add_substitution(t, subst);
+    }
+    /** Add the substitution given by the map where left sides of
+     * substitutions come from another parser. The right sides are
+     * from this object. The given t is from the given parser fp. */
+    int
+    add_substitution(int t, const map<int, int> &subst,
+                     const FormulaParser &fp)
+    {
+      return otree.add_substitution(t, subst, fp.otree);
+    }
+    /** This adds formulas from the given parser with (possibly)
+     * different atoms applying substitutions from the given map
+     * mapping atoms from fp to atoms of the object. */
+    void add_subst_formulas(const map<int, int> &subst, const FormulaParser &fp);
+    /** Substitute formulas. For each i from 1 through all
+     * formulas, it adds a substitution of the i-th formula and
+     * make it to be i-th formula.*/
+    void substitute_formulas(const std::map<int, int> &subst);
+    /** This method turns the given term to nulary operation. It
+     * should be used with caution, since this method does not
+     * anything do with atoms, but usually some action is also
+     * needed (at leat to assign the tree index t to some
+     * atom). */
+    void
+    nularify(int t)
+    {
+      otree.nularify(t);
+    }
+    /** Returns a set of nulary terms of the given term. Just
+     * calls OperationTree::nulary_of_term. */
+    const unordered_set<int> &
+    nulary_of_term(int t) const
+    {
+      return otree.nulary_of_term(t);
+    }
 
-		/** Parse a given string containing one or more formulas. The
-		 * formulas are parsed and added to the OperationTree and to
-		 * the formulas vector. */
-		void parse(int length, const char* stream);
-		/** Processes a syntax error from bison. */
-		void error(const char* mes) const;
-		/** Differentiate all the formulas up to the given order. The
-		 * variables with respect to which the derivatives are taken
-		 * are obtained by Atoms::variables(). If the derivates exist,
-		 * they are destroyed and created again (with possibly
-		 * different order). */
-		void differentiate(int max_order);
-		/** Return i-th formula derivatives. */
-		const FormulaDerivatives& derivatives(int i) const;
+    /** Parse a given string containing one or more formulas. The
+     * formulas are parsed and added to the OperationTree and to
+     * the formulas vector. */
+    void parse(int length, const char *stream);
+    /** Processes a syntax error from bison. */
+    void error(const char *mes) const;
+    /** Differentiate all the formulas up to the given order. The
+     * variables with respect to which the derivatives are taken
+     * are obtained by Atoms::variables(). If the derivates exist,
+     * they are destroyed and created again (with possibly
+     * different order). */
+    void differentiate(int max_order);
+    /** Return i-th formula derivatives. */
+    const FormulaDerivatives&derivatives(int i) const;
 
-		/** This returns a maximum index of zero derivative formulas
-		 * including all nulary terms. This is a mimumum length of the
-		 * tree for which it is safe to evaluate zero derivatives of
-		 * the formulas. */
-		int last_formula() const;
-		/** This returns a tree index of the i-th formula in the
-		 * vector. */
-		int formula(int i) const
-			{return formulas[i];}
+    /** This returns a maximum index of zero derivative formulas
+     * including all nulary terms. This is a mimumum length of the
+     * tree for which it is safe to evaluate zero derivatives of
+     * the formulas. */
+    int last_formula() const;
+    /** This returns a tree index of the i-th formula in the
+     * vector. */
+    int
+    formula(int i) const
+    {
+      return formulas[i];
+    }
 
+    /** This returns a tree index of the last formula and pops its
+     * item from the formulas vector. The number of formulas is
+     * then less by one. Returns -1 if there is no formula. If
+     * there are derivatives of the last formula, they are
+     * destroyed and the vector ders is popped from the back. */
+    int pop_last_formula();
 
-		/** This returns a tree index of the last formula and pops its
-		 * item from the formulas vector. The number of formulas is
-		 * then less by one. Returns -1 if there is no formula. If
-		 * there are derivatives of the last formula, they are
-		 * destroyed and the vector ders is popped from the back. */
-		int pop_last_formula();
+    /** This returns a number of formulas. */
+    int
+    nformulas() const
+    {
+      return (int) (formulas.size());
+    }
 
-		/** This returns a number of formulas. */
-		int nformulas() const
-			{return (int)(formulas.size());}
+    /** This returns a reference to atoms. */
+    const Atoms &
+    getAtoms() const
+    {
+      return atoms;
+    }
+    Atoms &
+    getAtoms()
+    {
+      return atoms;
+    }
+    /** This returns the tree. */
+    const OperationTree &
+    getTree() const
+    {
+      return otree;
+    }
+    OperationTree &
+    getTree()
+    {
+      return otree;
+    }
 
-		/** This returns a reference to atoms. */
-		const Atoms& getAtoms() const
-			{return atoms;}
-		Atoms& getAtoms()
-			{return atoms;}
-		/** This returns the tree. */
-		const OperationTree& getTree() const
-			{return otree;}
-		OperationTree& getTree()
-			{return otree;}
+    /** Debug print. */
+    void print() const;
+  private:
+    /** Hide this copy constructor declaration by declaring it as
+     * private. */
+    FormulaParser(const FormulaParser &fp);
+    /** Destroy all derivatives. */
+    void destroy_derivatives();
+  };
 
-		/** Debug print. */
-		void print() const;
-	private:
-		/** Hide this copy constructor declaration by declaring it as
-		 * private. */
-		FormulaParser(const FormulaParser& fp);
-		/** Destroy all derivatives. */
-		void destroy_derivatives();
-	};
+  /** This is a pure virtual class defining an interface for all
+   * classes which will load the results of formula (zero
+   * derivative) evaluations. A primitive implementation of this
+   * class can be a vector of doubles. */
+  class FormulaEvalLoader
+  {
+  public:
+    virtual ~FormulaEvalLoader()
+    {
+    }
+    /** Set the value res for the given formula. The formula is
+     * identified by an index corresponding to the ordering in
+     * which the formulas have been parsed (starting from
+     * zero). */
+    virtual void load(int i, double res) = 0;
+  };
 
-	/** This is a pure virtual class defining an interface for all
-	 * classes which will load the results of formula (zero
-	 * derivative) evaluations. A primitive implementation of this
-	 * class can be a vector of doubles. */
-	class FormulaEvalLoader {
-	public:
-		virtual ~FormulaEvalLoader() {}
-		/** Set the value res for the given formula. The formula is
-		 * identified by an index corresponding to the ordering in
-		 * which the formulas have been parsed (starting from
-		 * zero). */
-		virtual void load(int i, double res) = 0;
-	};
+  /** This class evaluates a selected subset of terms of the
+   * tree. In the protected constructor, one can constraint the
+   * initialization of the evaluation tree to a given number of
+   * terms in the beginning. Using this constructor, one has to make
+   * sure, that the terms in the beginning do not refer to terms
+   * behind the initial part. */
+  class FormulaCustomEvaluator
+  {
+  protected:
+    /** The evaluation tree. */
+    EvalTree etree;
+    /** The custom tree indices to be evaluated. */
+    vector<int> terms;
+  public:
+    /** Construct from FormulaParser and given list of terms. */
+    FormulaCustomEvaluator(const FormulaParser &fp, const vector<int> &ts)
+      : etree(fp.otree), terms(ts)
+    {
+    }
+    /** Construct from OperationTree and given list of terms. */
+    FormulaCustomEvaluator(const OperationTree &ot, const vector<int> &ts)
+      : etree(ot), terms(ts)
+    {
+    }
+    /** Evaluate the terms using the given AtomValues and load the
+     * results using the given loader. The loader is called for
+     * each term in the order of the terms. */
+    void eval(const AtomValues &av, FormulaEvalLoader &loader);
+  protected:
+    FormulaCustomEvaluator(const FormulaParser &fp)
+      : etree(fp.otree, fp.last_formula()), terms(fp.formulas)
+    {
+    }
+  };
 
-	/** This class evaluates a selected subset of terms of the
-	 * tree. In the protected constructor, one can constraint the
-	 * initialization of the evaluation tree to a given number of
-	 * terms in the beginning. Using this constructor, one has to make
-	 * sure, that the terms in the beginning do not refer to terms
-	 * behind the initial part. */
-	class FormulaCustomEvaluator {
-	protected:
-		/** The evaluation tree. */
-		EvalTree etree;
-		/** The custom tree indices to be evaluated. */
-		vector<int> terms;
-	public:
-		/** Construct from FormulaParser and given list of terms. */
-		FormulaCustomEvaluator(const FormulaParser& fp, const vector<int>& ts)
-			: etree(fp.otree), terms(ts)
-			{}
-		/** Construct from OperationTree and given list of terms. */
-		FormulaCustomEvaluator(const OperationTree& ot, const vector<int>& ts)
-			: etree(ot), terms(ts)
-			{}
-		/** Evaluate the terms using the given AtomValues and load the
-		 * results using the given loader. The loader is called for
-		 * each term in the order of the terms. */
-		void eval(const AtomValues& av, FormulaEvalLoader& loader);
-	protected:
-		FormulaCustomEvaluator(const FormulaParser& fp)
-			: etree(fp.otree, fp.last_formula()), terms(fp.formulas)
-			{}
-	};
+  /** This class evaluates zero derivatives of the FormulaParser. */
+  class FormulaEvaluator : public FormulaCustomEvaluator
+  {
+  public:
+    /** Construct from FormulaParser. */
+    FormulaEvaluator(const FormulaParser &fp)
+      : FormulaCustomEvaluator(fp)
+    {
+    }
+  };
 
-	/** This class evaluates zero derivatives of the FormulaParser. */
-	class FormulaEvaluator : public FormulaCustomEvaluator {
-	public:
-		/** Construct from FormulaParser. */
-		FormulaEvaluator(const FormulaParser& fp)
-			: FormulaCustomEvaluator(fp) {}
-	};
+  /** This is a pure virtual class defining an interface for all
+   * classes which will load the results of formula derivative
+   * evaluations. */
+  class FormulaDerEvalLoader
+  {
+  public:
+    virtual ~FormulaDerEvalLoader()
+    {
+    }
+    /** This loads the result of the derivative of the given
+     * order. The semantics of i is the same as in
+     * FormulaEvalLoader::load. The indices of variables with
+     * respect to which the derivative was taken are stored in
+     * memory pointed by vars. These are the tree indices of the
+     * variables. */
+    virtual void load(int i, int order, const int *vars, double res) = 0;
+  };
 
-	/** This is a pure virtual class defining an interface for all
-	 * classes which will load the results of formula derivative
-	 * evaluations. */
-	class FormulaDerEvalLoader {
-	public:
-		virtual ~FormulaDerEvalLoader() {}
-		/** This loads the result of the derivative of the given
-		 * order. The semantics of i is the same as in
-		 * FormulaEvalLoader::load. The indices of variables with
-		 * respect to which the derivative was taken are stored in
-		 * memory pointed by vars. These are the tree indices of the
-		 * variables. */
-		virtual void load(int i, int order, const int* vars, double res) = 0;
-	};
+  /** This class is a utility class representing the tensor
+   * multindex. It can basically increment itself, and calculate
+   * its offset in the folded tensor. */
+  class FoldMultiIndex
+  {
+    /** Number of variables. */
+    int nvar;
+    /** Dimension. */
+    int ord;
+    /** The multiindex. */
+    int *data;
+  public:
+    /** Initializes to the zero derivative. Order is 0, data is
+     * empty. */
+    FoldMultiIndex(int nv);
+    /** Initializes the multiindex to zeros or given i. */
+    FoldMultiIndex(int nv, int order, int i = 0);
+    /** Makes a new multiindex of the same order applying a given
+     * mapping to the indices. The mapping is supposed to be monotone. */
+    FoldMultiIndex(int nv, const FoldMultiIndex &mi, const vector<int> &mp);
+    /** Shifting constructor. This adds a given number of orders
+     * to the end, copying the last item to the newly added items,
+     * keeping the index ordered. If the index was empty (zero-th
+     * dimension), then zeros are added. */
+    FoldMultiIndex(const FoldMultiIndex &fmi, int new_orders);
+    /** Copy constructor. */
+    FoldMultiIndex(const FoldMultiIndex &fmi);
+    /** Desctructor. */
+    virtual ~FoldMultiIndex()
+    {
+      delete [] data;
+    }
+    /** Assignment operator. */
+    const FoldMultiIndex &operator=(const FoldMultiIndex &fmi);
+    /** Operator < implementing lexicographic ordering within one
+     * order, increasing order across orders. */
+    bool operator<(const FoldMultiIndex &fmi) const;
+    bool operator==(const FoldMultiIndex &fmi) const;
+    /** Increment the multiindex. */
+    void increment();
+    /** Return offset of the multiindex in the folded tensor. */
+    int offset() const;
+    const int &
+    operator[](int i) const
+    {
+      return data[i];
+    }
+    /** Return order of the multiindex, i.e. dimension of the
+     * tensor. */
+    int
+    order() const
+    {
+      return ord;
+    }
+    /** Return the number of variables. */
+    int
+    nv() const
+    {
+      return nvar;
+    }
+    /** Return the data. */
+    const int *
+    ind() const
+    {
+      return data;
+    }
+    /** Return true if the end of the tensor is reached. The
+     * result of a subsequent increment should be considered
+     * unpredictable. */
+    bool
+    past_the_end() const
+    {
+      return (ord == 0) || (data[0] == nvar);
+    }
+    /** Prints the multiindex in the brackets. */
+    void print() const;
+  private:
+    static int offset_recurse(int *data, int len, int nv);
+  };
 
-	/** This class is a utility class representing the tensor
-	 * multindex. It can basically increment itself, and calculate
-	 * its offset in the folded tensor. */
-	class FoldMultiIndex {
-		/** Number of variables. */
-		int nvar;
-		/** Dimension. */
-		int ord;
-		/** The multiindex. */
-		int* data;
-	public:
-		/** Initializes to the zero derivative. Order is 0, data is
-		 * empty. */
-		FoldMultiIndex(int nv);
-		/** Initializes the multiindex to zeros or given i. */
-		FoldMultiIndex(int nv, int order, int i = 0);
-		/** Makes a new multiindex of the same order applying a given
-		 * mapping to the indices. The mapping is supposed to be monotone. */
-		FoldMultiIndex(int nv, const FoldMultiIndex& mi, const vector<int>& mp);
-		/** Shifting constructor. This adds a given number of orders
-		 * to the end, copying the last item to the newly added items,
-		 * keeping the index ordered. If the index was empty (zero-th
-		 * dimension), then zeros are added. */
-		FoldMultiIndex(const FoldMultiIndex& fmi, int new_orders);
-		/** Copy constructor. */
-		FoldMultiIndex(const FoldMultiIndex& fmi);
-		/** Desctructor. */
-		virtual ~FoldMultiIndex()
-			{delete [] data;}
-		/** Assignment operator. */
-		const FoldMultiIndex& operator=(const FoldMultiIndex& fmi);
-		/** Operator < implementing lexicographic ordering within one
-		 * order, increasing order across orders. */
-		bool operator<(const FoldMultiIndex& fmi) const;
-		bool operator==(const FoldMultiIndex& fmi) const;
-		/** Increment the multiindex. */
-		void increment();
-		/** Return offset of the multiindex in the folded tensor. */ 
-		int offset() const;
-		const int& operator[](int i) const
-			{return data[i];}
-		/** Return order of the multiindex, i.e. dimension of the
-		 * tensor. */ 
-		int order() const
-			{return ord;}
-		/** Return the number of variables. */
-		int nv() const
-			{return nvar;}
-		/** Return the data. */
-		const int* ind() const
-			{return data;}
-		/** Return true if the end of the tensor is reached. The
-		 * result of a subsequent increment should be considered
-		 * unpredictable. */
-		bool past_the_end() const
-			{return (ord == 0) || (data[0] == nvar);}
-		/** Prints the multiindex in the brackets. */
-		void print() const;
-	private:
-		static int offset_recurse(int* data, int len, int nv);
-	};
-
-	/** This class evaluates derivatives of the FormulaParser. */
-	class FormulaDerEvaluator {
-		/** Its own instance of EvalTree. */
-		EvalTree etree;
-		/** The indices of derivatives for each formula. This is a
-		 * const copy FormulaParser::ders. We do not allocate nor
-		 * deallocate anything here. */
-		vector<const FormulaDerivatives*> ders;
-		/** A copy of tree indices corresponding to atoms to with
-		 * respect the derivatives were taken. */
-		vector<int> der_atoms;
-	public:
-		/** Construct the object from FormulaParser. */
-		FormulaDerEvaluator(const FormulaParser& fp);
-		/** Evaluate the derivatives from the FormulaParser wrt to all
-		 * atoms in variables vector at the given AtomValues. The
-		 * given loader is used for output. */
-		void eval(const AtomValues& av, FormulaDerEvalLoader& loader, int order);
-		/** Evaluate the derivatives from the FormulaParser wrt to a
-		 * selection of atoms of the atoms in der_atoms vector at the
-		 * given AtomValues. The selection is given by a monotone
-		 * mapping to the indices (not values) of the der_atoms. */
-		void eval(const vector<int>& mp, const AtomValues& av, FormulaDerEvalLoader& loader,
-				  int order);
-	};
+  /** This class evaluates derivatives of the FormulaParser. */
+  class FormulaDerEvaluator
+  {
+    /** Its own instance of EvalTree. */
+    EvalTree etree;
+    /** The indices of derivatives for each formula. This is a
+     * const copy FormulaParser::ders. We do not allocate nor
+     * deallocate anything here. */
+    vector<const FormulaDerivatives *> ders;
+    /** A copy of tree indices corresponding to atoms to with
+     * respect the derivatives were taken. */
+    vector<int> der_atoms;
+  public:
+    /** Construct the object from FormulaParser. */
+    FormulaDerEvaluator(const FormulaParser &fp);
+    /** Evaluate the derivatives from the FormulaParser wrt to all
+     * atoms in variables vector at the given AtomValues. The
+     * given loader is used for output. */
+    void eval(const AtomValues &av, FormulaDerEvalLoader &loader, int order);
+    /** Evaluate the derivatives from the FormulaParser wrt to a
+     * selection of atoms of the atoms in der_atoms vector at the
+     * given AtomValues. The selection is given by a monotone
+     * mapping to the indices (not values) of the der_atoms. */
+    void eval(const vector<int> &mp, const AtomValues &av, FormulaDerEvalLoader &loader,
+              int order);
+  };
 };
 
 #endif
diff --git a/dynare++/parser/cc/location.h b/dynare++/parser/cc/location.h
index 55182942b..93b51cf17 100644
--- a/dynare++/parser/cc/location.h
+++ b/dynare++/parser/cc/location.h
@@ -15,29 +15,32 @@
 // in EVERY action consuming material (this can be done with #define
 // YY_USER_ACTION) and in bison you must use option %locations.
 
-
 #ifndef OG_LOCATION_H
 #define OG_LOCATION_H
 
-namespace ogp {
+namespace ogp
+{
 
-	struct location_type {
-		int off; // offset of the token
-		int ll; // length ot the token
-		location_type() : off(0), ll(0) {}
-	};
+  struct location_type
+  {
+    int off; // offset of the token
+    int ll; // length ot the token
+    location_type() : off(0), ll(0)
+    {
+    }
+  };
 
 };
 
 #define YYLTYPE ogp::location_type
 
 // set current off to the first off and add all lengths
-#define YYLLOC_DEFAULT(Current, Rhs, N) \
-  {(Current).off    =  (Rhs)[1].off;    \
-   (Current).ll     =  0;               \
-   for (int i = 1; i <= N; i++) (Current).ll += (Rhs)[i].ll;}
+#define YYLLOC_DEFAULT(Current, Rhs, N)                         \
+  {(Current).off    =  (Rhs)[1].off;                            \
+    (Current).ll     =  0;                                      \
+    for (int i = 1; i <= N; i++) (Current).ll += (Rhs)[i].ll; }
 
-#define SET_LLOC(prefix) (prefix##lloc.off += prefix##lloc.ll, prefix##lloc.ll = prefix##leng)
+#define SET_LLOC(prefix) (prefix ## lloc.off += prefix ## lloc.ll, prefix ## lloc.ll = prefix ## leng)
 
 #endif
 
diff --git a/dynare++/parser/cc/matrix_parser.h b/dynare++/parser/cc/matrix_parser.h
index f2c85d2eb..e86f57f0e 100644
--- a/dynare++/parser/cc/matrix_parser.h
+++ b/dynare++/parser/cc/matrix_parser.h
@@ -8,110 +8,143 @@
 #include <cstdlib> // For NULL
 #include <vector>
 
-namespace ogp {
-	using std::vector;
+namespace ogp
+{
+  using std::vector;
 
-	/** This class reads the given string and parses it as a
-	 * matrix. The matrix is read row by row. The row delimiter is
-	 * either a newline character or semicolon (first newline
-	 * character after the semicolon is ignored), the column delimiter
-	 * is either blank character or comma. A different number of items
-	 * in the row is not reconciliated, we do not construct a matrix
-	 * here. The class provides only an iterator to go through all
-	 * read items, the iterator provides information on row number and
-	 * column number of the item. */
-	class MPIterator;
-	class MatrixParser {
-		friend class MPIterator;
-	protected:
-		/** Raw data as they were read. */
-		vector<double> data;
-		/** Number of items in each row. */
-		vector<int> row_lengths;
-		/** Maximum number of row lengths. */
-		int nc;
-	public:
-		MatrixParser()
-			: nc(0) {}
-		MatrixParser(const MatrixParser& mp)
-			: data(mp.data), row_lengths(mp.row_lengths), nc(mp.nc) {}
-		virtual ~MatrixParser() {}
-		/** Return a number of read rows. */
-		int nrows() const
-			{return (int) row_lengths.size();}
-		/** Return a maximum number of items in the rows. */
-		int ncols() const
-			{return nc;}
-		/** Parses a given data. This initializes the object data. */
-		void parse(int length, const char* stream);
-		/** Adds newly read item. This should be called from bison
-		 * parser. */
-		void add_item(double v);
-		/** Starts a new row. This should be called from bison
-		 * parser. */
-		void start_row();
-		/** Process a parse error from the parser. */
-		void error(const char* mes) const;
-		/** Return begin iterator. */
-		MPIterator begin() const;
-		/** Return end iterator. */
-		MPIterator end() const;
-	protected:
-		/** Returns an index of the first non-empty row starting at
-		 * start. If the start row is non-empty, returns the start. If
-		 * there is no other non-empty row, returns
-		 * row_lengths.size(). */
-		int find_first_non_empty_row(int start = 0) const;
-	};
+  /** This class reads the given string and parses it as a
+   * matrix. The matrix is read row by row. The row delimiter is
+   * either a newline character or semicolon (first newline
+   * character after the semicolon is ignored), the column delimiter
+   * is either blank character or comma. A different number of items
+   * in the row is not reconciliated, we do not construct a matrix
+   * here. The class provides only an iterator to go through all
+   * read items, the iterator provides information on row number and
+   * column number of the item. */
+  class MPIterator;
+  class MatrixParser
+  {
+    friend class MPIterator;
+  protected:
+    /** Raw data as they were read. */
+    vector<double> data;
+    /** Number of items in each row. */
+    vector<int> row_lengths;
+    /** Maximum number of row lengths. */
+    int nc;
+  public:
+    MatrixParser()
+      : nc(0)
+    {
+    }
+    MatrixParser(const MatrixParser &mp)
+      : data(mp.data), row_lengths(mp.row_lengths), nc(mp.nc)
+    {
+    }
+    virtual ~MatrixParser()
+    {
+    }
+    /** Return a number of read rows. */
+    int
+    nrows() const
+    {
+      return (int) row_lengths.size();
+    }
+    /** Return a maximum number of items in the rows. */
+    int
+    ncols() const
+    {
+      return nc;
+    }
+    /** Parses a given data. This initializes the object data. */
+    void parse(int length, const char *stream);
+    /** Adds newly read item. This should be called from bison
+     * parser. */
+    void add_item(double v);
+    /** Starts a new row. This should be called from bison
+     * parser. */
+    void start_row();
+    /** Process a parse error from the parser. */
+    void error(const char *mes) const;
+    /** Return begin iterator. */
+    MPIterator begin() const;
+    /** Return end iterator. */
+    MPIterator end() const;
+  protected:
+    /** Returns an index of the first non-empty row starting at
+     * start. If the start row is non-empty, returns the start. If
+     * there is no other non-empty row, returns
+     * row_lengths.size(). */
+    int find_first_non_empty_row(int start = 0) const;
+  };
 
-	/** This is an iterator intended to iterate through a matrix parsed
-	 * by MatrixParser. The iterator provides only read-only access. */
-	class MPIterator {
-		friend class MatrixParser;
-	protected:
-		/** Reference to the matrix parser. */
-		const MatrixParser* p;
-		/** The index of the pointed item in the matrix parser. */
-		unsigned int i;
-		/** The column number of the pointed item starting from zero. */
-		int c;
-		/** The row number of the pointed item starting from zero. */
-		int r;
+  /** This is an iterator intended to iterate through a matrix parsed
+   * by MatrixParser. The iterator provides only read-only access. */
+  class MPIterator
+  {
+    friend class MatrixParser;
+  protected:
+    /** Reference to the matrix parser. */
+    const MatrixParser *p;
+    /** The index of the pointed item in the matrix parser. */
+    unsigned int i;
+    /** The column number of the pointed item starting from zero. */
+    int c;
+    /** The row number of the pointed item starting from zero. */
+    int r;
 
-	public:
-		MPIterator() : p(NULL), i(0), c(0), r(0) {}
-		/** Constructs an iterator pointing to the beginning of the
-		 * parsed matrix. */
-		MPIterator(const MatrixParser& mp);
-		/** Constructs an iterator pointing to the past-the-end of the
-		 * parsed matrix. */
-		MPIterator(const MatrixParser& mp, const char* dummy);
-		/** Return read-only reference to the pointed item. */
-		const double& operator*() const
-			{return p->data[i];}
-		/** Return a row index of the pointed item. */
-		int row() const
-			{return r;}
-		/** Return a column index of the pointed item. */
-		int col() const
-			{return c;}
-		/** Assignment operator. */
-		const MPIterator& operator=(const MPIterator& it)
-			{p = it.p; i = it.i; c = it.c; r = it.r; return *this;}
-		/** Return true if the iterators are the same, this is if they
-		 * have the same underlying object and the same item index. */ 
-		bool operator==(const MPIterator& it) const
-			{return it.p == p && it.i == i;}
-		/** Negative of the operator==. */
-		bool operator!=(const MPIterator& it) const
-			{return ! (it == *this);} 
-		/** Increment operator. */
-		MPIterator& operator++();
-	};
+  public:
+    MPIterator() : p(NULL), i(0), c(0), r(0)
+    {
+    }
+    /** Constructs an iterator pointing to the beginning of the
+     * parsed matrix. */
+    MPIterator(const MatrixParser &mp);
+    /** Constructs an iterator pointing to the past-the-end of the
+     * parsed matrix. */
+    MPIterator(const MatrixParser &mp, const char *dummy);
+    /** Return read-only reference to the pointed item. */
+    const double &
+    operator*() const
+    {
+      return p->data[i];
+    }
+    /** Return a row index of the pointed item. */
+    int
+    row() const
+    {
+      return r;
+    }
+    /** Return a column index of the pointed item. */
+    int
+    col() const
+    {
+      return c;
+    }
+    /** Assignment operator. */
+    const MPIterator &
+    operator=(const MPIterator &it)
+    {
+      p = it.p; i = it.i; c = it.c; r = it.r; return *this;
+    }
+    /** Return true if the iterators are the same, this is if they
+     * have the same underlying object and the same item index. */
+    bool
+    operator==(const MPIterator &it) const
+    {
+      return it.p == p && it.i == i;
+    }
+    /** Negative of the operator==. */
+    bool
+    operator!=(const MPIterator &it) const
+    {
+      return !(it == *this);
+    }
+    /** Increment operator. */
+    MPIterator &operator++();
+  };
 };
 
-
-
 #endif
 
 // Local Variables:
diff --git a/dynare++/parser/cc/namelist.h b/dynare++/parser/cc/namelist.h
index 0bde12325..e704c8f67 100644
--- a/dynare++/parser/cc/namelist.h
+++ b/dynare++/parser/cc/namelist.h
@@ -5,24 +5,28 @@
 #ifndef OGP_NAMELIST
 #define OGP_NAMELIST
 
-namespace ogp {
+namespace ogp
+{
 
-	/** Parent class of all parsers parsing a namelist. They must
-	 * implement add_name() method and error() method, which is called
-	 * when an parse error occurs. 
-	 *
-	 * Parsing a name list is done as follows: implement
-	 * NameListParser interface, create the object, and call
-	 * NameListParser::namelist_parse(int lengt, const char*
-	 * text). When implementing error(), one may consult global
-	 * location_type namelist_lloc. */
-	class NameListParser {
-	public:
-		virtual ~NameListParser() {}
-		virtual void add_name(const char* name) = 0;
-		virtual void namelist_error(const char* mes) = 0;
-		void namelist_parse(int length, const char* text);
-	};
+  /** Parent class of all parsers parsing a namelist. They must
+   * implement add_name() method and error() method, which is called
+   * when an parse error occurs.
+   *
+   * Parsing a name list is done as follows: implement
+   * NameListParser interface, create the object, and call
+   * NameListParser::namelist_parse(int lengt, const char*
+   * text). When implementing error(), one may consult global
+   * location_type namelist_lloc. */
+  class NameListParser
+  {
+  public:
+    virtual ~NameListParser()
+    {
+    }
+    virtual void add_name(const char *name) = 0;
+    virtual void namelist_error(const char *mes) = 0;
+    void namelist_parse(int length, const char *text);
+  };
 };
 
 #endif
diff --git a/dynare++/parser/cc/parser_exception.h b/dynare++/parser/cc/parser_exception.h
index 2a8668a93..5b7766406 100644
--- a/dynare++/parser/cc/parser_exception.h
+++ b/dynare++/parser/cc/parser_exception.h
@@ -7,61 +7,88 @@
 
 #include <string>
 
-namespace ogp {
-	using std::string;
+namespace ogp
+{
+  using std::string;
 
-	/** This is an easy exception, which, besides the message, stores
-	 * also an offset of the parse error. Since we might need to track
-	 * the argument number and for example the filed in the argument
-	 * which caused the error, we add three integers, which have no
-	 * semantics here. They should be documented in the function which
-	 * throws an exception and sets them. Their default value is -1,
-	 * which means they have not been set. */
-	class ParserException {
-	protected:
-		char* mes;
-		int off;
-		int aux_i1;
-		int aux_i2;
-		int aux_i3;
-	public:
-		ParserException(const char* m, int offset);
-		ParserException(const string& m, int offset);
-		ParserException(const string& m, const char* dum, int i1);
-		ParserException(const string& m, const char* dum, int i1, int i2);
-		ParserException(const string& m, const char* dum, int i1, int i2, int i3);
-		ParserException(const ParserException& e, int plus_offset);
-		/** Makes a copy and pushes given integer to aux_i1 shuffling
-		 * others and forgetting the last. */
-		ParserException(const ParserException& e, const char* dum, int i);
-		/** Makes a copy and pushes given two integers to aux_i1 and aux_i2  shuffling
-		 * others and forgetting the last two. */
-		ParserException(const ParserException& e, const char* dum, int i1, int i2);
-		/** Makes a copy and pushes given three integers to aux_i1, aux_i2, aus_i3 shuffling
-		 * others and forgetting the last three. */
-		ParserException(const ParserException& e, const char* dum, int i1, int i2, int i3);
-		ParserException(const ParserException& e);
-		virtual ~ParserException();
-		void print(FILE* fd) const;
-		const char* message() const
-			{return mes;}
-		int offset() const
-			{return off;}
-		const int& i1() const
-			{return aux_i1;}
-		int& i1()
-			{return aux_i1;}
-		const int& i2() const
-			{return aux_i2;}
-		int& i2()
-			{return aux_i2;}
-		const int& i3() const
-			{return aux_i3;}
-		int& i3()
-			{return aux_i3;}
-	protected:
-		void copy(const ParserException& e);
-	};
+  /** This is an easy exception, which, besides the message, stores
+   * also an offset of the parse error. Since we might need to track
+   * the argument number and for example the filed in the argument
+   * which caused the error, we add three integers, which have no
+   * semantics here. They should be documented in the function which
+   * throws an exception and sets them. Their default value is -1,
+   * which means they have not been set. */
+  class ParserException
+  {
+  protected:
+    char *mes;
+    int off;
+    int aux_i1;
+    int aux_i2;
+    int aux_i3;
+  public:
+    ParserException(const char *m, int offset);
+    ParserException(const string &m, int offset);
+    ParserException(const string &m, const char *dum, int i1);
+    ParserException(const string &m, const char *dum, int i1, int i2);
+    ParserException(const string &m, const char *dum, int i1, int i2, int i3);
+    ParserException(const ParserException &e, int plus_offset);
+    /** Makes a copy and pushes given integer to aux_i1 shuffling
+     * others and forgetting the last. */
+    ParserException(const ParserException &e, const char *dum, int i);
+    /** Makes a copy and pushes given two integers to aux_i1 and aux_i2  shuffling
+     * others and forgetting the last two. */
+    ParserException(const ParserException &e, const char *dum, int i1, int i2);
+    /** Makes a copy and pushes given three integers to aux_i1, aux_i2, aus_i3 shuffling
+     * others and forgetting the last three. */
+    ParserException(const ParserException &e, const char *dum, int i1, int i2, int i3);
+    ParserException(const ParserException &e);
+    virtual
+    ~ParserException();
+    void print(FILE *fd) const;
+    const char *
+    message() const
+    {
+      return mes;
+    }
+    int
+    offset() const
+    {
+      return off;
+    }
+    const int &
+    i1() const
+    {
+      return aux_i1;
+    }
+    int &
+    i1()
+    {
+      return aux_i1;
+    }
+    const int &
+    i2() const
+    {
+      return aux_i2;
+    }
+    int &
+    i2()
+    {
+      return aux_i2;
+    }
+    const int &
+    i3() const
+    {
+      return aux_i3;
+    }
+    int &
+    i3()
+    {
+      return aux_i3;
+    }
+  protected:
+    void copy(const ParserException &e);
+  };
 };
 
 #endif
diff --git a/dynare++/parser/cc/static_atoms.h b/dynare++/parser/cc/static_atoms.h
index dbe58017a..e94825d29 100644
--- a/dynare++/parser/cc/static_atoms.h
+++ b/dynare++/parser/cc/static_atoms.h
@@ -7,79 +7,95 @@
 
 #include "dynamic_atoms.h"
 
-namespace ogp {
+namespace ogp
+{
 
-	class StaticAtoms : public Atoms, public Constants {
-	protected:
-		typedef map<const char*, int, ltstr> Tvarmap;
-		typedef map<int, const char*> Tinvmap;
-		/** Storage for names. */
-		NameStorage varnames;
-		/** Outer order of variables. */
-		vector<const char*> varorder;
-		/** This is the map mapping a variable name to the tree
-		 * index. */
-		Tvarmap vars;
-		/** This is the inverse mapping. It maps a tree index to the
-		 * variable name. */
-		Tinvmap indices;
-	public:
-		StaticAtoms() : Atoms(), Constants(), varnames(), varorder(), vars()
-			{}
-		/* Copy constructor. */
-		StaticAtoms(const StaticAtoms& a);
-		/** Conversion from DynamicAtoms. This takes all atoms from
-		 * the DynamicAtoms and adds its static version. The new tree
-		 * indices are allocated in the passed OperationTree. Whole
-		 * the process is traced in the map mapping old tree indices
-		 * to new tree indices. */
-		StaticAtoms(const DynamicAtoms& da, OperationTree& otree, Tintintmap& tmap)
-			: Atoms(), Constants(), varnames(), varorder(), vars()
-			{import_atoms(da, otree, tmap);}
-		/* Destructor. */
-		virtual ~StaticAtoms() {}
-		/** This imports atoms from dynamic atoms inserting the new
-		 * tree indices to the given tree (including constants). The
-		 * mapping from old atoms to new atoms is traced in tmap. */
-		void import_atoms(const DynamicAtoms& da, OperationTree& otree,
-						  Tintintmap& tmap);
-		/** If the name is constant, it returns its tree index if the
-		 * constant is registered in Constants, it returns -1
-		 * otherwise. If the name is not constant, it returns result
-		 * from check_variable, which is implemented by a subclass. */
-		int check(const char* name) const;
-		/** This assigns a given tree index to the variable name. The
-		 * name should have been checked before the call. */
-		void assign(const char* name, int t);
-		int nvar() const
-			{return varnames.num();}
-		/** This returns a vector of all variables. */
-		vector<int> variables() const;
-		/** This returns a tree index of the given variable. */
-		int index(const char* name) const;
-		/** This returns a name from the given tree index. NULL is
-		 * returned if the tree index doesn't exist. */
-		const char* inv_index(int t) const;
-		/** This returns a name in a outer ordering. (There is no other ordering.) */
-		const char* name(int i) const
-			{return varorder[i];}
-		/** Debug print. */
-		void print() const;
-		/** This registers a variable. A subclass can reimplement
-		 * this, for example, to ensure uniqueness of the
-		 * name. However, this method should be always called in
-		 * overriding methods to do the registering job. */
-		virtual void register_name(const char* name);
-		/** Return the name storage to allow querying to other
-		 * classes. */
-		const NameStorage& get_name_storage() const
-			{return varnames;}
-	protected:
-		/** This checks the variable. The implementing subclass might
-		 * want to throw an exception if the variable has not been
-		 * registered. */
-		virtual int check_variable(const char* name) const = 0;
-	};
+  class StaticAtoms : public Atoms, public Constants
+  {
+  protected:
+    typedef map<const char *, int, ltstr> Tvarmap;
+    typedef map<int, const char *> Tinvmap;
+    /** Storage for names. */
+    NameStorage varnames;
+    /** Outer order of variables. */
+    vector<const char *> varorder;
+    /** This is the map mapping a variable name to the tree
+     * index. */
+    Tvarmap vars;
+    /** This is the inverse mapping. It maps a tree index to the
+     * variable name. */
+    Tinvmap indices;
+  public:
+    StaticAtoms() : Atoms(), Constants(), varnames(), varorder(), vars()
+    {
+    }
+    /* Copy constructor. */
+    StaticAtoms(const StaticAtoms &a);
+    /** Conversion from DynamicAtoms. This takes all atoms from
+     * the DynamicAtoms and adds its static version. The new tree
+     * indices are allocated in the passed OperationTree. Whole
+     * the process is traced in the map mapping old tree indices
+     * to new tree indices. */
+    StaticAtoms(const DynamicAtoms &da, OperationTree &otree, Tintintmap &tmap)
+      : Atoms(), Constants(), varnames(), varorder(), vars()
+    {
+      import_atoms(da, otree, tmap);
+    }
+    /* Destructor. */
+    virtual ~StaticAtoms()
+    {
+    }
+    /** This imports atoms from dynamic atoms inserting the new
+     * tree indices to the given tree (including constants). The
+     * mapping from old atoms to new atoms is traced in tmap. */
+    void import_atoms(const DynamicAtoms &da, OperationTree &otree,
+                      Tintintmap &tmap);
+    /** If the name is constant, it returns its tree index if the
+     * constant is registered in Constants, it returns -1
+     * otherwise. If the name is not constant, it returns result
+     * from check_variable, which is implemented by a subclass. */
+    int check(const char *name) const;
+    /** This assigns a given tree index to the variable name. The
+     * name should have been checked before the call. */
+    void assign(const char *name, int t);
+    int
+    nvar() const
+    {
+      return varnames.num();
+    }
+    /** This returns a vector of all variables. */
+    vector<int> variables() const;
+    /** This returns a tree index of the given variable. */
+    int index(const char *name) const;
+    /** This returns a name from the given tree index. NULL is
+     * returned if the tree index doesn't exist. */
+    const char *inv_index(int t) const;
+    /** This returns a name in a outer ordering. (There is no other ordering.) */
+    const char *
+    name(int i) const
+    {
+      return varorder[i];
+    }
+    /** Debug print. */
+    void print() const;
+    /** This registers a variable. A subclass can reimplement
+     * this, for example, to ensure uniqueness of the
+     * name. However, this method should be always called in
+     * overriding methods to do the registering job. */
+    virtual void register_name(const char *name);
+    /** Return the name storage to allow querying to other
+     * classes. */
+    const NameStorage &
+    get_name_storage() const
+    {
+      return varnames;
+    }
+  protected:
+    /** This checks the variable. The implementing subclass might
+     * want to throw an exception if the variable has not been
+     * registered. */
+    virtual int check_variable(const char *name) const = 0;
+  };
 };
 
 #endif
diff --git a/dynare++/parser/cc/static_fine_atoms.h b/dynare++/parser/cc/static_fine_atoms.h
index e80af1eae..c4247f4a7 100644
--- a/dynare++/parser/cc/static_fine_atoms.h
+++ b/dynare++/parser/cc/static_fine_atoms.h
@@ -8,165 +8,202 @@
 #include "static_atoms.h"
 #include "fine_atoms.h"
 
-namespace ogp {
+namespace ogp
+{
 
-	/** This class represents static atoms distinguishing between
-	 * parameters, endogenous and exogenous variables. The class
-	 * maintains also ordering of all three categories (referenced as
-	 * outer or inner, since there is only one ordering). It can be
-	 * constructed either from scratch, or from fine dynamic atoms. In
-	 * the latter case, one can decide if the ordering of this static
-	 * atoms should be internal or external ordering of the original
-	 * dynamic fine atoms. */
-	class StaticFineAtoms : public StaticAtoms {
-	public:
-		typedef map<int,int> Tintintmap;
-	protected:
-		typedef map<const char*, int, ltstr> Tvarintmap;
-	private:
-		/** The vector of parameter names, gives the parameter
-		 * ordering. */
-		vector<const char*> params;
-		/** A map mappping a parameter name to an index in the ordering. */
-		Tvarintmap param_outer_map;
-		/** The vector of endogenous variables. This defines the order
-		 * like parameters. */
-		vector<const char*> endovars;
-		/** A map mapping a name of an endogenous variable to an index
-		 * in the ordering. */
-		Tvarintmap endo_outer_map;
-		/** The vector of exogenous variables. Also defines the order
-		 * like parameters and endovars. */
-		vector<const char*> exovars;
-		/** A map mapping a name of an exogenous variable to an index
-		 * in the outer ordering. */
-		Tvarintmap exo_outer_map;
-		/** This vector defines a set of atoms as tree indices used
-		 * for differentiation. The order of the atoms in is the
-		 * concatenation of the outer ordering of endogenous and
-		 * exogenous. This vector is setup by parsing_finished() and
-		 * is returned by variables(). */
-		vector<int> der_atoms;
-		/** This is a mapping from endogenous atoms to all atoms in
-		 * der_atoms member. The mapping maps index in endogenous atom
-		 * ordering to index (not value) in der_atoms. It is useful if
-		 * one wants to evaluate derivatives wrt only endogenous
-		 * variables. It is set by parsing_finished(). By definition,
-		 * it is monotone. */
-		vector<int> endo_atoms_map;
-		/** This is a mapping from exogenous atoms to all atoms in
-		 * der_atoms member. It is the same as endo_atoms_map for
-		 * atoms of exogenous variables. */
-		vector<int> exo_atoms_map;		
-	public:
-		StaticFineAtoms() {}
-		/** Copy constructor making a new storage for atom names. */
-		StaticFineAtoms(const StaticFineAtoms& sfa);
-		/** Conversion from dynamic FineAtoms taking its outer
-		 * ordering as ordering of parameters, endogenous and
-		 * exogenous. A biproduct is an integer to integer map mapping
-		 * tree indices of the dynamic atoms to tree indices of the
-		 * static atoms. */
-		StaticFineAtoms(const FineAtoms& fa, OperationTree& otree, Tintintmap& tmap)
-			{StaticFineAtoms::import_atoms(fa, otree, tmap);}
-		/** Conversion from dynamic FineAtoms taking its internal
-		 * ordering as ordering of parameters, endogenous and
-		 * exogenous. A biproduct is an integer to integer map mapping
-		 * tree indices of the dynamic atoms to tree indices of the
-		 * static atoms. */
-		StaticFineAtoms(const FineAtoms& fa, OperationTree& otree, Tintintmap& tmap,
-						const char* dummy)
-			{StaticFineAtoms::import_atoms(fa, otree, tmap, dummy);}
-		virtual ~StaticFineAtoms() {}
-		/** This adds atoms from dynamic atoms inserting new tree
-		 * indices to the given tree and tracing the mapping from old
-		 * atoms to new atoms in tmap. The ordering of the static
-		 * atoms is the same as outer ordering of dynamic atoms. */
-		void import_atoms(const FineAtoms& fa, OperationTree& otree, Tintintmap& tmap);
-		/** This adds atoms from dynamic atoms inserting new tree
-		 * indices to the given tree and tracing the mapping from old
-		 * atoms to new atoms in tmap. The ordering of the static
-		 * atoms is the same as internal ordering of dynamic atoms. */
-		void import_atoms(const FineAtoms& fa, OperationTree& otree, Tintintmap& tmap,
-						  const char* dummy);
-		/** Overrides StaticAtoms::check_variable so that the error
-		 * would be raised if the variable name is not declared. A
-		 * variable is declared by inserting it to
-		 * StaticAtoms::varnames, which is done with registering
-		 * methods. This a responsibility of a subclass. */
-		int check_variable(const char* name) const;
-		/** Return an (external) ordering of parameters. */
-		const vector<const char*>& get_params() const
-			{return params;}
-		/** Return an external ordering of endogenous variables. */
-		const vector<const char*>& get_endovars() const
-			{return endovars;}
-		/** Return an external ordering of exogenous variables. */
-		const vector<const char*>& get_exovars() const
-			{return exovars;}
-		/** This constructs der_atoms, and the endo_endoms_map and
-		 * exo_atoms_map, which can be created only after the parsing
-		 * is finished. */
-		void parsing_finished();
-		/** Return the atoms with respect to which we are going to
-		 * differentiate. */
-		vector<int> variables() const
-			{return der_atoms;}
-		/** Return the endo_atoms_map. */
-		const vector<int>& get_endo_atoms_map() const
-			{return endo_atoms_map;}
-		/** Return the exo_atoms_map. */
-		const vector<int>& get_exo_atoms_map() const
-			{return endo_atoms_map;}
-		/** Return an index in the outer ordering of a given
-		 * parameter. An exception is thrown if the name is not a
-		 * parameter. */
-		int name2outer_param(const char* name) const;
-		/** Return an index in the outer ordering of a given
-		 * endogenous variable. An exception is thrown if the name is not a
-		 * and endogenous variable. */
-		int name2outer_endo(const char* name) const;
-		/** Return an index in the outer ordering of a given
-		 * exogenous variable. An exception is thrown if the name is not a
-		 * and exogenous variable. */
-		int name2outer_exo(const char* name) const;
-		/** Return the number of endogenous variables. */
-		int ny() const
-			{return endovars.size();}
-		/** Return the number of exogenous variables. */
-		int nexo() const
-			{return (int)exovars.size();}
-		/** Return the number of parameters. */
-		int np() const
-			{return (int)(params.size());}
-		/** Register unique endogenous variable name. The order of
-		 * calls defines the endo outer ordering. The method is
-		 * virtual, since a superclass may want to do some additional
-		 * action. */
-		virtual void register_uniq_endo(const char* name);
-		/** Register unique exogenous variable name. The order of
-		 * calls defines the exo outer ordering. The method is
-		 * virtual, since a superclass may want to do somem additional
-		 * action. */
-		virtual void register_uniq_exo(const char* name);
-		/** Register unique parameter name. The order of calls defines
-		 * the param outer ordering. The method is
-		 * virtual, since a superclass may want to do somem additional
-		 * action. */
-		virtual void register_uniq_param(const char* name);
-		/** Debug print. */
-		void print() const;
-	private:
-		/** Add endogenous variable name, which is already in the name
-		 * storage. */
-		void register_endo(const char* name);
-		/** Add exogenous variable name, which is already in the name
-		 * storage. */
-		void register_exo(const char* name);
-		/** Add parameter name, which is already in the name
-		 * storage. */
-		void register_param(const char* name);
-	};
+  /** This class represents static atoms distinguishing between
+   * parameters, endogenous and exogenous variables. The class
+   * maintains also ordering of all three categories (referenced as
+   * outer or inner, since there is only one ordering). It can be
+   * constructed either from scratch, or from fine dynamic atoms. In
+   * the latter case, one can decide if the ordering of this static
+   * atoms should be internal or external ordering of the original
+   * dynamic fine atoms. */
+  class StaticFineAtoms : public StaticAtoms
+  {
+  public:
+    typedef map<int, int> Tintintmap;
+  protected:
+    typedef map<const char *, int, ltstr> Tvarintmap;
+  private:
+    /** The vector of parameter names, gives the parameter
+     * ordering. */
+    vector<const char *> params;
+    /** A map mappping a parameter name to an index in the ordering. */
+    Tvarintmap param_outer_map;
+    /** The vector of endogenous variables. This defines the order
+     * like parameters. */
+    vector<const char *> endovars;
+    /** A map mapping a name of an endogenous variable to an index
+     * in the ordering. */
+    Tvarintmap endo_outer_map;
+    /** The vector of exogenous variables. Also defines the order
+     * like parameters and endovars. */
+    vector<const char *> exovars;
+    /** A map mapping a name of an exogenous variable to an index
+     * in the outer ordering. */
+    Tvarintmap exo_outer_map;
+    /** This vector defines a set of atoms as tree indices used
+     * for differentiation. The order of the atoms in is the
+     * concatenation of the outer ordering of endogenous and
+     * exogenous. This vector is setup by parsing_finished() and
+     * is returned by variables(). */
+    vector<int> der_atoms;
+    /** This is a mapping from endogenous atoms to all atoms in
+     * der_atoms member. The mapping maps index in endogenous atom
+     * ordering to index (not value) in der_atoms. It is useful if
+     * one wants to evaluate derivatives wrt only endogenous
+     * variables. It is set by parsing_finished(). By definition,
+     * it is monotone. */
+    vector<int> endo_atoms_map;
+    /** This is a mapping from exogenous atoms to all atoms in
+     * der_atoms member. It is the same as endo_atoms_map for
+     * atoms of exogenous variables. */
+    vector<int> exo_atoms_map;
+  public:
+    StaticFineAtoms()
+    {
+    }
+    /** Copy constructor making a new storage for atom names. */
+    StaticFineAtoms(const StaticFineAtoms &sfa);
+    /** Conversion from dynamic FineAtoms taking its outer
+     * ordering as ordering of parameters, endogenous and
+     * exogenous. A biproduct is an integer to integer map mapping
+     * tree indices of the dynamic atoms to tree indices of the
+     * static atoms. */
+    StaticFineAtoms(const FineAtoms &fa, OperationTree &otree, Tintintmap &tmap)
+    {
+      StaticFineAtoms::import_atoms(fa, otree, tmap);
+    }
+    /** Conversion from dynamic FineAtoms taking its internal
+     * ordering as ordering of parameters, endogenous and
+     * exogenous. A biproduct is an integer to integer map mapping
+     * tree indices of the dynamic atoms to tree indices of the
+     * static atoms. */
+    StaticFineAtoms(const FineAtoms &fa, OperationTree &otree, Tintintmap &tmap,
+                    const char *dummy)
+    {
+      StaticFineAtoms::import_atoms(fa, otree, tmap, dummy);
+    }
+    virtual ~StaticFineAtoms()
+    {
+    }
+    /** This adds atoms from dynamic atoms inserting new tree
+     * indices to the given tree and tracing the mapping from old
+     * atoms to new atoms in tmap. The ordering of the static
+     * atoms is the same as outer ordering of dynamic atoms. */
+    void import_atoms(const FineAtoms &fa, OperationTree &otree, Tintintmap &tmap);
+    /** This adds atoms from dynamic atoms inserting new tree
+     * indices to the given tree and tracing the mapping from old
+     * atoms to new atoms in tmap. The ordering of the static
+     * atoms is the same as internal ordering of dynamic atoms. */
+    void import_atoms(const FineAtoms &fa, OperationTree &otree, Tintintmap &tmap,
+                      const char *dummy);
+    /** Overrides StaticAtoms::check_variable so that the error
+     * would be raised if the variable name is not declared. A
+     * variable is declared by inserting it to
+     * StaticAtoms::varnames, which is done with registering
+     * methods. This a responsibility of a subclass. */
+    int check_variable(const char *name) const;
+    /** Return an (external) ordering of parameters. */
+    const vector<const char *> &
+    get_params() const
+    {
+      return params;
+    }
+    /** Return an external ordering of endogenous variables. */
+    const vector<const char *> &
+    get_endovars() const
+    {
+      return endovars;
+    }
+    /** Return an external ordering of exogenous variables. */
+    const vector<const char *> &
+    get_exovars() const
+    {
+      return exovars;
+    }
+    /** This constructs der_atoms, and the endo_endoms_map and
+     * exo_atoms_map, which can be created only after the parsing
+     * is finished. */
+    void parsing_finished();
+    /** Return the atoms with respect to which we are going to
+     * differentiate. */
+    vector<int>
+    variables() const
+    {
+      return der_atoms;
+    }
+    /** Return the endo_atoms_map. */
+    const vector<int> &
+    get_endo_atoms_map() const
+    {
+      return endo_atoms_map;
+    }
+    /** Return the exo_atoms_map. */
+    const vector<int> &
+    get_exo_atoms_map() const
+    {
+      return endo_atoms_map;
+    }
+    /** Return an index in the outer ordering of a given
+     * parameter. An exception is thrown if the name is not a
+     * parameter. */
+    int name2outer_param(const char *name) const;
+    /** Return an index in the outer ordering of a given
+     * endogenous variable. An exception is thrown if the name is not a
+     * and endogenous variable. */
+    int name2outer_endo(const char *name) const;
+    /** Return an index in the outer ordering of a given
+     * exogenous variable. An exception is thrown if the name is not a
+     * and exogenous variable. */
+    int name2outer_exo(const char *name) const;
+    /** Return the number of endogenous variables. */
+    int
+    ny() const
+    {
+      return endovars.size();
+    }
+    /** Return the number of exogenous variables. */
+    int
+    nexo() const
+    {
+      return (int) exovars.size();
+    }
+    /** Return the number of parameters. */
+    int
+    np() const
+    {
+      return (int) (params.size());
+    }
+    /** Register unique endogenous variable name. The order of
+     * calls defines the endo outer ordering. The method is
+     * virtual, since a superclass may want to do some additional
+     * action. */
+    virtual void register_uniq_endo(const char *name);
+    /** Register unique exogenous variable name. The order of
+     * calls defines the exo outer ordering. The method is
+     * virtual, since a superclass may want to do somem additional
+     * action. */
+    virtual void register_uniq_exo(const char *name);
+    /** Register unique parameter name. The order of calls defines
+     * the param outer ordering. The method is
+     * virtual, since a superclass may want to do somem additional
+     * action. */
+    virtual void register_uniq_param(const char *name);
+    /** Debug print. */
+    void print() const;
+  private:
+    /** Add endogenous variable name, which is already in the name
+     * storage. */
+    void register_endo(const char *name);
+    /** Add exogenous variable name, which is already in the name
+     * storage. */
+    void register_exo(const char *name);
+    /** Add parameter name, which is already in the name
+     * storage. */
+    void register_param(const char *name);
+  };
 
 };
 
diff --git a/dynare++/parser/cc/tree.h b/dynare++/parser/cc/tree.h
index a01b441fd..d8def9889 100644
--- a/dynare++/parser/cc/tree.h
+++ b/dynare++/parser/cc/tree.h
@@ -10,442 +10,511 @@
 #include <boost/unordered_set.hpp>
 #include <cstdio>
 
-namespace ogp {
+namespace ogp
+{
 
-	using boost::unordered_set;
-	using boost::unordered_map;
-	using std::vector;
-	using std::set;
-	using std::map;
+  using boost::unordered_set;
+  using boost::unordered_map;
+  using std::vector;
+  using std::set;
+  using std::map;
 
-	/** Enumerator representing nulary, unary and binary operation
-	 * codes. For nulary, 'none' is used. When one is adding a new
-	 * codes, he should update the code of #OperationTree::add_unary,
-	 * #OperationTree::add_binary, and of course
-	 * #OperationTree::add_derivative. */
-	enum code_t {NONE, UMINUS, LOG, EXP, SIN, COS, TAN, SQRT, ERF,
-				 ERFC, PLUS, MINUS, TIMES, DIVIDE, POWER};
+  /** Enumerator representing nulary, unary and binary operation
+   * codes. For nulary, 'none' is used. When one is adding a new
+   * codes, he should update the code of #OperationTree::add_unary,
+   * #OperationTree::add_binary, and of course
+   * #OperationTree::add_derivative. */
+  enum code_t {NONE, UMINUS, LOG, EXP, SIN, COS, TAN, SQRT, ERF,
+               ERFC, PLUS, MINUS, TIMES, DIVIDE, POWER};
 
-	/** Class representing a nulary, unary, or binary operation. */
-	class Operation {
-	protected:
-		/** Code of the operation. */
-		code_t code;
-		/** First operand. If none, then it is -1. */
-		int op1;
-		/** Second operand. If none, then it is -1. */
-		int op2;
+  /** Class representing a nulary, unary, or binary operation. */
+  class Operation
+  {
+  protected:
+    /** Code of the operation. */
+    code_t code;
+    /** First operand. If none, then it is -1. */
+    int op1;
+    /** Second operand. If none, then it is -1. */
+    int op2;
 
-	public:
-		/** Constructs a binary operation. */
-		Operation(code_t cd, int oper1, int oper2)
-			: code(cd), op1(oper1), op2(oper2) {}
-		/** Constructs a unary operation. */
-		Operation(code_t cd, int oper1)
-			: code(cd), op1(oper1), op2(-1) {}
-		/** Constructs a nulary operation. */
-		Operation()
-			: code(NONE), op1(-1), op2(-1) {}
-		/** A copy constructor. */
-		Operation(const Operation& op)
-			: code(op.code), op1(op.op1), op2(op.op2) {}
+  public:
+    /** Constructs a binary operation. */
+    Operation(code_t cd, int oper1, int oper2)
+      : code(cd), op1(oper1), op2(oper2)
+    {
+    }
+    /** Constructs a unary operation. */
+    Operation(code_t cd, int oper1)
+      : code(cd), op1(oper1), op2(-1)
+    {
+    }
+    /** Constructs a nulary operation. */
+    Operation()
+      : code(NONE), op1(-1), op2(-1)
+    {
+    }
+    /** A copy constructor. */
+    Operation(const Operation &op)
+      : code(op.code), op1(op.op1), op2(op.op2)
+    {
+    }
 
-		/** Operator =. */
-		const Operation& operator=(const Operation& op)
-			{
-				code = op.code;
-				op1 = op.op1;
-				op2 = op.op2;
-				return *this;
-			}
-		/** Operator ==. */
-		bool operator==(const Operation& op) const
-			{
-				return code == op.code && op1 == op.op1 && op2 == op.op2;
-			}
-		/** Operator < implementing lexicographic ordering. */
-		bool operator<(const Operation& op) const
-			{
-				return (code < op.code ||
-						code == op.code &&
-						(op1 < op.op1 || op1 == op.op1 && op2 < op.op2));
-			}
-		/** Returns a number of operands. */
-		int nary() const
-			{
-				return (op2 == -1)? ((op1 == -1) ? 0 : 1) : 2;
-			}
-		/** Returns a hash value of the operation. */
-		size_t hashval() const
-			{
-				return op2+1 + (op1+1)^15 + code^30;
-			}
+    /** Operator =. */
+    const Operation &
+    operator=(const Operation &op)
+    {
+      code = op.code;
+      op1 = op.op1;
+      op2 = op.op2;
+      return *this;
+    }
+    /** Operator ==. */
+    bool
+    operator==(const Operation &op) const
+    {
+      return code == op.code && op1 == op.op1 && op2 == op.op2;
+    }
+    /** Operator < implementing lexicographic ordering. */
+    bool
+    operator<(const Operation &op) const
+    {
+      return (code < op.code
+              || code == op.code
+              && (op1 < op.op1 || op1 == op.op1 && op2 < op.op2));
+    }
+    /** Returns a number of operands. */
+    int
+    nary() const
+    {
+      return (op2 == -1) ? ((op1 == -1) ? 0 : 1) : 2;
+    }
+    /** Returns a hash value of the operation. */
+    size_t
+    hashval() const
+    {
+      return op2+1 + (op1+1)^15 + code^30;
+    }
 
-		code_t getCode() const
-			{ return code; }
-		int getOp1() const
-			{ return op1; }
-		int getOp2() const
-			{ return op2; }
+    code_t
+    getCode() const
+    {
+      return code;
+    }
+    int
+    getOp1() const
+    {
+      return op1;
+    }
+    int
+    getOp2() const
+    {
+      return op2;
+    }
 
-	};
+  };
 
-	/** This struct is a predicate for ordering of the operations in
-	 * OperationTree class. now obsolete */
-	struct ltoper {
-		bool operator()(const Operation& oper1, const Operation& oper2) const
-			{return oper1 < oper2;}
-	};
+  /** This struct is a predicate for ordering of the operations in
+   * OperationTree class. now obsolete */
+  struct ltoper
+  {
+    bool
+    operator()(const Operation &oper1, const Operation &oper2) const
+    {
+      return oper1 < oper2;
+    }
+  };
 
-	/** Hash function object for Operation. */
-	struct ophash {
-		size_t operator()(const Operation& op) const
-			{ return op.hashval(); }
-	};
+  /** Hash function object for Operation. */
+  struct ophash
+  {
+    size_t
+    operator()(const Operation &op) const
+    {
+      return op.hashval();
+    }
+  };
 
-	/** This struct is a function object selecting some
-	 * operations. The operation is given by a tree index. */
-	struct opselector {
-		virtual bool operator()(int t) const = 0;
-		virtual ~opselector() {}
-	};
+  /** This struct is a function object selecting some
+   * operations. The operation is given by a tree index. */
+  struct opselector
+  {
+    virtual bool operator()(int t) const = 0;
+    virtual ~opselector()
+    {
+    }
+  };
 
-	/** Forward declaration of OperationFormatter. */
-	class OperationFormatter;
-	class DefaultOperationFormatter;
+  /** Forward declaration of OperationFormatter. */
+  class OperationFormatter;
+  class DefaultOperationFormatter;
 
-	/** Forward declaration of EvalTree to make it friend of OperationTree. */
-	class EvalTree;
+  /** Forward declaration of EvalTree to make it friend of OperationTree. */
+  class EvalTree;
 
-	/** Class representing a set of trees for terms. Each term is
-	 * given a unique non-negative integer. The terms are basically
-	 * operations whose (integer) operands point to another terms in
-	 * the tree. The terms are stored in the vector. Equivalent unary
-	 * and binary terms are stored only once. This class guarantees
-	 * the uniqueness. The uniqueness of nulary terms is guaranteed by
-	 * the caller, since at this level of Operation abstraction, one
-	 * cannot discriminate between different nulary operations
-	 * (constants, variables). The uniqueness is enforced by the
-	 * unordered_map whose keys are operations and values are integers
-	 * (indices of the terms).
+  /** Class representing a set of trees for terms. Each term is
+   * given a unique non-negative integer. The terms are basically
+   * operations whose (integer) operands point to another terms in
+   * the tree. The terms are stored in the vector. Equivalent unary
+   * and binary terms are stored only once. This class guarantees
+   * the uniqueness. The uniqueness of nulary terms is guaranteed by
+   * the caller, since at this level of Operation abstraction, one
+   * cannot discriminate between different nulary operations
+   * (constants, variables). The uniqueness is enforced by the
+   * unordered_map whose keys are operations and values are integers
+   * (indices of the terms).
 
-	 * This class can also make derivatives of a given term with
-	 * respect to a given nulary term. I order to be able to quickly
-	 * recognize zero derivativates, we maintain a list of nulary
-	 * terms contained in the term. A possible zero derivative is then quickly
-	 * recognized by looking at the list. The list is implemented as a
-	 * unordered_set of integers.
-	 *
-	 * In addition, many term can be differentiated multiple times wrt
-	 * one variable since they can be referenced multiple times. To
-	 * avoid this, for each term we maintain a map mapping variables
-	 * to the derivatives of the term. As the caller will
-	 * differentiate wrt more and more variables, these maps will
-	 * become richer and richer.
-	 */
-	class OperationTree {
-		friend class EvalTree;
-		friend class DefaultOperationFormatter;
-	protected:
-		/** This is the vector of the terms. An index to this vector
-		 * uniquelly determines the term. */
-		vector<Operation> terms;
+   * This class can also make derivatives of a given term with
+   * respect to a given nulary term. I order to be able to quickly
+   * recognize zero derivativates, we maintain a list of nulary
+   * terms contained in the term. A possible zero derivative is then quickly
+   * recognized by looking at the list. The list is implemented as a
+   * unordered_set of integers.
+   *
+   * In addition, many term can be differentiated multiple times wrt
+   * one variable since they can be referenced multiple times. To
+   * avoid this, for each term we maintain a map mapping variables
+   * to the derivatives of the term. As the caller will
+   * differentiate wrt more and more variables, these maps will
+   * become richer and richer.
+   */
+  class OperationTree
+  {
+    friend class EvalTree;
+    friend class DefaultOperationFormatter;
+  protected:
+    /** This is the vector of the terms. An index to this vector
+     * uniquelly determines the term. */
+    vector<Operation> terms;
 
-		/** This defines a type for a map mapping the unary and binary
-		 * operations to their indices. */
-		typedef unordered_map<Operation, int, ophash> _Topmap;
-		typedef _Topmap::value_type _Topval;
+    /** This defines a type for a map mapping the unary and binary
+     * operations to their indices. */
+    typedef unordered_map<Operation, int, ophash> _Topmap;
+    typedef _Topmap::value_type _Topval;
 
-		/** This is the map mapping the unary and binary operations to
-		 * the indices of the terms.*/
-		_Topmap opmap;
+    /** This is the map mapping the unary and binary operations to
+     * the indices of the terms.*/
+    _Topmap opmap;
 
-		/** This is a type for a set of integers. */
-		typedef unordered_set<int> _Tintset;
-		/** This is a vector of integer sets corresponding to the
-		 * nulary terms contained in the term. */
-		vector<_Tintset> nul_incidence;
+    /** This is a type for a set of integers. */
+    typedef unordered_set<int> _Tintset;
+    /** This is a vector of integer sets corresponding to the
+     * nulary terms contained in the term. */
+    vector<_Tintset> nul_incidence;
 
-		/** This is a type of the map from variables (nulary terms) to
-		 * the terms. */
-		typedef unordered_map<int, int> _Tderivmap;
-		/** This is a vector of derivative mappings. For each term, it
-		 * maps variables to the derivatives of the term with respect
-		 * to the variables. */
-		vector<_Tderivmap> derivatives;
+    /** This is a type of the map from variables (nulary terms) to
+     * the terms. */
+    typedef unordered_map<int, int> _Tderivmap;
+    /** This is a vector of derivative mappings. For each term, it
+     * maps variables to the derivatives of the term with respect
+     * to the variables. */
+    vector<_Tderivmap> derivatives;
 
-		/** The tree index of the last nulary term. */
-		int last_nulary;
-	public:
-		/** This is a number of constants set in the following
-		 * enum. This number reserves space in a vector of terms for
-		 * the constants. */
-		static const int num_constants = 4;
-		/** Enumeration for special terms. We need zero, one, nan and
-		 * 2/pi.  These will be always first four terms having indices
-		 * zero, one and two, three. If adding anything to this
-		 * enumeration, make sure you have updated num_constants above.*/
-		enum {zero=0, one=1, nan=2, two_over_pi=3};
+    /** The tree index of the last nulary term. */
+    int last_nulary;
+  public:
+    /** This is a number of constants set in the following
+     * enum. This number reserves space in a vector of terms for
+     * the constants. */
+    static const int num_constants = 4;
+    /** Enumeration for special terms. We need zero, one, nan and
+     * 2/pi.  These will be always first four terms having indices
+     * zero, one and two, three. If adding anything to this
+     * enumeration, make sure you have updated num_constants above.*/
+    enum {zero = 0, one = 1, nan = 2, two_over_pi = 3};
 
-		/** The unique constructor which initializes the object to
-		 * contain only zero, one and nan and two_over_pi.*/
-		OperationTree();
+    /** The unique constructor which initializes the object to
+     * contain only zero, one and nan and two_over_pi.*/
+    OperationTree();
 
-		/** Copy constructor. */
-		OperationTree(const OperationTree& ot)
-			: terms(ot.terms), opmap(ot.opmap), nul_incidence(ot.nul_incidence),
-			  derivatives(ot.derivatives),
-			  last_nulary(ot.last_nulary)
-			{}
+    /** Copy constructor. */
+    OperationTree(const OperationTree &ot)
+      : terms(ot.terms), opmap(ot.opmap), nul_incidence(ot.nul_incidence),
+        derivatives(ot.derivatives),
+        last_nulary(ot.last_nulary)
+    {
+    }
 
-		/** Add a nulary operation. The caller is responsible for not
-		 * inserting two semantically equivalent nulary operations.
-		 * @return newly allocated index
-		 */
-		int add_nulary();
+    /** Add a nulary operation. The caller is responsible for not
+     * inserting two semantically equivalent nulary operations.
+     * @return newly allocated index
+     */
+    int add_nulary();
 
-		/** Add a unary operation. The uniqness is checked, if it
-		 * already exists, then it is not added.
-		 * @param code the code of the unary operation
-		 * @param op the index of the operand
-		 * @return the index of the operation
-		*/
-		int add_unary(code_t code, int op);
+    /** Add a unary operation. The uniqness is checked, if it
+     * already exists, then it is not added.
+     * @param code the code of the unary operation
+     * @param op the index of the operand
+     * @return the index of the operation
+     */
+    int add_unary(code_t code, int op);
 
-		/** Add a binary operation. The uniqueness is checked, if it
-		 * already exists, then it is not added. 
-		 * @param code the code of the binary operation
-		 * @param op1 the index of the first operand
-		 * @param op2 the index of the second operand
-		 * @return the index of the operation
-		 */
-		int add_binary(code_t code, int op1, int op2);
+    /** Add a binary operation. The uniqueness is checked, if it
+     * already exists, then it is not added.
+     * @param code the code of the binary operation
+     * @param op1 the index of the first operand
+     * @param op2 the index of the second operand
+     * @return the index of the operation
+     */
+    int add_binary(code_t code, int op1, int op2);
 
-		/** Add the derivative of the given term with respect to the
-		 * given nulary operation.
-		 * @param t the index of the operation being differentiated
-		 * @param v the index of the nulary operation
-		 * @return the index of the derivative
-		 */
-		int add_derivative(int t, int v);
+    /** Add the derivative of the given term with respect to the
+     * given nulary operation.
+     * @param t the index of the operation being differentiated
+     * @param v the index of the nulary operation
+     * @return the index of the derivative
+     */
+    int add_derivative(int t, int v);
 
-		/** Add the substitution given by the map. This adds a new
-		 * term which is equal to the given term with applied
-		 * substitutions given by the map replacing each term on the
-		 * left by a term on the right. We do not check that the terms
-		 * on the left are not subterms of the terms on the right. If
-		 * so, the substituted terms are not subject of further
-		 * substitution. */
-		int add_substitution(int t, const map<int,int>& subst);
+    /** Add the substitution given by the map. This adds a new
+     * term which is equal to the given term with applied
+     * substitutions given by the map replacing each term on the
+     * left by a term on the right. We do not check that the terms
+     * on the left are not subterms of the terms on the right. If
+     * so, the substituted terms are not subject of further
+     * substitution. */
+    int add_substitution(int t, const map<int, int> &subst);
 
-		/** Add the substitution given by the map where left sides of
-		 * substitutions come from another tree. The right sides are
-		 * from this tree. The given t is from the given otree. */
-		int add_substitution(int t, const map<int,int>& subst,
-							 const OperationTree& otree);
+    /** Add the substitution given by the map where left sides of
+     * substitutions come from another tree. The right sides are
+     * from this tree. The given t is from the given otree. */
+    int add_substitution(int t, const map<int, int> &subst,
+                         const OperationTree &otree);
 
-		/** This method turns the given term to a nulary
-		 * operation. This is an only method, which changes already
-		 * existing term (all other methods add something new). User
-		 * should use this with caution and must make sure that
-		 * something similar has happened for atoms. In addition, it
-		 * does not do anything with derivatives, so it should not be
-		 * used after some derivatives were created, and derivatives
-		 * already created and saved in derivatives mappings should be
-		 * forgotten with forget_derivative_maps. */
-		void nularify(int t);
+    /** This method turns the given term to a nulary
+     * operation. This is an only method, which changes already
+     * existing term (all other methods add something new). User
+     * should use this with caution and must make sure that
+     * something similar has happened for atoms. In addition, it
+     * does not do anything with derivatives, so it should not be
+     * used after some derivatives were created, and derivatives
+     * already created and saved in derivatives mappings should be
+     * forgotten with forget_derivative_maps. */
+    void nularify(int t);
 
-		/** Return the set of nulary terms of the given term. */
-		const unordered_set<int>& nulary_of_term(int t) const
-			{return nul_incidence[t];}
+    /** Return the set of nulary terms of the given term. */
+    const unordered_set<int> &
+    nulary_of_term(int t) const
+    {
+      return nul_incidence[t];
+    }
 
-		/** Select subterms of the given term according a given
-		 * operation selector and return the set of terms that
-		 * correspond to the compounded operations. The given term is
-		 * a compound function of the returned subterms and the
-		 * function consists only from operations which yield false in
-		 * the selector. */
-		unordered_set<int> select_terms(int t, const opselector& sel) const;
+    /** Select subterms of the given term according a given
+     * operation selector and return the set of terms that
+     * correspond to the compounded operations. The given term is
+     * a compound function of the returned subterms and the
+     * function consists only from operations which yield false in
+     * the selector. */
+    unordered_set<int> select_terms(int t, const opselector &sel) const;
 
-		/** Select subterms of the given term according a given
-		 * operation selector and return the set of terms that
-		 * correspond to the compounded operations. The given term is
-		 * a compound function of the returned subterms and the
-		 * subterms are maximal subterms consisting from operations
-		 * yielding true in the selector. */
-		unordered_set<int> select_terms_inv(int t, const opselector& sel) const;
+    /** Select subterms of the given term according a given
+     * operation selector and return the set of terms that
+     * correspond to the compounded operations. The given term is
+     * a compound function of the returned subterms and the
+     * subterms are maximal subterms consisting from operations
+     * yielding true in the selector. */
+    unordered_set<int> select_terms_inv(int t, const opselector &sel) const;
 
-		/** This forgets all the derivative mappings. It is used after
-		 * a term has been nularified, and then the derivative
-		 * mappings carry wrong information. Note that the derivatives
-		 * mappings serve only as a tool for quick returns in
-		 * add_derivative. Resseting the mappings is harmless, all the
-		 * information is rebuilt in add_derivative without any
-		 * additional nodes (trees). */
-		void forget_derivative_maps();
+    /** This forgets all the derivative mappings. It is used after
+     * a term has been nularified, and then the derivative
+     * mappings carry wrong information. Note that the derivatives
+     * mappings serve only as a tool for quick returns in
+     * add_derivative. Resseting the mappings is harmless, all the
+     * information is rebuilt in add_derivative without any
+     * additional nodes (trees). */
+    void forget_derivative_maps();
 
-		/** This returns an operation of a given term. */
-		const Operation& operation(int t) const
-			{return terms[t];}
+    /** This returns an operation of a given term. */
+    const Operation &
+    operation(int t) const
+    {
+      return terms[t];
+    }
 
-		/** This outputs the operation to the given file descriptor
-		 * using the given OperationFormatter. */
-		void print_operation_tree(int t, FILE* fd, OperationFormatter& f) const;
+    /** This outputs the operation to the given file descriptor
+     * using the given OperationFormatter. */
+    void print_operation_tree(int t, FILE *fd, OperationFormatter &f) const;
 
-		/** Debug print of a given operation: */
-		void print_operation(int t) const;
+    /** Debug print of a given operation: */
+    void print_operation(int t) const;
 
-		/** Return the last tree index of a nulary term. */
-		int get_last_nulary() const
-			{return last_nulary;}
+    /** Return the last tree index of a nulary term. */
+    int
+    get_last_nulary() const
+    {
+      return last_nulary;
+    }
 
-		/** Get the number of all operations. */
-		int get_num_op() const
-			{return (int)(terms.size());}
-	private:
-		/** This registers a calculated derivative of the term in the
-		 * #derivatives vector.
-		 * @param t the index of the term for which we register the derivative
-		 * @param v the index of the nulary term (variable) to which
-		 * respect the derivative was taken
-		 * @param tder the index of the resulting derivative
-		 */
-		void register_derivative(int t, int v, int tder);
-		/** This does the same job as select_terms with the only
-		 * difference, that it adds the terms to the given set and
-		 * hence can be used recursivelly. */
-		void select_terms(int t, const opselector& sel, unordered_set<int>& subterms) const; 
-		/** This does the same job as select_terms_inv with the only
-		 * difference, that it adds the terms to the given set and
-		 * hence can be used recursivelly and returns true if the term
-		 * was selected. */
-		bool select_terms_inv(int t, const opselector& sel, unordered_set<int>& subterms) const; 
-		/** This updates nul_incidence information after the term t
-		 * was turned to a nulary term in all terms. It goes through
-		 * the tree from simplest terms to teh more complex ones and
-		 * changes the nul_incidence information where necesary. It
-		 * maintains a set where the changes have been made.*/
-		void update_nul_incidence_after_nularify(int t);
-	};
+    /** Get the number of all operations. */
+    int
+    get_num_op() const
+    {
+      return (int) (terms.size());
+    }
+  private:
+    /** This registers a calculated derivative of the term in the
+     * #derivatives vector.
+     * @param t the index of the term for which we register the derivative
+     * @param v the index of the nulary term (variable) to which
+     * respect the derivative was taken
+     * @param tder the index of the resulting derivative
+     */
+    void register_derivative(int t, int v, int tder);
+    /** This does the same job as select_terms with the only
+     * difference, that it adds the terms to the given set and
+     * hence can be used recursivelly. */
+    void select_terms(int t, const opselector &sel, unordered_set<int> &subterms) const;
+    /** This does the same job as select_terms_inv with the only
+     * difference, that it adds the terms to the given set and
+     * hence can be used recursivelly and returns true if the term
+     * was selected. */
+    bool select_terms_inv(int t, const opselector &sel, unordered_set<int> &subterms) const;
+    /** This updates nul_incidence information after the term t
+     * was turned to a nulary term in all terms. It goes through
+     * the tree from simplest terms to teh more complex ones and
+     * changes the nul_incidence information where necesary. It
+     * maintains a set where the changes have been made.*/
+    void update_nul_incidence_after_nularify(int t);
+  };
 
-	/** EvalTree class allows for an evaluation of the given tree for
-	 * a given values of nulary terms. For each term in the
-	 * OperationTree the class maintains a resulting value and a flag
-	 * if the value has been calculated or set. The life cycle of the
-	 * class is the following: After it is initialized, the user must
-	 * set values for necessary nulary terms. Then the object can be
-	 * requested to evaluate particular terms. During this process,
-	 * the number of evaluated terms is increasing. Then the user can
-	 * request overall reset of evaluation flags, set the nulary terms
-	 * to new values and evaluate a number of terms.
-	 *
-	 * Note that currently the user cannot request a reset of
-	 * evaluation flags only for those terms depending on a given
-	 * nulary term. This might be added in future and handeled by a
-	 * subclasses of OperationTree and EvalTree, since we need a
-	 * support for this in OperationTree.
-	 */
-	class EvalTree {
-	protected:
-		/** Reference to the OperationTree over which all evaluations
-		 * are done. */
-		const OperationTree& otree;
-		/** The array of values. */
-		double* const values;
-		/** The array of evaluation flags. */
-		bool* const flags;
-		/** The index of last operation in the EvalTree. Length of
-		 * values and flags will be then last_operation+1. */
-		int last_operation;
-	public:
-		/** Initializes the evaluation tree for the given operation
-		 * tree. If last is greater than -1, that the evaluation tree
-		 * will contain only formulas up to the given last index
-		 * (included). */
-		EvalTree(const OperationTree& otree, int last = -1);
-		virtual ~EvalTree()
-			{ delete [] values; delete [] flags; }
-		/** Set evaluation flag to all terms (besides the first
-		 * special terms) to false. */
-		void reset_all();
-		/** Set value for a given nulary term. */
-		void set_nulary(int t, double val);
-		/** Evaluate the given term with nulary terms set so far. */
-		double eval(int t);
-		/** Debug print. */
-		void print() const;
-		/* Return the operation tree. */
-		const OperationTree& getOperationTree() const
-			{return otree;}
-	private:
-		EvalTree(const EvalTree&);
-	};
+  /** EvalTree class allows for an evaluation of the given tree for
+   * a given values of nulary terms. For each term in the
+   * OperationTree the class maintains a resulting value and a flag
+   * if the value has been calculated or set. The life cycle of the
+   * class is the following: After it is initialized, the user must
+   * set values for necessary nulary terms. Then the object can be
+   * requested to evaluate particular terms. During this process,
+   * the number of evaluated terms is increasing. Then the user can
+   * request overall reset of evaluation flags, set the nulary terms
+   * to new values and evaluate a number of terms.
+   *
+   * Note that currently the user cannot request a reset of
+   * evaluation flags only for those terms depending on a given
+   * nulary term. This might be added in future and handeled by a
+   * subclasses of OperationTree and EvalTree, since we need a
+   * support for this in OperationTree.
+   */
+  class EvalTree
+  {
+  protected:
+    /** Reference to the OperationTree over which all evaluations
+     * are done. */
+    const OperationTree &otree;
+    /** The array of values. */
+    double *const values;
+    /** The array of evaluation flags. */
+    bool *const flags;
+    /** The index of last operation in the EvalTree. Length of
+     * values and flags will be then last_operation+1. */
+    int last_operation;
+  public:
+    /** Initializes the evaluation tree for the given operation
+     * tree. If last is greater than -1, that the evaluation tree
+     * will contain only formulas up to the given last index
+     * (included). */
+    EvalTree(const OperationTree &otree, int last = -1);
+    virtual ~EvalTree()
+    {
+      delete [] values; delete [] flags;
+    }
+    /** Set evaluation flag to all terms (besides the first
+     * special terms) to false. */
+    void reset_all();
+    /** Set value for a given nulary term. */
+    void set_nulary(int t, double val);
+    /** Evaluate the given term with nulary terms set so far. */
+    double eval(int t);
+    /** Debug print. */
+    void print() const;
+    /* Return the operation tree. */
+    const OperationTree &
+    getOperationTree() const
+    {
+      return otree;
+    }
+  private:
+    EvalTree(const EvalTree &);
+  };
 
-	/** This is an interface describing how a given operation is
-	 * formatted for output. */
-	class OperationFormatter {
-	public:
-		/** Empty virtual destructor. */
-		virtual ~OperationFormatter() {}
-		/** Print the formatted operation op with a given tree index t
-		 * to a given descriptor. (See class OperationTree to know
-		 * what is a tree index.) This prints all the tree. This
-		 * always writes equation, left hand side is a string
-		 * represenation (a variable, temporary, whatever) of the
-		 * term, the right hand side is a string representation of the
-		 * operation (which will refer to other string representation
-		 * of subterms). */
-		virtual void format(const Operation& op, int t, FILE* fd)=0;
-	};
+  /** This is an interface describing how a given operation is
+   * formatted for output. */
+  class OperationFormatter
+  {
+  public:
+    /** Empty virtual destructor. */
+    virtual ~OperationFormatter()
+    {
+    }
+    /** Print the formatted operation op with a given tree index t
+     * to a given descriptor. (See class OperationTree to know
+     * what is a tree index.) This prints all the tree. This
+     * always writes equation, left hand side is a string
+     * represenation (a variable, temporary, whatever) of the
+     * term, the right hand side is a string representation of the
+     * operation (which will refer to other string representation
+     * of subterms). */
+    virtual void format(const Operation &op, int t, FILE *fd) = 0;
+  };
 
-	/** The default formatter formats the formulas with a usual syntax
-	 * (for example Matlab). A formatting of atoms and terms might be
-	 * reimplemented by a subclass. In addition, during its life, the
-	 * object maintains a set of tree indices which have been output
-	 * and they are not output any more. */
-	class DefaultOperationFormatter : public OperationFormatter {
-	protected:
-		const OperationTree& otree;
-		set<int> stop_set;
-	public:
-		DefaultOperationFormatter(const OperationTree& ot)
-			: otree(ot) {}
-		/** Format the operation with the default syntax. */
-		void format(const Operation& op, int t, FILE* fd);
-		/** This prints a string represenation of the given term, for
-		 * example 'tmp10' for term 10. In this implementation it
-		 * prints $10. */
-		virtual void format_term(int t, FILE* fd) const;
-		/** Print a string representation of the nulary term. */
-		virtual void format_nulary(int t, FILE* fd) const;
-		/** Print a delimiter between two statements. By default it is
-		 * "\n". */
-		virtual void print_delim(FILE* fd) const;
-	};
+  /** The default formatter formats the formulas with a usual syntax
+   * (for example Matlab). A formatting of atoms and terms might be
+   * reimplemented by a subclass. In addition, during its life, the
+   * object maintains a set of tree indices which have been output
+   * and they are not output any more. */
+  class DefaultOperationFormatter : public OperationFormatter
+  {
+  protected:
+    const OperationTree &otree;
+    set<int> stop_set;
+  public:
+    DefaultOperationFormatter(const OperationTree &ot)
+      : otree(ot)
+    {
+    }
+    /** Format the operation with the default syntax. */
+    void format(const Operation &op, int t, FILE *fd);
+    /** This prints a string represenation of the given term, for
+     * example 'tmp10' for term 10. In this implementation it
+     * prints $10. */
+    virtual void format_term(int t, FILE *fd) const;
+    /** Print a string representation of the nulary term. */
+    virtual void format_nulary(int t, FILE *fd) const;
+    /** Print a delimiter between two statements. By default it is
+     * "\n". */
+    virtual void print_delim(FILE *fd) const;
+  };
 
-	class NularyStringConvertor {
-	public:
-		virtual ~NularyStringConvertor() {}
-		/** Return the string representation of the atom with the tree
-		 * index t. */
-		virtual std::string convert(int t) const = 0;
-	};
+  class NularyStringConvertor
+  {
+  public:
+    virtual ~NularyStringConvertor()
+    {
+    }
+    /** Return the string representation of the atom with the tree
+     * index t. */
+    virtual std::string convert(int t) const = 0;
+  };
 
-	/** This class converts the given term to its mathematical string representation. */
-	class OperationStringConvertor {
-	protected:
-		const NularyStringConvertor& nulsc;
-		const OperationTree& otree;
-	public:
-		OperationStringConvertor(const NularyStringConvertor& nsc, const OperationTree& ot)
-			: nulsc(nsc), otree(ot) {}
-		/** Empty virtual destructor. */
-		virtual ~OperationStringConvertor() {}
-		/** Convert the operation to the string mathematical
-		 * representation. This does not write any equation, just
-		 * returns a string representation of the formula. */
-		std::string convert(const Operation& op, int t) const;
-	};
+  /** This class converts the given term to its mathematical string representation. */
+  class OperationStringConvertor
+  {
+  protected:
+    const NularyStringConvertor &nulsc;
+    const OperationTree &otree;
+  public:
+    OperationStringConvertor(const NularyStringConvertor &nsc, const OperationTree &ot)
+      : nulsc(nsc), otree(ot)
+    {
+    }
+    /** Empty virtual destructor. */
+    virtual ~OperationStringConvertor()
+    {
+    }
+    /** Convert the operation to the string mathematical
+     * representation. This does not write any equation, just
+     * returns a string representation of the formula. */
+    std::string convert(const Operation &op, int t) const;
+  };
 };
 
 #endif
diff --git a/dynare++/src/dynare3.h b/dynare++/src/dynare3.h
index a106f52aa..723060a95 100644
--- a/dynare++/src/dynare3.h
+++ b/dynare++/src/dynare3.h
@@ -18,175 +18,286 @@
 
 class Dynare;
 
-class DynareNameList : public NameList {
-	vector<const char*> names;
+class DynareNameList : public NameList
+{
+  vector<const char *> names;
 public:
-	DynareNameList(const Dynare& dynare);
-	int getNum() const
-		{return (int)names.size();}
-	const char* getName(int i) const
-		{return names[i];}
-	/** This for each string of the input vector calculates its index
-	 * in the names. And returns the resulting vector of indices. If
-	 * the name cannot be found, then an exception is raised. */
-	vector<int> selectIndices(const vector<const char*>& ns) const;
+  DynareNameList(const Dynare &dynare);
+  int
+  getNum() const
+  {
+    return (int) names.size();
+  }
+  const char *
+  getName(int i) const
+  {
+    return names[i];
+  }
+  /** This for each string of the input vector calculates its index
+   * in the names. And returns the resulting vector of indices. If
+   * the name cannot be found, then an exception is raised. */
+  vector<int> selectIndices(const vector<const char *> &ns) const;
 };
 
-class DynareExogNameList : public NameList {
-	vector<const char*> names;
+class DynareExogNameList : public NameList
+{
+  vector<const char *> names;
 public:
-	DynareExogNameList(const Dynare& dynare);
-	int getNum() const
-		{return (int)names.size();}
-	const char* getName(int i) const
-		{return names[i];}
+  DynareExogNameList(const Dynare &dynare);
+  int
+  getNum() const
+  {
+    return (int) names.size();
+  }
+  const char *
+  getName(int i) const
+  {
+    return names[i];
+  }
 };
 
-class DynareStateNameList : public NameList {
-	vector<const char*> names;
+class DynareStateNameList : public NameList
+{
+  vector<const char *> names;
 public:
-	DynareStateNameList(const Dynare& dynare, const DynareNameList& dnl,
-						const DynareExogNameList& denl);
-	int getNum() const
-		{return (int)names.size();}
-	const char* getName(int i) const
-		{return names[i];}
+  DynareStateNameList(const Dynare &dynare, const DynareNameList &dnl,
+                      const DynareExogNameList &denl);
+  int
+  getNum() const
+  {
+    return (int) names.size();
+  }
+  const char *
+  getName(int i) const
+  {
+    return names[i];
+  }
 };
 
 // The following only implements DynamicModel with help of ogdyn::DynareModel
 
 class DynareJacobian;
-class Dynare : public DynamicModel {
-	friend class DynareNameList;
-	friend class DynareExogNameList;
-	friend class DynareStateNameList;
-	friend class DynareJacobian;
-	Journal& journal;
-	ogdyn::DynareModel* model;
-	Vector* ysteady;
-	TensorContainer<FSSparseTensor> md;
-	DynareNameList* dnl;
-	DynareExogNameList* denl;
-	DynareStateNameList* dsnl;
-	ogp::FormulaEvaluator* fe;
-	ogp::FormulaDerEvaluator* fde;
-	const double ss_tol;
+class Dynare : public DynamicModel
+{
+  friend class DynareNameList;
+  friend class DynareExogNameList;
+  friend class DynareStateNameList;
+  friend class DynareJacobian;
+  Journal &journal;
+  ogdyn::DynareModel *model;
+  Vector *ysteady;
+  TensorContainer<FSSparseTensor> md;
+  DynareNameList *dnl;
+  DynareExogNameList *denl;
+  DynareStateNameList *dsnl;
+  ogp::FormulaEvaluator *fe;
+  ogp::FormulaDerEvaluator *fde;
+  const double ss_tol;
 public:
-	/** Parses the given model file and uses the given order to
-	 * override order from the model file (if it is != -1). */
-	Dynare(const char* modname, int ord, double sstol, Journal& jr);
-	/** Parses the given equations with explicitly given names. */
-	Dynare(const char** endo, int num_endo,
-		   const char** exo, int num_exo,
-		   const char** par, int num_par,
-		   const char* equations, int len, int ord,
-		   double sstol, Journal& jr);
-	/** Makes a deep copy of the object. */
-	Dynare(const Dynare& dyn);
-	DynamicModel* clone() const
-		{return new Dynare(*this);}
-	virtual ~Dynare();
-	int nstat() const
-		{return model->getAtoms().nstat();}
-	int nboth() const
-		{return model->getAtoms().nboth();}
-	int npred() const
-		{return model->getAtoms().npred();}
-	int nforw() const
-		{return model->getAtoms().nforw();}
-	int nexog() const
-		{return model->getAtoms().nexo();}
-	int nys() const
-		{return model->getAtoms().nys();}
-	int nyss() const
-		{return model->getAtoms().nyss();}
-	int ny() const
-		{return model->getAtoms().ny();}
-	int order() const
-		{return model->getOrder();}
+  /** Parses the given model file and uses the given order to
+   * override order from the model file (if it is != -1). */
+  Dynare(const char *modname, int ord, double sstol, Journal &jr);
+  /** Parses the given equations with explicitly given names. */
+  Dynare(const char **endo, int num_endo,
+         const char **exo, int num_exo,
+         const char **par, int num_par,
+         const char *equations, int len, int ord,
+         double sstol, Journal &jr);
+  /** Makes a deep copy of the object. */
+  Dynare(const Dynare &dyn);
+  DynamicModel *
+  clone() const
+  {
+    return new Dynare(*this);
+  }
+  virtual
+  ~Dynare();
+  int
+  nstat() const
+  {
+    return model->getAtoms().nstat();
+  }
+  int
+  nboth() const
+  {
+    return model->getAtoms().nboth();
+  }
+  int
+  npred() const
+  {
+    return model->getAtoms().npred();
+  }
+  int
+  nforw() const
+  {
+    return model->getAtoms().nforw();
+  }
+  int
+  nexog() const
+  {
+    return model->getAtoms().nexo();
+  }
+  int
+  nys() const
+  {
+    return model->getAtoms().nys();
+  }
+  int
+  nyss() const
+  {
+    return model->getAtoms().nyss();
+  }
+  int
+  ny() const
+  {
+    return model->getAtoms().ny();
+  }
+  int
+  order() const
+  {
+    return model->getOrder();
+  }
 
-	const NameList& getAllEndoNames() const
-		{return *dnl;}
-	const NameList& getStateNames() const
-		{return *dsnl;}
-	const NameList& getExogNames() const
-		{return *denl;}
+  const NameList &
+  getAllEndoNames() const
+  {
+    return *dnl;
+  }
+  const NameList &
+  getStateNames() const
+  {
+    return *dsnl;
+  }
+  const NameList &
+  getExogNames() const
+  {
+    return *denl;
+  }
 
-	TwoDMatrix& getVcov()
-		{return model->getVcov();}
-	const TwoDMatrix& getVcov() const
-		{return model->getVcov();}
-	Vector& getParams()
-		{return model->getParams();}
-	const Vector& getParams() const
-		{return model->getParams();}
-	void setInitOuter(const Vector& x)
-		{model->setInitOuter(x);}
+  TwoDMatrix &
+  getVcov()
+  {
+    return model->getVcov();
+  }
+  const TwoDMatrix &
+  getVcov() const
+  {
+    return model->getVcov();
+  }
+  Vector &
+  getParams()
+  {
+    return model->getParams();
+  }
+  const Vector &
+  getParams() const
+  {
+    return model->getParams();
+  }
+  void
+  setInitOuter(const Vector &x)
+  {
+    model->setInitOuter(x);
+  }
 
-	const TensorContainer<FSSparseTensor>& getModelDerivatives() const
-		{return md;}
-	const Vector& getSteady() const
-		{return *ysteady;}
-	Vector& getSteady()
-		{return *ysteady;}
-	const ogdyn::DynareModel& getModel() const
-		{return *model;}
+  const TensorContainer<FSSparseTensor> &
+  getModelDerivatives() const
+  {
+    return md;
+  }
+  const Vector &
+  getSteady() const
+  {
+    return *ysteady;
+  }
+  Vector &
+  getSteady()
+  {
+    return *ysteady;
+  }
+  const ogdyn::DynareModel &
+  getModel() const
+  {
+    return *model;
+  }
 
-	// here is true public interface
-	void solveDeterministicSteady(Vector& steady);
-	void solveDeterministicSteady()
-		{solveDeterministicSteady(*ysteady);}
-	void evaluateSystem(Vector& out, const Vector& yy, const Vector& xx);
-	void evaluateSystem(Vector& out, const Vector& yym, const Vector& yy,
-						const Vector& yyp, const Vector& xx);
-	void calcDerivatives(const Vector& yy, const Vector& xx);
-	void calcDerivativesAtSteady();
+  // here is true public interface
+  void solveDeterministicSteady(Vector &steady);
+  void
+  solveDeterministicSteady()
+  {
+    solveDeterministicSteady(*ysteady);
+  }
+  void evaluateSystem(Vector &out, const Vector &yy, const Vector &xx);
+  void evaluateSystem(Vector &out, const Vector &yym, const Vector &yy,
+                      const Vector &yyp, const Vector &xx);
+  void calcDerivatives(const Vector &yy, const Vector &xx);
+  void calcDerivativesAtSteady();
 
-	void writeMat(mat_t *fd, const char* prefix) const;
-	void writeDump(const std::string& basename) const;
+  void writeMat(mat_t *fd, const char *prefix) const;
+  void writeDump(const std::string &basename) const;
 private:
-	void writeModelInfo(Journal& jr) const;
+  void writeModelInfo(Journal &jr) const;
 };
 
-class DynareEvalLoader : public ogp::FormulaEvalLoader, public Vector {
+class DynareEvalLoader : public ogp::FormulaEvalLoader, public Vector
+{
 public:
-	DynareEvalLoader(const ogp::FineAtoms& a, Vector& out);
-	void load(int i, double res)
-		{operator[](i) = res;}
+  DynareEvalLoader(const ogp::FineAtoms &a, Vector &out);
+  void
+  load(int i, double res)
+  {
+    operator[](i) = res;
+  }
 };
 
-class DynareDerEvalLoader : public ogp::FormulaDerEvalLoader {
+class DynareDerEvalLoader : public ogp::FormulaDerEvalLoader
+{
 protected:
-	const ogp::FineAtoms& atoms;
-	TensorContainer<FSSparseTensor>& md;
+  const ogp::FineAtoms &atoms;
+  TensorContainer<FSSparseTensor> &md;
 public:
-	DynareDerEvalLoader(const ogp::FineAtoms& a, TensorContainer<FSSparseTensor>& mod_ders,
-						int order);
-	void load(int i, int iord, const int* vars, double res);
+  DynareDerEvalLoader(const ogp::FineAtoms &a, TensorContainer<FSSparseTensor> &mod_ders,
+                      int order);
+  void load(int i, int iord, const int *vars, double res);
 };
 
-class DynareJacobian : public ogu::Jacobian, public ogp::FormulaDerEvalLoader {
+class DynareJacobian : public ogu::Jacobian, public ogp::FormulaDerEvalLoader
+{
 protected:
-	Dynare& d;
+  Dynare &d;
 public:
-	DynareJacobian(Dynare& dyn);
-	virtual ~DynareJacobian() {}
-	void load(int i, int iord, const int* vars, double res);
-	void eval(const Vector& in);
+  DynareJacobian(Dynare &dyn);
+  virtual ~DynareJacobian()
+  {
+  }
+  void load(int i, int iord, const int *vars, double res);
+  void eval(const Vector &in);
 };
 
-class DynareVectorFunction : public ogu::VectorFunction {
+class DynareVectorFunction : public ogu::VectorFunction
+{
 protected:
-	Dynare& d;
+  Dynare &d;
 public:
-	DynareVectorFunction(Dynare& dyn)
-		: d(dyn) {}
-	virtual ~DynareVectorFunction() {}
-	int inDim() const
-		{return d.ny();}
-	int outDim() const
-		{return d.ny();}
-	void eval(const ConstVector& in, Vector& out);
+  DynareVectorFunction(Dynare &dyn)
+    : d(dyn)
+  {
+  }
+  virtual ~DynareVectorFunction()
+  {
+  }
+  int
+  inDim() const
+  {
+    return d.ny();
+  }
+  int
+  outDim() const
+  {
+    return d.ny();
+  }
+  void eval(const ConstVector &in, Vector &out);
 };
 
 #endif
diff --git a/dynare++/src/dynare_atoms.h b/dynare++/src/dynare_atoms.h
index 7cdcce6c2..68b938199 100644
--- a/dynare++/src/dynare_atoms.h
+++ b/dynare++/src/dynare_atoms.h
@@ -15,196 +15,222 @@
 #include <map>
 #include <vector>
 
-namespace ogdyn {
+namespace ogdyn
+{
 
-	using std::map;
-	using std::vector;
+  using std::map;
+  using std::vector;
 
-	/** A definition of a type mapping a string to an integer. Used as
-	 * a substitution map, saying what names are substituted for what
-	 * expressions represented by tree indices. */
-	typedef map<const char*, int, ogp::ltstr> Tsubstmap;
+  /** A definition of a type mapping a string to an integer. Used as
+   * a substitution map, saying what names are substituted for what
+   * expressions represented by tree indices. */
+  typedef map<const char *, int, ogp::ltstr> Tsubstmap;
 
-	class DynareStaticAtoms : public ogp::StaticAtoms {
-	public:
-		DynareStaticAtoms()
-			: StaticAtoms() {}
-		DynareStaticAtoms(const DynareStaticAtoms& a)
-			: StaticAtoms(a) {}
-		virtual ~DynareStaticAtoms() {}
-		/** This registers a unique varname identifier. It throws an
-		 * exception if the variable name is duplicate. It checks the
-		 * uniqueness and then it calls StaticAtoms::register_name. */
-		void register_name(const char* name);
-	protected:
-		/** This returns a tree index of the given variable, and if
-		 * the variable has not been registered, it throws an
-		 * exception. */
-		int check_variable(const char* name) const;
-	};
+  class DynareStaticAtoms : public ogp::StaticAtoms
+  {
+  public:
+    DynareStaticAtoms()
+      : StaticAtoms()
+    {
+    }
+    DynareStaticAtoms(const DynareStaticAtoms &a)
+      : StaticAtoms(a)
+    {
+    }
+    virtual ~DynareStaticAtoms()
+    {
+    }
+    /** This registers a unique varname identifier. It throws an
+     * exception if the variable name is duplicate. It checks the
+     * uniqueness and then it calls StaticAtoms::register_name. */
+    void register_name(const char *name);
+  protected:
+    /** This returns a tree index of the given variable, and if
+     * the variable has not been registered, it throws an
+     * exception. */
+    int check_variable(const char *name) const;
+  };
 
+  class DynareDynamicAtoms : public ogp::SAtoms, public ogp::NularyStringConvertor
+  {
+  public:
+    enum atype {endovar, exovar, param};
+  protected:
+    typedef map<const char *, atype, ogp::ltstr> Tatypemap;
+    /** The map assigining a type to each name. */
+    Tatypemap atom_type;
+  public:
+    DynareDynamicAtoms()
+      : ogp::SAtoms()
+    {
+    }
+    DynareDynamicAtoms(const DynareDynamicAtoms &dda);
+    virtual ~DynareDynamicAtoms()
+    {
+    }
+    /** This parses a variable of the forms: varname(+3),
+     * varname(3), varname, varname(-3), varname(0), varname(+0),
+     * varname(-0). */
+    virtual void parse_variable(const char *in, std::string &out, int &ll) const;
+    /** Registers unique name of endogenous variable. */
+    void register_uniq_endo(const char *name);
+    /** Registers unique name of exogenous variable. */
+    void register_uniq_exo(const char *name);
+    /** Registers unique name of parameter. */
+    void register_uniq_param(const char *name);
+    /** Return true if the name is a given type. */
+    bool is_type(const char *name, atype tp) const;
+    /** Debug print. */
+    void print() const;
+    /** Implement NularyStringConvertor::convert. */
+    std::string convert(int t) const;
+  };
 
-	class DynareDynamicAtoms : public ogp::SAtoms, public ogp::NularyStringConvertor {
-	public:
-		enum atype {endovar, exovar, param};
-	protected:
-		typedef map<const char*, atype, ogp::ltstr> Tatypemap;
-		/** The map assigining a type to each name. */
-		Tatypemap atom_type;
-	public:
-		DynareDynamicAtoms()
-			: ogp::SAtoms() {}
-		DynareDynamicAtoms(const DynareDynamicAtoms& dda);
-		virtual ~DynareDynamicAtoms() {}
-		/** This parses a variable of the forms: varname(+3),
-		 * varname(3), varname, varname(-3), varname(0), varname(+0),
-		 * varname(-0). */
-		virtual void parse_variable(const char* in, std::string& out, int& ll) const;
-		/** Registers unique name of endogenous variable. */
-		void register_uniq_endo(const char* name);
-		/** Registers unique name of exogenous variable. */
-		void register_uniq_exo(const char* name);
-		/** Registers unique name of parameter. */
-		void register_uniq_param(const char* name);
-		/** Return true if the name is a given type. */
-		bool is_type(const char* name, atype tp) const;
-		/** Debug print. */
-		void print() const;
-		/** Implement NularyStringConvertor::convert. */
-		std::string convert(int t) const;
-	};
+  /** This class represents the atom values for dynare, where
+   * exogenous variables can occur only at time t, and endogenous at
+   * times t-1, t, and t+1. */
+  class DynareAtomValues : public ogp::AtomValues
+  {
+  protected:
+    /** Reference to the atoms (we suppose that they are only at
+     * t-1,t,t+1. */
+    const ogp::FineAtoms &atoms;
+    /** De facto reference to the values of parameters. */
+    const ConstVector paramvals;
+    /** De facto reference to the values of endogenous at time t-1. Only
+     * predetermined and both part. */
+    const ConstVector yym;
+    /** De facto reference to the values of endogenous at time t. Ordering
+     * given by the atoms. */
+    const ConstVector yy;
+    /** De facto reference to the values of endogenous at time t+1. Only
+     * both and forward looking part. */
+    const ConstVector yyp;
+    /** De facto reference to the values of exogenous at time t. */
+    const ConstVector xx;
+  public:
+    DynareAtomValues(const ogp::FineAtoms &a, const Vector &pvals, const Vector &ym,
+                     const Vector &y, const Vector &yp, const Vector &x)
+      : atoms(a), paramvals(pvals), yym(ym), yy(y), yyp(yp), xx(x)
+    {
+    }
+    DynareAtomValues(const ogp::FineAtoms &a, const Vector &pvals, const ConstVector &ym,
+                     const Vector &y, const ConstVector &yp, const Vector &x)
+      : atoms(a), paramvals(pvals), yym(ym), yy(y), yyp(yp), xx(x)
+    {
+    }
+    void setValues(ogp::EvalTree &et) const;
+  };
 
+  /** This class represents the atom values at the steady state. It
+   * makes only appropriate subvector yym and yyp of the y vector,
+   * makes a vector of zero exogenous variables and uses
+   * DynareAtomValues with more general interface. */
+  class DynareSteadyAtomValues : public ogp::AtomValues
+  {
+  protected:
+    /** Subvector of yy. */
+    const ConstVector yym;
+    /** Subvector of yy. */
+    const ConstVector yyp;
+    /** Vector of zeros for exogenous variables. */
+    Vector xx;
+    /** Atom values using this yym, yyp and xx. */
+    DynareAtomValues av;
+  public:
+    DynareSteadyAtomValues(const ogp::FineAtoms &a, const Vector &pvals, const Vector &y)
+      : yym(y, a.nstat(), a.nys()),
+        yyp(y, a.nstat()+a.npred(), a.nyss()),
+        xx(a.nexo()),
+        av(a, pvals, yym, y, yyp, xx)
+    {
+      xx.zeros();
+    }
+    void
+    setValues(ogp::EvalTree &et) const
+    {
+      av.setValues(et);
+    }
+  };
 
-	/** This class represents the atom values for dynare, where
-	 * exogenous variables can occur only at time t, and endogenous at
-	 * times t-1, t, and t+1. */
-	class DynareAtomValues : public ogp::AtomValues {
-	protected:
-		/** Reference to the atoms (we suppose that they are only at
-		 * t-1,t,t+1. */
-		const ogp::FineAtoms& atoms;
-		/** De facto reference to the values of parameters. */
-		const ConstVector paramvals;
-		/** De facto reference to the values of endogenous at time t-1. Only
-		 * predetermined and both part. */
-		const ConstVector yym;
-		/** De facto reference to the values of endogenous at time t. Ordering
-		 * given by the atoms. */
-		const ConstVector yy;
-		/** De facto reference to the values of endogenous at time t+1. Only
-		 * both and forward looking part. */
-		const ConstVector yyp;
-		/** De facto reference to the values of exogenous at time t. */
-		const ConstVector xx;
-	public:
-		DynareAtomValues(const ogp::FineAtoms& a, const Vector& pvals, const Vector& ym,
-						 const Vector& y, const Vector& yp, const Vector& x)
-			: atoms(a), paramvals(pvals), yym(ym), yy(y), yyp(yp), xx(x) {}
-		DynareAtomValues(const ogp::FineAtoms& a, const Vector& pvals, const ConstVector& ym,
-						 const Vector& y, const ConstVector& yp, const Vector& x)
-			: atoms(a), paramvals(pvals), yym(ym), yy(y), yyp(yp), xx(x) {}
-		void setValues(ogp::EvalTree& et) const;
-	};
+  class DynareStaticSteadyAtomValues : public ogp::AtomValues
+  {
+  protected:
+    /** Reference to static atoms over which the tree, where the
+     * values go, is defined. */
+    const ogp::StaticFineAtoms &atoms_static;
+    /** Reference to dynamic atoms for which the class gets input
+     * data. */
+    const ogp::FineAtoms &atoms;
+    /** De facto reference to input data, this is a vector of
+     * endogenous variables in internal ordering of the dynamic
+     * atoms. */
+    ConstVector yy;
+    /** De facto reference to input parameters corresponding to
+     * ordering defined by the dynamic atoms. */
+    ConstVector paramvals;
+  public:
+    /** Construct the object. */
+    DynareStaticSteadyAtomValues(const ogp::FineAtoms &a, const ogp::StaticFineAtoms &sa,
+                                 const Vector &pvals, const Vector &yyy)
+      : atoms_static(sa),
+        atoms(a),
+        yy(yyy),
+        paramvals(pvals)
+    {
+    }
+    /** Set the values to the tree defined over the static atoms. */
+    void setValues(ogp::EvalTree &et) const;
+  };
 
-	/** This class represents the atom values at the steady state. It
-	 * makes only appropriate subvector yym and yyp of the y vector,
-	 * makes a vector of zero exogenous variables and uses
-	 * DynareAtomValues with more general interface. */ 
-	class DynareSteadyAtomValues : public ogp::AtomValues {
-	protected:
-		/** Subvector of yy. */
-		const ConstVector yym;
-		/** Subvector of yy. */
-		const ConstVector yyp;
-		/** Vector of zeros for exogenous variables. */
-		Vector xx;
-		/** Atom values using this yym, yyp and xx. */
-		DynareAtomValues av;
-	public:
-		DynareSteadyAtomValues(const ogp::FineAtoms& a, const Vector& pvals, const Vector& y)
-			: yym(y, a.nstat(), a.nys()),
-			  yyp(y, a.nstat()+a.npred(), a.nyss()),
-			  xx(a.nexo()),
-			  av(a, pvals, yym, y, yyp, xx)
-			{xx.zeros();}
-		void setValues(ogp::EvalTree& et) const
-			{av.setValues(et);}
-	};
+  /** This class takes a vector of endogenous variables and a
+   * substitution map. It supposes that variables at the right hand
+   * sides of the substitutions are set in the endogenous vector. It
+   * evaluates the substitutions and if the variables corresponding
+   * to left hand sides are not set in the endogenous vector it sets
+   * them to calculated values. If a variable is already set, it
+   * does not override its value. It has no methods, everything is
+   * done in the constructor. */
+  class DynareSteadySubstitutions : public ogp::FormulaEvalLoader
+  {
+  protected:
+    const ogp::FineAtoms &atoms;
+  public:
+    DynareSteadySubstitutions(const ogp::FineAtoms &a, const ogp::OperationTree &tree,
+                              const Tsubstmap &subst,
+                              const Vector &pvals, Vector &yy);
+    void load(int i, double res);
+  protected:
+    Vector &y;
+    vector<const char *> left_hand_sides;
+    vector<int> right_hand_sides;
+  };
 
-	class DynareStaticSteadyAtomValues : public ogp::AtomValues {
-	protected:
-		/** Reference to static atoms over which the tree, where the
-		 * values go, is defined. */
-		const ogp::StaticFineAtoms& atoms_static;
-		/** Reference to dynamic atoms for which the class gets input
-		 * data. */
-		const ogp::FineAtoms& atoms;
-		/** De facto reference to input data, this is a vector of
-		 * endogenous variables in internal ordering of the dynamic
-		 * atoms. */
-		ConstVector yy;
-		/** De facto reference to input parameters corresponding to
-		 * ordering defined by the dynamic atoms. */
-		ConstVector paramvals;
-	public:
-		/** Construct the object. */
-		DynareStaticSteadyAtomValues(const ogp::FineAtoms& a, const ogp::StaticFineAtoms& sa,
-									 const Vector& pvals, const Vector& yyy)
-			: atoms_static(sa),
-			  atoms(a),
-			  yy(yyy),
-			  paramvals(pvals) {}
-		/** Set the values to the tree defined over the static atoms. */
-		void setValues(ogp::EvalTree& et) const;
-	};
-
-	/** This class takes a vector of endogenous variables and a
-	 * substitution map. It supposes that variables at the right hand
-	 * sides of the substitutions are set in the endogenous vector. It
-	 * evaluates the substitutions and if the variables corresponding
-	 * to left hand sides are not set in the endogenous vector it sets
-	 * them to calculated values. If a variable is already set, it
-	 * does not override its value. It has no methods, everything is
-	 * done in the constructor. */ 
-	class DynareSteadySubstitutions : public ogp::FormulaEvalLoader {
-	protected:
-		const ogp::FineAtoms& atoms;
-	public:
-		DynareSteadySubstitutions(const ogp::FineAtoms& a, const ogp::OperationTree& tree,
-								  const Tsubstmap& subst,
-								  const Vector& pvals, Vector& yy);
-		void load(int i, double res);
-	protected:
-		Vector& y;
-		vector<const char*> left_hand_sides;
-		vector<int> right_hand_sides;
-	};
-
-	/** This class is a static version of DynareSteadySustitutions. It
-	 * works for static atoms and static tree and substitution map
-	 * over the static tree. It also needs dynamic version of the
-	 * atoms, since it defines ordering of the vectors pvals, and
-	 * yy. */ 
-	class DynareStaticSteadySubstitutions : public ogp::FormulaEvalLoader {
-	protected:
-		const ogp::FineAtoms& atoms;
-		const ogp::StaticFineAtoms& atoms_static;
-	public:
-		DynareStaticSteadySubstitutions(const ogp::FineAtoms& a,
-										const ogp::StaticFineAtoms& sa,
-										const ogp::OperationTree& tree,
-										const Tsubstmap& subst,
-										const Vector& pvals, Vector& yy);
-		void load(int i, double res);
-	protected:
-		Vector& y;
-		vector<const char*> left_hand_sides;
-		vector<int> right_hand_sides;
-	};
+  /** This class is a static version of DynareSteadySustitutions. It
+   * works for static atoms and static tree and substitution map
+   * over the static tree. It also needs dynamic version of the
+   * atoms, since it defines ordering of the vectors pvals, and
+   * yy. */
+  class DynareStaticSteadySubstitutions : public ogp::FormulaEvalLoader
+  {
+  protected:
+    const ogp::FineAtoms &atoms;
+    const ogp::StaticFineAtoms &atoms_static;
+  public:
+    DynareStaticSteadySubstitutions(const ogp::FineAtoms &a,
+                                    const ogp::StaticFineAtoms &sa,
+                                    const ogp::OperationTree &tree,
+                                    const Tsubstmap &subst,
+                                    const Vector &pvals, Vector &yy);
+    void load(int i, double res);
+  protected:
+    Vector &y;
+    vector<const char *> left_hand_sides;
+    vector<int> right_hand_sides;
+  };
 
 };
 
-
 #endif
 
 // Local Variables:
diff --git a/dynare++/src/dynare_exception.h b/dynare++/src/dynare_exception.h
index c91048a3a..682b66132 100644
--- a/dynare++/src/dynare_exception.h
+++ b/dynare++/src/dynare_exception.h
@@ -7,31 +7,39 @@
 
 #include <string>
 
-class DynareException {
-	char* mes;
+class DynareException
+{
+  char *mes;
 public:
-	DynareException(const char* m, const char* fname, int line, int col)
-		{
-			mes = new char[strlen(m) + strlen(fname) + 100];
-			sprintf(mes, "Parse error at %s, line %d, column %d: %s", fname, line, col, m);
-		}
-	DynareException(const char* fname, int line, const std::string& m)
-		{
-			mes = new char[m.size() + strlen(fname) + 50];
-			sprintf(mes, "%s:%d: %s", fname, line, m.c_str());
-		}
-	DynareException(const char* m, int offset)
-		{
-			mes = new char[strlen(m) + 100];
-			sprintf(mes, "Parse error in provided string at offset %d: %s", offset, m);
-		}
-	DynareException(const DynareException& e)
-		: mes(new char[strlen(e.mes)+1])
-		{strcpy(mes, e.mes);}
-	virtual ~DynareException()
-		{delete [] mes;}
-	const char* message() const
-		{return mes;}
+  DynareException(const char *m, const char *fname, int line, int col)
+  {
+    mes = new char[strlen(m) + strlen(fname) + 100];
+    sprintf(mes, "Parse error at %s, line %d, column %d: %s", fname, line, col, m);
+  }
+  DynareException(const char *fname, int line, const std::string &m)
+  {
+    mes = new char[m.size() + strlen(fname) + 50];
+    sprintf(mes, "%s:%d: %s", fname, line, m.c_str());
+  }
+  DynareException(const char *m, int offset)
+  {
+    mes = new char[strlen(m) + 100];
+    sprintf(mes, "Parse error in provided string at offset %d: %s", offset, m);
+  }
+  DynareException(const DynareException &e)
+    : mes(new char[strlen(e.mes)+1])
+  {
+    strcpy(mes, e.mes);
+  }
+  virtual ~DynareException()
+  {
+    delete [] mes;
+  }
+  const char *
+  message() const
+  {
+    return mes;
+  }
 };
 
 #endif
diff --git a/dynare++/src/dynare_model.h b/dynare++/src/dynare_model.h
index 8fb87ce21..d5c183446 100644
--- a/dynare++/src/dynare_model.h
+++ b/dynare++/src/dynare_model.h
@@ -15,377 +15,463 @@
 #include <map>
 #include <boost/unordered_set.hpp>
 
-namespace ogdyn {
-	using boost::unordered_set;
-	using std::map;
+namespace ogdyn
+{
+  using boost::unordered_set;
+  using std::map;
 
-	/** This represents an interval in a string by the pair of
-	 * positions (including the first, excluding the second). A
-	 * position is given by the line and the column within the line
-	 * (both starting from 1). */
-	struct PosInterval {
-		int fl;
-		int fc;
-		int ll;
-		int lc;
-		PosInterval() {}
-		PosInterval(int ifl, int ifc, int ill, int ilc)
-			: fl(ifl), fc(ifc), ll(ill), lc(ilc) {}
-		const PosInterval& operator=(const PosInterval& pi)
-			{fl = pi.fl; fc = pi.fc; ll = pi.ll; lc = pi.lc; return *this;}
-		/** This returns the interval beginning and interval length
-		 * within the given string. */
-		void translate(const char* beg, int len, const char*& ibeg, int& ilen) const;
-		/** Debug print. */
-		void print() const
-			{printf("fl=%d fc=%d ll=%d lc=%d\n",fl,fc,ll,lc);}
-	};
+  /** This represents an interval in a string by the pair of
+   * positions (including the first, excluding the second). A
+   * position is given by the line and the column within the line
+   * (both starting from 1). */
+  struct PosInterval
+  {
+    int fl;
+    int fc;
+    int ll;
+    int lc;
+    PosInterval()
+    {
+    }
+    PosInterval(int ifl, int ifc, int ill, int ilc)
+      : fl(ifl), fc(ifc), ll(ill), lc(ilc)
+    {
+    }
+    const PosInterval &
+    operator=(const PosInterval &pi)
+    {
+      fl = pi.fl; fc = pi.fc; ll = pi.ll; lc = pi.lc; return *this;
+    }
+    /** This returns the interval beginning and interval length
+     * within the given string. */
+    void translate(const char *beg, int len, const char * &ibeg, int &ilen) const;
+    /** Debug print. */
+    void
+    print() const
+    {
+      printf("fl=%d fc=%d ll=%d lc=%d\n", fl, fc, ll, lc);
+    }
+  };
 
-	/** This class is basically a GeneralMatrix but is created from
-	 * parsed matrix data. */
-	class ParsedMatrix : public TwoDMatrix {
-	public:
-		/** Construct the object from the parsed data of ogp::MatrixParser. */
-		ParsedMatrix(const ogp::MatrixParser& mp);
-	};
+  /** This class is basically a GeneralMatrix but is created from
+   * parsed matrix data. */
+  class ParsedMatrix : public TwoDMatrix
+  {
+  public:
+    /** Construct the object from the parsed data of ogp::MatrixParser. */
+    ParsedMatrix(const ogp::MatrixParser &mp);
+  };
 
+  class PlannerBuilder;
+  class PlannerInfo;
+  class ForwSubstBuilder;
+  class ForwSubstInfo;
+  class MultInitSS;
+  class ModelSSWriter;
 
-	class PlannerBuilder;
-	class PlannerInfo;
-	class ForwSubstBuilder;
-	class ForwSubstInfo;
-	class MultInitSS;
-	class ModelSSWriter;
+  /** A subclass is responsible for creating param_vals, init_vals,
+   * and vcov_mat. */
+  class DynareModel
+  {
+    friend class PlannerBuilder;
+    friend class ForwSubstBuilder;
+    friend class MultInitSS;
+    friend class ModelSSWriter;
+  protected:
+    /** All atoms for whole model. */
+    DynareDynamicAtoms atoms;
+    /** Parsed model equations. */
+    ogp::FormulaParser eqs;
+    /** Order of approximation. */
+    int order;
+    /** A vector of parameters values created by a subclass. It
+     * is stored with natural ordering (outer) of the parameters
+     * given by atoms. */
+    Vector *param_vals;
+    /** A vector of initial values created by a subclass. It is
+     * stored with internal ordering given by atoms. */
+    Vector *init_vals;
+    /** A matrix for vcov. It is created by a subclass. */
+    TwoDMatrix *vcov_mat;
+    /** Tree index of the planner objective. If there was no
+     * planner objective keyword, the value is set to -1. */
+    int t_plobjective;
+    /** Tree index of the planner discount. If there was no
+     * planner discount keyword, the value is set to -1. */
+    int t_pldiscount;
+    /** Pointer to PlannerBuilder, which is created only if the
+     * planner's FOC are added to the model. */
+    PlannerBuilder *pbuilder;
+    /** Pointer to an object which builds auxiliary variables and
+     * equations to rewrite a model containing multiple leads to
+     * an equivalent model having only +1 leads. */
+    ForwSubstBuilder *fbuilder;
+    /** Pointer to AtomSubstitutions which are created when the
+     * atoms are being substituted because of multiple lags
+     * etc. It uses also an old copy of atoms, which is
+     * created. */
+    ogp::AtomSubstitutions *atom_substs;
+    /** Pointer to a copy of original atoms before substitutions
+     * took place. */
+    ogp::SAtoms *old_atoms;
+  public:
+    /** Initializes the object to an empty state. */
+    DynareModel();
+    /** Construct a new deep copy. */
+    DynareModel(const DynareModel &dm);
+    virtual
+    ~DynareModel();
+    virtual DynareModel *clone() const = 0;
+    const DynareDynamicAtoms &
+    getAtoms() const
+    {
+      return atoms;
+    }
+    const ogp::FormulaParser &
+    getParser() const
+    {
+      return eqs;
+    }
+    int
+    getOrder() const
+    {
+      return order;
+    }
+    /** Return the vector of parameter values. */
+    const Vector &
+    getParams() const
+    {
+      return *param_vals;
+    }
+    Vector &
+    getParams()
+    {
+      return *param_vals;
+    }
+    /** Return the vector of initial values of endo variables. */
+    const Vector &
+    getInit() const
+    {
+      return *init_vals;
+    }
+    Vector &
+    getInit()
+    {
+      return *init_vals;
+    }
+    /** Return the vcov matrix. */
+    const TwoDMatrix &
+    getVcov() const
+    {
+      return *vcov_mat;
+    }
+    TwoDMatrix &
+    getVcov()
+    {
+      return *vcov_mat;
+    }
+    /** Return planner info. */
+    const PlannerInfo *get_planner_info() const;
+    /** Return forward substitutions info. */
+    const ForwSubstInfo *get_forw_subst_info() const;
+    /** Return substitutions info. */
+    const ogp::SubstInfo *get_subst_info() const;
+    /** This sets initial values given in outer ordering. */
+    void setInitOuter(const Vector &x);
+    /** This returns true if the given term is a function of
+     * hardwired constants, numerical constants and parameters. */
+    bool is_constant_term(int t) const;
+    /** Debug print. */
+    void print() const;
+    /** Dump the model to the output stream. This includes
+     * variable declarations, parameter values, model code,
+     * initval, vcov and order. */
+    void dump_model(std::ostream &os) const;
+  protected:
+    /** Adds a name of endogenous, exogenous or a parameter. The
+     * sort is governed by the flag. See dynglob.y for values of
+     * the flag. This is used by a subclass when declaring the
+     * names. */
+    void add_name(const char *name, int flag);
+    /** This checks the model consistency. Thus includes: number
+     * of endo variables and number of equations, min and max lag
+     * of endogenous variables and occurrrences of exogenous
+     * variables. It throws an exception, if there is a problem. */
+    void check_model() const;
+    /** This shifts the given variable identified by the tree
+     * index in time. So if the given tree index represents a(+3)
+     * and the tshift is -4, the method returns tree index of the
+     * a(-1). If a(-1) doesn't exist, it is added to the tree. If
+     * it exists, its tree index is returned. If the tree index
+     * doesn't correspond to an endogenous nor exogenous variable,
+     * an exception is thrown. */
+    int variable_shift(int t, int tshift);
+    /** For the given set of atoms identified by tree indices and
+     * given time shift, this method returns a map mapping each
+     * variable in the given set to its time shifted variable. The
+     * map is passed through the reference and is cleared in the
+     * beginning. */
+    void variable_shift_map(const unordered_set<int> &a_set, int tshift,
+                            map<int, int> &s_map);
+    /** This returns maximum lead and minimum lag of an endogenous
+     * or exogenous variable in the given term. If there are no
+     * endo or exo variables, than it returns the least integer as
+     * max lead and the greatest integer as min lag. */
+    void termspan(int t, int &mlead, int &mlag) const;
+    /** This function returns a set of non-linear subterms of the
+     * given term, these are terms whose linear combination
+     * constitutes the given term. */
+    unordered_set<int> get_nonlinear_subterms(int t) const;
+    /** This method assigns already used tree index of some term
+     * to the not-yet used atom name with the given lead/lag. In
+     * this way, all occurrences of term t are substituted with
+     * the atom name(ll). The method handles also rewriting
+     * operation tree including derivatives of the term t. */
+    void substitute_atom_for_term(const char *name, int ll, int t);
+    /** This performs a final job after the model is parsed. It
+     * creates the PlannerBuilder object if the planner's FOC are
+     * needed, then it creates ForwSubstBuilder handling multiple
+     * leads and finally it creates the substitution object saving
+     * old atoms and performs the substitutions. */
+    void final_job();
+  };
 
-	/** A subclass is responsible for creating param_vals, init_vals,
-	 * and vcov_mat. */
-	class DynareModel {
-		friend class PlannerBuilder;
-		friend class ForwSubstBuilder;
-		friend class MultInitSS;
-		friend class ModelSSWriter;
-	protected:
-		/** All atoms for whole model. */
-		DynareDynamicAtoms atoms;
-		/** Parsed model equations. */
-		ogp::FormulaParser eqs;
-		/** Order of approximation. */
-		int order;
-		/** A vector of parameters values created by a subclass. It
-		 * is stored with natural ordering (outer) of the parameters
-		 * given by atoms. */
-		Vector* param_vals;
-		/** A vector of initial values created by a subclass. It is
-		 * stored with internal ordering given by atoms. */
-		Vector* init_vals;
-		/** A matrix for vcov. It is created by a subclass. */
-		TwoDMatrix* vcov_mat;
-		/** Tree index of the planner objective. If there was no
-		 * planner objective keyword, the value is set to -1. */
-		int t_plobjective;
-		/** Tree index of the planner discount. If there was no
-		 * planner discount keyword, the value is set to -1. */
-		int t_pldiscount;
-		/** Pointer to PlannerBuilder, which is created only if the
-		 * planner's FOC are added to the model. */
-		PlannerBuilder* pbuilder;
-		/** Pointer to an object which builds auxiliary variables and
-		 * equations to rewrite a model containing multiple leads to
-		 * an equivalent model having only +1 leads. */
-		ForwSubstBuilder* fbuilder;
-		/** Pointer to AtomSubstitutions which are created when the
-		 * atoms are being substituted because of multiple lags
-		 * etc. It uses also an old copy of atoms, which is
-		 * created. */
-		ogp::AtomSubstitutions* atom_substs;
-		/** Pointer to a copy of original atoms before substitutions
-		 * took place. */
-		ogp::SAtoms* old_atoms;
-	public:
-		/** Initializes the object to an empty state. */
-		DynareModel();
-		/** Construct a new deep copy. */
-		DynareModel(const DynareModel& dm);
-		virtual ~DynareModel();		
-		virtual DynareModel* clone() const = 0;
-		const DynareDynamicAtoms& getAtoms() const
-			{return atoms;}
-		const ogp::FormulaParser& getParser() const
-			{return eqs;}
-		int getOrder() const
-			{return order;}
-		/** Return the vector of parameter values. */
-		const Vector& getParams() const
-			{return *param_vals;}
-		Vector& getParams()
-			{return *param_vals;}
-		/** Return the vector of initial values of endo variables. */
-		const Vector& getInit() const
-			{return *init_vals;} 
-		Vector& getInit()
-			{return *init_vals;}
-		/** Return the vcov matrix. */
-		const TwoDMatrix& getVcov() const
-			{return *vcov_mat;}
-		TwoDMatrix& getVcov()
-			{return *vcov_mat;}
-		/** Return planner info. */
-		const PlannerInfo* get_planner_info() const;
-		/** Return forward substitutions info. */
-		const ForwSubstInfo* get_forw_subst_info() const;
-		/** Return substitutions info. */
-		const ogp::SubstInfo* get_subst_info() const;
-		/** This sets initial values given in outer ordering. */
-		void setInitOuter(const Vector& x);
-		/** This returns true if the given term is a function of
-		 * hardwired constants, numerical constants and parameters. */
-		bool is_constant_term(int t) const;
-		/** Debug print. */
-		void print() const;
-		/** Dump the model to the output stream. This includes
-		 * variable declarations, parameter values, model code,
-		 * initval, vcov and order. */
-		void dump_model(std::ostream& os) const;
-	protected:
-		/** Adds a name of endogenous, exogenous or a parameter. The
-		 * sort is governed by the flag. See dynglob.y for values of
-		 * the flag. This is used by a subclass when declaring the
-		 * names. */
-		void add_name(const char* name, int flag);
-		/** This checks the model consistency. Thus includes: number
-		 * of endo variables and number of equations, min and max lag
-		 * of endogenous variables and occurrrences of exogenous
-		 * variables. It throws an exception, if there is a problem. */
-		void check_model() const;
-		/** This shifts the given variable identified by the tree
-		 * index in time. So if the given tree index represents a(+3)
-		 * and the tshift is -4, the method returns tree index of the
-		 * a(-1). If a(-1) doesn't exist, it is added to the tree. If
-		 * it exists, its tree index is returned. If the tree index
-		 * doesn't correspond to an endogenous nor exogenous variable,
-		 * an exception is thrown. */
-		int variable_shift(int t, int tshift);
-		/** For the given set of atoms identified by tree indices and
-		 * given time shift, this method returns a map mapping each
-		 * variable in the given set to its time shifted variable. The
-		 * map is passed through the reference and is cleared in the
-		 * beginning. */
-		void variable_shift_map(const unordered_set<int>& a_set, int tshift,
-								map<int,int>& s_map);
-		/** This returns maximum lead and minimum lag of an endogenous
-		 * or exogenous variable in the given term. If there are no
-		 * endo or exo variables, than it returns the least integer as
-		 * max lead and the greatest integer as min lag. */ 
-		void termspan(int t, int& mlead, int& mlag) const;
-		/** This function returns a set of non-linear subterms of the
-		 * given term, these are terms whose linear combination
-		 * constitutes the given term. */
-		unordered_set<int> get_nonlinear_subterms(int t) const;
-		/** This method assigns already used tree index of some term
-		 * to the not-yet used atom name with the given lead/lag. In
-		 * this way, all occurrences of term t are substituted with
-		 * the atom name(ll). The method handles also rewriting
-		 * operation tree including derivatives of the term t. */
-		void substitute_atom_for_term(const char* name, int ll, int t);
-		/** This performs a final job after the model is parsed. It
-		 * creates the PlannerBuilder object if the planner's FOC are
-		 * needed, then it creates ForwSubstBuilder handling multiple
-		 * leads and finally it creates the substitution object saving
-		 * old atoms and performs the substitutions. */
-		void final_job();
-	};
+  /** This class constructs DynareModel from dynare++ model file. It
+   * parses variable declarations, model equations, parameter
+   * assignments, initval assignments, vcov matrix and order of
+   * approximation. */
+  class DynareParser : public DynareModel
+  {
+  protected:
+    /** Static atoms for parameter assignments. */
+    DynareStaticAtoms pa_atoms;
+    /** Assignments for the parameters. */
+    ogp::AtomAssignings paramset;
+    /** Static atoms for initval assignments. */
+    DynareStaticAtoms ia_atoms;
+    /** Assignments for the initval. */
+    ogp::AtomAssignings initval;
+    /** Matrix parser for vcov. */
+    ogp::MatrixParser vcov;
+  public:
+    /** This, in fact, creates DynareModel from the given string
+     * of the given length corresponding to the Dynare++ model
+     * file. If the given ord is not -1, then it overrides setting
+     * in the model file. */
+    DynareParser(const char *str, int len, int ord);
+    DynareParser(const DynareParser &p);
+    virtual
+    ~DynareParser();
+    DynareModel *
+    clone() const
+    {
+      return new DynareParser(*this);
+    }
+    /** Adds a name of endogenous, exogenous or a parameter. This
+     * addss the name to the parent class DynareModel and also
+     * registers the name to either paramset, or initval. */
+    void add_name(const char *name, int flag);
+    /** Sets position of the model section. Called from
+     * dynglob.y. */
+    void
+    set_model_pos(int off1, int off2)
+    {
+      model_beg = off1; model_end = off2;
+    }
+    /** Sets position of the section setting parameters. Called
+     * from dynglob.y. */
+    void
+    set_paramset_pos(int off1, int off2)
+    {
+      paramset_beg = off1; paramset_end = off2;
+    }
+    /** Sets position of the initval section. Called from
+     * dynglob.y. */
+    void
+    set_initval_pos(int off1, int off2)
+    {
+      initval_beg = off1; initval_end = off2;
+    }
+    /** Sets position of the vcov section. Called from
+     * dynglob.y. */
+    void
+    set_vcov_pos(int off1, int off2)
+    {
+      vcov_beg = off1; vcov_end = off2;
+    }
+    /** Parser the given string as integer and set to as the
+     * order. */
+    void
+    set_order_pos(int off1, int off2)
+    {
+      order_beg = off1; order_end = off2;
+    }
+    /** Sets position of the planner_objective section. Called
+     * from dynglob.y. */
+    void
+    set_pl_objective_pos(int off1, int off2)
+    {
+      plobjective_beg = off1; plobjective_end = off2;
+    }
+    /** Sets position of the planner_discount section. Called from
+     * dynglob.y. */
+    void
+    set_pl_discount_pos(int off1, int off2)
+    {
+      pldiscount_beg = off1; pldiscount_end = off2;
+    }
+    /** Processes a syntax error from bison. */
+    void error(const char *mes);
+    /** Debug print. */
+    void print() const;
+  protected:
+    void parse_glob(int length, const char *stream);
+    int parse_order(int length, const char *stream);
+    int parse_pldiscount(int length, const char *stream);
+    /** Evaluate paramset assignings and set param_vals. */
+    void calc_params();
+    /** Evaluate initval assignings and set init_vals. */
+    void calc_init();
+    /** Do the final job. This includes building the planner
+     * problem (if any) and substituting for multiple lags, and
+     * one period leads of exogenous variables, and calculating
+     * initial guess of lagrange multipliers in the social planner
+     * problem. Precondtion: everything parsed and calculated
+     * parameters, postcondition: calculated initvals vector and
+     * parsing_finished for expanded vectors. */
+    void final_job();
+  private:
+    int model_beg, model_end;
+    int paramset_beg, paramset_end;
+    int initval_beg, initval_end;
+    int vcov_beg, vcov_end;
+    int order_beg, order_end;
+    int plobjective_beg, plobjective_end;
+    int pldiscount_beg, pldiscount_end;
+  };
 
-	/** This class constructs DynareModel from dynare++ model file. It
-	 * parses variable declarations, model equations, parameter
-	 * assignments, initval assignments, vcov matrix and order of
-	 * approximation. */
-	class DynareParser : public DynareModel {
-	protected:
-		/** Static atoms for parameter assignments. */
-		DynareStaticAtoms pa_atoms;
-		/** Assignments for the parameters. */
-		ogp::AtomAssignings paramset;
-		/** Static atoms for initval assignments. */
-		DynareStaticAtoms ia_atoms;
-		/** Assignments for the initval. */
-		ogp::AtomAssignings initval;
-		/** Matrix parser for vcov. */
-		ogp::MatrixParser vcov;
-	public:
-		/** This, in fact, creates DynareModel from the given string
-		 * of the given length corresponding to the Dynare++ model
-		 * file. If the given ord is not -1, then it overrides setting
-		 * in the model file. */
-		DynareParser(const char* str, int len, int ord);
-		DynareParser(const DynareParser& p);
-		virtual ~DynareParser();
-		DynareModel* clone() const
-			{return new DynareParser(*this);}
-		/** Adds a name of endogenous, exogenous or a parameter. This
-		 * addss the name to the parent class DynareModel and also
-		 * registers the name to either paramset, or initval. */
-		void add_name(const char* name, int flag);
-		/** Sets position of the model section. Called from
-		 * dynglob.y. */
-		void set_model_pos(int off1, int off2)
-			{model_beg = off1; model_end = off2;}
-		/** Sets position of the section setting parameters. Called
-		 * from dynglob.y. */
-		void set_paramset_pos(int off1, int off2)
-			{paramset_beg = off1; paramset_end = off2;}
-		/** Sets position of the initval section. Called from
-		 * dynglob.y. */
-		void set_initval_pos(int off1, int off2)
-			{initval_beg = off1; initval_end = off2;}
-		/** Sets position of the vcov section. Called from
-		 * dynglob.y. */
-		void set_vcov_pos(int off1, int off2)
-			{vcov_beg = off1; vcov_end = off2;}
-		/** Parser the given string as integer and set to as the
-		 * order. */
-		void set_order_pos(int off1, int off2)
-			{order_beg = off1; order_end = off2;}
-		/** Sets position of the planner_objective section. Called
-		 * from dynglob.y. */
-		void set_pl_objective_pos(int off1, int off2)
-			{plobjective_beg = off1; plobjective_end = off2;}
-		/** Sets position of the planner_discount section. Called from
-		 * dynglob.y. */
-		void set_pl_discount_pos(int off1, int off2)
-			{pldiscount_beg = off1; pldiscount_end = off2;}		
-		/** Processes a syntax error from bison. */
-		void error(const char* mes);
-		/** Debug print. */
-		void print() const;
-	protected:
-		void parse_glob(int length, const char* stream);
-		int parse_order(int length, const char* stream);
-		int parse_pldiscount(int length, const char* stream);
-		/** Evaluate paramset assignings and set param_vals. */
-		void calc_params();
-		/** Evaluate initval assignings and set init_vals. */
-		void calc_init();
-		/** Do the final job. This includes building the planner
-		 * problem (if any) and substituting for multiple lags, and
-		 * one period leads of exogenous variables, and calculating
-		 * initial guess of lagrange multipliers in the social planner
-		 * problem. Precondtion: everything parsed and calculated
-		 * parameters, postcondition: calculated initvals vector and
-		 * parsing_finished for expanded vectors. */
-		void final_job();
-	private:
-		int model_beg, model_end;
-		int paramset_beg, paramset_end;
-		int initval_beg, initval_end;
-		int vcov_beg, vcov_end;
-		int order_beg, order_end;
-		int plobjective_beg, plobjective_end;
-		int pldiscount_beg, pldiscount_end;
-	};
+  /** Semiparsed model. The equations are given by a string,
+   * everything other by C/C++ objects. The initial values are set
+   * manually after the creation of this object. This implies that
+   * no automatic substitutions cannot be done here, which in turn
+   * implies that we cannot do here a social planner nor substitutions
+   * of multiple lags. */
+  class DynareSPModel : public DynareModel
+  {
+  public:
+    DynareSPModel(const char **endo, int num_endo,
+                  const char **exo, int num_exo,
+                  const char **par, int num_par,
+                  const char *equations, int len, int ord);
+    DynareSPModel(const DynareSPModel &dm)
+      : DynareModel(dm)
+    {
+    }
+    ~DynareSPModel()
+    {
+    }
+    virtual DynareModel *
+    clone() const
+    {
+      return new DynareSPModel(*this);
+    }
+  };
 
-	/** Semiparsed model. The equations are given by a string,
-	 * everything other by C/C++ objects. The initial values are set
-	 * manually after the creation of this object. This implies that
-	 * no automatic substitutions cannot be done here, which in turn
-	 * implies that we cannot do here a social planner nor substitutions
-	 * of multiple lags. */
-	class DynareSPModel : public DynareModel {
-	public:
-		DynareSPModel(const char** endo, int num_endo,
-					  const char** exo, int num_exo,
-					  const char** par, int num_par,
-					  const char* equations, int len, int ord);
-		DynareSPModel(const DynareSPModel& dm)
-			: DynareModel(dm) {}
-		~DynareSPModel() {}
-		virtual DynareModel* clone() const
-			{return new DynareSPModel(*this);}
-	};
+  /** This class implements a selector of operations which correspond
+   * to non-linear functions. This inherits from ogp::opselector and
+   * is used to calculate non-linear subterms in
+   * DynareModel::get_nonlinear_subterms(). */
+  class NLSelector : public ogp::opselector
+  {
+  private:
+    const DynareModel &model;
+  public:
+    NLSelector(const DynareModel &m) : model(m)
+    {
+    }
+    bool operator()(int t) const;
+  };
 
-	/** This class implements a selector of operations which correspond
-	 * to non-linear functions. This inherits from ogp::opselector and
-	 * is used to calculate non-linear subterms in
-	 * DynareModel::get_nonlinear_subterms(). */
-	class NLSelector : public ogp::opselector {
-	private:
-		const DynareModel& model;
-	public:
-		NLSelector(const DynareModel& m) : model(m) {}
-		bool operator()(int t) const;
-	};
+  /** This class writes a mathematical code evaluating the system of
+   * equations and the first derivatives at zero shocks and at the
+   * given (static) state. Static means that lags and leads are
+   * ignored. */
+  class ModelSSWriter : public ogp::DefaultOperationFormatter
+  {
+  protected:
+    const DynareModel &model;
+  public:
+    ModelSSWriter(const DynareModel &m)
+      : DefaultOperationFormatter(m.eqs.getTree()),
+        model(m)
+    {
+    }
+    /** This writes the evaluation of the system. It calls pure
+     * virtual methods for writing a preamble, then assignment of
+     * atoms, and then assignment for resulting object. These are
+     * language dependent and are implemented in the subclass. */
+    void write_der0(FILE *fd);
+    /** This writes the evaluation of the first order derivative of
+        the system. It calls pure virtual methods for writing a
+        preamble, assignment, and assignemnt of the resulting
+        objects. */
+    void write_der1(FILE *fd);
+  protected:
+    virtual void write_der0_preamble(FILE *fd) const = 0;
+    virtual void write_der1_preamble(FILE *fd) const = 0;
+    virtual void write_atom_assignment(FILE *fd) const = 0;
+    virtual void write_der0_assignment(FILE *fd) const = 0;
+    virtual void write_der1_assignment(FILE *fd) const = 0;
+  };
 
-	/** This class writes a mathematical code evaluating the system of
-	 * equations and the first derivatives at zero shocks and at the
-	 * given (static) state. Static means that lags and leads are
-	 * ignored. */
-	class ModelSSWriter : public ogp::DefaultOperationFormatter {
-	protected:
-		const DynareModel& model;
-	public:
-		ModelSSWriter(const DynareModel& m)
-			: DefaultOperationFormatter(m.eqs.getTree()),
-			  model(m) {}
-		/** This writes the evaluation of the system. It calls pure
-		 * virtual methods for writing a preamble, then assignment of
-		 * atoms, and then assignment for resulting object. These are
-		 * language dependent and are implemented in the subclass. */
-		void write_der0(FILE* fd);
-		/** This writes the evaluation of the first order derivative of
-		the system. It calls pure virtual methods for writing a
-		preamble, assignment, and assignemnt of the resulting
-		objects. */
-		void write_der1(FILE* fd);
-	protected:
-		virtual void write_der0_preamble(FILE* fd) const =0;
-		virtual void write_der1_preamble(FILE* fd) const =0;
-		virtual void write_atom_assignment(FILE* fd) const =0;
-		virtual void write_der0_assignment(FILE* fd) const =0;
-		virtual void write_der1_assignment(FILE* fd) const =0;
-	};
+  class MatlabSSWriter : public ModelSSWriter
+  {
+  protected:
+    /** Identifier used in function names. */
+    char *id;
+  public:
+    MatlabSSWriter(const DynareModel &dm, const char *idd);
+    virtual ~MatlabSSWriter()
+    {
+      delete [] id;
+    }
+  protected:
+    // from ModelSSWriter
+    void write_der0_preamble(FILE *fd) const;
+    void write_der1_preamble(FILE *fd) const;
+    /** This writes atom assignments. We have four kinds of atoms
+     * set here: endogenous vars coming from one parameter,
+     * parameter values given by the second parameter, constants,
+     * and the OperationTree::num_constants hardwired constants in
+     * ogp::OperationTree. */
+    void write_atom_assignment(FILE *fd) const;
+    void write_der0_assignment(FILE *fd) const;
+    void write_der1_assignment(FILE *fd) const;
+    /** This prints t10 for t=10. */
+    void format_term(int t, FILE *fd) const;
+    /** This prints a10 for t=10. The atoms a10 are supposed to be
+     * set by write_atom_assignments(). */
+    void format_nulary(int t, FILE *fd) const;
+  private:
+    void write_common1_preamble(FILE *fd) const;
+    void write_common2_preamble(FILE *fd) const;
+  };
 
-
-	class MatlabSSWriter : public ModelSSWriter {
-	protected:
-		/** Identifier used in function names. */
-		char* id;
-	public:
-		MatlabSSWriter(const DynareModel& dm, const char* idd);
-		virtual ~MatlabSSWriter()
-			{delete [] id;}
-	protected:
-		// from ModelSSWriter
-		void write_der0_preamble(FILE* fd) const;
-		void write_der1_preamble(FILE* fd) const;
-		/** This writes atom assignments. We have four kinds of atoms
-		 * set here: endogenous vars coming from one parameter,
-		 * parameter values given by the second parameter, constants,
-		 * and the OperationTree::num_constants hardwired constants in
-		 * ogp::OperationTree. */
-		void write_atom_assignment(FILE* fd) const;
-		void write_der0_assignment(FILE* fd) const;
-		void write_der1_assignment(FILE* fd) const;
-		/** This prints t10 for t=10. */
-		void format_term(int t, FILE* fd) const;
-		/** This prints a10 for t=10. The atoms a10 are supposed to be
-		 * set by write_atom_assignments(). */
-		void format_nulary(int t, FILE* fd) const;
-	private:
-		void write_common1_preamble(FILE* fd) const;
-		void write_common2_preamble(FILE* fd) const;
-	};
-
-	/** This class implements OperationFormatter for debugging
-	 * purposes. It renders atoms in a more friendly way than the
-	 * ogp::DefaulOperationFormatter. */
-	class DebugOperationFormatter : public ogp::DefaultOperationFormatter {
-	protected:
-		const DynareModel& model;
-	public:
-		DebugOperationFormatter(const DynareModel& m)
-			: DefaultOperationFormatter(m.getParser().getTree()),
-			  model(m) {}
-		void format_nulary(int t, FILE* fd) const;
-	};
+  /** This class implements OperationFormatter for debugging
+   * purposes. It renders atoms in a more friendly way than the
+   * ogp::DefaulOperationFormatter. */
+  class DebugOperationFormatter : public ogp::DefaultOperationFormatter
+  {
+  protected:
+    const DynareModel &model;
+  public:
+    DebugOperationFormatter(const DynareModel &m)
+      : DefaultOperationFormatter(m.getParser().getTree()),
+        model(m)
+    {
+    }
+    void format_nulary(int t, FILE *fd) const;
+  };
 };
 
 #endif
diff --git a/dynare++/src/dynare_params.h b/dynare++/src/dynare_params.h
index 594c35ea2..113e48fb0 100644
--- a/dynare++/src/dynare_params.h
+++ b/dynare++/src/dynare_params.h
@@ -3,71 +3,87 @@
 // Copyright 2004, Ondra Kamenik
 
 /*
-along shocks: m    mult    max_evals
-ellipse:      m    mult    max_evals  (10*m) (0.5*mult)
-simul:        m            max_evals  (10*m)
+  along shocks: m    mult    max_evals
+  ellipse:      m    mult    max_evals  (10*m) (0.5*mult)
+  simul:        m            max_evals  (10*m)
 
---check-scale 2.0 --check-evals 1000 --check-num 10 --check PES
- */
+  --check-scale 2.0 --check-evals 1000 --check-num 10 --check PES
+*/
 
 #include <vector>
 #include <string>
 
-struct DynareParams {
-	const char* modname;
-	std::string basename;
-	int num_per;
-	int num_burn;
-	int num_sim;
-	int num_rtper;
-	int num_rtsim;
-	int num_condper;
-	int num_condsim;
-	int num_threads;
-	int num_steps;
-	const char* prefix;
-	int seed;
-	int order;
-	/** Tolerance used for steady state calcs. */
-	double ss_tol;
-	bool check_along_path;
-	bool check_along_shocks;
-	bool check_on_ellipse;
-	int check_evals;
-	int check_num;
-	double check_scale;
-	/** Flag for doing IRFs even if the irf_list is empty. */
-	bool do_irfs_all;
-	/** List of shocks for which IRF will be calculated. */
-	std::vector<const char*> irf_list;
-	bool do_centralize;
-	double qz_criterium;
-	bool help;
-	bool version;
-	DynareParams(int argc, char** argv);
-	void printHelp() const;
-	int getCheckShockPoints() const
-		{return check_num;}
-	double getCheckShockScale() const
-		{return check_scale;}
-	int getCheckEllipsePoints() const
-		{return 10*check_num;}
-	double getCheckEllipseScale() const
-		{return 0.5*check_scale;}
-	int getCheckPathPoints() const
-		{return 10*check_num;}
+struct DynareParams
+{
+  const char *modname;
+  std::string basename;
+  int num_per;
+  int num_burn;
+  int num_sim;
+  int num_rtper;
+  int num_rtsim;
+  int num_condper;
+  int num_condsim;
+  int num_threads;
+  int num_steps;
+  const char *prefix;
+  int seed;
+  int order;
+  /** Tolerance used for steady state calcs. */
+  double ss_tol;
+  bool check_along_path;
+  bool check_along_shocks;
+  bool check_on_ellipse;
+  int check_evals;
+  int check_num;
+  double check_scale;
+  /** Flag for doing IRFs even if the irf_list is empty. */
+  bool do_irfs_all;
+  /** List of shocks for which IRF will be calculated. */
+  std::vector<const char *> irf_list;
+  bool do_centralize;
+  double qz_criterium;
+  bool help;
+  bool version;
+  DynareParams(int argc, char **argv);
+  void printHelp() const;
+  int
+  getCheckShockPoints() const
+  {
+    return check_num;
+  }
+  double
+  getCheckShockScale() const
+  {
+    return check_scale;
+  }
+  int
+  getCheckEllipsePoints() const
+  {
+    return 10*check_num;
+  }
+  double
+  getCheckEllipseScale() const
+  {
+    return 0.5*check_scale;
+  }
+  int
+  getCheckPathPoints() const
+  {
+    return 10*check_num;
+  }
 private:
-	enum {opt_per, opt_burn, opt_sim, opt_rtper, opt_rtsim, opt_condper, opt_condsim,
-		  opt_prefix, opt_threads,
-		  opt_steps, opt_seed, opt_order, opt_ss_tol, opt_check,
-		  opt_check_along_path, opt_check_along_shocks, opt_check_on_ellipse,
-		  opt_check_evals, opt_check_scale, opt_check_num, opt_noirfs, opt_irfs,
-                  opt_help, opt_version, opt_centralize, opt_no_centralize, opt_qz_criterium};
-	void processCheckFlags(const char* flags);
-	/** This gathers strings from argv[optind] and on not starting
-	 * with '-' to the irf_list. It stops one item before the end,
-	 * since this is the model file. */  
-	void processIRFList(int argc, char** argv);
+  enum {opt_per, opt_burn, opt_sim, opt_rtper, opt_rtsim, opt_condper, opt_condsim,
+        opt_prefix, opt_threads,
+        opt_steps, opt_seed, opt_order, opt_ss_tol, opt_check,
+        opt_check_along_path, opt_check_along_shocks, opt_check_on_ellipse,
+        opt_check_evals, opt_check_scale, opt_check_num, opt_noirfs, opt_irfs,
+        opt_help, opt_version, opt_centralize, opt_no_centralize, opt_qz_criterium};
+  void processCheckFlags(const char *flags);
+  /** This gathers strings from argv[optind] and on not starting
+   * with '-' to the irf_list. It stops one item before the end,
+   * since this is the model file. */
+  void processIRFList(int argc, char **argv);
 };
 
 // Local Variables:
diff --git a/dynare++/src/forw_subst_builder.h b/dynare++/src/forw_subst_builder.h
index 7f703092d..9a51c2cbc 100644
--- a/dynare++/src/forw_subst_builder.h
+++ b/dynare++/src/forw_subst_builder.h
@@ -5,75 +5,85 @@
 #ifndef FORW_SUBST_BUILDER_H
 #define FORW_SUBST_BUILDER_H
 
-
 #include "dynare_model.h"
 
-namespace ogdyn {
+namespace ogdyn
+{
 
-	/** This struct encapsulates information about the process of
-	 * forward substitutions. */
-	struct ForwSubstInfo {
-		int num_affected_equations;
-		int num_subst_terms;
-		int num_aux_variables;
-		int num_new_terms;
-		ForwSubstInfo()
-			: num_affected_equations(0),
-			  num_subst_terms(0),
-			  num_aux_variables(0),
-			  num_new_terms(0) {}
-	};
+  /** This struct encapsulates information about the process of
+   * forward substitutions. */
+  struct ForwSubstInfo
+  {
+    int num_affected_equations;
+    int num_subst_terms;
+    int num_aux_variables;
+    int num_new_terms;
+    ForwSubstInfo()
+      : num_affected_equations(0),
+        num_subst_terms(0),
+        num_aux_variables(0),
+        num_new_terms(0)
+    {
+    }
+  };
 
-	class ForwSubstBuilder {
-		typedef map<int, const char*> Ttermauxmap;
-	protected:
-		/** Reference to the model, to which we will add equations and
-		 * change some equations. */
-		DynareModel& model;
-		/** A map mapping new auxiliary variables to the terms in the
-		 * tree in the DynareModel. */
-		Tsubstmap aux_map;
-		/** Information about the substitutions. */
-		ForwSubstInfo info;
-	public:
-		/** Do all the jobs needed. This scans all equations in the
-		 * model, and for equations containing forward looking
-		 * variables greater than 1 lead, it makes corresponding
-		 * substitutions. Basically, it breaks each equation to its
-		 * non-linear components and creates substitutions for these
-		 * components, not for whole equation. This is because the
-		 * expectation operator can go through the linear part of the
-		 * function. This will save us many occurrences of other
-		 * variables involved in the equation. */
-		ForwSubstBuilder(DynareModel& m);
-		/** Copy constructor with a new instance of the model. */
-		ForwSubstBuilder(const ForwSubstBuilder& b, DynareModel& m);
-		/** Return the auxiliary variable mapping. */
-		const Tsubstmap& get_aux_map() const
-			{return aux_map;}
-		/** Return the information. */
-		const ForwSubstInfo& get_info() const
-			{return info;}
-	private:
-		ForwSubstBuilder(const ForwSubstBuilder& b);
-		/** This method takes a nonlinear term t, and if it has leads
-		 * of greater than 1, then it substitutes the term for the new
-		 * variable (or string of variables). Note that the
-		 * substitution is done by DynamicAtoms::assign_variable. This
-		 * means that the substitution is made for all other
-		 * ocurrences of t in the model. So there is no need of
-		 * tracking already substituted terms. The other two
-		 * parameters are just for identification of the new auxiliary
-		 * variables. When called from the constructor, i is an
-		 * equation number, j is an order of the non-linear term in
-		 * the equation. */
-		void substitute_for_term(int t, int i, int j);
-		/** This is called just at the end of the job. It unassigns
-		 * all nulary terms with a lead greater than 1. */
-		void unassign_gt_1_leads();
-		/** This unassigns all leads greater than 1 of the given name. */
-		void unassign_gt_1_leads(const char* name);
-	};
+  class ForwSubstBuilder
+  {
+    typedef map<int, const char *> Ttermauxmap;
+  protected:
+    /** Reference to the model, to which we will add equations and
+     * change some equations. */
+    DynareModel &model;
+    /** A map mapping new auxiliary variables to the terms in the
+     * tree in the DynareModel. */
+    Tsubstmap aux_map;
+    /** Information about the substitutions. */
+    ForwSubstInfo info;
+  public:
+    /** Do all the jobs needed. This scans all equations in the
+     * model, and for equations containing forward looking
+     * variables greater than 1 lead, it makes corresponding
+     * substitutions. Basically, it breaks each equation to its
+     * non-linear components and creates substitutions for these
+     * components, not for whole equation. This is because the
+     * expectation operator can go through the linear part of the
+     * function. This will save us many occurrences of other
+     * variables involved in the equation. */
+    ForwSubstBuilder(DynareModel &m);
+    /** Copy constructor with a new instance of the model. */
+    ForwSubstBuilder(const ForwSubstBuilder &b, DynareModel &m);
+    /** Return the auxiliary variable mapping. */
+    const Tsubstmap &
+    get_aux_map() const
+    {
+      return aux_map;
+    }
+    /** Return the information. */
+    const ForwSubstInfo &
+    get_info() const
+    {
+      return info;
+    }
+  private:
+    ForwSubstBuilder(const ForwSubstBuilder &b);
+    /** This method takes a nonlinear term t, and if it has leads
+     * of greater than 1, then it substitutes the term for the new
+     * variable (or string of variables). Note that the
+     * substitution is done by DynamicAtoms::assign_variable. This
+     * means that the substitution is made for all other
+     * ocurrences of t in the model. So there is no need of
+     * tracking already substituted terms. The other two
+     * parameters are just for identification of the new auxiliary
+     * variables. When called from the constructor, i is an
+     * equation number, j is an order of the non-linear term in
+     * the equation. */
+    void substitute_for_term(int t, int i, int j);
+    /** This is called just at the end of the job. It unassigns
+     * all nulary terms with a lead greater than 1. */
+    void unassign_gt_1_leads();
+    /** This unassigns all leads greater than 1 of the given name. */
+    void unassign_gt_1_leads(const char *name);
+  };
 };
 
 #endif
diff --git a/dynare++/src/nlsolve.h b/dynare++/src/nlsolve.h
index 0cd19b1f3..b8de181d4 100644
--- a/dynare++/src/nlsolve.h
+++ b/dynare++/src/nlsolve.h
@@ -8,82 +8,102 @@
 #include "twod_matrix.h"
 #include "journal.h"
 
-namespace ogu {
+namespace ogu
+{
 
-	class OneDFunction {
-	public:
-		virtual ~OneDFunction() {}
-		virtual double eval(double) = 0;
-	};
+  class OneDFunction
+  {
+  public:
+    virtual ~OneDFunction()
+    {
+    }
+    virtual double eval(double) = 0;
+  };
 
-	class GoldenSectionSearch {
-	protected:
-		static double tol;
-		static double golden;
-	public:
-		static double search(OneDFunction& f, double x1, double x2);
-	protected:
-		/** This initializes a bracket by moving x2 and b (as a golden
-		 * section of x1,x2) so that f(x1)>f(b) && f(b)<f(x2). The point
-		 * x1 is not moved, since it is considered as reliable and f(x1)
-		 * is supposed to be finite. If initialization of a bracket
-		 * succeeded, then [x1, b, x2] is the bracket and true is
-		 * returned. Otherwise, b is the minimum found and false is
-		 * returned. */
-		static bool init_bracket(OneDFunction& f, double x1, double& x2, double& b);
-		/** This supposes that f(x1) is finite and it moves x2 toward x1
-		 * until x2 and b (as a golden section of x1,x2) are finite. If
-		 * succeeded, the routine returns true and x2, and b. Otherwise,
-		 * it returns false. */
-		static bool search_for_finite(OneDFunction& f, double x1, double& x2, double& b);
-	};
+  class GoldenSectionSearch
+  {
+  protected:
+    static double tol;
+    static double golden;
+  public:
+    static double search(OneDFunction &f, double x1, double x2);
+  protected:
+    /** This initializes a bracket by moving x2 and b (as a golden
+     * section of x1,x2) so that f(x1)>f(b) && f(b)<f(x2). The point
+     * x1 is not moved, since it is considered as reliable and f(x1)
+     * is supposed to be finite. If initialization of a bracket
+     * succeeded, then [x1, b, x2] is the bracket and true is
+     * returned. Otherwise, b is the minimum found and false is
+     * returned. */
+    static bool init_bracket(OneDFunction &f, double x1, double &x2, double &b);
+    /** This supposes that f(x1) is finite and it moves x2 toward x1
+     * until x2 and b (as a golden section of x1,x2) are finite. If
+     * succeeded, the routine returns true and x2, and b. Otherwise,
+     * it returns false. */
+    static bool search_for_finite(OneDFunction &f, double x1, double &x2, double &b);
+  };
 
-	class VectorFunction {
-	public:
-		VectorFunction() {}
-		virtual ~VectorFunction() {}
-		virtual int inDim() const = 0;
-		virtual int outDim() const = 0;
-		/** Check dimensions of eval parameters. */
-		void check_for_eval(const ConstVector& in, Vector& out) const;
-		/** Evaluate the vector function. */
-		virtual void eval(const ConstVector& in, Vector& out) = 0;
-	};
+  class VectorFunction
+  {
+  public:
+    VectorFunction()
+    {
+    }
+    virtual ~VectorFunction()
+    {
+    }
+    virtual int inDim() const = 0;
+    virtual int outDim() const = 0;
+    /** Check dimensions of eval parameters. */
+    void check_for_eval(const ConstVector &in, Vector &out) const;
+    /** Evaluate the vector function. */
+    virtual void eval(const ConstVector &in, Vector &out) = 0;
+  };
 
-	class Jacobian : public TwoDMatrix {
-	public:
-		Jacobian(int n)
-			: TwoDMatrix(n,n) {}
-		virtual ~Jacobian() {}
-		virtual void eval(const Vector& in) = 0;
-	};
+  class Jacobian : public TwoDMatrix
+  {
+  public:
+    Jacobian(int n)
+      : TwoDMatrix(n, n)
+    {
+    }
+    virtual ~Jacobian()
+    {
+    }
+    virtual void eval(const Vector &in) = 0;
+  };
 
-	class NLSolver : public OneDFunction {
-	protected:
-		Journal& journal;
-		VectorFunction& func;
-		Jacobian& jacob;
-		const int max_iter;
-		const double tol;
-	private:
-		Vector xnewton;
-		Vector xcauchy;
-		Vector x;
-	public:
-		NLSolver(VectorFunction& f, Jacobian& j, int maxit, double tl, Journal& jr)
-			: journal(jr), func(f), jacob(j), max_iter(maxit), tol(tl),
-			  xnewton(f.inDim()), xcauchy(f.inDim()), x(f.inDim())
-			{xnewton.zeros(); xcauchy.zeros(); x.zeros();}
-		virtual ~NLSolver() {}
-		/** Returns true if the problem has converged. xx as input is the
-		 * starting value, as output it is a solution. */
-		bool solve(Vector& xx, int& iter);
-		/** To implement OneDFunction interface. It returns
-		 * func(xx)^T*func(xx), where
-		 * xx=x+lambda*xcauchy+(1-lambda)*xnewton. It is non-const only
-		 * because it calls func, x, xnewton, xcauchy is not changed. */
-		double eval(double lambda);
-	};
+  class NLSolver : public OneDFunction
+  {
+  protected:
+    Journal &journal;
+    VectorFunction &func;
+    Jacobian &jacob;
+    const int max_iter;
+    const double tol;
+  private:
+    Vector xnewton;
+    Vector xcauchy;
+    Vector x;
+  public:
+    NLSolver(VectorFunction &f, Jacobian &j, int maxit, double tl, Journal &jr)
+      : journal(jr), func(f), jacob(j), max_iter(maxit), tol(tl),
+        xnewton(f.inDim()), xcauchy(f.inDim()), x(f.inDim())
+    {
+      xnewton.zeros(); xcauchy.zeros(); x.zeros();
+    }
+    virtual ~NLSolver()
+    {
+    }
+    /** Returns true if the problem has converged. xx as input is the
+     * starting value, as output it is a solution. */
+    bool solve(Vector &xx, int &iter);
+    /** To implement OneDFunction interface. It returns
+     * func(xx)^T*func(xx), where
+     * xx=x+lambda*xcauchy+(1-lambda)*xnewton. It is non-const only
+     * because it calls func, x, xnewton, xcauchy is not changed. */
+    double eval(double lambda);
+  };
 
 };
 
diff --git a/dynare++/src/planner_builder.h b/dynare++/src/planner_builder.h
index 9e46832d7..4d888d905 100644
--- a/dynare++/src/planner_builder.h
+++ b/dynare++/src/planner_builder.h
@@ -5,273 +5,322 @@
 
 #include "dynare_model.h"
 
-namespace ogdyn {
+namespace ogdyn
+{
 
-	using boost::unordered_set;
-	using std::map;
-	using std::vector;
+  using boost::unordered_set;
+  using std::map;
+  using std::vector;
 
-	/** This is a two dimensional array of integers. Nothing
-	 * difficult. */ 
-	class IntegerMatrix {
-	protected:
-		/** Number of rows. */
-		int nr;
-		/** Number of columns. */
-		int nc;
-		/** The pointer to the data. */
-		int* data;
-	public:
-		/** Construct uninitialized array. */
-		IntegerMatrix(int nrr, int ncc)
-			: nr(nrr), nc(ncc), data(new int[nr*nc]) {}
-		/** Copy constructor. */
-		IntegerMatrix(const IntegerMatrix& im)
-			: nr(im.nr), nc(im.nc), data(new int[nr*nc])
-			{memcpy(data, im.data, nr*nc*sizeof(int));}
-		virtual ~IntegerMatrix()
-			{delete [] data;}
-		/** Assignment operator. It can only assing array with the
-		 * same dimensions. */
-		const IntegerMatrix& operator=(const IntegerMatrix& im);
-		int& operator()(int i, int j)
-			{return data[i+j*nr];}
-		const int& operator()(int i, int j) const
-			{return data[i+j*nr];}
-		int nrows() const
-			{return nr;}
-		int ncols() const
-			{return nc;}
-	};
+  /** This is a two dimensional array of integers. Nothing
+   * difficult. */
+  class IntegerMatrix
+  {
+  protected:
+    /** Number of rows. */
+    int nr;
+    /** Number of columns. */
+    int nc;
+    /** The pointer to the data. */
+    int *data;
+  public:
+    /** Construct uninitialized array. */
+    IntegerMatrix(int nrr, int ncc)
+      : nr(nrr), nc(ncc), data(new int[nr*nc])
+    {
+    }
+    /** Copy constructor. */
+    IntegerMatrix(const IntegerMatrix &im)
+      : nr(im.nr), nc(im.nc), data(new int[nr*nc])
+    {
+      memcpy(data, im.data, nr*nc*sizeof(int));
+    }
+    virtual ~IntegerMatrix()
+    {
+      delete [] data;
+    }
+    /** Assignment operator. It can only assing array with the
+     * same dimensions. */
+    const IntegerMatrix &operator=(const IntegerMatrix &im);
+    int &
+    operator()(int i, int j)
+    {
+      return data[i+j*nr];
+    }
+    const int &
+    operator()(int i, int j) const
+    {
+      return data[i+j*nr];
+    }
+    int
+    nrows() const
+    {
+      return nr;
+    }
+    int
+    ncols() const
+    {
+      return nc;
+    }
+  };
 
-	/** The three dimensional array of integers. Nothing difficult. */
-	class IntegerArray3 {
-	protected:
-		/** First dimension. */
-		int n1;
-		/** Second dimension. */
-		int n2;
-		/** Third dimension. */
-		int n3;
-		/** The data. */
-		int* data;
-	public:
-		/** Constrcut unitialized array. */
-		IntegerArray3(int nn1, int nn2, int nn3)
-			: n1(nn1), n2(nn2), n3(nn3), data(new int[n1*n2*n3]) {}
-		/** Copy constructor. */
-		IntegerArray3(const IntegerArray3& ia3)
-			: n1(ia3.n1), n2(ia3.n2), n3(ia3.n3), data(new int[n1*n2*n3])
-			{memcpy(data, ia3.data, n1*n2*n3*sizeof(int));}
-		virtual ~IntegerArray3()
-			{delete [] data;}
-		/** Assignment operator assigning the arrays with the same dimensions. */
-		const IntegerArray3& operator=(const IntegerArray3& ia3);
-		int& operator()(int i, int j, int k)
-			{return data[i+j*n1+k*n1*n2];}
-		const int& operator()(int i, int j, int k) const
-			{return data[i+j*n1+k*n1*n2];}
-		int dim1() const
-			{return n1;}
-		int dim2() const
-			{return n2;}
-		int dim3() const
-			{return n3;}
-	};
+  /** The three dimensional array of integers. Nothing difficult. */
+  class IntegerArray3
+  {
+  protected:
+    /** First dimension. */
+    int n1;
+    /** Second dimension. */
+    int n2;
+    /** Third dimension. */
+    int n3;
+    /** The data. */
+    int *data;
+  public:
+    /** Constrcut unitialized array. */
+    IntegerArray3(int nn1, int nn2, int nn3)
+      : n1(nn1), n2(nn2), n3(nn3), data(new int[n1*n2*n3])
+    {
+    }
+    /** Copy constructor. */
+    IntegerArray3(const IntegerArray3 &ia3)
+      : n1(ia3.n1), n2(ia3.n2), n3(ia3.n3), data(new int[n1*n2*n3])
+    {
+      memcpy(data, ia3.data, n1*n2*n3*sizeof(int));
+    }
+    virtual ~IntegerArray3()
+    {
+      delete [] data;
+    }
+    /** Assignment operator assigning the arrays with the same dimensions. */
+    const IntegerArray3 &operator=(const IntegerArray3 &ia3);
+    int &
+    operator()(int i, int j, int k)
+    {
+      return data[i+j*n1+k*n1*n2];
+    }
+    const int &
+    operator()(int i, int j, int k) const
+    {
+      return data[i+j*n1+k*n1*n2];
+    }
+    int
+    dim1() const
+    {
+      return n1;
+    }
+    int
+    dim2() const
+    {
+      return n2;
+    }
+    int
+    dim3() const
+    {
+      return n3;
+    }
+  };
 
-	/** This struct encapsulates information about the building of a
-	 * planner's problem. */
-	struct PlannerInfo {
-		int num_lagrange_mults;
-		int num_aux_variables;
-		int num_new_terms;
-		PlannerInfo()
-			: num_lagrange_mults(0),
-			  num_aux_variables(0),
-			  num_new_terms(0) {}
-	};
+  /** This struct encapsulates information about the building of a
+   * planner's problem. */
+  struct PlannerInfo
+  {
+    int num_lagrange_mults;
+    int num_aux_variables;
+    int num_new_terms;
+    PlannerInfo()
+      : num_lagrange_mults(0),
+        num_aux_variables(0),
+        num_new_terms(0)
+    {
+    }
+  };
 
-	class MultInitSS;
+  class MultInitSS;
 
-	/** This class builds the first order conditions of the social
-	 * planner problem with constraints being the equations in the
-	 * model. The model is non-const parameter to the constructor
-	 * which adds appropriate FOCs to the system. It also allows for
-	 * an estimation of the lagrange multipliers given all other
-	 * endogenous variables of the static system. For this purpose we
-	 * need to create static atoms and static versions of all the tree
-	 * index matrices. The algorithm and algebra are documented in
-	 * dynare++-ramsey.pdf. */  
-	class PlannerBuilder {
-		friend class MultInitSS;
-	public:
-		/** Type for a set of variable names. */
-		typedef unordered_set<const char*> Tvarset;
-		/** Type for a set of equations. An equation is identified by
-		 * an index to an equation in the equation vector given by
-		 * DynareModel::eqs. The tree index of the i-th formula is
-		 * retrieved as DynareModel::egs.formula(i). */
-		typedef vector<int> Teqset;
-	protected:
-		/** This is a set of variables wrt which the planner
-		 * optimizes. These could be all endogenous variables, but it
-		 * is beneficial to exclude all variables which are
-		 * deterministic transformations of past exogenous variables,
-		 * since the planner cannot influence them. This could save a
-		 * few equations. This is not changed after it is constructed,
-		 * but it is constructed manually, so it cannot be declared as
-		 * const. */
-		Tvarset yset;
-		/** These are the equation indices constituing the constraints
-		 * for the planner. Again, it is beneficial to exclude all
-		 * equations defining exogenous variables excluded from
-		 * yset. */
-		const Teqset fset;
-		/** Reference to the model. */ 
-		ogdyn::DynareModel& model;
-		/** Tree index of the planner objective. */
-		int tb;
-		/** Tree index of the planner discount parameter. */
-		int tbeta;
-		/** The maximum lead in the model including the planner's
-		 * objective before building the planner's FOCs. */
-		const int maxlead;
-		/** The minimum lag in the model including the planner's objective
-		 * before building the planner's FOCs. */
-		const int minlag;
-		/** Tree indices of formulas in the planner FOCs involving
-		 * derivatives of the planner's objective. Rows correspond to the
-		 * endogenous variables, columns correspond to lags in the
-		 * objective function. The contents of the matrix will evolve as
-		 * the algorithm proceeds. */
-		IntegerMatrix diff_b;
-		/** Tree indices of formulas in the planner FOCs involving
-		 * derivatives of the model equations (constraints). The first
-		 * dimension corresponds to endogenous variables, the second to
-		 * the constraints, the third to lags or leads of endogenous
-		 * variables in the constraints. The contents of the array will
-		 * evolve as the algorithm proceeds.*/
-		IntegerArray3 diff_f;
-		/** Static version of the model atoms. It is needed to build
-		 * static version of diff_b and diff_f. */
-		ogp::StaticFineAtoms static_atoms;
-		/** Static version of all the trees of diff_b and diff_f build
-		 * over static_atoms. */
-		ogp::OperationTree static_tree;
-		/** Tree indices of static version of diff_b over static_atoms and static_tree. */
-		IntegerMatrix diff_b_static;
-		/** Tree indices of static version of diff_f over static_atoms
-		 * and static_tree. This member is created before calling
-		 * lagrange_mult_f(), so it does not contain the
-		 * multiplication with the lagrange multipliers. */
-		IntegerArray3 diff_f_static;
-		/** Auxiliary variables mapping. During the algorithm, some
-		 * auxiliary variables for the terms might be created, so we
-		 * remember their names and tree indices of the terms. This
-		 * maps a name to the tree index of an expression equal to the
-		 * auxiliary variable at time zero. The auxiliary variables
-		 * names point to the dynamic atoms storage, tree inidices to
-		 * the dynamic model tree. */
-		Tsubstmap aux_map;
-		/** Static version of aux_map. The names point to static_atoms
-		 * storage, the tree indices to the static_tree. */
-		Tsubstmap static_aux_map;
-		/** Information about the number of various things. */
-		PlannerInfo info;
-	public:
-		/** Build the planner problem for the given model optimizing
-		 * through the given endogenous variables with the given
-		 * constraints. We allow for a selection of a subset of
-		 * equations and variables in order to eliminate exogenous
-		 * predetermined process which cannot be influenced by the
-		 * social planner. */
-		PlannerBuilder(ogdyn::DynareModel& m, const Tvarset& yyset,
-					   const Teqset& ffset);
-		/** Construct a copy of the builder with provided model, which
-		 * is supposed to be the copy of the model in the builder. */
-		PlannerBuilder(const PlannerBuilder& pb, ogdyn::DynareModel& m);
-		/** Return the information. */
-		const PlannerInfo& get_info() const
-			{return info;}
-	protected:
-		/** Differentiate the planner objective wrt endogenous
-		 * variables with different lags. */
-		void add_derivatives_of_b();
-		/** Differentiate the constraints wrt endogenous variables
-		 * with different lags and leads. */
-		void add_derivatives_of_f();
-		/** Shift derivatives of diff_b. */
-		void shift_derivatives_of_b();
-		/** Shift derivatives of diff_ff. */
-		void shift_derivatives_of_f();
-		/** Multiply with the discount factor terms in diff_b. */
-		void beta_multiply_b();
-		/** Multiply with the discount factor terms in diff_f. */
-		void beta_multiply_f();
-		/** Fill static_atoms and static_tree and build diff_b_static,
-		 * diff_f_static and aux_map_static with static versions of diff_b,
-		 * diff_f and aux_map. */
-		void make_static_version();
-		/** Multiply diff_f with Langrange multipliers. */
-		void lagrange_mult_f();
-		/** Add the equations to the mode, including equation for auxiliary variables. */
-		void form_equations();
-	private:
-		/** Fill yset for a given yyset and given name storage. */
-		void fill_yset(const ogp::NameStorage& ns, const Tvarset& yyset);
-		/** Fill aux_map and aux_map_static for a given aaux_map and
-		 * aaux_map_static for a given storage of dynamic atoms (used
-		 * for aux_map) and static atoms storage from this object for
-		 * aux_map_static. */
-		void fill_aux_map(const ogp::NameStorage& ns, const Tsubstmap& aaux_map,
-						  const Tsubstmap& astatic_aux_map);
-		/** Avoid copying from only PlannerBuilder. */
-		PlannerBuilder(const PlannerBuilder& pb);
-  	};
+  /** This class builds the first order conditions of the social
+   * planner problem with constraints being the equations in the
+   * model. The model is non-const parameter to the constructor
+   * which adds appropriate FOCs to the system. It also allows for
+   * an estimation of the lagrange multipliers given all other
+   * endogenous variables of the static system. For this purpose we
+   * need to create static atoms and static versions of all the tree
+   * index matrices. The algorithm and algebra are documented in
+   * dynare++-ramsey.pdf. */
+  class PlannerBuilder
+  {
+    friend class MultInitSS;
+  public:
+    /** Type for a set of variable names. */
+    typedef unordered_set<const char *> Tvarset;
+    /** Type for a set of equations. An equation is identified by
+     * an index to an equation in the equation vector given by
+     * DynareModel::eqs. The tree index of the i-th formula is
+     * retrieved as DynareModel::egs.formula(i). */
+    typedef vector<int> Teqset;
+  protected:
+    /** This is a set of variables wrt which the planner
+     * optimizes. These could be all endogenous variables, but it
+     * is beneficial to exclude all variables which are
+     * deterministic transformations of past exogenous variables,
+     * since the planner cannot influence them. This could save a
+     * few equations. This is not changed after it is constructed,
+     * but it is constructed manually, so it cannot be declared as
+     * const. */
+    Tvarset yset;
+    /** These are the equation indices constituing the constraints
+     * for the planner. Again, it is beneficial to exclude all
+     * equations defining exogenous variables excluded from
+     * yset. */
+    const Teqset fset;
+    /** Reference to the model. */
+    ogdyn::DynareModel &model;
+    /** Tree index of the planner objective. */
+    int tb;
+    /** Tree index of the planner discount parameter. */
+    int tbeta;
+    /** The maximum lead in the model including the planner's
+     * objective before building the planner's FOCs. */
+    const int maxlead;
+    /** The minimum lag in the model including the planner's objective
+     * before building the planner's FOCs. */
+    const int minlag;
+    /** Tree indices of formulas in the planner FOCs involving
+     * derivatives of the planner's objective. Rows correspond to the
+     * endogenous variables, columns correspond to lags in the
+     * objective function. The contents of the matrix will evolve as
+     * the algorithm proceeds. */
+    IntegerMatrix diff_b;
+    /** Tree indices of formulas in the planner FOCs involving
+     * derivatives of the model equations (constraints). The first
+     * dimension corresponds to endogenous variables, the second to
+     * the constraints, the third to lags or leads of endogenous
+     * variables in the constraints. The contents of the array will
+     * evolve as the algorithm proceeds.*/
+    IntegerArray3 diff_f;
+    /** Static version of the model atoms. It is needed to build
+     * static version of diff_b and diff_f. */
+    ogp::StaticFineAtoms static_atoms;
+    /** Static version of all the trees of diff_b and diff_f build
+     * over static_atoms. */
+    ogp::OperationTree static_tree;
+    /** Tree indices of static version of diff_b over static_atoms and static_tree. */
+    IntegerMatrix diff_b_static;
+    /** Tree indices of static version of diff_f over static_atoms
+     * and static_tree. This member is created before calling
+     * lagrange_mult_f(), so it does not contain the
+     * multiplication with the lagrange multipliers. */
+    IntegerArray3 diff_f_static;
+    /** Auxiliary variables mapping. During the algorithm, some
+     * auxiliary variables for the terms might be created, so we
+     * remember their names and tree indices of the terms. This
+     * maps a name to the tree index of an expression equal to the
+     * auxiliary variable at time zero. The auxiliary variables
+     * names point to the dynamic atoms storage, tree inidices to
+     * the dynamic model tree. */
+    Tsubstmap aux_map;
+    /** Static version of aux_map. The names point to static_atoms
+     * storage, the tree indices to the static_tree. */
+    Tsubstmap static_aux_map;
+    /** Information about the number of various things. */
+    PlannerInfo info;
+  public:
+    /** Build the planner problem for the given model optimizing
+     * through the given endogenous variables with the given
+     * constraints. We allow for a selection of a subset of
+     * equations and variables in order to eliminate exogenous
+     * predetermined process which cannot be influenced by the
+     * social planner. */
+    PlannerBuilder(ogdyn::DynareModel &m, const Tvarset &yyset,
+                   const Teqset &ffset);
+    /** Construct a copy of the builder with provided model, which
+     * is supposed to be the copy of the model in the builder. */
+    PlannerBuilder(const PlannerBuilder &pb, ogdyn::DynareModel &m);
+    /** Return the information. */
+    const PlannerInfo &
+    get_info() const
+    {
+      return info;
+    }
+  protected:
+    /** Differentiate the planner objective wrt endogenous
+     * variables with different lags. */
+    void add_derivatives_of_b();
+    /** Differentiate the constraints wrt endogenous variables
+     * with different lags and leads. */
+    void add_derivatives_of_f();
+    /** Shift derivatives of diff_b. */
+    void shift_derivatives_of_b();
+    /** Shift derivatives of diff_ff. */
+    void shift_derivatives_of_f();
+    /** Multiply with the discount factor terms in diff_b. */
+    void beta_multiply_b();
+    /** Multiply with the discount factor terms in diff_f. */
+    void beta_multiply_f();
+    /** Fill static_atoms and static_tree and build diff_b_static,
+     * diff_f_static and aux_map_static with static versions of diff_b,
+     * diff_f and aux_map. */
+    void make_static_version();
+    /** Multiply diff_f with Langrange multipliers. */
+    void lagrange_mult_f();
+    /** Add the equations to the mode, including equation for auxiliary variables. */
+    void form_equations();
+  private:
+    /** Fill yset for a given yyset and given name storage. */
+    void fill_yset(const ogp::NameStorage &ns, const Tvarset &yyset);
+    /** Fill aux_map and aux_map_static for a given aaux_map and
+     * aaux_map_static for a given storage of dynamic atoms (used
+     * for aux_map) and static atoms storage from this object for
+     * aux_map_static. */
+    void fill_aux_map(const ogp::NameStorage &ns, const Tsubstmap &aaux_map,
+                      const Tsubstmap &astatic_aux_map);
+    /** Avoid copying from only PlannerBuilder. */
+    PlannerBuilder(const PlannerBuilder &pb);
+  };
 
-	/** This class only calculates for the given initial guess of
-	 * endogenous variables, initial guess of the Langrange
-	 * multipliers of the social planner problem yielding the least
-	 * square error. It is used by just calling its constructor. The
-	 * constructor takes non-const reference to the vector of
-	 * endogenous variables, calculates lambdas and put the values of
-	 * lambdas to the vector. The algbera is found in
-	 * dynare++-ramsey.pdf.
-	 *
-	 * The code can be run only after the parsing has been finished in
-	 * atoms. */
-	class MultInitSS : public ogp::FormulaEvalLoader {
-	protected:
-		/** The constant reference to the builder. */
-		const PlannerBuilder& builder;
-		/** The constant term of the problem. Its length is the number
-		 * of endogenous variable wrt the planner optimizes. */
-		Vector b;
-		/** The matrix of the overdetermined problem. The number of
-		 * rows is equal to the number of endogenous variables wrt
-		 * which the planner optimizes, the number of columns is equal
-		 * to the number of Langrange multipliers which is equal to
-		 * the number of constraints which is smaller than the number
-		 * of endogenous variables. Hence the system b+F*lambda=0 is
-		 * overdetermined. */
-		GeneralMatrix F;
-	public:
-		/** The constructor of the object which does everything. Its
-		 * main goal is to update yy. Note that if an item of yy
-		 * corresponding to a lagrange multiplier is already set, it
-		 * is not reset. */
-		MultInitSS(const PlannerBuilder& pb, const Vector& pvals, Vector& yy);
-		/** This loads evaluated parts of b or F and decodes i and
-		 * advances b or F depending on the decoded i. The decoding is
-		 * dependent on the way how the terms of builder.diff_b and
-		 * builder.diff_f_save have been put the the
-		 * ogp::FormulaCustomEvaluator. This is documented in the code
-		 * of the constructor. */
-		void load(int i, double res);
-	};
+  /** This class only calculates for the given initial guess of
+   * endogenous variables, initial guess of the Langrange
+   * multipliers of the social planner problem yielding the least
+   * square error. It is used by just calling its constructor. The
+   * constructor takes non-const reference to the vector of
+   * endogenous variables, calculates lambdas and put the values of
+   * lambdas to the vector. The algbera is found in
+   * dynare++-ramsey.pdf.
+   *
+   * The code can be run only after the parsing has been finished in
+   * atoms. */
+  class MultInitSS : public ogp::FormulaEvalLoader
+  {
+  protected:
+    /** The constant reference to the builder. */
+    const PlannerBuilder &builder;
+    /** The constant term of the problem. Its length is the number
+     * of endogenous variable wrt the planner optimizes. */
+    Vector b;
+    /** The matrix of the overdetermined problem. The number of
+     * rows is equal to the number of endogenous variables wrt
+     * which the planner optimizes, the number of columns is equal
+     * to the number of Langrange multipliers which is equal to
+     * the number of constraints which is smaller than the number
+     * of endogenous variables. Hence the system b+F*lambda=0 is
+     * overdetermined. */
+    GeneralMatrix F;
+  public:
+    /** The constructor of the object which does everything. Its
+     * main goal is to update yy. Note that if an item of yy
+     * corresponding to a lagrange multiplier is already set, it
+     * is not reset. */
+    MultInitSS(const PlannerBuilder &pb, const Vector &pvals, Vector &yy);
+    /** This loads evaluated parts of b or F and decodes i and
+     * advances b or F depending on the decoded i. The decoding is
+     * dependent on the way how the terms of builder.diff_b and
+     * builder.diff_f_save have been put the the
+     * ogp::FormulaCustomEvaluator. This is documented in the code
+     * of the constructor. */
+    void load(int i, double res);
+  };
 };
 
-
 #endif
 
 // Local Variables:
diff --git a/dynare++/sylv/cc/BlockDiagonal.h b/dynare++/sylv/cc/BlockDiagonal.h
index c2b94313a..f44965338 100644
--- a/dynare++/sylv/cc/BlockDiagonal.h
+++ b/dynare++/sylv/cc/BlockDiagonal.h
@@ -7,47 +7,55 @@
 
 #include "QuasiTriangular.h"
 
-
-class BlockDiagonal : public QuasiTriangular {
-	int* const row_len;
-	int* const col_len;
+class BlockDiagonal : public QuasiTriangular
+{
+  int *const row_len;
+  int *const col_len;
 public:
-	BlockDiagonal(const double* d, int d_size);
-	BlockDiagonal(int p, const BlockDiagonal& b);
-	BlockDiagonal(const BlockDiagonal& b);
-	BlockDiagonal(const QuasiTriangular& t);
-	const BlockDiagonal& operator=(const QuasiTriangular& t)
-		{GeneralMatrix::operator=(t); return *this;}
-	const BlockDiagonal& operator=(const BlockDiagonal& b);
-	~BlockDiagonal() {delete [] row_len; delete [] col_len;}
-	void setZeroBlockEdge(diag_iter edge);
-	int getNumZeros() const;
-	int getNumBlocks() const;
-	int getLargestBlock() const;
-	void printInfo() const;
+  BlockDiagonal(const double *d, int d_size);
+  BlockDiagonal(int p, const BlockDiagonal &b);
+  BlockDiagonal(const BlockDiagonal &b);
+  BlockDiagonal(const QuasiTriangular &t);
+  const BlockDiagonal &
+  operator=(const QuasiTriangular &t)
+  {
+    GeneralMatrix::operator=(t); return *this;
+  }
+  const BlockDiagonal &operator=(const BlockDiagonal &b);
+  ~BlockDiagonal()
+  {
+    delete [] row_len; delete [] col_len;
+  }
+  void setZeroBlockEdge(diag_iter edge);
+  int getNumZeros() const;
+  int getNumBlocks() const;
+  int getLargestBlock() const;
+  void printInfo() const;
 
-	void multKron(KronVector& x) const;
-	void multKronTrans(KronVector& x) const;
+  void multKron(KronVector &x) const;
+  void multKronTrans(KronVector &x) const;
 
-	const_col_iter col_begin(const DiagonalBlock& b) const;
-	col_iter col_begin(const DiagonalBlock& b);
-	const_row_iter row_end(const DiagonalBlock& b) const;
-	row_iter row_end(const DiagonalBlock& b);
-	QuasiTriangular* clone() const
-		{return new BlockDiagonal(*this);}
+  const_col_iter col_begin(const DiagonalBlock &b) const;
+  col_iter col_begin(const DiagonalBlock &b);
+  const_row_iter row_end(const DiagonalBlock &b) const;
+  row_iter row_end(const DiagonalBlock &b);
+  QuasiTriangular *
+  clone() const
+  {
+    return new BlockDiagonal(*this);
+  }
 private:
-	void setZerosToRU(diag_iter edge);
-	const_diag_iter findBlockStart(const_diag_iter from) const;
-	static void savePartOfX(int si, int ei, const KronVector& x, Vector& work);
-	void multKronBlock(const_diag_iter start, const_diag_iter end,
-					   KronVector& x, Vector& work) const;
-	void multKronBlockTrans(const_diag_iter start, const_diag_iter end,
-							KronVector& x, Vector& work) const;
+  void setZerosToRU(diag_iter edge);
+  const_diag_iter findBlockStart(const_diag_iter from) const;
+  static void savePartOfX(int si, int ei, const KronVector &x, Vector &work);
+  void multKronBlock(const_diag_iter start, const_diag_iter end,
+                     KronVector &x, Vector &work) const;
+  void multKronBlockTrans(const_diag_iter start, const_diag_iter end,
+                          KronVector &x, Vector &work) const;
 };
 
 #endif /* BLOCK_DIAGONAL_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/GeneralMatrix.h b/dynare++/sylv/cc/GeneralMatrix.h
index d24c11cad..494dcf406 100644
--- a/dynare++/sylv/cc/GeneralMatrix.h
+++ b/dynare++/sylv/cc/GeneralMatrix.h
@@ -11,310 +11,484 @@
 
 class GeneralMatrix;
 
-class ConstGeneralMatrix {
-	friend class GeneralMatrix;
+class ConstGeneralMatrix
+{
+  friend class GeneralMatrix;
 protected:
-	ConstVector data;
-	int rows;
-	int cols;
-	int ld;
+  ConstVector data;
+  int rows;
+  int cols;
+  int ld;
 public:
-	ConstGeneralMatrix(const double* d, int m, int n)
-		: data(d, m*n), rows(m), cols(n), ld(m) {}
-	ConstGeneralMatrix(const GeneralMatrix& m);
-	ConstGeneralMatrix(const GeneralMatrix& m, int i, int j, int nrows, int ncols);
-	ConstGeneralMatrix(const ConstGeneralMatrix& m, int i, int j, int nrows, int ncols);
-	virtual ~ConstGeneralMatrix() {}
+  ConstGeneralMatrix(const double *d, int m, int n)
+    : data(d, m*n), rows(m), cols(n), ld(m)
+  {
+  }
+  ConstGeneralMatrix(const GeneralMatrix &m);
+  ConstGeneralMatrix(const GeneralMatrix &m, int i, int j, int nrows, int ncols);
+  ConstGeneralMatrix(const ConstGeneralMatrix &m, int i, int j, int nrows, int ncols);
+  virtual ~ConstGeneralMatrix()
+  {
+  }
 
-	const double& get(int i, int j) const
-		{return data[j*ld+i];}
-	int numRows() const {return rows;}
-	int numCols() const {return cols;}
-	int getLD() const {return ld;}
-	const double* base() const {return data.base();}
-	const ConstVector& getData() const {return data;}
+  const double &
+  get(int i, int j) const
+  {
+    return data[j*ld+i];
+  }
+  int
+  numRows() const
+  {
+    return rows;
+  }
+  int
+  numCols() const
+  {
+    return cols;
+  }
+  int
+  getLD() const
+  {
+    return ld;
+  }
+  const double *
+  base() const
+  {
+    return data.base();
+  }
+  const ConstVector &
+  getData() const
+  {
+    return data;
+  }
 
-	double getNormInf() const;
-	double getNorm1() const;
-	/* x = scalar(a)*x + scalar(b)*this*d */
-	void multVec(double a, Vector& x, double b, const ConstVector& d) const;
-	/* x = scalar(a)*x + scalar(b)*this'*d */
-	void multVecTrans(double a, Vector& x, double b, const ConstVector& d) const;
-	/* x = x + this*d */
-	void multaVec(Vector& x, const ConstVector& d) const
-		{multVec(1.0, x, 1.0, d);}
-	/* x = x + this'*d */
-	void multaVecTrans(Vector& x, const ConstVector& d) const
-		{multVecTrans(1.0, x, 1.0, d);}
-	/* x = x - this*d */
-	void multsVec(Vector& x, const ConstVector& d) const
-		{multVec(1.0, x, -1.0, d);}
-	/* x = x - this'*d */
-	void multsVecTrans(Vector& x, const ConstVector& d) const
-		{multVecTrans(1.0, x, -1.0, d);}
-	/* m = inv(this)*m */
-	void multInvLeft(GeneralMatrix& m) const;
-	/* m = inv(this')*m */
-	void multInvLeftTrans(GeneralMatrix& m) const;
-	/* d = inv(this)*d */
-	void multInvLeft(Vector& d) const;
-	/* d = inv(this')*d */
-	void multInvLeftTrans(Vector& d) const;
+  double getNormInf() const;
+  double getNorm1() const;
+  /* x = scalar(a)*x + scalar(b)*this*d */
+  void multVec(double a, Vector &x, double b, const ConstVector &d) const;
+  /* x = scalar(a)*x + scalar(b)*this'*d */
+  void multVecTrans(double a, Vector &x, double b, const ConstVector &d) const;
+  /* x = x + this*d */
+  void
+  multaVec(Vector &x, const ConstVector &d) const
+  {
+    multVec(1.0, x, 1.0, d);
+  }
+  /* x = x + this'*d */
+  void
+  multaVecTrans(Vector &x, const ConstVector &d) const
+  {
+    multVecTrans(1.0, x, 1.0, d);
+  }
+  /* x = x - this*d */
+  void
+  multsVec(Vector &x, const ConstVector &d) const
+  {
+    multVec(1.0, x, -1.0, d);
+  }
+  /* x = x - this'*d */
+  void
+  multsVecTrans(Vector &x, const ConstVector &d) const
+  {
+    multVecTrans(1.0, x, -1.0, d);
+  }
+  /* m = inv(this)*m */
+  void multInvLeft(GeneralMatrix &m) const;
+  /* m = inv(this')*m */
+  void multInvLeftTrans(GeneralMatrix &m) const;
+  /* d = inv(this)*d */
+  void multInvLeft(Vector &d) const;
+  /* d = inv(this')*d */
+  void multInvLeftTrans(Vector &d) const;
 
-	bool isFinite() const;
-	/** Returns true of the matrix is exactly zero. */
-	bool isZero() const;
+  bool isFinite() const;
+  /** Returns true of the matrix is exactly zero. */
+  bool isZero() const;
 
-	virtual void print() const;
+  virtual void print() const;
 protected:
-	void multInvLeft(const char* trans, int mrows, int mcols, int mld, double* d) const;
+  void multInvLeft(const char *trans, int mrows, int mcols, int mld, double *d) const;
 };
 
-
-class GeneralMatrix {
-	friend class ConstGeneralMatrix;
+class GeneralMatrix
+{
+  friend class ConstGeneralMatrix;
 protected:
-	Vector data;
-	int rows;
-	int cols;
-	int ld;
+  Vector data;
+  int rows;
+  int cols;
+  int ld;
 public:
-	GeneralMatrix(int m, int n)
-		: data(m*n), rows(m), cols(n), ld(m) {}
-	GeneralMatrix(const double* d, int m, int n)
-		: data(d, m*n), rows(m), cols(n), ld(m) {}
-	GeneralMatrix(double* d, int m, int n)
-		: data(d, m*n), rows(m), cols(n), ld(m) {}
-	GeneralMatrix(const GeneralMatrix& m);
-	GeneralMatrix(const ConstGeneralMatrix& m);
-	GeneralMatrix(const GeneralMatrix&m, const char* dummy); // transpose
-	GeneralMatrix(const ConstGeneralMatrix&m, const char* dummy); // transpose
-	GeneralMatrix(const GeneralMatrix& m, int i, int j, int nrows, int ncols);
-	GeneralMatrix(GeneralMatrix& m, int i, int j, int nrows, int ncols);
-	/* this = a*b */
-	GeneralMatrix(const GeneralMatrix& a, const GeneralMatrix& b);
-	/* this = a*b' */
-	GeneralMatrix(const GeneralMatrix& a, const GeneralMatrix& b, const char* dum);
-	/* this = a'*b */
-	GeneralMatrix(const GeneralMatrix& a, const char* dum, const GeneralMatrix& b);
-	/* this = a'*b */
-	GeneralMatrix(const GeneralMatrix& a, const char* dum1,
-				  const GeneralMatrix& b, const char* dum2);
+  GeneralMatrix(int m, int n)
+    : data(m*n), rows(m), cols(n), ld(m)
+  {
+  }
+  GeneralMatrix(const double *d, int m, int n)
+    : data(d, m*n), rows(m), cols(n), ld(m)
+  {
+  }
+  GeneralMatrix(double *d, int m, int n)
+    : data(d, m*n), rows(m), cols(n), ld(m)
+  {
+  }
+  GeneralMatrix(const GeneralMatrix &m);
+  GeneralMatrix(const ConstGeneralMatrix &m);
+  GeneralMatrix(const GeneralMatrix &m, const char *dummy); // transpose
+  GeneralMatrix(const ConstGeneralMatrix &m, const char *dummy); // transpose
+  GeneralMatrix(const GeneralMatrix &m, int i, int j, int nrows, int ncols);
+  GeneralMatrix(GeneralMatrix &m, int i, int j, int nrows, int ncols);
+  /* this = a*b */
+  GeneralMatrix(const GeneralMatrix &a, const GeneralMatrix &b);
+  /* this = a*b' */
+  GeneralMatrix(const GeneralMatrix &a, const GeneralMatrix &b, const char *dum);
+  /* this = a'*b */
+  GeneralMatrix(const GeneralMatrix &a, const char *dum, const GeneralMatrix &b);
+  /* this = a'*b */
+  GeneralMatrix(const GeneralMatrix &a, const char *dum1,
+                const GeneralMatrix &b, const char *dum2);
 
-	virtual ~GeneralMatrix();
-	const GeneralMatrix& operator=(const GeneralMatrix& m)
-		{data=m.data; rows=m.rows; cols=m.cols; ld=m.ld; return *this;}
+  virtual
+  ~GeneralMatrix();
+  const GeneralMatrix &
+  operator=(const GeneralMatrix &m)
+  {
+    data = m.data; rows = m.rows; cols = m.cols; ld = m.ld; return *this;
+  }
 
-	const double& get(int i, int j) const
-		{return data[j*ld+i];}
-	double& get(int i, int j)
-		{return data[j*ld+i];}
-	int numRows() const {return rows;}
-	int numCols() const {return cols;}
-	int getLD() const {return ld;}
-	double* base() {return data.base();}
-	const double* base() const {return data.base();}
-	Vector& getData() {return data;}
-	const Vector& getData() const {return data;}
+  const double &
+  get(int i, int j) const
+  {
+    return data[j*ld+i];
+  }
+  double &
+  get(int i, int j)
+  {
+    return data[j*ld+i];
+  }
+  int
+  numRows() const
+  {
+    return rows;
+  }
+  int
+  numCols() const
+  {
+    return cols;
+  }
+  int
+  getLD() const
+  {
+    return ld;
+  }
+  double *
+  base()
+  {
+    return data.base();
+  }
+  const double *
+  base() const
+  {
+    return data.base();
+  }
+  Vector &
+  getData()
+  {
+    return data;
+  }
+  const Vector &
+  getData() const
+  {
+    return data;
+  }
 
-	double getNormInf() const
-		{return ConstGeneralMatrix(*this).getNormInf();}
-	double getNorm1() const
-		{return ConstGeneralMatrix(*this).getNorm1();}
+  double
+  getNormInf() const
+  {
+    return ConstGeneralMatrix(*this).getNormInf();
+  }
+  double
+  getNorm1() const
+  {
+    return ConstGeneralMatrix(*this).getNorm1();
+  }
 
-	/* place matrix m to the position (i,j) */
-	void place(const ConstGeneralMatrix& m, int i, int j);
-	void place(const GeneralMatrix& m, int i, int j)
-		{place(ConstGeneralMatrix(m), i, j);}
+  /* place matrix m to the position (i,j) */
+  void place(const ConstGeneralMatrix &m, int i, int j);
+  void
+  place(const GeneralMatrix &m, int i, int j)
+  {
+    place(ConstGeneralMatrix(m), i, j);
+  }
 
-	/* this = a*b */
-	void mult(const ConstGeneralMatrix& a, const ConstGeneralMatrix& b);
-	void mult(const GeneralMatrix& a, const GeneralMatrix& b)
-		{mult(ConstGeneralMatrix(a), ConstGeneralMatrix(b));}
+  /* this = a*b */
+  void mult(const ConstGeneralMatrix &a, const ConstGeneralMatrix &b);
+  void
+  mult(const GeneralMatrix &a, const GeneralMatrix &b)
+  {
+    mult(ConstGeneralMatrix(a), ConstGeneralMatrix(b));
+  }
 
-	/* this = this + scalar*a*b */
-	void multAndAdd(const ConstGeneralMatrix& a, const ConstGeneralMatrix& b,
-					double mult=1.0);
-	void multAndAdd(const GeneralMatrix& a, const GeneralMatrix& b,
-					double mult=1.0)
-		{multAndAdd(ConstGeneralMatrix(a), ConstGeneralMatrix(b), mult);}
+  /* this = this + scalar*a*b */
+  void multAndAdd(const ConstGeneralMatrix &a, const ConstGeneralMatrix &b,
+                  double mult = 1.0);
+  void
+  multAndAdd(const GeneralMatrix &a, const GeneralMatrix &b,
+             double mult = 1.0)
+  {
+    multAndAdd(ConstGeneralMatrix(a), ConstGeneralMatrix(b), mult);
+  }
 
-	/* this = this + scalar*a*b' */
-	void multAndAdd(const ConstGeneralMatrix& a, const ConstGeneralMatrix& b,
-					const char* dum, double mult=1.0);
-	void multAndAdd(const GeneralMatrix& a, const GeneralMatrix& b,
-					const char* dum, double mult=1.0)
-		{multAndAdd(ConstGeneralMatrix(a), ConstGeneralMatrix(b), dum, mult);}
+  /* this = this + scalar*a*b' */
+  void multAndAdd(const ConstGeneralMatrix &a, const ConstGeneralMatrix &b,
+                  const char *dum, double mult = 1.0);
+  void
+  multAndAdd(const GeneralMatrix &a, const GeneralMatrix &b,
+             const char *dum, double mult = 1.0)
+  {
+    multAndAdd(ConstGeneralMatrix(a), ConstGeneralMatrix(b), dum, mult);
+  }
 
-	/* this = this + scalar*a'*b */
-	void multAndAdd(const ConstGeneralMatrix& a, const char* dum, const ConstGeneralMatrix& b,
-					double mult=1.0);
-	void multAndAdd(const GeneralMatrix& a, const char* dum, const GeneralMatrix& b,
-					double mult=1.0)
-		{multAndAdd(ConstGeneralMatrix(a), dum, ConstGeneralMatrix(b), mult);}
+  /* this = this + scalar*a'*b */
+  void multAndAdd(const ConstGeneralMatrix &a, const char *dum, const ConstGeneralMatrix &b,
+                  double mult = 1.0);
+  void
+  multAndAdd(const GeneralMatrix &a, const char *dum, const GeneralMatrix &b,
+             double mult = 1.0)
+  {
+    multAndAdd(ConstGeneralMatrix(a), dum, ConstGeneralMatrix(b), mult);
+  }
 
-	/* this = this + scalar*a'*b' */
-	void multAndAdd(const ConstGeneralMatrix& a, const char* dum1,
-					const ConstGeneralMatrix& b, const char* dum2, double mult=1.0);
-	void multAndAdd(const GeneralMatrix& a, const char* dum1,
-					const GeneralMatrix& b, const char* dum2, double mult=1.0)
-		{multAndAdd(ConstGeneralMatrix(a), dum1, ConstGeneralMatrix(b),dum2, mult);}
+  /* this = this + scalar*a'*b' */
+  void multAndAdd(const ConstGeneralMatrix &a, const char *dum1,
+                  const ConstGeneralMatrix &b, const char *dum2, double mult = 1.0);
+  void
+  multAndAdd(const GeneralMatrix &a, const char *dum1,
+             const GeneralMatrix &b, const char *dum2, double mult = 1.0)
+  {
+    multAndAdd(ConstGeneralMatrix(a), dum1, ConstGeneralMatrix(b), dum2, mult);
+  }
 
-	/* this = this + scalar*a*a' */
-	void addOuter(const ConstVector& a, double mult=1.0);
-	void addOuter(const Vector& a, double mult=1.0)
-		{addOuter(ConstVector(a), mult);}
+  /* this = this + scalar*a*a' */
+  void addOuter(const ConstVector &a, double mult = 1.0);
+  void
+  addOuter(const Vector &a, double mult = 1.0)
+  {
+    addOuter(ConstVector(a), mult);
+  }
 
-	/* this = this * m */
-	void multRight(const ConstGeneralMatrix& m);
-	void multRight(const GeneralMatrix& m)
-		{multRight(ConstGeneralMatrix(m));}
+  /* this = this * m */
+  void multRight(const ConstGeneralMatrix &m);
+  void
+  multRight(const GeneralMatrix &m)
+  {
+    multRight(ConstGeneralMatrix(m));
+  }
 
-	/* this = m * this */
-	void multLeft(const ConstGeneralMatrix& m);
-	void multLeft(const GeneralMatrix& m)
-		{multLeft(ConstGeneralMatrix(m));}
+  /* this = m * this */
+  void multLeft(const ConstGeneralMatrix &m);
+  void
+  multLeft(const GeneralMatrix &m)
+  {
+    multLeft(ConstGeneralMatrix(m));
+  }
 
-	/* this = this * m' */
-	void multRightTrans(const ConstGeneralMatrix& m);
-	void multRightTrans(const GeneralMatrix& m)
-		{multRightTrans(ConstGeneralMatrix(m));}
+  /* this = this * m' */
+  void multRightTrans(const ConstGeneralMatrix &m);
+  void
+  multRightTrans(const GeneralMatrix &m)
+  {
+    multRightTrans(ConstGeneralMatrix(m));
+  }
 
-	/* this = m' * this */
-	void multLeftTrans(const ConstGeneralMatrix& m);
-	void multLeftTrans(const GeneralMatrix& m)
-		{multLeftTrans(ConstGeneralMatrix(m));}
+  /* this = m' * this */
+  void multLeftTrans(const ConstGeneralMatrix &m);
+  void
+  multLeftTrans(const GeneralMatrix &m)
+  {
+    multLeftTrans(ConstGeneralMatrix(m));
+  }
 
-	/* x = scalar(a)*x + scalar(b)*this*d */
-	void multVec(double a, Vector& x, double b, const ConstVector& d) const
-		{ConstGeneralMatrix(*this).multVec(a, x, b, d);}
+  /* x = scalar(a)*x + scalar(b)*this*d */
+  void
+  multVec(double a, Vector &x, double b, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multVec(a, x, b, d);
+  }
 
-	/* x = scalar(a)*x + scalar(b)*this'*d */
-	void multVecTrans(double a, Vector& x, double b, const ConstVector& d) const
-		{ConstGeneralMatrix(*this).multVecTrans(a, x, b, d);}
+  /* x = scalar(a)*x + scalar(b)*this'*d */
+  void
+  multVecTrans(double a, Vector &x, double b, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multVecTrans(a, x, b, d);
+  }
 
-	/* x = x + this*d */
-	void multaVec(Vector& x, const ConstVector& d) const
-		{ConstGeneralMatrix(*this).multaVec(x, d);}
+  /* x = x + this*d */
+  void
+  multaVec(Vector &x, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multaVec(x, d);
+  }
 
-	/* x = x + this'*d */
-	void multaVecTrans(Vector& x, const ConstVector& d) const
-		{ConstGeneralMatrix(*this).multaVecTrans(x, d);}
+  /* x = x + this'*d */
+  void
+  multaVecTrans(Vector &x, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multaVecTrans(x, d);
+  }
 
-	/* x = x - this*d */
-	void multsVec(Vector& x, const ConstVector& d) const
-		{ConstGeneralMatrix(*this).multsVec(x, d);}
+  /* x = x - this*d */
+  void
+  multsVec(Vector &x, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multsVec(x, d);
+  }
 
-	/* x = x - this'*d */
-	void multsVecTrans(Vector& x, const ConstVector& d) const
-		{ConstGeneralMatrix(*this).multsVecTrans(x, d);}
+  /* x = x - this'*d */
+  void
+  multsVecTrans(Vector &x, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multsVecTrans(x, d);
+  }
 
-	/* this = zero */
-	void zeros();
+  /* this = zero */
+  void zeros();
 
-	/** this = unit (on main diagonal) */
-	void unit();
+  /** this = unit (on main diagonal) */
+  void unit();
 
-	/* this = NaN */
-	void nans();
+  /* this = NaN */
+  void nans();
 
-	/* this = Inf */
-	void infs();
+  /* this = Inf */
+  void infs();
 
-	/* this = scalar*this */
-	void mult(double a);
+  /* this = scalar*this */
+  void mult(double a);
 
-	/* this = this + scalar*m */
-	void add(double a, const ConstGeneralMatrix& m);
-	void add(double a, const GeneralMatrix& m)
-		{add(a, ConstGeneralMatrix(m));}
+  /* this = this + scalar*m */
+  void add(double a, const ConstGeneralMatrix &m);
+  void
+  add(double a, const GeneralMatrix &m)
+  {
+    add(a, ConstGeneralMatrix(m));
+  }
 
-	/* this = this + scalar*m' */
-	void add(double a, const ConstGeneralMatrix& m, const char* dum);
-	void add(double a, const GeneralMatrix& m, const char* dum)
-		{add(a, ConstGeneralMatrix(m), dum);}
+  /* this = this + scalar*m' */
+  void add(double a, const ConstGeneralMatrix &m, const char *dum);
+  void
+  add(double a, const GeneralMatrix &m, const char *dum)
+  {
+    add(a, ConstGeneralMatrix(m), dum);
+  }
 
-	bool isFinite() const
-		{return (ConstGeneralMatrix(*this)).isFinite();}
+  bool
+  isFinite() const
+  {
+    return (ConstGeneralMatrix(*this)).isFinite();
+  }
 
-	bool isZero() const
-		{return (ConstGeneralMatrix(*this)).isZero();}
+  bool
+  isZero() const
+  {
+    return (ConstGeneralMatrix(*this)).isZero();
+  }
 
-	virtual void print() const
-		{ConstGeneralMatrix(*this).print();}
+  virtual void
+  print() const
+  {
+    ConstGeneralMatrix(*this).print();
+  }
 private:
-	void copy(const ConstGeneralMatrix& m, int ioff = 0, int joff = 0);
-	void copy(const GeneralMatrix& m, int ioff = 0, int joff = 0)
-		{copy(ConstGeneralMatrix(m), ioff, joff);}
+  void copy(const ConstGeneralMatrix &m, int ioff = 0, int joff = 0);
+  void
+  copy(const GeneralMatrix &m, int ioff = 0, int joff = 0)
+  {
+    copy(ConstGeneralMatrix(m), ioff, joff);
+  }
 
-	void gemm(const char* transa, const ConstGeneralMatrix& a,
-			  const char* transb, const ConstGeneralMatrix& b,
-			  double alpha, double beta);
-	void gemm(const char* transa, const GeneralMatrix& a,
-			  const char* transb, const GeneralMatrix& b,
-			  double alpha, double beta)
-		{gemm(transa, ConstGeneralMatrix(a), transb, ConstGeneralMatrix(b),
-			  alpha, beta);}
+  void gemm(const char *transa, const ConstGeneralMatrix &a,
+            const char *transb, const ConstGeneralMatrix &b,
+            double alpha, double beta);
+  void
+  gemm(const char *transa, const GeneralMatrix &a,
+       const char *transb, const GeneralMatrix &b,
+       double alpha, double beta)
+  {
+    gemm(transa, ConstGeneralMatrix(a), transb, ConstGeneralMatrix(b),
+         alpha, beta);
+  }
 
-	/* this = this * op(m) (without whole copy of this) */
-	void gemm_partial_right(const char* trans, const ConstGeneralMatrix& m,
-							double alpha, double beta);
-	void gemm_partial_right(const char* trans, const GeneralMatrix& m,
-							double alpha, double beta)
-		{gemm_partial_right(trans, ConstGeneralMatrix(m), alpha, beta);}
+  /* this = this * op(m) (without whole copy of this) */
+  void gemm_partial_right(const char *trans, const ConstGeneralMatrix &m,
+                          double alpha, double beta);
+  void
+  gemm_partial_right(const char *trans, const GeneralMatrix &m,
+                     double alpha, double beta)
+  {
+    gemm_partial_right(trans, ConstGeneralMatrix(m), alpha, beta);
+  }
 
-	/* this = op(m) *this (without whole copy of this) */
-	void gemm_partial_left(const char* trans, const ConstGeneralMatrix& m,
-						   double alpha, double beta);
-	void gemm_partial_left(const char* trans, const GeneralMatrix& m,
-						   double alpha, double beta)
-		{gemm_partial_left(trans, ConstGeneralMatrix(m), alpha, beta);}
+  /* this = op(m) *this (without whole copy of this) */
+  void gemm_partial_left(const char *trans, const ConstGeneralMatrix &m,
+                         double alpha, double beta);
+  void
+  gemm_partial_left(const char *trans, const GeneralMatrix &m,
+                    double alpha, double beta)
+  {
+    gemm_partial_left(trans, ConstGeneralMatrix(m), alpha, beta);
+  }
 
-	/* number of rows/columns for copy used in gemm_partial_* */
-	static int md_length;
+  /* number of rows/columns for copy used in gemm_partial_* */
+  static int md_length;
 };
 
-class SVDDecomp {
+class SVDDecomp
+{
 protected:
-    /** Minimum of number of rows and columns of the decomposed
-     * matrix. */
-    const int minmn;
-    /** Singular values. */
-    Vector sigma;
-    /** Orthogonal matrix U. */
-    GeneralMatrix U;
-    /** Orthogonal matrix V^T. */
-    GeneralMatrix VT;
-    /** Convered flag. */
-    bool conv;
+  /** Minimum of number of rows and columns of the decomposed
+   * matrix. */
+  const int minmn;
+  /** Singular values. */
+  Vector sigma;
+  /** Orthogonal matrix U. */
+  GeneralMatrix U;
+  /** Orthogonal matrix V^T. */
+  GeneralMatrix VT;
+  /** Convered flag. */
+  bool conv;
 public:
-    SVDDecomp(const GeneralMatrix& A)
-        : minmn(std::min<int>(A.numRows(), A.numCols())),
-          sigma(minmn),
-          U(A.numRows(), A.numRows()),
-          VT(A.numCols(), A.numCols()),
-          conv(false)
-        {construct(A);}
-    const GeneralMatrix& getU() const
-        {return U;}
-    const GeneralMatrix& getVT() const
-        {return VT;}
-    void solve(const GeneralMatrix& B, GeneralMatrix& X) const;
-    void solve(const Vector& b, Vector& x) const
-        {
-            GeneralMatrix xmat(x.base(), x.length(), 1);
-            solve(GeneralMatrix(b.base(), b.length(), 1), xmat);
-        }
+  SVDDecomp(const GeneralMatrix &A)
+    : minmn(std::min<int>(A.numRows(), A.numCols())),
+      sigma(minmn),
+      U(A.numRows(), A.numRows()),
+      VT(A.numCols(), A.numCols()),
+      conv(false)
+  {
+    construct(A);
+  }
+  const GeneralMatrix &
+  getU() const
+  {
+    return U;
+  }
+  const GeneralMatrix &
+  getVT() const
+  {
+    return VT;
+  }
+  void solve(const GeneralMatrix &B, GeneralMatrix &X) const;
+  void
+  solve(const Vector &b, Vector &x) const
+  {
+    GeneralMatrix xmat(x.base(), x.length(), 1);
+    solve(GeneralMatrix(b.base(), b.length(), 1), xmat);
+  }
 private:
-    void construct(const GeneralMatrix& A);
+  void construct(const GeneralMatrix &A);
 };
 
-
-
-
 #endif /* GENERAL_MATRIX_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/GeneralSylvester.h b/dynare++/sylv/cc/GeneralSylvester.h
index a81f5a2d4..9e2603f48 100644
--- a/dynare++/sylv/cc/GeneralSylvester.h
+++ b/dynare++/sylv/cc/GeneralSylvester.h
@@ -10,52 +10,73 @@
 #include "SimilarityDecomp.h"
 #include "SylvesterSolver.h"
 
-class GeneralSylvester {
-	SylvParams pars;
-	SylvMemoryDriver mem_driver;
-	int order;
-	const SqSylvMatrix a;
-	const SylvMatrix b;
-	const SqSylvMatrix c;
-	SylvMatrix d;
-	bool solved;
-	SchurDecompZero* bdecomp;
-	SimilarityDecomp* cdecomp;
-	SylvesterSolver* sylv;
+class GeneralSylvester
+{
+  SylvParams pars;
+  SylvMemoryDriver mem_driver;
+  int order;
+  const SqSylvMatrix a;
+  const SylvMatrix b;
+  const SqSylvMatrix c;
+  SylvMatrix d;
+  bool solved;
+  SchurDecompZero *bdecomp;
+  SimilarityDecomp *cdecomp;
+  SylvesterSolver *sylv;
 public:
-	/* construct with my copy of d*/
-	GeneralSylvester(int ord, int n, int m, int zero_cols,
-					 const double* da, const double* db,
-					 const double* dc, const double* dd,
-					 const SylvParams& ps);
-	GeneralSylvester(int ord, int n, int m, int zero_cols,
-					 const double* da, const double* db,
-					 const double* dc, const double* dd,
-					 bool alloc_for_check = false);
-	/* construct with provided storage for d */
-	GeneralSylvester(int ord, int n, int m, int zero_cols,
-					 const double* da, const double* db,
-					 const double* dc, double* dd,
-					 bool alloc_for_check = false);
-	GeneralSylvester(int ord, int n, int m, int zero_cols,
-					 const double* da, const double* db,
-					 const double* dc, double* dd,
-					 const SylvParams& ps);
-	virtual ~GeneralSylvester();
-	int getM() const {return c.numRows();}
-	int getN() const {return a.numRows();}
-	const double* getResult() const {return d.base();}
-	const SylvParams& getParams() const {return pars;}
-	SylvParams& getParams() {return pars;}
-	void solve();
-	void check(const double* ds);
+  /* construct with my copy of d*/
+  GeneralSylvester(int ord, int n, int m, int zero_cols,
+                   const double *da, const double *db,
+                   const double *dc, const double *dd,
+                   const SylvParams &ps);
+  GeneralSylvester(int ord, int n, int m, int zero_cols,
+                   const double *da, const double *db,
+                   const double *dc, const double *dd,
+                   bool alloc_for_check = false);
+  /* construct with provided storage for d */
+  GeneralSylvester(int ord, int n, int m, int zero_cols,
+                   const double *da, const double *db,
+                   const double *dc, double *dd,
+                   bool alloc_for_check = false);
+  GeneralSylvester(int ord, int n, int m, int zero_cols,
+                   const double *da, const double *db,
+                   const double *dc, double *dd,
+                   const SylvParams &ps);
+  virtual
+  ~GeneralSylvester();
+  int
+  getM() const
+  {
+    return c.numRows();
+  }
+  int
+  getN() const
+  {
+    return a.numRows();
+  }
+  const double *
+  getResult() const
+  {
+    return d.base();
+  }
+  const SylvParams &
+  getParams() const
+  {
+    return pars;
+  }
+  SylvParams &
+  getParams()
+  {
+    return pars;
+  }
+  void solve();
+  void check(const double *ds);
 private:
-	void init();
+  void init();
 };
 
 #endif /* GENERAL_SYLVESTER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/IterativeSylvester.h b/dynare++/sylv/cc/IterativeSylvester.h
index cb69fbf7c..6e30d75d0 100644
--- a/dynare++/sylv/cc/IterativeSylvester.h
+++ b/dynare++/sylv/cc/IterativeSylvester.h
@@ -10,24 +10,30 @@
 #include "QuasiTriangular.h"
 #include "SimilarityDecomp.h"
 
-class IterativeSylvester : public SylvesterSolver {
+class IterativeSylvester : public SylvesterSolver
+{
 public:
-	IterativeSylvester(const QuasiTriangular& k, const QuasiTriangular& f)
-		: SylvesterSolver(k, f) {}
-	IterativeSylvester(const SchurDecompZero& kdecomp, const SchurDecomp& fdecomp)
-		: SylvesterSolver(kdecomp, fdecomp) {}
-	IterativeSylvester(const SchurDecompZero& kdecomp, const SimilarityDecomp& fdecomp)
-		: SylvesterSolver(kdecomp, fdecomp) {}
-	void solve(SylvParams& pars, KronVector& x) const;
+  IterativeSylvester(const QuasiTriangular &k, const QuasiTriangular &f)
+    : SylvesterSolver(k, f)
+  {
+  }
+  IterativeSylvester(const SchurDecompZero &kdecomp, const SchurDecomp &fdecomp)
+    : SylvesterSolver(kdecomp, fdecomp)
+  {
+  }
+  IterativeSylvester(const SchurDecompZero &kdecomp, const SimilarityDecomp &fdecomp)
+    : SylvesterSolver(kdecomp, fdecomp)
+  {
+  }
+  void solve(SylvParams &pars, KronVector &x) const;
 private:
-	double performFirstStep(KronVector& x) const;
-	static double performStep(const QuasiTriangular& k, const QuasiTriangular& f,
-							  KronVector& x);
+  double performFirstStep(KronVector &x) const;
+  static double performStep(const QuasiTriangular &k, const QuasiTriangular &f,
+                            KronVector &x);
 };
 
 #endif /* ITERATIVE_SYLVESTER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/KronUtils.h b/dynare++/sylv/cc/KronUtils.h
index 2ebeeee30..a0d2339f0 100644
--- a/dynare++/sylv/cc/KronUtils.h
+++ b/dynare++/sylv/cc/KronUtils.h
@@ -8,21 +8,22 @@
 #include "KronVector.h"
 #include "QuasiTriangular.h"
 
-class KronUtils {
+class KronUtils
+{
 public:
-	/* multiplies I_m\otimes..\I_m\otimes T\otimes I_m...I_m\otimes I_n
-	   with given b and returns x. T must be (m,m), number of
-	   \otimes is b.getDepth(), level is a number of I_m's between T
-	   and I_n plus 1. If level=0, then we multiply
-       \I_m\otimes ..\otimes I_m\otimes T, T is (n,n) */
-	static void multAtLevel(int level, const QuasiTriangular& t,
-							KronVector& x);
-	static void multAtLevelTrans(int level, const QuasiTriangular& t,
-								 KronVector& x);
+  /* multiplies I_m\otimes..\I_m\otimes T\otimes I_m...I_m\otimes I_n
+     with given b and returns x. T must be (m,m), number of
+     \otimes is b.getDepth(), level is a number of I_m's between T
+     and I_n plus 1. If level=0, then we multiply
+     \I_m\otimes ..\otimes I_m\otimes T, T is (n,n) */
+  static void multAtLevel(int level, const QuasiTriangular &t,
+                          KronVector &x);
+  static void multAtLevelTrans(int level, const QuasiTriangular &t,
+                               KronVector &x);
 
-	/* multiplies x=(F'\otimes F'\otimes..\otimes K)x */
-	static void multKron(const QuasiTriangular& f, const QuasiTriangular& k,
-						 KronVector& x);
+  /* multiplies x=(F'\otimes F'\otimes..\otimes K)x */
+  static void multKron(const QuasiTriangular &f, const QuasiTriangular &k,
+                       KronVector &x);
 };
 
 #endif /* KRON_UTILS_H */
diff --git a/dynare++/sylv/cc/KronVector.h b/dynare++/sylv/cc/KronVector.h
index db721c3b7..dc8b6fb91 100644
--- a/dynare++/sylv/cc/KronVector.h
+++ b/dynare++/sylv/cc/KronVector.h
@@ -9,44 +9,77 @@
 
 class ConstKronVector;
 
-class KronVector : public Vector {
+class KronVector : public Vector
+{
 protected:
-	int m;
-	int n;
-	int depth;
+  int m;
+  int n;
+  int depth;
 public:
-	KronVector() : Vector((double*)0, 0), m(0), n(0), depth(0)  {}
-	KronVector(int mm, int nn, int dp); // new instance
-	KronVector(Vector& v, int mm, int nn, int dp); // conversion
-	KronVector(KronVector&, int i); // picks i-th subvector
-	KronVector(const ConstKronVector& v); // new instance and copy
-	const KronVector& operator=(KronVector& v)
-		{Vector::operator=(v); m=v.m; n=v.n; depth = v.depth; return *this;}
-	const KronVector& operator=(const KronVector& v)
-		{Vector::operator=(v); m=v.m; n=v.n; depth = v.depth; return *this;}
-	const KronVector& operator=(const ConstKronVector& v);
-	const KronVector& operator=(const Vector& v);
-	int getM() const {return m;}
-	int getN() const {return n;}
-	int getDepth() const {return depth;}
+  KronVector() : Vector((double *) 0, 0), m(0), n(0), depth(0)
+  {
+  }
+  KronVector(int mm, int nn, int dp); // new instance
+  KronVector(Vector &v, int mm, int nn, int dp); // conversion
+  KronVector(KronVector &, int i); // picks i-th subvector
+  KronVector(const ConstKronVector &v); // new instance and copy
+  const KronVector &
+  operator=(KronVector &v)
+  {
+    Vector::operator=(v); m = v.m; n = v.n; depth = v.depth; return *this;
+  }
+  const KronVector &
+  operator=(const KronVector &v)
+  {
+    Vector::operator=(v); m = v.m; n = v.n; depth = v.depth; return *this;
+  }
+  const KronVector &operator=(const ConstKronVector &v);
+  const KronVector &operator=(const Vector &v);
+  int
+  getM() const
+  {
+    return m;
+  }
+  int
+  getN() const
+  {
+    return n;
+  }
+  int
+  getDepth() const
+  {
+    return depth;
+  }
 };
 
 class ConstKronVector : public ConstVector
 {
 protected:
-	int m;
-	int n;
-	int depth;
+  int m;
+  int n;
+  int depth;
 public:
-	ConstKronVector(const KronVector& v);
-	ConstKronVector(const ConstKronVector& v);
-	ConstKronVector(const Vector& v, int mm, int nn, int dp);
-	ConstKronVector(const ConstVector& v, int mm, int nn, int dp);
-	ConstKronVector(const KronVector& v, int i);
-	ConstKronVector(const ConstKronVector& v, int i);
-	int getM() const {return m;}
-	int getN() const {return n;}
-	int getDepth() const {return depth;}
+  ConstKronVector(const KronVector &v);
+  ConstKronVector(const ConstKronVector &v);
+  ConstKronVector(const Vector &v, int mm, int nn, int dp);
+  ConstKronVector(const ConstVector &v, int mm, int nn, int dp);
+  ConstKronVector(const KronVector &v, int i);
+  ConstKronVector(const ConstKronVector &v, int i);
+  int
+  getM() const
+  {
+    return m;
+  }
+  int
+  getN() const
+  {
+    return n;
+  }
+  int
+  getDepth() const
+  {
+    return depth;
+  }
 };
 
 int power(int m, int depth);
diff --git a/dynare++/sylv/cc/QuasiTriangular.h b/dynare++/sylv/cc/QuasiTriangular.h
index ff7281141..d09fede07 100644
--- a/dynare++/sylv/cc/QuasiTriangular.h
+++ b/dynare++/sylv/cc/QuasiTriangular.h
@@ -15,325 +15,521 @@ using namespace std;
 
 class DiagonalBlock;
 class Diagonal;
-class DiagPair {
+class DiagPair
+{
 private:
-	double* a1;
-	double* a2;
+  double *a1;
+  double *a2;
 public:
-	DiagPair() {}
-	DiagPair(double* aa1, double* aa2) {a1 = aa1; a2 = aa2;}
-	DiagPair(const DiagPair& p) {a1 = p.a1; a2 = p.a2;}
-	const DiagPair& operator=(const DiagPair& p) {a1 = p.a1; a2 = p.a2; return *this;}
-	const DiagPair& operator=(double v) {*a1 = v; *a2 = v; return *this;}
-	const double& operator*() const {return *a1;}
-	/** here we must not define double& operator*(), since it wouldn't 
-	 rewrite both values, we use operator= for this */ 
-	friend class Diagonal;
-	friend class DiagonalBlock;
+  DiagPair()
+  {
+  }
+  DiagPair(double *aa1, double *aa2)
+  {
+    a1 = aa1; a2 = aa2;
+  }
+  DiagPair(const DiagPair &p)
+  {
+    a1 = p.a1; a2 = p.a2;
+  }
+  const DiagPair &
+  operator=(const DiagPair &p)
+  {
+    a1 = p.a1; a2 = p.a2; return *this;
+  }
+  const DiagPair &
+  operator=(double v)
+  {
+    *a1 = v; *a2 = v; return *this;
+  }
+  const double &
+  operator*() const
+  {
+    return *a1;
+  }
+  /** here we must not define double& operator*(), since it wouldn't
+      rewrite both values, we use operator= for this */
+  friend class Diagonal;
+  friend class DiagonalBlock;
 };
 
-class DiagonalBlock {
+class DiagonalBlock
+{
 private:
-	int jbar;
-	bool real;
-	DiagPair alpha;
-	double* beta1;
-	double* beta2;
+  int jbar;
+  bool real;
+  DiagPair alpha;
+  double *beta1;
+  double *beta2;
 
-	void copy(const DiagonalBlock& b) {
-		jbar = b.jbar;
-		real = b.real;
-		alpha = b.alpha;
-		beta1 = b.beta1;
-		beta2 = b.beta2;
-	}
+  void
+  copy(const DiagonalBlock &b)
+  {
+    jbar = b.jbar;
+    real = b.real;
+    alpha = b.alpha;
+    beta1 = b.beta1;
+    beta2 = b.beta2;
+  }
 
 public:
-	DiagonalBlock() {}
-	DiagonalBlock(int jb, bool r, double* a1, double* a2,
-				  double* b1, double* b2)
-		: alpha(a1, a2)
-		{
-			jbar = jb;
-			real = r;
-			beta1 = b1;
-			beta2 = b2;
-		}
-	// construct complex block
-	DiagonalBlock(int jb, double* a1, double* a2)
-		: alpha(a1, a2)
-		{
-			jbar = jb;
-			real = false;
-			beta1 = a2 - 1;
-			beta2 = a1 + 1;
-		}
-	// construct real block
-	DiagonalBlock(int jb, double* a1)
-		: alpha(a1, a1)
-		{
-			jbar = jb;
-			real = true;
-			beta1 = 0;
-			beta2 = 0;
-		}
-	DiagonalBlock(const DiagonalBlock& b)
-		{copy(b);}
-	const DiagonalBlock& operator=(const DiagonalBlock& b)
-		{copy(b); return *this;}
-	int getIndex() const
-		{return jbar;}
-	bool isReal() const
-		{return real;}
-	const DiagPair& getAlpha() const
-		{return alpha;}
-	DiagPair& getAlpha()
-		{return alpha;}
-	double& getBeta1() const
-		{return *beta1;}
-	double& getBeta2() const
-		{return *beta2;}
-	double getDeterminant() const;
-	double getSBeta() const;
-	double getSize() const;
-	void setReal();
-	// for debugging
-	void checkBlock(const double* d, int d_size);
-	friend class Diagonal;
+  DiagonalBlock()
+  {
+  }
+  DiagonalBlock(int jb, bool r, double *a1, double *a2,
+                double *b1, double *b2)
+    : alpha(a1, a2)
+  {
+    jbar = jb;
+    real = r;
+    beta1 = b1;
+    beta2 = b2;
+  }
+  // construct complex block
+  DiagonalBlock(int jb, double *a1, double *a2)
+    : alpha(a1, a2)
+  {
+    jbar = jb;
+    real = false;
+    beta1 = a2 - 1;
+    beta2 = a1 + 1;
+  }
+  // construct real block
+  DiagonalBlock(int jb, double *a1)
+    : alpha(a1, a1)
+  {
+    jbar = jb;
+    real = true;
+    beta1 = 0;
+    beta2 = 0;
+  }
+  DiagonalBlock(const DiagonalBlock &b)
+  {
+    copy(b);
+  }
+  const DiagonalBlock &
+  operator=(const DiagonalBlock &b)
+  {
+    copy(b); return *this;
+  }
+  int
+  getIndex() const
+  {
+    return jbar;
+  }
+  bool
+  isReal() const
+  {
+    return real;
+  }
+  const DiagPair &
+  getAlpha() const
+  {
+    return alpha;
+  }
+  DiagPair &
+  getAlpha()
+  {
+    return alpha;
+  }
+  double &
+  getBeta1() const
+  {
+    return *beta1;
+  }
+  double &
+  getBeta2() const
+  {
+    return *beta2;
+  }
+  double getDeterminant() const;
+  double getSBeta() const;
+  double getSize() const;
+  void setReal();
+  // for debugging
+  void checkBlock(const double *d, int d_size);
+  friend class Diagonal;
 };
 
 template <class _Tdiag, class _Tblock, class _Titer>
-struct _diag_iter {
-	typedef _diag_iter<_Tdiag, _Tblock, _Titer> _Self;
-	_Tdiag diag;
-	_Titer it;
+struct _diag_iter
+{
+  typedef _diag_iter<_Tdiag, _Tblock, _Titer> _Self;
+  _Tdiag diag;
+  _Titer it;
 public:
-	_diag_iter(_Tdiag d, _Titer iter) : diag(d), it(iter) {}
-	_Tblock operator*() const {return *it;}
-	_Self& operator++() {++it; return *this;}
-	_Self& operator--() {--it; return *this;}
-	bool operator==(const _Self& x) const {return x.it == it;}
-	bool operator!=(const _Self& x) const {return x.it != it;}
-	const _Self& operator=(const _Self& x) {it = x.it; return *this;}
-	_Titer iter() const {return it;}
+  _diag_iter(_Tdiag d, _Titer iter) : diag(d), it(iter)
+  {
+  }
+  _Tblock
+  operator*() const
+  {
+    return *it;
+  }
+  _Self &
+  operator++()
+  {
+    ++it; return *this;
+  }
+  _Self &
+  operator--()
+  {
+    --it; return *this;
+  }
+  bool
+  operator==(const _Self &x) const
+  {
+    return x.it == it;
+  }
+  bool
+  operator!=(const _Self &x) const
+  {
+    return x.it != it;
+  }
+  const _Self &
+  operator=(const _Self &x)
+  {
+    it = x.it; return *this;
+  }
+  _Titer
+  iter() const
+  {
+    return it;
+  }
 };
 
-class Diagonal {
+class Diagonal
+{
 public:
-	typedef _diag_iter<const Diagonal&, const DiagonalBlock&, list<DiagonalBlock>::const_iterator> const_diag_iter;
-	typedef _diag_iter<Diagonal&, DiagonalBlock&, list<DiagonalBlock>::iterator> diag_iter;
+  typedef _diag_iter<const Diagonal &, const DiagonalBlock &, list<DiagonalBlock>::const_iterator> const_diag_iter;
+  typedef _diag_iter<Diagonal &, DiagonalBlock &, list<DiagonalBlock>::iterator> diag_iter;
 private:
-	int num_all;
-	list<DiagonalBlock> blocks;
-	int num_real;
-	void copy(const Diagonal&);
+  int num_all;
+  list<DiagonalBlock> blocks;
+  int num_real;
+  void copy(const Diagonal &);
 public:
-	Diagonal() : num_all(0), num_real(0) {}
-	Diagonal(double* data, int d_size);
-	Diagonal(double* data, const Diagonal& d);
-	Diagonal(const Diagonal& d) {copy(d);}
-	const Diagonal& operator =(const Diagonal& d) {copy(d); return *this;}
-	virtual ~Diagonal() {}
+  Diagonal() : num_all(0), num_real(0)
+  {
+  }
+  Diagonal(double *data, int d_size);
+  Diagonal(double *data, const Diagonal &d);
+  Diagonal(const Diagonal &d)
+  {
+    copy(d);
+  }
+  const Diagonal &
+  operator=(const Diagonal &d)
+  {
+    copy(d); return *this;
+  }
+  virtual ~Diagonal()
+  {
+  }
 
-	int getNumComplex() const {return num_all - num_real;}
-	int getNumReal() const {return num_real;}
-	int getSize() const {return getNumReal() + 2*getNumComplex();}
-	int getNumBlocks() const {return num_all;}
-	void getEigenValues(Vector& eig) const;
-	void swapLogically(diag_iter it);
-	void checkConsistency(diag_iter it);
-	double getAverageSize(diag_iter start, diag_iter end);
-	diag_iter findClosestBlock(diag_iter start, diag_iter end, double a);
-	diag_iter findNextLargerBlock(diag_iter start, diag_iter end, double a);
-	void print() const;
+  int
+  getNumComplex() const
+  {
+    return num_all - num_real;
+  }
+  int
+  getNumReal() const
+  {
+    return num_real;
+  }
+  int
+  getSize() const
+  {
+    return getNumReal() + 2*getNumComplex();
+  }
+  int
+  getNumBlocks() const
+  {
+    return num_all;
+  }
+  void getEigenValues(Vector &eig) const;
+  void swapLogically(diag_iter it);
+  void checkConsistency(diag_iter it);
+  double getAverageSize(diag_iter start, diag_iter end);
+  diag_iter findClosestBlock(diag_iter start, diag_iter end, double a);
+  diag_iter findNextLargerBlock(diag_iter start, diag_iter end, double a);
+  void print() const;
 
-	diag_iter begin()
-		{return diag_iter(*this, blocks.begin());}
-	const_diag_iter begin() const
-		{return const_diag_iter(*this, blocks.begin());}
-	diag_iter end()
-		{return diag_iter(*this, blocks.end());}
-	const_diag_iter end() const
-		{return const_diag_iter(*this, blocks.end());}
+  diag_iter
+  begin()
+  {
+    return diag_iter(*this, blocks.begin());
+  }
+  const_diag_iter
+  begin() const
+  {
+    return const_diag_iter(*this, blocks.begin());
+  }
+  diag_iter
+  end()
+  {
+    return diag_iter(*this, blocks.end());
+  }
+  const_diag_iter
+  end() const
+  {
+    return const_diag_iter(*this, blocks.end());
+  }
 
-	/* redefine pointers as data start at p */
-	void changeBase(double* p);
+  /* redefine pointers as data start at p */
+  void changeBase(double *p);
 private:
-	static double EPS;
-	static int getNumComplex(const double* data, int d_size);
-	static bool isZero(double p);
+  static double EPS;
+  static int getNumComplex(const double *data, int d_size);
+  static bool isZero(double p);
 };
 
 template <class _TRef, class _TPtr>
-struct _matrix_iter {
-	typedef _matrix_iter<_TRef, _TPtr> _Self;
-	int d_size;
-	bool real;
-	_TPtr ptr;
+struct _matrix_iter
+{
+  typedef _matrix_iter<_TRef, _TPtr> _Self;
+  int d_size;
+  bool real;
+  _TPtr ptr;
 public:
-	_matrix_iter(_TPtr base, int ds, bool r)
-		{ptr = base; d_size = ds; real = r;}
-	virtual ~_matrix_iter() {}
-	const _Self& operator=(const _Self& it)
-		{ptr = it.ptr; d_size = it.d_size; real = it.real; return *this;}
-	bool operator==(const _Self& it) const
-		{return ptr == it.ptr;}
-	bool operator!=(const _Self& it) const
-		{return ptr != it.ptr;}
-	_TRef operator*() const
-		{return *ptr;}
-	_TRef a() const
-		{return *ptr;}
-	virtual _Self& operator++() =0;
+  _matrix_iter(_TPtr base, int ds, bool r)
+  {
+    ptr = base; d_size = ds; real = r;
+  }
+  virtual ~_matrix_iter()
+  {
+  }
+  const _Self &
+  operator=(const _Self &it)
+  {
+    ptr = it.ptr; d_size = it.d_size; real = it.real; return *this;
+  }
+  bool
+  operator==(const _Self &it) const
+  {
+    return ptr == it.ptr;
+  }
+  bool
+  operator!=(const _Self &it) const
+  {
+    return ptr != it.ptr;
+  }
+  _TRef
+  operator*() const
+  {
+    return *ptr;
+  }
+  _TRef
+  a() const
+  {
+    return *ptr;
+  }
+  virtual _Self &operator++() = 0;
 };
 
 template <class _TRef, class _TPtr>
-class _column_iter : public _matrix_iter<_TRef, _TPtr> {
-	typedef _matrix_iter<_TRef, _TPtr> _Tparent; 
-	typedef _column_iter<_TRef, _TPtr> _Self;
-	int row;
+class _column_iter : public _matrix_iter<_TRef, _TPtr>
+{
+  typedef _matrix_iter<_TRef, _TPtr> _Tparent;
+  typedef _column_iter<_TRef, _TPtr> _Self;
+  int row;
 public:
-	_column_iter(_TPtr base, int ds, bool r, int rw)
-		: _matrix_iter<_TRef, _TPtr>(base, ds, r), row(rw) {};
-	_Self& operator++()
-		{_Tparent::ptr++; row++; return *this;}
-	_TRef b() const
-		{
-			if (_Tparent::real) {
-				return *(_Tparent::ptr);
-			} else {
-				return *(_Tparent::ptr+_Tparent::d_size);
-			}
-		}
-	int getRow() const {return row;}
+  _column_iter(_TPtr base, int ds, bool r, int rw)
+    : _matrix_iter<_TRef, _TPtr>(base, ds, r), row(rw)
+  {
+  };
+  _Self &
+  operator++()
+  {
+    _Tparent::ptr++; row++; return *this;
+  }
+  _TRef
+  b() const
+  {
+    if (_Tparent::real)
+      {
+        return *(_Tparent::ptr);
+      }
+    else
+      {
+        return *(_Tparent::ptr+_Tparent::d_size);
+      }
+  }
+  int
+  getRow() const
+  {
+    return row;
+  }
 };
 
 template <class _TRef, class _TPtr>
-class _row_iter : public _matrix_iter<_TRef, _TPtr> {
-	typedef _matrix_iter<_TRef, _TPtr> _Tparent; 
-	typedef _row_iter<_TRef, _TPtr> _Self;
-	int col;
+class _row_iter : public _matrix_iter<_TRef, _TPtr>
+{
+  typedef _matrix_iter<_TRef, _TPtr> _Tparent;
+  typedef _row_iter<_TRef, _TPtr> _Self;
+  int col;
 public:
-	_row_iter(_TPtr base, int ds, bool r, int cl)
-		: _matrix_iter<_TRef, _TPtr>(base, ds, r), col(cl) {};
-	_Self& operator++()
-		{_Tparent::ptr += _Tparent::d_size; col++; return *this;}
-	virtual _TRef b() const
-		{
-			if (_Tparent::real) {
-				return *(_Tparent::ptr);
-			}else {
-				return *(_Tparent::ptr+1);
-			}
-		}
-	int getCol() const {return col;}
+  _row_iter(_TPtr base, int ds, bool r, int cl)
+    : _matrix_iter<_TRef, _TPtr>(base, ds, r), col(cl)
+  {
+  };
+  _Self &
+  operator++()
+  {
+    _Tparent::ptr += _Tparent::d_size; col++; return *this;
+  }
+  virtual _TRef
+  b() const
+  {
+    if (_Tparent::real)
+      {
+        return *(_Tparent::ptr);
+      }
+    else
+      {
+        return *(_Tparent::ptr+1);
+      }
+  }
+  int
+  getCol() const
+  {
+    return col;
+  }
 };
 
 class SchurDecomp;
 class SchurDecompZero;
 
-class QuasiTriangular : public SqSylvMatrix {
+class QuasiTriangular : public SqSylvMatrix
+{
 public:
-	typedef _column_iter<const double&, const double*> const_col_iter;
-	typedef _column_iter<double&, double*> col_iter;
-	typedef _row_iter<const double&, const double*> const_row_iter;
-	typedef _row_iter<double&, double*> row_iter;	
-	typedef Diagonal::const_diag_iter const_diag_iter;
-	typedef Diagonal::diag_iter diag_iter;
+  typedef _column_iter<const double &, const double *> const_col_iter;
+  typedef _column_iter<double &, double *> col_iter;
+  typedef _row_iter<const double &, const double *> const_row_iter;
+  typedef _row_iter<double &, double *> row_iter;
+  typedef Diagonal::const_diag_iter const_diag_iter;
+  typedef Diagonal::diag_iter diag_iter;
 protected:
-	Diagonal diagonal;
+  Diagonal diagonal;
 public:
-	QuasiTriangular(const double* d, int d_size);
-	QuasiTriangular(double r, const QuasiTriangular& t);
-	QuasiTriangular(double r, const QuasiTriangular& t,
-					double rr, const QuasiTriangular& tt);
-	QuasiTriangular(int p, const QuasiTriangular& t);
-	QuasiTriangular(const SchurDecomp& decomp);
-	QuasiTriangular(const SchurDecompZero& decomp);
-	QuasiTriangular(const QuasiTriangular& t);
-	virtual ~QuasiTriangular();
-	const Diagonal& getDiagonal() const {return diagonal;}
-	int getNumOffdiagonal() const;
-	void swapDiagLogically(diag_iter it);
-	void checkDiagConsistency(diag_iter it);
-	double getAverageDiagSize(diag_iter start, diag_iter end);
-	diag_iter findClosestDiagBlock(diag_iter start, diag_iter end, double a);
-	diag_iter findNextLargerBlock(diag_iter start, diag_iter end, double a);
+  QuasiTriangular(const double *d, int d_size);
+  QuasiTriangular(double r, const QuasiTriangular &t);
+  QuasiTriangular(double r, const QuasiTriangular &t,
+                  double rr, const QuasiTriangular &tt);
+  QuasiTriangular(int p, const QuasiTriangular &t);
+  QuasiTriangular(const SchurDecomp &decomp);
+  QuasiTriangular(const SchurDecompZero &decomp);
+  QuasiTriangular(const QuasiTriangular &t);
+  virtual
+  ~QuasiTriangular();
+  const Diagonal &
+  getDiagonal() const
+  {
+    return diagonal;
+  }
+  int getNumOffdiagonal() const;
+  void swapDiagLogically(diag_iter it);
+  void checkDiagConsistency(diag_iter it);
+  double getAverageDiagSize(diag_iter start, diag_iter end);
+  diag_iter findClosestDiagBlock(diag_iter start, diag_iter end, double a);
+  diag_iter findNextLargerBlock(diag_iter start, diag_iter end, double a);
 
+  /* (I+T)y = x, y-->x  */
+  virtual void solvePre(Vector &x, double &eig_min);
+  /* (I+T')y = x, y-->x */
+  virtual void solvePreTrans(Vector &x, double &eig_min);
+  /* (I+T)x = b */
+  virtual void solve(Vector &x, const ConstVector &b, double &eig_min);
+  /* (I+T')x = b */
+  virtual void solveTrans(Vector &x, const ConstVector &b, double &eig_min);
+  /* x = Tb */
+  virtual void multVec(Vector &x, const ConstVector &b) const;
+  /* x = T'b */
+  virtual void multVecTrans(Vector &x, const ConstVector &b) const;
+  /* x = x + Tb */
+  virtual void multaVec(Vector &x, const ConstVector &b) const;
+  /* x = x + T'b */
+  virtual void multaVecTrans(Vector &x, const ConstVector &b) const;
+  /* x = (T\otimes I)x */
+  virtual void multKron(KronVector &x) const;
+  /* x = (T'\otimes I)x */
+  virtual void multKronTrans(KronVector &x) const;
+  /* A = T*A */
+  virtual void multLeftOther(GeneralMatrix &a) const;
+  /* A = T'*A */
+  virtual void multLeftOtherTrans(GeneralMatrix &a) const;
 
-	/* (I+T)y = x, y-->x  */
-	virtual void solvePre(Vector& x, double& eig_min);
-	/* (I+T')y = x, y-->x */
-	virtual void solvePreTrans(Vector& x, double& eig_min);
-	/* (I+T)x = b */
-	virtual void solve(Vector& x, const ConstVector& b, double& eig_min);
-	/* (I+T')x = b */
-	virtual void solveTrans(Vector& x, const ConstVector& b, double& eig_min);
-	/* x = Tb */
-	virtual void multVec(Vector& x, const ConstVector& b) const;
-	/* x = T'b */
-	virtual void multVecTrans(Vector& x, const ConstVector& b) const;
-	/* x = x + Tb */
-	virtual void multaVec(Vector& x, const ConstVector& b) const;
-	/* x = x + T'b */
-	virtual void multaVecTrans(Vector& x, const ConstVector& b) const;
-	/* x = (T\otimes I)x */
-	virtual void multKron(KronVector& x) const;
-	/* x = (T'\otimes I)x */
-	virtual void multKronTrans(KronVector& x) const;
-	/* A = T*A */
-	virtual void multLeftOther(GeneralMatrix& a) const;
-	/* A = T'*A */
-	virtual void multLeftOtherTrans(GeneralMatrix& a) const;
+  const_diag_iter
+  diag_begin() const
+  {
+    return diagonal.begin();
+  }
+  diag_iter
+  diag_begin()
+  {
+    return diagonal.begin();
+  }
+  const_diag_iter
+  diag_end() const
+  {
+    return diagonal.end();
+  }
+  diag_iter
+  diag_end()
+  {
+    return diagonal.end();
+  }
 
-	const_diag_iter diag_begin() const
-		{return diagonal.begin();}
-	diag_iter diag_begin()
-		{return diagonal.begin();}
-	const_diag_iter diag_end() const 
-		{return diagonal.end();}
-	diag_iter diag_end()
-		{return diagonal.end();}
+  /* iterators for off diagonal elements */
+  virtual const_col_iter col_begin(const DiagonalBlock &b) const;
+  virtual col_iter col_begin(const DiagonalBlock &b);
+  virtual const_row_iter row_begin(const DiagonalBlock &b) const;
+  virtual row_iter row_begin(const DiagonalBlock &b);
+  virtual const_col_iter col_end(const DiagonalBlock &b) const;
+  virtual col_iter col_end(const DiagonalBlock &b);
+  virtual const_row_iter row_end(const DiagonalBlock &b) const;
+  virtual row_iter row_end(const DiagonalBlock &b);
 
-	/* iterators for off diagonal elements */
-	virtual const_col_iter col_begin(const DiagonalBlock& b) const;
-	virtual col_iter col_begin(const DiagonalBlock& b);
-	virtual const_row_iter row_begin(const DiagonalBlock& b) const;
-	virtual row_iter row_begin(const DiagonalBlock& b);
-	virtual const_col_iter col_end(const DiagonalBlock& b) const;
-	virtual col_iter col_end(const DiagonalBlock& b);
-	virtual const_row_iter row_end(const DiagonalBlock& b) const;
-	virtual row_iter row_end(const DiagonalBlock& b);
-
-	/* clone */
-	virtual QuasiTriangular* clone() const
-		{return new QuasiTriangular(*this);}
-	virtual QuasiTriangular* clone(int p, const QuasiTriangular& t) const
-		{return new QuasiTriangular(p, t);}
-	virtual QuasiTriangular* clone(double r) const
-		{return new QuasiTriangular(r, *this);}
-	virtual QuasiTriangular* clone(double r, double rr, const QuasiTriangular& tt) const
-		{return new QuasiTriangular(r, *this, rr, tt);}
+  /* clone */
+  virtual QuasiTriangular *
+  clone() const
+  {
+    return new QuasiTriangular(*this);
+  }
+  virtual QuasiTriangular *
+  clone(int p, const QuasiTriangular &t) const
+  {
+    return new QuasiTriangular(p, t);
+  }
+  virtual QuasiTriangular *
+  clone(double r) const
+  {
+    return new QuasiTriangular(r, *this);
+  }
+  virtual QuasiTriangular *
+  clone(double r, double rr, const QuasiTriangular &tt) const
+  {
+    return new QuasiTriangular(r, *this, rr, tt);
+  }
 protected:
-	void setMatrix(double r, const QuasiTriangular& t);
-	void addMatrix(double r, const QuasiTriangular& t);
+  void setMatrix(double r, const QuasiTriangular &t);
+  void addMatrix(double r, const QuasiTriangular &t);
 private:
-	void addUnit();
-	/* x = x + (T\otimes I)b */
-	void multaKron(KronVector& x, const ConstKronVector& b) const;
-	/* x = x + (T'\otimes I)b */
-	void multaKronTrans(KronVector& x, const ConstKronVector& b) const;
-	/* implementation via iterators, useful for large matrices */
-	void setMatrixViaIter(double r, const QuasiTriangular& t);
-	void addMatrixViaIter(double r, const QuasiTriangular& t);	
-	/* hide noneffective implementations of parents */
-	void multsVec(Vector& x, const ConstVector& d) const;
-	void multsVecTrans(Vector& x, const ConstVector& d) const;
+  void addUnit();
+  /* x = x + (T\otimes I)b */
+  void multaKron(KronVector &x, const ConstKronVector &b) const;
+  /* x = x + (T'\otimes I)b */
+  void multaKronTrans(KronVector &x, const ConstKronVector &b) const;
+  /* implementation via iterators, useful for large matrices */
+  void setMatrixViaIter(double r, const QuasiTriangular &t);
+  void addMatrixViaIter(double r, const QuasiTriangular &t);
+  /* hide noneffective implementations of parents */
+  void multsVec(Vector &x, const ConstVector &d) const;
+  void multsVecTrans(Vector &x, const ConstVector &d) const;
 };
 
 #endif /* QUASI_TRIANGULAR_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/QuasiTriangularZero.h b/dynare++/sylv/cc/QuasiTriangularZero.h
index 6396eed18..243c02123 100644
--- a/dynare++/sylv/cc/QuasiTriangularZero.h
+++ b/dynare++/sylv/cc/QuasiTriangularZero.h
@@ -8,37 +8,50 @@
 #include "QuasiTriangular.h"
 #include "GeneralMatrix.h"
 
-class QuasiTriangularZero : public QuasiTriangular {
-	int nz; // number of zero columns
-	GeneralMatrix ru; // data in right upper part (nz,d_size)
+class QuasiTriangularZero : public QuasiTriangular
+{
+  int nz; // number of zero columns
+  GeneralMatrix ru; // data in right upper part (nz,d_size)
 public:
-	QuasiTriangularZero(int num_zeros, const double* d, int d_size);
-	QuasiTriangularZero(double r, const QuasiTriangularZero& t);
-	QuasiTriangularZero(double r, const QuasiTriangularZero& t,
-						double rr, const QuasiTriangularZero& tt);
-	QuasiTriangularZero(int p, const QuasiTriangularZero& t);
-	QuasiTriangularZero(const QuasiTriangular& t);
-	QuasiTriangularZero(const SchurDecompZero& decomp);
-	~QuasiTriangularZero();
-	void solvePre(Vector& x, double& eig_min);
-	void solvePreTrans(Vector& x, double& eig_min);
-	void multVec(Vector& x, const ConstVector& b) const;
-	void multVecTrans(Vector& x, const ConstVector& b) const;
-	void multaVec(Vector& x, const ConstVector& b) const;
-	void multaVecTrans(Vector& x, const ConstVector& b) const;
-	void multKron(KronVector& x) const;
-	void multKronTrans(KronVector& x) const;
-	void multLeftOther(GeneralMatrix& a) const;
-	/* clone */
-	virtual QuasiTriangular* clone() const
-		{return new QuasiTriangularZero(*this);}
-	virtual QuasiTriangular* clone(int p, const QuasiTriangular& t) const
-		{return new QuasiTriangularZero(p, (const QuasiTriangularZero&)t);}
-	virtual QuasiTriangular* clone(double r) const
-		{return new QuasiTriangularZero(r, *this);}
-	virtual QuasiTriangular* clone(double r, double rr, const QuasiTriangular& tt) const
-		{return new QuasiTriangularZero(r, *this, rr, (const QuasiTriangularZero&)tt);}
-	void print() const;
+  QuasiTriangularZero(int num_zeros, const double *d, int d_size);
+  QuasiTriangularZero(double r, const QuasiTriangularZero &t);
+  QuasiTriangularZero(double r, const QuasiTriangularZero &t,
+                      double rr, const QuasiTriangularZero &tt);
+  QuasiTriangularZero(int p, const QuasiTriangularZero &t);
+  QuasiTriangularZero(const QuasiTriangular &t);
+  QuasiTriangularZero(const SchurDecompZero &decomp);
+  ~QuasiTriangularZero();
+  void solvePre(Vector &x, double &eig_min);
+  void solvePreTrans(Vector &x, double &eig_min);
+  void multVec(Vector &x, const ConstVector &b) const;
+  void multVecTrans(Vector &x, const ConstVector &b) const;
+  void multaVec(Vector &x, const ConstVector &b) const;
+  void multaVecTrans(Vector &x, const ConstVector &b) const;
+  void multKron(KronVector &x) const;
+  void multKronTrans(KronVector &x) const;
+  void multLeftOther(GeneralMatrix &a) const;
+  /* clone */
+  virtual QuasiTriangular *
+  clone() const
+  {
+    return new QuasiTriangularZero(*this);
+  }
+  virtual QuasiTriangular *
+  clone(int p, const QuasiTriangular &t) const
+  {
+    return new QuasiTriangularZero(p, (const QuasiTriangularZero &) t);
+  }
+  virtual QuasiTriangular *
+  clone(double r) const
+  {
+    return new QuasiTriangularZero(r, *this);
+  }
+  virtual QuasiTriangular *
+  clone(double r, double rr, const QuasiTriangular &tt) const
+  {
+    return new QuasiTriangularZero(r, *this, rr, (const QuasiTriangularZero &) tt);
+  }
+  void print() const;
 };
 
 #endif /* QUASI_TRIANGULAR_ZERO_H */
diff --git a/dynare++/sylv/cc/SchurDecomp.h b/dynare++/sylv/cc/SchurDecomp.h
index 644e5d5c5..9e83c9221 100644
--- a/dynare++/sylv/cc/SchurDecomp.h
+++ b/dynare++/sylv/cc/SchurDecomp.h
@@ -9,35 +9,61 @@
 #include "QuasiTriangular.h"
 
 class QuasiTriangular;
-class SchurDecomp {
-	bool q_destroy;
-	SqSylvMatrix* q;
-	bool t_destroy;
-	QuasiTriangular* t;
+class SchurDecomp
+{
+  bool q_destroy;
+  SqSylvMatrix *q;
+  bool t_destroy;
+  QuasiTriangular *t;
 public:
-	SchurDecomp(const SqSylvMatrix& m);
-	SchurDecomp(const QuasiTriangular& tr);
-	SchurDecomp(QuasiTriangular& tr);
-	const SqSylvMatrix& getQ() const {return *q;}
-	const QuasiTriangular& getT() const {return *t;}
-	SqSylvMatrix& getQ() {return *q;}
-	QuasiTriangular& getT() {return *t;}
-	virtual int getDim() const;
-	virtual ~SchurDecomp();
+  SchurDecomp(const SqSylvMatrix &m);
+  SchurDecomp(const QuasiTriangular &tr);
+  SchurDecomp(QuasiTriangular &tr);
+  const SqSylvMatrix &
+  getQ() const
+  {
+    return *q;
+  }
+  const QuasiTriangular &
+  getT() const
+  {
+    return *t;
+  }
+  SqSylvMatrix &
+  getQ()
+  {
+    return *q;
+  }
+  QuasiTriangular &
+  getT()
+  {
+    return *t;
+  }
+  virtual int getDim() const;
+  virtual
+  ~SchurDecomp();
 };
 
-class SchurDecompZero : public SchurDecomp {
-	GeneralMatrix ru; /* right upper matrix */
+class SchurDecompZero : public SchurDecomp
+{
+  GeneralMatrix ru; /* right upper matrix */
 public:
-	SchurDecompZero(const GeneralMatrix& m);
-	const GeneralMatrix& getRU() const {return ru;}
-	int getDim() const;
-	int getZeroCols() const {return ru.numRows();}
+  SchurDecompZero(const GeneralMatrix &m);
+  const GeneralMatrix &
+  getRU() const
+  {
+    return ru;
+  }
+  int getDim() const;
+  int
+  getZeroCols() const
+  {
+    return ru.numRows();
+  }
 };
 
 #endif /* SCHUR_DECOMP_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SchurDecompEig.h b/dynare++/sylv/cc/SchurDecompEig.h
index 0e0da38d5..567f45783 100644
--- a/dynare++/sylv/cc/SchurDecompEig.h
+++ b/dynare++/sylv/cc/SchurDecompEig.h
@@ -10,22 +10,27 @@
 #include "SchurDecomp.h"
 #include "QuasiTriangular.h"
 
-class SchurDecompEig : public SchurDecomp {
+class SchurDecompEig : public SchurDecomp
+{
 public:
-	typedef QuasiTriangular::diag_iter diag_iter;
-	SchurDecompEig(const SqSylvMatrix& m) : SchurDecomp(m) {}
-	SchurDecompEig(const QuasiTriangular& tr) : SchurDecomp(tr) {};
-	SchurDecompEig(QuasiTriangular& tr) : SchurDecomp(tr) {}
-	diag_iter bubbleEigen(diag_iter from, diag_iter to);
-	void orderEigen();
+  typedef QuasiTriangular::diag_iter diag_iter;
+  SchurDecompEig(const SqSylvMatrix &m) : SchurDecomp(m)
+  {
+  }
+  SchurDecompEig(const QuasiTriangular &tr) : SchurDecomp(tr)
+  {
+  };
+  SchurDecompEig(QuasiTriangular &tr) : SchurDecomp(tr)
+  {
+  }
+  diag_iter bubbleEigen(diag_iter from, diag_iter to);
+  void orderEigen();
 protected:
-	bool tryToSwap(diag_iter& it, diag_iter& itadd);
+  bool tryToSwap(diag_iter &it, diag_iter &itadd);
 };
 
 #endif /* SCHUR_DECOMP_EIG_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
-
diff --git a/dynare++/sylv/cc/SimilarityDecomp.h b/dynare++/sylv/cc/SimilarityDecomp.h
index 14f79297a..107da24e0 100644
--- a/dynare++/sylv/cc/SimilarityDecomp.h
+++ b/dynare++/sylv/cc/SimilarityDecomp.h
@@ -9,33 +9,43 @@
 #include "BlockDiagonal.h"
 #include "SylvParams.h"
 
-class SimilarityDecomp {
-	SqSylvMatrix* q;
-	BlockDiagonal* b;
-	SqSylvMatrix* invq;
-	typedef BlockDiagonal::diag_iter diag_iter;
+class SimilarityDecomp
+{
+  SqSylvMatrix *q;
+  BlockDiagonal *b;
+  SqSylvMatrix *invq;
+  typedef BlockDiagonal::diag_iter diag_iter;
 public:
-	SimilarityDecomp(const double* d, int d_size, double log10norm = 3.0);
-	virtual ~SimilarityDecomp();
-	const SqSylvMatrix& getQ() const
-		{return *q;}
-	const SqSylvMatrix& getInvQ() const
-		{return *invq;}
-	const BlockDiagonal& getB() const
-		{return *b;}
-	void check(SylvParams& pars, const GeneralMatrix& m) const;
-	void infoToPars(SylvParams& pars) const;
+  SimilarityDecomp(const double *d, int d_size, double log10norm = 3.0);
+  virtual
+  ~SimilarityDecomp();
+  const SqSylvMatrix &
+  getQ() const
+  {
+    return *q;
+  }
+  const SqSylvMatrix &
+  getInvQ() const
+  {
+    return *invq;
+  }
+  const BlockDiagonal &
+  getB() const
+  {
+    return *b;
+  }
+  void check(SylvParams &pars, const GeneralMatrix &m) const;
+  void infoToPars(SylvParams &pars) const;
 protected:
-	void getXDim(diag_iter start, diag_iter end, int& rows, int& cols) const;
-	bool solveX(diag_iter start, diag_iter end, GeneralMatrix& X, double norm) const;
-	void updateTransform(diag_iter start, diag_iter end, GeneralMatrix& X);
-	void bringGuiltyBlock(diag_iter start, diag_iter& end);
-	void diagonalize(double norm);
+  void getXDim(diag_iter start, diag_iter end, int &rows, int &cols) const;
+  bool solveX(diag_iter start, diag_iter end, GeneralMatrix &X, double norm) const;
+  void updateTransform(diag_iter start, diag_iter end, GeneralMatrix &X);
+  void bringGuiltyBlock(diag_iter start, diag_iter &end);
+  void diagonalize(double norm);
 };
 
 #endif /* SIMILARITY_DECOMP_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SylvException.h b/dynare++/sylv/cc/SylvException.h
index f3c22338a..5beb212a3 100644
--- a/dynare++/sylv/cc/SylvException.h
+++ b/dynare++/sylv/cc/SylvException.h
@@ -7,33 +7,34 @@
 
 #include "SylvMemory.h"
 
-
-class SylvException : public MallocAllocator {
+class SylvException : public MallocAllocator
+{
 protected:
-	char file[50];
-	int line;
-	const SylvException* source;
+  char file[50];
+  int line;
+  const SylvException *source;
 public:
-	SylvException(const char* f, int l, const SylvException* s);
-	virtual ~SylvException();
-	virtual int printMessage(char* str, int maxlen) const;
-	void printMessage() const;
+  SylvException(const char *f, int l, const SylvException *s);
+  virtual
+  ~SylvException();
+  virtual int printMessage(char *str, int maxlen) const;
+  void printMessage() const;
 };
 
-class SylvExceptionMessage : public SylvException {
-	char message[500];
+class SylvExceptionMessage : public SylvException
+{
+  char message[500];
 public:
-	SylvExceptionMessage(const char* f, int l, const char* mes);
-	virtual int printMessage(char* str, int maxlen) const;
+  SylvExceptionMessage(const char *f, int l, const char *mes);
+  virtual int printMessage(char *str, int maxlen) const;
 };
 
 // define macros:
 #define SYLV_EXCEPTION(exc) (SylvException(__FILE__, __LINE__, exc))
-#define SYLV_MES_EXCEPTION(mes) (SylvExceptionMessage(__FILE__, __LINE__, mes)) 
+#define SYLV_MES_EXCEPTION(mes) (SylvExceptionMessage(__FILE__, __LINE__, mes))
 
 #endif /* SYLV_EXCEPTION_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SylvMatrix.h b/dynare++/sylv/cc/SylvMatrix.h
index 99ab504ae..063e6b30b 100644
--- a/dynare++/sylv/cc/SylvMatrix.h
+++ b/dynare++/sylv/cc/SylvMatrix.h
@@ -10,72 +10,100 @@
 
 class SqSylvMatrix;
 
-class SylvMatrix : public GeneralMatrix {
+class SylvMatrix : public GeneralMatrix
+{
 public:
-	SylvMatrix(int m, int n)
-		: GeneralMatrix(m,n) {}
-	SylvMatrix(const double* d, int m, int n)
-		: GeneralMatrix(d, m, n) {}
-	SylvMatrix(double* d, int m, int n)
-		: GeneralMatrix(d, m, n) {}
-	SylvMatrix(const GeneralMatrix& m)
-		: GeneralMatrix(m) {}
-	SylvMatrix(const GeneralMatrix& m, int i, int j, int nrows, int ncols)
-		: GeneralMatrix(m, i, j, nrows, ncols) {}
-	SylvMatrix(GeneralMatrix& m, int i, int j, int nrows, int ncols)
-		: GeneralMatrix(m, i, j, nrows, ncols) {}
-	SylvMatrix(const GeneralMatrix& a, const GeneralMatrix& b)
-		: GeneralMatrix(a, b) {}
+  SylvMatrix(int m, int n)
+    : GeneralMatrix(m, n)
+  {
+  }
+  SylvMatrix(const double *d, int m, int n)
+    : GeneralMatrix(d, m, n)
+  {
+  }
+  SylvMatrix(double *d, int m, int n)
+    : GeneralMatrix(d, m, n)
+  {
+  }
+  SylvMatrix(const GeneralMatrix &m)
+    : GeneralMatrix(m)
+  {
+  }
+  SylvMatrix(const GeneralMatrix &m, int i, int j, int nrows, int ncols)
+    : GeneralMatrix(m, i, j, nrows, ncols)
+  {
+  }
+  SylvMatrix(GeneralMatrix &m, int i, int j, int nrows, int ncols)
+    : GeneralMatrix(m, i, j, nrows, ncols)
+  {
+  }
+  SylvMatrix(const GeneralMatrix &a, const GeneralMatrix &b)
+    : GeneralMatrix(a, b)
+  {
+  }
 
-	/* this = |I 0|* this
-	          |0 m|         */
-	void multLeftI(const SqSylvMatrix& m);
-	/* this = |I  0|* this
-	          |0 m'|         */
-	void multLeftITrans(const SqSylvMatrix& m);
-	/* this = |0 a|*b, so that |0 a| is square */
-	void multLeft(int zero_cols, const GeneralMatrix& a, const GeneralMatrix& b);
-	/* this = this * (m\otimes m..\otimes m) */
-	void multRightKron(const SqSylvMatrix& m, int order);
-	/* this = this * (m'\otimes m'..\otimes m') */
-	void multRightKronTrans(const SqSylvMatrix& m, int order);
-	/* this = P*this, x = P*x, where P is gauss transformation setting
-	 * a given element to zero */
-	void eliminateLeft(int row, int col, Vector& x);
-	/* this = this*P, x = P'*x, where P is gauss transformation setting
-	 * a given element to zero */
-	void eliminateRight(int row, int col, Vector& x);
+  /* this = |I 0|* this
+     |0 m|         */
+  void multLeftI(const SqSylvMatrix &m);
+  /* this = |I  0|* this
+     |0 m'|         */
+  void multLeftITrans(const SqSylvMatrix &m);
+  /* this = |0 a|*b, so that |0 a| is square */
+  void multLeft(int zero_cols, const GeneralMatrix &a, const GeneralMatrix &b);
+  /* this = this * (m\otimes m..\otimes m) */
+  void multRightKron(const SqSylvMatrix &m, int order);
+  /* this = this * (m'\otimes m'..\otimes m') */
+  void multRightKronTrans(const SqSylvMatrix &m, int order);
+  /* this = P*this, x = P*x, where P is gauss transformation setting
+   * a given element to zero */
+  void eliminateLeft(int row, int col, Vector &x);
+  /* this = this*P, x = P'*x, where P is gauss transformation setting
+   * a given element to zero */
+  void eliminateRight(int row, int col, Vector &x);
 };
 
-
-class SqSylvMatrix : public SylvMatrix {
+class SqSylvMatrix : public SylvMatrix
+{
 public:
-	SqSylvMatrix(int m) : SylvMatrix(m, m) {}
-	SqSylvMatrix(const double* d, int m) : SylvMatrix(d, m, m) {}
-	SqSylvMatrix(double* d, int m) : SylvMatrix(d, m, m) {}
-	SqSylvMatrix(const SqSylvMatrix& m) : SylvMatrix(m) {}
-	SqSylvMatrix(const GeneralMatrix& m, int i, int j, int nrows)
-		: SylvMatrix(m, i, j, nrows, nrows) {} 
-	SqSylvMatrix(GeneralMatrix& m, int i, int j, int nrows)
-		: SylvMatrix(m, i, j, nrows, nrows) {} 
-	SqSylvMatrix(const GeneralMatrix& a, const GeneralMatrix& b);
-	const SqSylvMatrix& operator=(const SqSylvMatrix& m)
-		{GeneralMatrix::operator=(m); return *this;}
-	/* x = (this \otimes this..\otimes this)*d */
-	void multVecKron(KronVector& x, const KronVector& d) const;
-	/* x = (this' \otimes this'..\otimes this')*d */
-	void multVecKronTrans(KronVector& x, const KronVector& d) const;
-	/* a = inv(this)*a, b=inv(this)*b */
-	void multInvLeft2(GeneralMatrix& a, GeneralMatrix& b,
-					  double& rcond1, double& rcondinf) const;
-	/* this = I */
-	void setUnit();
+  SqSylvMatrix(int m) : SylvMatrix(m, m)
+  {
+  }
+  SqSylvMatrix(const double *d, int m) : SylvMatrix(d, m, m)
+  {
+  }
+  SqSylvMatrix(double *d, int m) : SylvMatrix(d, m, m)
+  {
+  }
+  SqSylvMatrix(const SqSylvMatrix &m) : SylvMatrix(m)
+  {
+  }
+  SqSylvMatrix(const GeneralMatrix &m, int i, int j, int nrows)
+    : SylvMatrix(m, i, j, nrows, nrows)
+  {
+  }
+  SqSylvMatrix(GeneralMatrix &m, int i, int j, int nrows)
+    : SylvMatrix(m, i, j, nrows, nrows)
+  {
+  }
+  SqSylvMatrix(const GeneralMatrix &a, const GeneralMatrix &b);
+  const SqSylvMatrix &
+  operator=(const SqSylvMatrix &m)
+  {
+    GeneralMatrix::operator=(m); return *this;
+  }
+  /* x = (this \otimes this..\otimes this)*d */
+  void multVecKron(KronVector &x, const KronVector &d) const;
+  /* x = (this' \otimes this'..\otimes this')*d */
+  void multVecKronTrans(KronVector &x, const KronVector &d) const;
+  /* a = inv(this)*a, b=inv(this)*b */
+  void multInvLeft2(GeneralMatrix &a, GeneralMatrix &b,
+                    double &rcond1, double &rcondinf) const;
+  /* this = I */
+  void setUnit();
 };
 
-
 #endif /* SYLV_MATRIX_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SylvMemory.h b/dynare++/sylv/cc/SylvMemory.h
index 187aac0b5..48a0fcd3d 100644
--- a/dynare++/sylv/cc/SylvMemory.h
+++ b/dynare++/sylv/cc/SylvMemory.h
@@ -9,55 +9,57 @@
 
 #include <new>
 
-class MallocAllocator {
+class MallocAllocator
+{
 #ifdef USE_MEMORY_POOL
 public:
-	void* operator new(size_t size);
-	void* operator new[](size_t size);
-	void operator delete(void* p);
-	void operator delete[](void* p);
+  void *operator new(size_t size);
+  void *operator new[](size_t size);
+  void operator delete(void *p);
+  void operator delete[](void *p);
 #endif
 };
 
 #ifdef USE_MEMORY_POOL
-void* operator new(size_t size);
-void* operator new[](size_t size);
-void operator delete(void* p);
-void operator delete[](void* p);
+void *operator new(size_t size);
+void *operator new[](size_t size);
+void operator delete(void *p);
+void operator delete[](void *p);
 #endif
 
-class SylvMemoryPool {
-	char* base;
-	size_t length;
-	size_t allocated;
-	bool stack_mode;
-	SylvMemoryPool(const SylvMemoryPool&);
-	const SylvMemoryPool& operator=(const SylvMemoryPool&);
+class SylvMemoryPool
+{
+  char *base;
+  size_t length;
+  size_t allocated;
+  bool stack_mode;
+  SylvMemoryPool(const SylvMemoryPool &);
+  const SylvMemoryPool &operator=(const SylvMemoryPool &);
 public:
-	SylvMemoryPool();
-	~SylvMemoryPool();
-	void init(size_t size);
-	void* allocate(size_t size);
-	void free(void* p);
-	void reset();
-	void setStackMode(bool);
+  SylvMemoryPool();
+  ~SylvMemoryPool();
+  void init(size_t size);
+  void *allocate(size_t size);
+  void free(void *p);
+  void reset();
+  void setStackMode(bool);
 };
 
-class SylvMemoryDriver {
-	SylvMemoryDriver(const SylvMemoryDriver&);
-	const SylvMemoryDriver& operator=(const SylvMemoryDriver&);
+class SylvMemoryDriver
+{
+  SylvMemoryDriver(const SylvMemoryDriver &);
+  const SylvMemoryDriver &operator=(const SylvMemoryDriver &);
 public:
-	SylvMemoryDriver(int num_d, int m, int n, int order);
-	SylvMemoryDriver(const SylvParams& pars, int num_d, int m, int n, int order);
-	static void setStackMode(bool);
-	~SylvMemoryDriver();
+  SylvMemoryDriver(int num_d, int m, int n, int order);
+  SylvMemoryDriver(const SylvParams &pars, int num_d, int m, int n, int order);
+  static void setStackMode(bool);
+  ~SylvMemoryDriver();
 protected:
-	void allocate(int num_d, int m, int n, int order);
+  void allocate(int num_d, int m, int n, int order);
 };
 
 #endif /* SYLV_MEMORY_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SylvParams.h b/dynare++/sylv/cc/SylvParams.h
index beb292670..9b58e92e5 100644
--- a/dynare++/sylv/cc/SylvParams.h
+++ b/dynare++/sylv/cc/SylvParams.h
@@ -15,148 +15,217 @@
 typedef enum {def, changed, undef} status;
 
 template <class _Type>
-struct ParamItem {
+struct ParamItem
+{
 protected:
-	typedef ParamItem<_Type> _Self;
-	status s;
-	_Type value;
+  typedef ParamItem<_Type> _Self;
+  status s;
+  _Type value;
 public:
-	ParamItem()
-		{s = undef;}
-	ParamItem(_Type val)
-		{value = val; s = def;}
-	ParamItem(const _Self& item)
-		{value = item.value; s = item.s;}
-	const _Self& operator=(const _Self& item)
-		{value = item.value; s = item.s; return *this;}
-	const _Self& operator=(const _Type& val)
-		{value = val; s = changed; return *this;}
-	_Type operator*() const
-		{return value;}
-	status getStatus() const
-		{return s;}
-	void print(FILE* f, const char* prefix, const char* str, const char* fmt) const
-		{
-			if (s == undef)
-				return;
-			char out[1000];
-			strcpy(out, prefix);
-			strcat(out, str);
-			strcat(out, "= ");
-			strcat(out, fmt);
-			if (s == def)
-				strcat(out, " <default>");
-			strcat(out,"\n");
-			fprintf(f, out, value);
-		} 
+  ParamItem()
+  {
+    s = undef;
+  }
+  ParamItem(_Type val)
+  {
+    value = val; s = def;
+  }
+  ParamItem(const _Self &item)
+  {
+    value = item.value; s = item.s;
+  }
+  const _Self &
+  operator=(const _Self &item)
+  {
+    value = item.value; s = item.s; return *this;
+  }
+  const _Self &
+  operator=(const _Type &val)
+  {
+    value = val; s = changed; return *this;
+  }
+  _Type
+  operator*() const
+  {
+    return value;
+  }
+  status
+  getStatus() const
+  {
+    return s;
+  }
+  void
+  print(FILE *f, const char *prefix, const char *str, const char *fmt) const
+  {
+    if (s == undef)
+      return;
+    char out[1000];
+    strcpy(out, prefix);
+    strcat(out, str);
+    strcat(out, "= ");
+    strcat(out, fmt);
+    if (s == def)
+      strcat(out, " <default>");
+    strcat(out, "\n");
+    fprintf(f, out, value);
+  }
 };
 
-class SylvParams {
+class SylvParams
+{
 public:
-	typedef enum {iter, recurse} solve_method;
+  typedef enum {iter, recurse} solve_method;
 
 protected:
-	class DoubleParamItem : public ParamItem<double> {
-	public:
-		DoubleParamItem() : ParamItem<double>() {}
-		DoubleParamItem(double val) : ParamItem<double>(val) {}
-		DoubleParamItem(const DoubleParamItem& item) : ParamItem<double>(item) {}
-		const DoubleParamItem& operator=(const double& val)
-			{ParamItem<double>::operator=(val); return *this;}
+  class DoubleParamItem : public ParamItem<double>
+  {
+  public:
+    DoubleParamItem() : ParamItem<double>()
+    {
+    }
+    DoubleParamItem(double val) : ParamItem<double>(val)
+    {
+    }
+    DoubleParamItem(const DoubleParamItem &item) : ParamItem<double>(item)
+    {
+    }
+    const DoubleParamItem &
+    operator=(const double &val)
+    {
+      ParamItem<double>::operator=(val); return *this;
+    }
 #if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
-		mxArray* createMatlabArray() const;
+    mxArray *createMatlabArray() const;
 #endif
-	};
+  };
 
-	class IntParamItem : public ParamItem<int> {
-	public:
-		IntParamItem() : ParamItem<int>() {}
-		IntParamItem(int val) : ParamItem<int>(val) {}
-		IntParamItem(const IntParamItem& item) : ParamItem<int>(item) {}
-		const IntParamItem& operator=(const int& val)
-			{ParamItem<int>::operator=(val); return *this;}
+  class IntParamItem : public ParamItem<int>
+  {
+  public:
+    IntParamItem() : ParamItem<int>()
+    {
+    }
+    IntParamItem(int val) : ParamItem<int>(val)
+    {
+    }
+    IntParamItem(const IntParamItem &item) : ParamItem<int>(item)
+    {
+    }
+    const IntParamItem &
+    operator=(const int &val)
+    {
+      ParamItem<int>::operator=(val); return *this;
+    }
 #if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
-		mxArray* createMatlabArray() const;
+    mxArray *createMatlabArray() const;
 #endif
-	};
+  };
 
-	class BoolParamItem : public ParamItem<bool> {
-	public:
-		BoolParamItem() : ParamItem<bool>() {}
-		BoolParamItem(bool val) : ParamItem<bool>(val) {}
-		BoolParamItem(const BoolParamItem& item) : ParamItem<bool>(item) {}
-		const BoolParamItem& operator=(const bool& val)
-			{ParamItem<bool>::operator=(val); return *this;}
+  class BoolParamItem : public ParamItem<bool>
+  {
+  public:
+    BoolParamItem() : ParamItem<bool>()
+    {
+    }
+    BoolParamItem(bool val) : ParamItem<bool>(val)
+    {
+    }
+    BoolParamItem(const BoolParamItem &item) : ParamItem<bool>(item)
+    {
+    }
+    const BoolParamItem &
+    operator=(const bool &val)
+    {
+      ParamItem<bool>::operator=(val); return *this;
+    }
 #if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
-		mxArray* createMatlabArray() const;
+    mxArray *createMatlabArray() const;
 #endif
-	};
+  };
 
-	class MethodParamItem : public ParamItem<solve_method> {
-	public:
-		MethodParamItem() : ParamItem<solve_method>() {}
-		MethodParamItem(solve_method val) : ParamItem<solve_method>(val) {}
-		MethodParamItem(const MethodParamItem& item) : ParamItem<solve_method>(item) {}
-		const MethodParamItem operator=(const solve_method& val)
-			{ParamItem<solve_method>::operator=(val); return *this;}
+  class MethodParamItem : public ParamItem<solve_method>
+  {
+  public:
+    MethodParamItem() : ParamItem<solve_method>()
+    {
+    }
+    MethodParamItem(solve_method val) : ParamItem<solve_method>(val)
+    {
+    }
+    MethodParamItem(const MethodParamItem &item) : ParamItem<solve_method>(item)
+    {
+    }
+    const MethodParamItem
+    operator=(const solve_method &val)
+    {
+      ParamItem<solve_method>::operator=(val); return *this;
+    }
 #if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
-		mxArray* createMatlabArray() const;
+    mxArray *createMatlabArray() const;
 #endif
-	};
+  };
 
 public:
-	// input parameters
-	MethodParamItem method; // method of solution: iter/recurse
-	DoubleParamItem convergence_tol; // norm for what we consider converged
-	IntParamItem max_num_iter; // max number of iterations
-	DoubleParamItem bs_norm; // Bavely Stewart log10 of norm for diagonalization
-	BoolParamItem want_check; // true => allocate extra space for checks
-	// output parameters
-	BoolParamItem converged; // true if converged
-	DoubleParamItem iter_last_norm; // norm of the last iteration
-	IntParamItem num_iter; // number of iterations
-	DoubleParamItem f_err1; // norm 1 of diagonalization abs. error C-V*F*inv(V)
-	DoubleParamItem f_errI; // norm Inf of diagonalization abs. error C-V*F*inv(V)
-	DoubleParamItem viv_err1; // norm 1 of error I-V*inv(V)
-	DoubleParamItem viv_errI; // norm Inf of error I-V*inv(V)
-	DoubleParamItem ivv_err1; // norm 1 of error I-inv(V)*V
-	DoubleParamItem ivv_errI; // norm Inf of error I-inv(V)*V
-	IntParamItem f_blocks; // number of diagonal blocks of F
-	IntParamItem f_largest; // size of largest diagonal block in F
-	IntParamItem f_zeros; // number of off diagonal zeros in F
-	IntParamItem f_offdiag; // number of all off diagonal elements in F
-	DoubleParamItem rcondA1; // reciprocal cond 1 number of A
-	DoubleParamItem rcondAI; // reciprocal cond Inf number of A
-	DoubleParamItem eig_min; // minimum eigenvalue of the solved system
-	DoubleParamItem mat_err1; // rel. matrix 1 norm of A*X-B*X*kron(C,..,C)-D
-	DoubleParamItem mat_errI; // rel. matrix Inf norm of A*X-B*X*kron(C,..,C)-D
-	DoubleParamItem mat_errF; // rel. matrix Frob. norm of A*X-B*X*kron(C,..,C)-D
-	DoubleParamItem vec_err1; // rel. vector 1 norm of A*X-B*X*kron(C,..,C)-D
-	DoubleParamItem vec_errI; // rel. vector Inf norm of A*X-B*X*kron(C,..,C)-D
-	DoubleParamItem cpu_time; // time of the job in CPU seconds
-	// note: remember to change copy() if adding/removing member
+  // input parameters
+  MethodParamItem method; // method of solution: iter/recurse
+  DoubleParamItem convergence_tol; // norm for what we consider converged
+  IntParamItem max_num_iter; // max number of iterations
+  DoubleParamItem bs_norm; // Bavely Stewart log10 of norm for diagonalization
+  BoolParamItem want_check; // true => allocate extra space for checks
+  // output parameters
+  BoolParamItem converged; // true if converged
+  DoubleParamItem iter_last_norm; // norm of the last iteration
+  IntParamItem num_iter; // number of iterations
+  DoubleParamItem f_err1; // norm 1 of diagonalization abs. error C-V*F*inv(V)
+  DoubleParamItem f_errI; // norm Inf of diagonalization abs. error C-V*F*inv(V)
+  DoubleParamItem viv_err1; // norm 1 of error I-V*inv(V)
+  DoubleParamItem viv_errI; // norm Inf of error I-V*inv(V)
+  DoubleParamItem ivv_err1; // norm 1 of error I-inv(V)*V
+  DoubleParamItem ivv_errI; // norm Inf of error I-inv(V)*V
+  IntParamItem f_blocks; // number of diagonal blocks of F
+  IntParamItem f_largest; // size of largest diagonal block in F
+  IntParamItem f_zeros; // number of off diagonal zeros in F
+  IntParamItem f_offdiag; // number of all off diagonal elements in F
+  DoubleParamItem rcondA1; // reciprocal cond 1 number of A
+  DoubleParamItem rcondAI; // reciprocal cond Inf number of A
+  DoubleParamItem eig_min; // minimum eigenvalue of the solved system
+  DoubleParamItem mat_err1; // rel. matrix 1 norm of A*X-B*X*kron(C,..,C)-D
+  DoubleParamItem mat_errI; // rel. matrix Inf norm of A*X-B*X*kron(C,..,C)-D
+  DoubleParamItem mat_errF; // rel. matrix Frob. norm of A*X-B*X*kron(C,..,C)-D
+  DoubleParamItem vec_err1; // rel. vector 1 norm of A*X-B*X*kron(C,..,C)-D
+  DoubleParamItem vec_errI; // rel. vector Inf norm of A*X-B*X*kron(C,..,C)-D
+  DoubleParamItem cpu_time; // time of the job in CPU seconds
+  // note: remember to change copy() if adding/removing member
 
-	SylvParams(bool wc = false)
-		: method(recurse), convergence_tol(1.e-30), max_num_iter(15),
-		  bs_norm(1.3), want_check(wc) {}
-	SylvParams(const SylvParams& p)
-		{copy(p);}
-	const SylvParams& operator=(const SylvParams& p)
-		{copy(p); return *this;}
-	~SylvParams() {}
-	void print(const char* prefix) const;
-	void print(FILE* fdesc, const char* prefix) const;
-	void setArrayNames(int& num, const char** names) const;
+  SylvParams(bool wc = false)
+    : method(recurse), convergence_tol(1.e-30), max_num_iter(15),
+      bs_norm(1.3), want_check(wc)
+  {
+  }
+  SylvParams(const SylvParams &p)
+  {
+    copy(p);
+  }
+  const SylvParams &
+  operator=(const SylvParams &p)
+  {
+    copy(p); return *this;
+  }
+  ~SylvParams()
+  {
+  }
+  void print(const char *prefix) const;
+  void print(FILE *fdesc, const char *prefix) const;
+  void setArrayNames(int &num, const char **names) const;
 #if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
-	mxArray* createStructArray() const;
+  mxArray *createStructArray() const;
 #endif
 private:
-	void copy(const SylvParams& p);
+  void copy(const SylvParams &p);
 };
 
 #endif /* SYLV_PARAMS_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SylvesterSolver.h b/dynare++/sylv/cc/SylvesterSolver.h
index df9bcce45..344abd127 100644
--- a/dynare++/sylv/cc/SylvesterSolver.h
+++ b/dynare++/sylv/cc/SylvesterSolver.h
@@ -12,40 +12,47 @@
 #include "SylvParams.h"
 #include "SchurDecomp.h"
 
-class SylvesterSolver {
+class SylvesterSolver
+{
 protected:
-	const QuasiTriangular* const matrixK;
-	const QuasiTriangular* const matrixF;
+  const QuasiTriangular *const matrixK;
+  const QuasiTriangular *const matrixF;
 private:
-	/* return true when it is more efficient to use QuasiTriangular
-	 * than QuasiTriangularZero */
-	static bool zeroPad(const SchurDecompZero& kdecomp) {
-		return ((kdecomp.getZeroCols()*3 < kdecomp.getDim()*2) ||
-				(kdecomp.getZeroCols() < 10));
-	}
+  /* return true when it is more efficient to use QuasiTriangular
+   * than QuasiTriangularZero */
+  static bool
+  zeroPad(const SchurDecompZero &kdecomp)
+  {
+    return ((kdecomp.getZeroCols()*3 < kdecomp.getDim()*2)
+            || (kdecomp.getZeroCols() < 10));
+  }
 public:
-	SylvesterSolver(const QuasiTriangular& k, const QuasiTriangular& f)
-		: matrixK(new QuasiTriangular(k)),
-		  matrixF(new QuasiTriangular(f))
-		{}
-	SylvesterSolver(const SchurDecompZero& kdecomp, const SchurDecomp& fdecomp)
-		: matrixK((zeroPad(kdecomp)) ?
-				  new QuasiTriangular(kdecomp) : new QuasiTriangularZero(kdecomp)),
-		  matrixF(new QuasiTriangular(fdecomp))
-		{}
-	SylvesterSolver(const SchurDecompZero& kdecomp, const SimilarityDecomp& fdecomp)
-		: matrixK((zeroPad(kdecomp)) ?
-				  new QuasiTriangular(kdecomp) : new QuasiTriangularZero(kdecomp)),
-		  matrixF(new BlockDiagonal(fdecomp.getB()))
-		{}
-	virtual ~SylvesterSolver()
-		{delete matrixK; delete matrixF;}
-	virtual void solve(SylvParams& pars, KronVector& x) const = 0;
+  SylvesterSolver(const QuasiTriangular &k, const QuasiTriangular &f)
+    : matrixK(new QuasiTriangular(k)),
+      matrixF(new QuasiTriangular(f))
+  {
+  }
+  SylvesterSolver(const SchurDecompZero &kdecomp, const SchurDecomp &fdecomp)
+    : matrixK((zeroPad(kdecomp)) ?
+              new QuasiTriangular(kdecomp) : new QuasiTriangularZero(kdecomp)),
+      matrixF(new QuasiTriangular(fdecomp))
+  {
+  }
+  SylvesterSolver(const SchurDecompZero &kdecomp, const SimilarityDecomp &fdecomp)
+    : matrixK((zeroPad(kdecomp)) ?
+              new QuasiTriangular(kdecomp) : new QuasiTriangularZero(kdecomp)),
+      matrixF(new BlockDiagonal(fdecomp.getB()))
+  {
+  }
+  virtual ~SylvesterSolver()
+  {
+    delete matrixK; delete matrixF;
+  }
+  virtual void solve(SylvParams &pars, KronVector &x) const = 0;
 };
 
 #endif /* SYLVESTER_SOLVER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/SymSchurDecomp.h b/dynare++/sylv/cc/SymSchurDecomp.h
index 784042111..9b95f36bf 100644
--- a/dynare++/sylv/cc/SymSchurDecomp.h
+++ b/dynare++/sylv/cc/SymSchurDecomp.h
@@ -7,35 +7,45 @@
 
 #include "SylvMatrix.h"
 
-class SymSchurDecomp {
+class SymSchurDecomp
+{
 protected:
-	Vector lambda;
-	SqSylvMatrix q;
+  Vector lambda;
+  SqSylvMatrix q;
 public:
-	/** Calculates A = Q*Lambda*Q^T, where A is assummed to be
-	 * symmetric and Lambda real diagonal, hence a vector. */
-	SymSchurDecomp(const GeneralMatrix& a);
-	SymSchurDecomp(const SymSchurDecomp& ssd)
-		: lambda(ssd.lambda), q(ssd.q) {}
-	virtual ~SymSchurDecomp() {}
-	const Vector& getLambda() const
-		{return lambda;}
-	const SqSylvMatrix& getQ() const
-		{return q;}
-	/** Return factor F*F^T = A, raises and exception if A is not
-	 * positive semidefinite, F must be square. */
-	void getFactor(GeneralMatrix& f) const;
-	/** Returns true if A is positive semidefinite. */
-	bool isPositiveSemidefinite() const;
-	/** Correct definitness. This sets all eigenvalues between minus
-	 * tolerance and zero to zero. */
-	void correctDefinitness(double tol);
+  /** Calculates A = Q*Lambda*Q^T, where A is assummed to be
+   * symmetric and Lambda real diagonal, hence a vector. */
+  SymSchurDecomp(const GeneralMatrix &a);
+  SymSchurDecomp(const SymSchurDecomp &ssd)
+    : lambda(ssd.lambda), q(ssd.q)
+  {
+  }
+  virtual ~SymSchurDecomp()
+  {
+  }
+  const Vector &
+  getLambda() const
+  {
+    return lambda;
+  }
+  const SqSylvMatrix &
+  getQ() const
+  {
+    return q;
+  }
+  /** Return factor F*F^T = A, raises and exception if A is not
+   * positive semidefinite, F must be square. */
+  void getFactor(GeneralMatrix &f) const;
+  /** Returns true if A is positive semidefinite. */
+  bool isPositiveSemidefinite() const;
+  /** Correct definitness. This sets all eigenvalues between minus
+   * tolerance and zero to zero. */
+  void correctDefinitness(double tol);
 
 };
 
 #endif
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/TriangularSylvester.h b/dynare++/sylv/cc/TriangularSylvester.h
index b4908729e..fa652bc12 100644
--- a/dynare++/sylv/cc/TriangularSylvester.h
+++ b/dynare++/sylv/cc/TriangularSylvester.h
@@ -11,105 +11,112 @@
 #include "QuasiTriangularZero.h"
 #include "SimilarityDecomp.h"
 
-class TriangularSylvester : public SylvesterSolver {
-	const QuasiTriangular* const matrixKK;
-	const QuasiTriangular* const matrixFF;
+class TriangularSylvester : public SylvesterSolver
+{
+  const QuasiTriangular *const matrixKK;
+  const QuasiTriangular *const matrixFF;
 public:
-	TriangularSylvester(const QuasiTriangular& k, const QuasiTriangular& f);
-	TriangularSylvester(const SchurDecompZero& kdecomp, const SchurDecomp& fdecomp);
-	TriangularSylvester(const SchurDecompZero& kdecomp, const SimilarityDecomp& fdecomp);
-	virtual ~TriangularSylvester();
-	void print() const;
-	void solve(SylvParams& pars, KronVector& d) const;
+  TriangularSylvester(const QuasiTriangular &k, const QuasiTriangular &f);
+  TriangularSylvester(const SchurDecompZero &kdecomp, const SchurDecomp &fdecomp);
+  TriangularSylvester(const SchurDecompZero &kdecomp, const SimilarityDecomp &fdecomp);
+  virtual
+  ~TriangularSylvester();
+  void print() const;
+  void solve(SylvParams &pars, KronVector &d) const;
 
-	void solvi(double r, KronVector& d, double& eig_min) const;
-	void solvii(double alpha, double beta1, double beta2,
-				KronVector& d1, KronVector& d2,
-				double& eig_min) const;
-	void solviip(double alpha, double betas,
-				 KronVector& d, double& eig_min) const;
-	/* evaluates:
-	   |x1|   |d1| |alpha -beta1|                       |d1|
-	   |  | = |  |+|            |\otimes F'...\otimes K |  |
-	   |x2|   |d2| |beta2  alpha|                       |d2|
-	*/
-	void linEval(double alpha, double beta1, double beta2,
-				 KronVector& x1, KronVector& x2,
-				 const ConstKronVector& d1, const ConstKronVector& d2) const;
-	void linEval(double alpha, double beta1, double beta2,
-				 KronVector& x1, KronVector& x2,
-				 const KronVector& d1, const KronVector& d2) const
-		{linEval(alpha, beta1, beta2, x1, x2,
-				 ConstKronVector(d1), ConstKronVector(d2));}
+  void solvi(double r, KronVector &d, double &eig_min) const;
+  void solvii(double alpha, double beta1, double beta2,
+              KronVector &d1, KronVector &d2,
+              double &eig_min) const;
+  void solviip(double alpha, double betas,
+               KronVector &d, double &eig_min) const;
+  /* evaluates:
+     |x1|   |d1| |alpha -beta1|                       |d1|
+     |  | = |  |+|            |\otimes F'...\otimes K |  |
+     |x2|   |d2| |beta2  alpha|                       |d2|
+  */
+  void linEval(double alpha, double beta1, double beta2,
+               KronVector &x1, KronVector &x2,
+               const ConstKronVector &d1, const ConstKronVector &d2) const;
+  void
+  linEval(double alpha, double beta1, double beta2,
+          KronVector &x1, KronVector &x2,
+          const KronVector &d1, const KronVector &d2) const
+  {
+    linEval(alpha, beta1, beta2, x1, x2,
+            ConstKronVector(d1), ConstKronVector(d2));
+  }
 
-	/* evaluates:
-	   |x1|   |d1|          |gamma -delta1|                       |d1|
-	   |  | = |  | + 2alpha*|             |\otimes F'...\otimes K |  | +
-	   |x2|   |d2|          |delta2  gamma|                       |d2|
+  /* evaluates:
+     |x1|   |d1|          |gamma -delta1|                       |d1|
+     |  | = |  | + 2alpha*|             |\otimes F'...\otimes K |  | +
+     |x2|   |d2|          |delta2  gamma|                       |d2|
 
-                                     |gamma -delta1|^2                       |d1|
-                   + (alpha^2+betas)*|             |\otimes F'2...\otimes K2 |  |
-                                     |delta2  gamma|                         |d2|
-	*/
-	void quaEval(double alpha, double betas,
-				 double gamma, double delta1, double delta2,
-				 KronVector& x1, KronVector& x2,
-				 const ConstKronVector& d1, const ConstKronVector& d2) const;
-	void quaEval(double alpha, double betas,
-				 double gamma, double delta1, double delta2,
-				 KronVector& x1, KronVector& x2,
-				 const KronVector& d1, const KronVector& d2) const
-		{quaEval(alpha, betas, gamma, delta1, delta2, x1, x2,
-				 ConstKronVector(d1), ConstKronVector(d2));}
+     |gamma -delta1|^2                       |d1|
+     + (alpha^2+betas)*|             |\otimes F'2...\otimes K2 |  |
+     |delta2  gamma|                         |d2|
+  */
+  void quaEval(double alpha, double betas,
+               double gamma, double delta1, double delta2,
+               KronVector &x1, KronVector &x2,
+               const ConstKronVector &d1, const ConstKronVector &d2) const;
+  void
+  quaEval(double alpha, double betas,
+          double gamma, double delta1, double delta2,
+          KronVector &x1, KronVector &x2,
+          const KronVector &d1, const KronVector &d2) const
+  {
+    quaEval(alpha, betas, gamma, delta1, delta2, x1, x2,
+            ConstKronVector(d1), ConstKronVector(d2));
+  }
 private:
-	/* returns square of size of minimal eigenvalue of the system solved,
-	   now obsolete */ 
-	double getEigSep(int depth) const;
-	/* recursivelly calculates kronecker product of complex vectors (used in getEigSep) */
-	static void multEigVector(KronVector& eig, const Vector& feig, const Vector& keig);
-	/* auxiliary typedefs */
-	typedef QuasiTriangular::const_diag_iter const_diag_iter;
-	typedef QuasiTriangular::const_row_iter const_row_iter;
-	/* called from solvi */
-	void solviRealAndEliminate(double r, const_diag_iter di,
-							   KronVector& d, double& eig_min) const;
-	void solviComplexAndEliminate(double r, const_diag_iter di,
-								  KronVector& d, double& eig_min) const;
-	/* called from solviip */
-	void solviipRealAndEliminate(double alpha, double betas,
-								 const_diag_iter di, const_diag_iter dsi,
-								 KronVector& d, double& eig_min) const;
-	void solviipComplexAndEliminate(double alpha, double betas,
-									const_diag_iter di, const_diag_iter dsi,
-									KronVector& d, double& eig_min) const;
-	/* eliminations */
-	void solviEliminateReal(const_diag_iter di, KronVector& d,
-							const KronVector& y, double divisor) const;
-	void solviEliminateComplex(const_diag_iter di, KronVector& d,
-							   const KronVector& y1, const KronVector& y2,
-							   double divisor) const;
-	void solviipEliminateReal(const_diag_iter di, const_diag_iter dsi,
-							  KronVector& d,
-							  const KronVector& y1, const KronVector& y2,
-							  double divisor, double divisor2) const;
-	void solviipEliminateComplex(const_diag_iter di, const_diag_iter dsi,
-								 KronVector& d,
-								 const KronVector& y1, const KronVector& y11,
-								 const KronVector& y2, const KronVector& y22,
-								 double divisor) const;
-	/* Lemma 2 */
-	void solviipComplex(double alpha, double betas, double gamma,
-						double delta1, double delta2,
-						KronVector& d1, KronVector& d2,
-						double& eig_min) const;
-	/* norms for what we consider zero on diagonal of F */
-	static double diag_zero;
-	static double diag_zero_sq; // square of diag_zero
+  /* returns square of size of minimal eigenvalue of the system solved,
+     now obsolete */
+  double getEigSep(int depth) const;
+  /* recursivelly calculates kronecker product of complex vectors (used in getEigSep) */
+  static void multEigVector(KronVector &eig, const Vector &feig, const Vector &keig);
+  /* auxiliary typedefs */
+  typedef QuasiTriangular::const_diag_iter const_diag_iter;
+  typedef QuasiTriangular::const_row_iter const_row_iter;
+  /* called from solvi */
+  void solviRealAndEliminate(double r, const_diag_iter di,
+                             KronVector &d, double &eig_min) const;
+  void solviComplexAndEliminate(double r, const_diag_iter di,
+                                KronVector &d, double &eig_min) const;
+  /* called from solviip */
+  void solviipRealAndEliminate(double alpha, double betas,
+                               const_diag_iter di, const_diag_iter dsi,
+                               KronVector &d, double &eig_min) const;
+  void solviipComplexAndEliminate(double alpha, double betas,
+                                  const_diag_iter di, const_diag_iter dsi,
+                                  KronVector &d, double &eig_min) const;
+  /* eliminations */
+  void solviEliminateReal(const_diag_iter di, KronVector &d,
+                          const KronVector &y, double divisor) const;
+  void solviEliminateComplex(const_diag_iter di, KronVector &d,
+                             const KronVector &y1, const KronVector &y2,
+                             double divisor) const;
+  void solviipEliminateReal(const_diag_iter di, const_diag_iter dsi,
+                            KronVector &d,
+                            const KronVector &y1, const KronVector &y2,
+                            double divisor, double divisor2) const;
+  void solviipEliminateComplex(const_diag_iter di, const_diag_iter dsi,
+                               KronVector &d,
+                               const KronVector &y1, const KronVector &y11,
+                               const KronVector &y2, const KronVector &y22,
+                               double divisor) const;
+  /* Lemma 2 */
+  void solviipComplex(double alpha, double betas, double gamma,
+                      double delta1, double delta2,
+                      KronVector &d1, KronVector &d2,
+                      double &eig_min) const;
+  /* norms for what we consider zero on diagonal of F */
+  static double diag_zero;
+  static double diag_zero_sq; // square of diag_zero
 };
 
 #endif /* TRIANGULAR_SYLVESTER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/cc/Vector.h b/dynare++/sylv/cc/Vector.h
index dc4acd532..3afd5d389 100644
--- a/dynare++/sylv/cc/Vector.h
+++ b/dynare++/sylv/cc/Vector.h
@@ -7,169 +7,252 @@
 
 /* NOTE! Vector and ConstVector have not common super class in order
  * to avoid running virtual method invokation mechanism. Some
- * members, and methods are thus duplicated */ 
+ * members, and methods are thus duplicated */
 
 #include <cstdio>
 
 class GeneralMatrix;
 class ConstVector;
 
-class Vector {
+class Vector
+{
 protected:
-	int len;
-	int s;
-	double* data;
-	bool destroy;
+  int len;
+  int s;
+  double *data;
+  bool destroy;
 public:
-	Vector() : len(0), s(1), data(0), destroy(false) {}
-	Vector(int l) : len(l), s(1), data(new double[l]), destroy(true) {}
-	Vector(Vector& v) : len(v.length()), s(v.skip()), data(v.base()), destroy(false) {}
-	Vector(const Vector& v);
-	Vector(const ConstVector& v);
-	Vector(const double* d, int l)
-		: len(l), s(1), data(new double[len]), destroy(true)
-		{copy(d, 1);}
-	Vector(double* d, int l)
-		: len(l), s(1), data(d), destroy(false) {}
-	Vector(double* d, int skip, int l)
-		: len(l), s(skip), data(d), destroy(false) {}
-	Vector(Vector& v, int off, int l);
-	Vector(const Vector& v, int off, int l);
-	Vector(GeneralMatrix& m, int col);
-	Vector(int row, GeneralMatrix& m);
-	const Vector& operator=(const Vector& v);
-	const Vector& operator=(const ConstVector& v);
-	double& operator[](int i)
-		{return data[s*i];}
-	const double& operator[](int i) const
-		{return data[s*i];}
-	const double* base() const
-		{return data;}
-	double* base()
-		{return data;}
-	int length() const
-		{return len;}
-	int skip() const
-		{return s;}
+  Vector() : len(0), s(1), data(0), destroy(false)
+  {
+  }
+  Vector(int l) : len(l), s(1), data(new double[l]), destroy(true)
+  {
+  }
+  Vector(Vector &v) : len(v.length()), s(v.skip()), data(v.base()), destroy(false)
+  {
+  }
+  Vector(const Vector &v);
+  Vector(const ConstVector &v);
+  Vector(const double *d, int l)
+    : len(l), s(1), data(new double[len]), destroy(true)
+  {
+    copy(d, 1);
+  }
+  Vector(double *d, int l)
+    : len(l), s(1), data(d), destroy(false)
+  {
+  }
+  Vector(double *d, int skip, int l)
+    : len(l), s(skip), data(d), destroy(false)
+  {
+  }
+  Vector(Vector &v, int off, int l);
+  Vector(const Vector &v, int off, int l);
+  Vector(GeneralMatrix &m, int col);
+  Vector(int row, GeneralMatrix &m);
+  const Vector &operator=(const Vector &v);
+  const Vector &operator=(const ConstVector &v);
+  double &
+  operator[](int i)
+  {
+    return data[s*i];
+  }
+  const double &
+  operator[](int i) const
+  {
+    return data[s*i];
+  }
+  const double *
+  base() const
+  {
+    return data;
+  }
+  double *
+  base()
+  {
+    return data;
+  }
+  int
+  length() const
+  {
+    return len;
+  }
+  int
+  skip() const
+  {
+    return s;
+  }
 
-	/** Exact equality. */
-	bool operator==(const Vector& y) const;
-	bool operator!=(const Vector& y) const;
-	/** Lexicographic ordering. */
-	bool operator<(const Vector& y) const;
-	bool operator<=(const Vector& y) const;
-	bool operator>(const Vector& y) const;
-	bool operator>=(const Vector& y) const;
+  /** Exact equality. */
+  bool operator==(const Vector &y) const;
+  bool operator!=(const Vector &y) const;
+  /** Lexicographic ordering. */
+  bool operator<(const Vector &y) const;
+  bool operator<=(const Vector &y) const;
+  bool operator>(const Vector &y) const;
+  bool operator>=(const Vector &y) const;
 
-	virtual ~Vector();
-	void zeros();
-	void nans();
-	void infs();
-	bool toBeDestroyed() const {return destroy;}
-	void rotatePair(double alpha, double beta1, double beta2, int i);
-	void add(double r, const Vector& v);
-	void add(double r, const ConstVector& v);
-	void add(const double* z, const Vector& v);
-	void add(const double* z, const ConstVector& v);
-	void mult(double r);
-	double getNorm() const;
-	double getMax() const;
-	double getNorm1() const;
-	double dot(const Vector& y) const;
-	bool isFinite() const;
-	void print() const;
+  virtual
+  ~Vector();
+  void zeros();
+  void nans();
+  void infs();
+  bool
+  toBeDestroyed() const
+  {
+    return destroy;
+  }
+  void rotatePair(double alpha, double beta1, double beta2, int i);
+  void add(double r, const Vector &v);
+  void add(double r, const ConstVector &v);
+  void add(const double *z, const Vector &v);
+  void add(const double *z, const ConstVector &v);
+  void mult(double r);
+  double getNorm() const;
+  double getMax() const;
+  double getNorm1() const;
+  double dot(const Vector &y) const;
+  bool isFinite() const;
+  void print() const;
 
-	/* multiplies | alpha -beta1|           |b1|   |x1|
-                  |             |\otimes I .|  | = |  |
-                  | -beta2 alpha|           |b2|   |x2|
-	*/
-	static void mult2(double alpha, double beta1, double beta2,
-					  Vector& x1, Vector& x2,
-					  const Vector& b1, const Vector& b2);
-	/* same, but adds instead of set */
-	static void mult2a(double alpha, double beta1, double beta2,
-					   Vector& x1, Vector& x2,
-					   const Vector& b1, const Vector& b2);
-	/* same, but subtracts instead of add */
-	static void mult2s(double alpha, double beta1, double beta2,
-					   Vector& x1, Vector& x2,
-					   const Vector& b1, const Vector& b2)
-		{mult2a(-alpha, -beta1, -beta2, x1, x2, b1, b2);}
+  /* multiplies | alpha -beta1|           |b1|   |x1|
+     |             |\otimes I .|  | = |  |
+     | -beta2 alpha|           |b2|   |x2|
+  */
+  static void mult2(double alpha, double beta1, double beta2,
+                    Vector &x1, Vector &x2,
+                    const Vector &b1, const Vector &b2);
+  /* same, but adds instead of set */
+  static void mult2a(double alpha, double beta1, double beta2,
+                     Vector &x1, Vector &x2,
+                     const Vector &b1, const Vector &b2);
+  /* same, but subtracts instead of add */
+  static void
+  mult2s(double alpha, double beta1, double beta2,
+         Vector &x1, Vector &x2,
+         const Vector &b1, const Vector &b2)
+  {
+    mult2a(-alpha, -beta1, -beta2, x1, x2, b1, b2);
+  }
 private:
-	void copy(const double* d, int inc);
-	const Vector& operator=(int); // must not be used (not implemented)
-	const Vector& operator=(double); // must not be used (not implemented)
+  void copy(const double *d, int inc);
+  const Vector &operator=(int); // must not be used (not implemented)
+  const Vector &operator=(double); // must not be used (not implemented)
 };
 
-
-class BaseConstVector {
+class BaseConstVector
+{
 protected:
-	int len;
-	int s;
-	const double* data;
+  int len;
+  int s;
+  const double *data;
 public:
-	BaseConstVector(int l, int si, const double* d) : len(l), s(si), data(d) {}
-	BaseConstVector(const BaseConstVector& v) : len(v.len), s(v.s), data(v.data) {}
-	const BaseConstVector& operator=(const BaseConstVector& v)
-		{len = v.len; s = v.s; data = v.data; return *this;}
-	const double& operator[](int i) const
-		{return data[s*i];}
-	const double* base() const
-		{return data;}
-	int length() const
-		{return len;}
-	int skip() const
-		{return s;}
+  BaseConstVector(int l, int si, const double *d) : len(l), s(si), data(d)
+  {
+  }
+  BaseConstVector(const BaseConstVector &v) : len(v.len), s(v.s), data(v.data)
+  {
+  }
+  const BaseConstVector &
+  operator=(const BaseConstVector &v)
+  {
+    len = v.len; s = v.s; data = v.data; return *this;
+  }
+  const double &
+  operator[](int i) const
+  {
+    return data[s*i];
+  }
+  const double *
+  base() const
+  {
+    return data;
+  }
+  int
+  length() const
+  {
+    return len;
+  }
+  int
+  skip() const
+  {
+    return s;
+  }
 };
 
 class ConstGeneralMatrix;
 
-class ConstVector : public BaseConstVector {
+class ConstVector : public BaseConstVector
+{
 public:
-	ConstVector(const Vector& v) : BaseConstVector(v.length(), v.skip(), v.base()) {}
-	ConstVector(const ConstVector& v) : BaseConstVector(v) {}
-	ConstVector(const double* d, int l) : BaseConstVector(l, 1, d) {}
-	ConstVector(const Vector& v, int off, int l);
-	ConstVector(const ConstVector& v, int off, int l);
-	ConstVector(const double* d, int skip, int l);
-	ConstVector(const ConstGeneralMatrix& m, int col);
-	ConstVector(int row, const ConstGeneralMatrix& m);
-	
-	virtual ~ConstVector() {}
-	/** Exact equality. */
-	bool operator==(const ConstVector& y) const;
-	bool operator!=(const ConstVector& y) const
-		{return ! operator==(y);}
-	/** Lexicographic ordering. */
-	bool operator<(const ConstVector& y) const;
-	bool operator<=(const ConstVector& y) const
-		{return operator<(y) || operator==(y);}
-	bool operator>(const ConstVector& y) const
-		{return ! operator<=(y);}
-	bool operator>=(const ConstVector& y) const
-		{return ! operator<(y);}
+  ConstVector(const Vector &v) : BaseConstVector(v.length(), v.skip(), v.base())
+  {
+  }
+  ConstVector(const ConstVector &v) : BaseConstVector(v)
+  {
+  }
+  ConstVector(const double *d, int l) : BaseConstVector(l, 1, d)
+  {
+  }
+  ConstVector(const Vector &v, int off, int l);
+  ConstVector(const ConstVector &v, int off, int l);
+  ConstVector(const double *d, int skip, int l);
+  ConstVector(const ConstGeneralMatrix &m, int col);
+  ConstVector(int row, const ConstGeneralMatrix &m);
 
-	double getNorm() const;
-	double getMax() const;
-	double getNorm1() const;
-	double dot(const ConstVector& y) const;
-	bool isFinite() const;
-	void print() const;
+  virtual ~ConstVector()
+  {
+  }
+  /** Exact equality. */
+  bool operator==(const ConstVector &y) const;
+  bool
+  operator!=(const ConstVector &y) const
+  {
+    return !operator==(y);
+  }
+  /** Lexicographic ordering. */
+  bool operator<(const ConstVector &y) const;
+  bool
+  operator<=(const ConstVector &y) const
+  {
+    return operator<(y) || operator==(y);
+  }
+  bool
+  operator>(const ConstVector &y) const
+  {
+    return !operator<=(y);
+  }
+  bool
+  operator>=(const ConstVector &y) const
+  {
+    return !operator<(y);
+  }
+
+  double getNorm() const;
+  double getMax() const;
+  double getNorm1() const;
+  double dot(const ConstVector &y) const;
+  bool isFinite() const;
+  void print() const;
 };
 
-class ZeroPad {
+class ZeroPad
+{
 public:
-	static const int length = 16;
+  static const int length = 16;
 private:
-	double pad[16];
+  double pad[16];
 public:
-	ZeroPad();
-	const double* getBase() const {return pad;} 
+  ZeroPad();
+  const double *
+  getBase() const
+  {
+    return pad;
+  }
 };
 
 #endif /* VECTOR_H */
 
-
 // Local Variables:
 // mode:C++
 // End:
diff --git a/dynare++/sylv/testing/MMMatrix.h b/dynare++/sylv/testing/MMMatrix.h
index e30842caf..f6afaa30d 100644
--- a/dynare++/sylv/testing/MMMatrix.h
+++ b/dynare++/sylv/testing/MMMatrix.h
@@ -12,31 +12,58 @@
 
 using namespace std;
 
-class MMException : public MallocAllocator {
-	string message;
+class MMException : public MallocAllocator
+{
+  string message;
 public:
-	MMException(string mes) : message(mes) {}
-	MMException(const char* mes) : message(mes) {}
-	const char* getMessage() const {return message.data();}
+  MMException(string mes) : message(mes)
+  {
+  }
+  MMException(const char *mes) : message(mes)
+  {
+  }
+  const char *
+  getMessage() const
+  {
+    return message.data();
+  }
 };
 
-class MMMatrixIn : public MallocAllocator {
-	double* data;
-	int rows;
-	int cols;
+class MMMatrixIn : public MallocAllocator
+{
+  double *data;
+  int rows;
+  int cols;
 public:
-	MMMatrixIn(const char* fname);
-	~MMMatrixIn();
-	const double* getData() const {return data;}
-	int size() const {return rows*cols;}
-	int row() const {return rows;}
-	int col() const {return cols;}
+  MMMatrixIn(const char *fname);
+  ~MMMatrixIn();
+  const double *
+  getData() const
+  {
+    return data;
+  }
+  int
+  size() const
+  {
+    return rows*cols;
+  }
+  int
+  row() const
+  {
+    return rows;
+  }
+  int
+  col() const
+  {
+    return cols;
+  }
 };
 
-class MMMatrixOut : public MallocAllocator {
+class MMMatrixOut : public MallocAllocator
+{
 public:
-	static void write(const char* fname, int rows, int cols, const double* data);
-	static void write(const char* fname, const GeneralMatrix& m);
+  static void write(const char *fname, int rows, int cols, const double *data);
+  static void write(const char *fname, const GeneralMatrix &m);
 };
 
 #endif /* MM_MATRIX_H */
diff --git a/dynare++/tl/testing/factory.h b/dynare++/tl/testing/factory.h
index fea223011..89f0b6be8 100644
--- a/dynare++/tl/testing/factory.h
+++ b/dynare++/tl/testing/factory.h
@@ -2,7 +2,7 @@
 /* Copyright 2004, Ondra Kamenik */
 
 #ifndef FACTORY_H
-#define FACTORY_H 
+#define FACTORY_H
 
 #include "symmetry.h"
 #include "int_sequence.h"
@@ -11,67 +11,78 @@
 #include "rfs_tensor.h"
 #include "t_container.h"
 
-class Factory {
-	void init(const Symmetry& s, const IntSequence& nvs);
-	void init(int dim, int nv);
-	void fillMatrix(TwoDMatrix& m) const;
+class Factory
+{
+  void init(const Symmetry &s, const IntSequence &nvs);
+  void init(int dim, int nv);
+  void fillMatrix(TwoDMatrix &m) const;
 public:
-	double get() const;
-	// this can be used with UGSTensor, FGSTensor
-	template <class _Ttype>
-	_Ttype* make(int r, const Symmetry& s, const IntSequence& nvs)
-		{
-			_Ttype* res = new _Ttype(r, TensorDimens(s, nvs));
-			init(s, nvs);
-			fillMatrix(*res);
-			return res;
-		}
+  double get() const;
+  // this can be used with UGSTensor, FGSTensor
+  template <class _Ttype>
+  _Ttype *
+  make(int r, const Symmetry &s, const IntSequence &nvs)
+  {
+    _Ttype *res = new _Ttype(r, TensorDimens(s, nvs));
+    init(s, nvs);
+    fillMatrix(*res);
+    return res;
+  }
 
-	// this can be used with FFSTensor, UFSTensor, FRTensor, URTensor
-	template <class _Ttype>
-	_Ttype* make(int r, int nv, int dim)
-		{
-			_Ttype* res = new _Ttype(r, nv, dim);
-			init(dim, nv);
-			fillMatrix(*res);
-			return res;
-		}
+  // this can be used with FFSTensor, UFSTensor, FRTensor, URTensor
+  template <class _Ttype>
+  _Ttype *
+  make(int r, int nv, int dim)
+  {
+    _Ttype *res = new _Ttype(r, nv, dim);
+    init(dim, nv);
+    fillMatrix(*res);
+    return res;
+  }
 
-	template <class _Ttype, class _Ctype>
-	_Ctype* makeCont(int r, const IntSequence& nvs, int maxdim)
-		{
-			int symnum = nvs.size();
-			_Ctype* res = new _Ctype(symnum);
-			for (int dim = 1; dim <= maxdim; dim++) {
-				if (symnum == 1) {
-					// full symmetry
-					Symmetry sym(dim);
-					_Ttype* t = make<_Ttype>(r, sym, nvs);
-					res->insert(t);
-				} else {
-					// general symmetry
-					for (int i = 0; i <= dim; i++) {
-						Symmetry sym(i, dim-i);
-						_Ttype* t = make<_Ttype>(r, sym, nvs);
-						res->insert(t);
-					}
-				}
-			}
-			return res;
-		}
+  template <class _Ttype, class _Ctype>
+  _Ctype *
+  makeCont(int r, const IntSequence &nvs, int maxdim)
+  {
+    int symnum = nvs.size();
+    _Ctype *res = new _Ctype(symnum);
+    for (int dim = 1; dim <= maxdim; dim++)
+      {
+        if (symnum == 1)
+          {
+            // full symmetry
+            Symmetry sym(dim);
+            _Ttype *t = make<_Ttype>(r, sym, nvs);
+            res->insert(t);
+          }
+        else
+          {
+            // general symmetry
+            for (int i = 0; i <= dim; i++)
+              {
+                Symmetry sym(i, dim-i);
+                _Ttype *t = make<_Ttype>(r, sym, nvs);
+                res->insert(t);
+              }
+          }
+      }
+    return res;
+  }
 
-	template <class _Ttype, class _Ptype>
-	_Ptype* makePoly(int r, int nv, int maxdim)
-		{
-			_Ptype* p = new _Ptype(r, nv);
-			for (int d = 1; d <= maxdim; d++) {
-				_Ttype* t = make<_Ttype>(r, nv, d);
-				p->insert(t);
-			}
-			return p;
-		}
+  template <class _Ttype, class _Ptype>
+  _Ptype *
+  makePoly(int r, int nv, int maxdim)
+  {
+    _Ptype *p = new _Ptype(r, nv);
+    for (int d = 1; d <= maxdim; d++)
+      {
+        _Ttype *t = make<_Ttype>(r, nv, d);
+        p->insert(t);
+      }
+    return p;
+  }
 
-	Vector* makeVector(int n);
+  Vector *makeVector(int n);
 };
 
 #endif
diff --git a/dynare++/tl/testing/monoms.h b/dynare++/tl/testing/monoms.h
index 94b34a3da..76c56e2a7 100644
--- a/dynare++/tl/testing/monoms.h
+++ b/dynare++/tl/testing/monoms.h
@@ -10,115 +10,121 @@
 #include "sparse_tensor.h"
 #include "Vector.h"
 
-class IntGenerator {
-	int maxim;
-	double probab;
+class IntGenerator
+{
+  int maxim;
+  double probab;
 public:
-	IntGenerator()
-		: maxim(5), probab(0.3) {}
-	void init(int nf, int ny, int nv, int nw, int nu, int mx, double prob);
-	int get() const;
+  IntGenerator()
+    : maxim(5), probab(0.3)
+  {
+  }
+  void init(int nf, int ny, int nv, int nw, int nu, int mx, double prob);
+  int get() const;
 };
 
 extern IntGenerator intgen;
 
-
-class Monom : public IntSequence {
+class Monom : public IntSequence
+{
 public:
-	Monom(int len); // generate a random monom
-	Monom(int len, int item); // generate monom whose items are the given item
-	double deriv(const IntSequence& vars) const;
-	// this = this*m^ex (in monomial sense)
-	void multiplyWith(int ex, const Monom& m);
-	void print() const;
+  Monom(int len); // generate a random monom
+  Monom(int len, int item); // generate monom whose items are the given item
+  double deriv(const IntSequence &vars) const;
+  // this = this*m^ex (in monomial sense)
+  void multiplyWith(int ex, const Monom &m);
+  void print() const;
 };
 
 class Monom2Vector;
-class Monom1Vector {
-	friend class Monom2Vector;
-	int nx;
-	int len;
-	Monom** const x;
+class Monom1Vector
+{
+  friend class Monom2Vector;
+  int nx;
+  int len;
+  Monom **const x;
 public:
-	Monom1Vector(int nxx, int l);
-	~Monom1Vector();
-	void deriv(const IntSequence& c, Vector& out) const;
-	FGSTensor* deriv(int dim) const;
-	void print() const;
+  Monom1Vector(int nxx, int l);
+  ~Monom1Vector();
+  void deriv(const IntSequence &c, Vector &out) const;
+  FGSTensor *deriv(int dim) const;
+  void print() const;
 };
 
 //class Monom3Vector;
-class Monom2Vector {
-	int ny;
-	int nu;
-	int len;
-	Monom** const y;
-	Monom** const u;
+class Monom2Vector
+{
+  int ny;
+  int nu;
+  int len;
+  Monom **const y;
+  Monom **const u;
 public:
-	// generate random vector of monom two vector
-	Monom2Vector(int nyy, int nuu, int l);
-	// calculate g(x(y,u))
-	Monom2Vector(const Monom1Vector& g, const Monom2Vector& xmon);
-	~Monom2Vector();
-	void deriv(const Symmetry& s, const IntSequence& c, Vector& out) const;
-	FGSTensor* deriv(const Symmetry& s) const;
-	FGSContainer* deriv(int maxdim) const;
-	void print() const;
+  // generate random vector of monom two vector
+  Monom2Vector(int nyy, int nuu, int l);
+  // calculate g(x(y,u))
+  Monom2Vector(const Monom1Vector &g, const Monom2Vector &xmon);
+  ~Monom2Vector();
+  void deriv(const Symmetry &s, const IntSequence &c, Vector &out) const;
+  FGSTensor *deriv(const Symmetry &s) const;
+  FGSContainer *deriv(int maxdim) const;
+  void print() const;
 };
 
-class Monom4Vector {
-	int len;
-	int nx1;
-	int nx2;
-	int nx3;
-	int nx4;
-	Monom** const x1;
-	Monom** const x2;
-	Monom** const x3;
-	Monom** const x4;
+class Monom4Vector
+{
+  int len;
+  int nx1;
+  int nx2;
+  int nx3;
+  int nx4;
+  Monom **const x1;
+  Monom **const x2;
+  Monom **const x3;
+  Monom **const x4;
 public:
-    /* random for g(y,u,sigma) */
-	Monom4Vector(int l, int ny, int nu);
-	/* random for G(y,u,u',sigma) */
-	Monom4Vector(int l, int ny, int nu, int nup);
-	/* random for f(y+,y,y-,u) */
-	Monom4Vector(int l, int nbigg, int ng, int ny, int nu);
-	/* substitution f(G(y,u,u',sigma),g(y,u,sigma),y,u) */
-	Monom4Vector(const Monom4Vector& f, const Monom4Vector& bigg,
-				 const Monom4Vector& g);
-	~Monom4Vector();
-	FSSparseTensor* deriv(int dim) const;
-	FGSTensor* deriv(const Symmetry& s) const;
-	void deriv(const Symmetry& s, const IntSequence& coor, Vector& out) const;
-	void print() const;
+  /* random for g(y,u,sigma) */
+  Monom4Vector(int l, int ny, int nu);
+  /* random for G(y,u,u',sigma) */
+  Monom4Vector(int l, int ny, int nu, int nup);
+  /* random for f(y+,y,y-,u) */
+  Monom4Vector(int l, int nbigg, int ng, int ny, int nu);
+  /* substitution f(G(y,u,u',sigma),g(y,u,sigma),y,u) */
+  Monom4Vector(const Monom4Vector &f, const Monom4Vector &bigg,
+               const Monom4Vector &g);
+  ~Monom4Vector();
+  FSSparseTensor *deriv(int dim) const;
+  FGSTensor *deriv(const Symmetry &s) const;
+  void deriv(const Symmetry &s, const IntSequence &coor, Vector &out) const;
+  void print() const;
 protected:
-	void init_random();
+  void init_random();
 };
 
-
-struct SparseDerivGenerator {
-	int maxdimen;
-	FGSContainer* bigg;
-	FGSContainer* g;
-	FGSContainer* rcont;
-	FSSparseTensor** const ts;
-	SparseDerivGenerator(int nf, int ny, int nu, int nup, int nbigg, int ng,
-						 int mx, double prob, int maxdim);
-	~SparseDerivGenerator();
+struct SparseDerivGenerator
+{
+  int maxdimen;
+  FGSContainer *bigg;
+  FGSContainer *g;
+  FGSContainer *rcont;
+  FSSparseTensor **const ts;
+  SparseDerivGenerator(int nf, int ny, int nu, int nup, int nbigg, int ng,
+                       int mx, double prob, int maxdim);
+  ~SparseDerivGenerator();
 };
 
-
-struct DenseDerivGenerator {
-	int maxdimen;
-	FGSContainer* xcont;
-	FGSContainer* rcont;
-	FGSTensor** const ts;
-	UGSContainer* uxcont;
-	UGSTensor** const uts;
-	DenseDerivGenerator(int ng, int nx, int ny, int nu,
-						int mx, double prob, int maxdim);
-	void unfold();
-	~DenseDerivGenerator();
+struct DenseDerivGenerator
+{
+  int maxdimen;
+  FGSContainer *xcont;
+  FGSContainer *rcont;
+  FGSTensor **const ts;
+  UGSContainer *uxcont;
+  UGSTensor **const uts;
+  DenseDerivGenerator(int ng, int nx, int ny, int nu,
+                      int mx, double prob, int maxdim);
+  void unfold();
+  ~DenseDerivGenerator();
 };
 
 #endif
diff --git a/dynare++/utils/cc/exception.h b/dynare++/utils/cc/exception.h
index 7f843b3ae..97de4863e 100644
--- a/dynare++/utils/cc/exception.h
+++ b/dynare++/utils/cc/exception.h
@@ -11,41 +11,54 @@
 #include <string>
 #include <algorithm>
 
-namespace ogu {
+namespace ogu
+{
 
-	/** A primitive exception. */
-	class Exception {
-		static const int file_length = 100;
-		static const int mes_length = 500;
-	protected:
-		char file[file_length];
-		int line;
-		char mes[mes_length];
-	public:
-		Exception(const char* f, int l, const char* m)
-			{
-				strncpy(file, f, file_length-1);
-				file[file_length-1] = '\0';
-				line = l;
-				strncpy(mes, m, std::min(mes_length-1,(int)strlen(m)));
-				mes[mes_length-1] = '\0';
-			}
-		Exception(const char* f, int l, const std::string& m)
-			{
-				strncpy(file, f, file_length-1);
-				file[file_length-1] = '\0';
-				line = l;
-				strncpy(mes, m.c_str(), std::min(mes_length-1,(int)m.length()));
-				mes[mes_length-1] = '\0';
-			}
-		virtual ~Exception() {}
-		void print(FILE* fd) const
-			{ fprintf(fd, "%s:%d: %s\n", file, line, mes); }
-		void print() const
-			{ print(stdout); }
-		const char* message() const
-			{ return mes; }
-	};
+  /** A primitive exception. */
+  class Exception
+  {
+    static const int file_length = 100;
+    static const int mes_length = 500;
+  protected:
+    char file[file_length];
+    int line;
+    char mes[mes_length];
+  public:
+    Exception(const char *f, int l, const char *m)
+    {
+      strncpy(file, f, file_length-1);
+      file[file_length-1] = '\0';
+      line = l;
+      strncpy(mes, m, std::min(mes_length-1, (int) strlen(m)));
+      mes[mes_length-1] = '\0';
+    }
+    Exception(const char *f, int l, const std::string &m)
+    {
+      strncpy(file, f, file_length-1);
+      file[file_length-1] = '\0';
+      line = l;
+      strncpy(mes, m.c_str(), std::min(mes_length-1, (int) m.length()));
+      mes[mes_length-1] = '\0';
+    }
+    virtual ~Exception()
+    {
+    }
+    void
+    print(FILE *fd) const
+    {
+      fprintf(fd, "%s:%d: %s\n", file, line, mes);
+    }
+    void
+    print() const
+    {
+      print(stdout);
+    }
+    const char *
+    message() const
+    {
+      return mes;
+    }
+  };
 };
 
 #endif
diff --git a/dynare++/utils/cc/memory_file.h b/dynare++/utils/cc/memory_file.h
index 79f08717e..a4937d14a 100644
--- a/dynare++/utils/cc/memory_file.h
+++ b/dynare++/utils/cc/memory_file.h
@@ -5,51 +5,69 @@
 #ifndef OGU_MEMORY_FILE
 #define OGU_MEMORY_FILE
 
-namespace ogu {
-	/** This function calculates an offset of a given position in a
-	 * given string. The position is given by the line number and by
-	 * the offset in the line (both starting from 1). */
-	int calc_pos_offset(int length, const char* str, int line, int col);
-	/** This function calculates a line number and column number of a
-	 * character given by the offset in the string. It is inverse to
-	 * calc_pos_offset. */
-	void calc_pos_line_and_col(int length, const char* str, int offset,
-							   int& line, int& col);
+namespace ogu
+{
+  /** This function calculates an offset of a given position in a
+   * given string. The position is given by the line number and by
+   * the offset in the line (both starting from 1). */
+  int calc_pos_offset(int length, const char *str, int line, int col);
+  /** This function calculates a line number and column number of a
+   * character given by the offset in the string. It is inverse to
+   * calc_pos_offset. */
+  void calc_pos_line_and_col(int length, const char *str, int offset,
+                             int &line, int &col);
 
-	/** This class opens a given file and makes its copy in memory and
-	 * appends it with the '\0' character. Since the type of length is
-	 * int, it can store files with size at most 4GB. If the file
-	 * could be opened for reading, data is NULL and length is -1. If
-	 * the file is empty but exists, len is zero and data points to a
-	 * newly allocated memory containing '\0' character at the end. */
-	class MemoryFile {
-	protected:
-		int len;
-		char* data;
-	public:
-		MemoryFile(const char* fname);
-		virtual ~MemoryFile()
-			{if (data) delete [] data;}
-		int length() const
-			{return len;}
-		const char* base() const
-			{return data;}
-		bool exists() const
-			{return len != -1;}
-		/** Return the offset of a character in the given line
-		 * (starting from 1) with the given offset in the line. */
-		int offset(int line, int lineoff) const
-			{return calc_pos_offset(len, data, line, lineoff);}
-		/** Return the line number and column number of the character
-		 * defined by the offset. */
-		void line_and_col(int offset, int& line, int& col) const
-			{calc_pos_line_and_col(len, data, offset, line, col);}
-	};
+  /** This class opens a given file and makes its copy in memory and
+   * appends it with the '\0' character. Since the type of length is
+   * int, it can store files with size at most 4GB. If the file
+   * could be opened for reading, data is NULL and length is -1. If
+   * the file is empty but exists, len is zero and data points to a
+   * newly allocated memory containing '\0' character at the end. */
+  class MemoryFile
+  {
+  protected:
+    int len;
+    char *data;
+  public:
+    MemoryFile(const char *fname);
+    virtual ~MemoryFile()
+    {
+      if (data)
+        delete [] data;
+    }
+    int
+    length() const
+    {
+      return len;
+    }
+    const char *
+    base() const
+    {
+      return data;
+    }
+    bool
+    exists() const
+    {
+      return len != -1;
+    }
+    /** Return the offset of a character in the given line
+     * (starting from 1) with the given offset in the line. */
+    int
+    offset(int line, int lineoff) const
+    {
+      return calc_pos_offset(len, data, line, lineoff);
+    }
+    /** Return the line number and column number of the character
+     * defined by the offset. */
+    void
+    line_and_col(int offset, int &line, int &col) const
+    {
+      calc_pos_line_and_col(len, data, offset, line, col);
+    }
+  };
 
-	
 };
 
-
 #endif
 
 // Local Variables:
diff --git a/dynare++/utils/cc/pascal_triangle.h b/dynare++/utils/cc/pascal_triangle.h
index 2e989aa57..66b4bac6b 100644
--- a/dynare++/utils/cc/pascal_triangle.h
+++ b/dynare++/utils/cc/pascal_triangle.h
@@ -7,43 +7,54 @@
 
 #include <vector>
 
-namespace ogu {
+namespace ogu
+{
 
-	using std::vector;
+  using std::vector;
 
-	class PascalRow : public vector<int> {
-		int k;
-	public:
-		PascalRow()
-			: vector<int>(), k(1)
-			{ push_back(2); }
-		void setFromPrevious(const PascalRow& prev);
-		void prolong(const PascalRow& prev);
-		void prolongFirst(int n);
-		void print() const;
-	};
+  class PascalRow : public vector<int>
+  {
+    int k;
+  public:
+    PascalRow()
+      : vector<int>(), k(1)
+    {
+      push_back(2);
+    }
+    void setFromPrevious(const PascalRow &prev);
+    void prolong(const PascalRow &prev);
+    void prolongFirst(int n);
+    void print() const;
+  };
 
-	class PascalTriangle {
-		vector<PascalRow> tr;
-	public:
-		PascalTriangle()
-			{tr.push_back(PascalRow());}
-		PascalTriangle(const PascalTriangle& triang)
-			: tr(triang.tr) {}
-		const PascalTriangle& operator=(const PascalTriangle& triang)
-			{ tr = triang.tr; return *this;}
-		int noverk(int n, int k);
-		void print() const;
-	protected:
-		void ensure(int n, int k);
-		int max_n() const;
-		int max_k() const;
-	};
+  class PascalTriangle
+  {
+    vector<PascalRow> tr;
+  public:
+    PascalTriangle()
+    {
+      tr.push_back(PascalRow());
+    }
+    PascalTriangle(const PascalTriangle &triang)
+      : tr(triang.tr)
+    {
+    }
+    const PascalTriangle &
+    operator=(const PascalTriangle &triang)
+    {
+      tr = triang.tr; return *this;
+    }
+    int noverk(int n, int k);
+    void print() const;
+  protected:
+    void ensure(int n, int k);
+    int max_n() const;
+    int max_k() const;
+  };
 };
 
 extern ogu::PascalTriangle ptriang;
 
-
 #endif
 
 // Local Variables:
diff --git a/examples/NK_baseline.mod b/examples/NK_baseline.mod
index 67afdec21..90954a4ed 100644
--- a/examples/NK_baseline.mod
+++ b/examples/NK_baseline.mod
@@ -155,18 +155,18 @@ sigma_m  =-5.85;
 Lambdamu=3.4e-3;
 LambdaA = 2.8e-3;
 
-LambdaYd= (LambdaA+alppha*Lambdamu)/(1-alppha);
 
 /*
 The following parameters are set in the steady state file as they depend on other 
-deep parameters that were estimated in the original study. Setting them in the
+deep parameters (some were estimated in the original study). Setting them in the
 steady state file means they are updated for every parameter draw in the MCMC
 algorithm, while the parameters initialized here are only set once for the initial
 values of the parameters they depend on:
 
-gammma1 as it depends on LambdaA, alppha, Lambdamu, betta, and delta
-Rbar =0 as it depends on PI, LambdaA, alppha, Lambdamu, and betta
-Lambdax
+gammma1=mu_z*mu_I/betta-(1-delta);
+R=1+(PIbar*mu_z/betta-1);
+Lambdax=exp(LambdaYd);
+LambdaYd= (LambdaA+alppha*Lambdamu)/(1-alppha);
 */
 
 
diff --git a/examples/NK_baseline_steadystate.m b/examples/NK_baseline_steadystate.m
index f7254b8fb..795c09979 100644
--- a/examples/NK_baseline_steadystate.m
+++ b/examples/NK_baseline_steadystate.m
@@ -36,6 +36,7 @@ d=1;
 phi=1;
 m=0;
 zeta=1;
+LambdaYd= (LambdaA+alppha*Lambdamu)/(1-alppha);
 mu_z=exp(LambdaYd);
 mu_I=exp(Lambdamu);
 mu_A=exp(LambdaA);
diff --git a/examples/fs2000.mod b/examples/fs2000.mod
index 5b7ac75b8..335937023 100644
--- a/examples/fs2000.mod
+++ b/examples/fs2000.mod
@@ -6,22 +6,26 @@
  * The data are in file "fsdat_simul.m", and have been artificially generated.
  * They are therefore different from the original dataset used by Schorfheide.
  *
- * The prior distribution follows the one originally specified in Schorfheide's paper.
- * Note that the beta prior for rho implies an asymptote and corresponding prior mode 
- * for rho at 0. It is generally recommended to avoid this extreme type of prior.  
+ * The prior distribution follows the one originally specified in Schorfheide's
+ * paper, except for parameter rho. In the paper, the elicited beta prior for rho
+ * implies an asymptote and corresponding prior mode at 0. It is generally
+ * recommended to avoid this extreme type of prior. Some optimizers, for instance
+ * mode_compute=12 (Mathworks' particleswarm algorithm) may find a posterior mode
+ * with rho equal to zero. We lowered the value of the prior standard deviation
+ * (changing .223 to .100) to remove the asymptote.
  *
  * The equations are taken from J. Nason and T. Cogley (1994): "Testing the
  * implications of long-run neutrality for monetary business cycle models",
  * Journal of Applied Econometrics, 9, S37-S70.
  * Note that there is an initial minus sign missing in equation (A1), p. S63.
  *
- * This implementation was written by Michel Juillard. Please note that the
+ * This implementation was originally written by Michel Juillard. Please note that the
  * following copyright notice only applies to this Dynare implementation of the
  * model.
  */
 
 /*
- * Copyright (C) 2004-2015 Dynare Team
+ * Copyright (C) 2004-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -109,7 +113,7 @@ alp, beta_pdf, 0.356, 0.02;
 bet, beta_pdf, 0.993, 0.002;
 gam, normal_pdf, 0.0085, 0.003;
 mst, normal_pdf, 1.0002, 0.007;
-rho, beta_pdf, 0.129, 0.223;
+rho, beta_pdf, 0.129, 0.100;
 psi, beta_pdf, 0.65, 0.05;
 del, beta_pdf, 0.01, 0.005;
 stderr e_a, inv_gamma_pdf, 0.035449, inf;
diff --git a/license.txt b/license.txt
index 76243fd5e..2decd038d 100644
--- a/license.txt
+++ b/license.txt
@@ -1,16 +1,15 @@
-Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: Dynare
-Upstream-Contact: Dynare Team, whose members in 2016 are:
+Upstream-Contact: Dynare Team, whose members in 2017 are:
                   Stéphane Adjemian <stephane.adjemian@univ-lemans.fr>
                   Houtan Bastani <houtan@dynare.org>
                   Michel Juillard <michel.juillard@mjui.fr>
                   Frédéric Karamé <frederic.karame@univ-lemans.fr>
                   Junior Maih <junior.maih@gmail.com>
                   Ferhat Mihoubi <fmihoubi@univ-evry.fr>
-                  George Perendia <george@perendia.orangehome.co.uk>
                   Johannes Pfeifer <jpfeifer@gmx.de>
-                  Marco Ratto <marco.ratto@jrc.ec.europa.eu>
-                  Sébastien Villemot <sebastien@dynare.org>
+                  Marco Ratto <marco.ratto@ec.europa.eu>
+                  Sébastien Villemot <sebastien.villemot@sciencespo.fr>
 Source: http://www.dynare.org
 
 Files: *
@@ -18,8 +17,8 @@ Copyright: 1996-2017 Dynare Team
 License: GPL-3+
 
 Files: matlab/AIM/SP*
-Copyright: public-domain
-License: public-domain
+Copyright: none
+License: public-domain-aim
  This code is in the public domain and may be used freely.
  However the authors would appreciate acknowledgement of the source by
  citation of any of the following papers:
@@ -86,6 +85,57 @@ Copyright: 2016 Benjamin Born and Johannes Pfeifer
            2016 Dynare Team
 License: GPL-3+
 
+Files: matlab/gsa/Morris_Measure_Groups.m
+       matlab/gsa/Sampling_Function_2.m
+Copyright: 2005 European Commission
+           2012 Dynare Team
+License: GPL-3+
+Comment: Written by Jessica Cariboni and Francesca Campolongo
+ Joint Research Centre, The European Commission,
+
+Files: matlab/gsa/cumplot.m
+       matlab/gsa/filt_mc_.m
+       matlab/gsa/gsa_plotmatrix.m
+       matlab/gsa/gsa_skewness.m
+       matlab/gsa/gsa_speed.m
+       matlab/gsa/log_trans_.m
+       matlab/gsa/map_calibration.m
+       matlab/gsa/map_ident_.m
+       matlab/gsa/mcf_analysis.m
+       matlab/gsa/myboxplot.m
+       matlab/gsa/myprctilecol.m
+       matlab/gsa/prior_draw_gsa.m
+       matlab/gsa/read_data.m
+       matlab/gsa/redform_map.m
+       matlab/gsa/redform_screen.m
+       matlab/gsa/scatter_mcf.m
+       matlab/gsa/smirnov.m
+       matlab/gsa/stab_map_.m
+       matlab/gsa/stab_map_1.m
+       matlab/gsa/stab_map_2.m
+       matlab/gsa/stand_.m
+       matlab/gsa/tcrit.m
+       matlab/gsa/teff.m
+       matlab/gsa/trank.m
+Copyright: 2011-2017 European Commission
+           2011-2017 Dynare Team
+License: GPL-3+
+
+Files: matlab/gsa/pick.m
+Copyright: none
+License: public-domain-jrc
+ This software has been developed at the Joint Research Centre of European Commission
+ by officers in the course of their official duties. This software is not subject to copyright
+ protection and is in the public domain. It is an experimental system. The Joint Research Centre
+ of European Commission assumes no responsibility whatsoever for its use by other parties
+ and makes no guarantees, expressed or implied, about its quality, reliability, or any other
+ characteristic. We would appreciate acknowledgement if the software is used.
+Comment: This file is part of GLUEWIN.
+ The program has been developed by M. Ratto, European Commission, Joint Research Centre,
+ Institute for the Protection and Security of The Citizen, Technological and Economic Risk Management,
+ Applied Statistics, as a deliverable of the IMPACT project
+ (EC Fifth Framework Programme, SCA Project, IST-1999-11313, DG-INFSO).
+
 Files: matlab/optimization/simpsa.m matlab/optimization/simpsaget.m matlab/optimization/simpsaset.m
 Copyright: 2005 Henning Schmidt, FCC, henning@fcc.chalmers.se
            2006 Brecht Donckels, BIOMATH, brecht.donckels@ugent.be
@@ -127,37 +177,24 @@ Copyright: 2005 Jos van der Geest <jos@jasen.nl>
            2013 Christophe Gouel
            2016 Dynare Team
 License: BSD-2-clause
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
- .
-     * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-     * Redistributions in binary form must reproduce the above copyright
-       notice, this list of conditions and the following disclaimer in
-       the documentation and/or other materials provided with the distribution
- .
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
 
 Files: matlab/lmmcp/lmmcp.m
 Copyright: 2005 Christian Kanzow and Stefania Petra
            2013 Christophe Gouel
            2014 Dynare Team
-License: permissive
+License: permissive-lmmcp
  Unlimited permission is granted to everyone to use, copy, modify or
  distribute this software.
 
-Files: doc/dynare.texi doc/*.tex doc/*.svg doc/*.dia doc/*.pdf doc/*.bib
+Files: matlab/utilities/graphics/distinguishable_colors.m
+Copyright: 2010-2011 Timothy E. Holy
+License: BSD-2-clause
+
+Files: matlab/utilities/graphics/colorspace.m
+Copyright: 2005-2010 Pascal Getreuer
+License: BSD-2-clause
+
+Files: doc/dynare.texi doc/*.tex doc/*.svg doc/*.pdf doc/*.bib
 Copyright: 1996-2017 Dynare Team
 License: GFDL-NIV-1.3+
 
@@ -206,7 +243,7 @@ Files: m4/ax_compare_version.m4
 Copyright: 2008 Tim Toolan <toolan@ele.uri.edu>
 License: permissive-autoconf
 
-Files: m4/ax_latex_bibtex_test.m4 m4/ax_latex_class.m4 m4/ax_tex_test.m4
+Files: m4/ax_latex_class.m4 m4/ax_tex_test.m4
 Copyright: 2008 Boretti Mathieu <boretti@eig.unige.ch>
            2009 Dynare Team
 License: LGPL-2.1+
@@ -235,7 +272,7 @@ Copyright: 1996-2011 Daniel Waggoner and Tao Zha
 License: GPL-3+
 
 Files: contrib/ms-sbvar/switch_dw/state_space/sbvar/dw_csminwel.c
- state_space/sbvar/dw_csminwel.h
+       contrib/ms-sbvar/switch_dw/state_space/sbvar/dw_csminwel.h
 Copyright: 1996 Christopher Sims
            2003 Karibzhanov, Waggoner and Zha
 License: GPL-3+
@@ -316,7 +353,7 @@ License: GPL-3+
 
 Files: contrib/dmm/randlib/*
 Copyright: none
-License: public-domain
+License: public-domain-dmm
  We place the Randlib code that we have written in the public domain.  
  .
                                  NO WARRANTY
@@ -336,6 +373,29 @@ License: public-domain
      ITS ANALYSIS BEING  RENDERED INACCURATE OR  LOSSES SUSTAINED  BY THIRD
      PARTIES) THE PROGRAM.
 
+License: BSD-2-clause
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+ .
+     * Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+     * Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the distribution
+ .
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
 License: GFDL-NIV-1.3+
  Permission is granted to copy, distribute and/or modify this document
  under the terms of the GNU Free Documentation License, Version 1.3 or
@@ -344,21 +404,6 @@ License: GFDL-NIV-1.3+
  .
  A copy of the license can be found at <http://www.gnu.org/licenses/fdl.txt>
 
-License: GPL-2+
- This program 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 2 of
- the License, or (at your option) any later version.
- .
- This program 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 this program.  If not, see
- <http://www.gnu.org/licenses/>.
-
 License: GPL-2+ with Autoconf exception
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
diff --git a/m4/ax_latex_bibtex_test.m4 b/m4/ax_latex_bibtex_test.m4
deleted file mode 100644
index 17ab4d57b..000000000
--- a/m4/ax_latex_bibtex_test.m4
+++ /dev/null
@@ -1,66 +0,0 @@
-# ===========================================================================
-#          http://www.nongnu.org/autoconf-archive/ax_latex_test.html
-# ===========================================================================
-#
-# OBSOLETE MACRO
-#
-#   Deprecated because of licensing issues. The Lesser GPL imposes licensing
-#   restrictions on the generated configure script unless it is augmented
-#   with an Autoconf Exception clause.
-#
-# SYNOPSIS
-#
-#   AX_LATEX_BIBTEX_TEST(FILEDATA,BIBDATA,VARIABLETOSET,[NOCLEAN])
-#
-# DESCRIPTION
-#
-#   This macros creates a bib file called contest.bib with BIBDATA,
-#   executes the latex application with FILEDATA as input, then runs
-#   bibtex on the resulting aux file, and finally sets VARIABLETOSET
-#   to yes or no depending on the result. If NOCLEAN is set, the folder
-#   used for the test is not deleted after testing.
-#
-#   The macro assumes that the variables PDFLATEX and BIBTEX are set.
-#
-#   Adapted from the macro AX_LATEX_TEST by Sébastien Villemot.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Boretti Mathieu <boretti@eig.unige.ch>
-#   Copyright (c) 2009 Dynare Team
-#
-#   This library is free software; you can redistribute it and/or modify it
-#   under the terms of the GNU Lesser General Public License as published by
-#   the Free Software Foundation; either version 2.1 of the License, or (at
-#   your option) any later version.
-#
-#   This library 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 Lesser
-#   General Public License for more details.
-#
-#   You should have received a copy of the GNU Lesser General Public License
-#   along with this library. If not, see <http://www.gnu.org/licenses/>.
-
-AC_DEFUN([AX_LATEX_BIBTEX_TEST],[
-rm -rf conftest.dir/.acltx
-AS_MKDIR_P([conftest.dir/.acltx])
-cd conftest.dir/.acltx
-m4_ifval([$3],[$3="no"; export $3;])
-cat > conftest.tex << ACLEOF
-$1
-ACLEOF
-cat > conftest.bib << ACLEOF
-$2
-ACLEOF
-$PDFLATEX conftest 2>&1 1>output
-$BIBTEX conftest 2>&1 1>output2 m4_ifval([$3],[&& $3=yes])
-cd ..
-cd ..
-sed 's/^/| /' conftest.dir/.acltx/conftest.tex >&5
-echo "$as_me:$LINENO: executing $PDFLATEX conftest" >&5
-sed 's/^/| /' conftest.dir/.acltx/output >&5
-echo "$as_me:$LINENO: executing $BIBTEX conftest" >&5
-sed 's/^/| /' conftest.dir/.acltx/output2 >&5
-m4_ifval([$4],,[rm -rf conftest.dir/.acltx])
-])
diff --git a/m4/ax_matlab_version.m4 b/m4/ax_matlab_version.m4
index 282d2ad54..6f01df9f2 100644
--- a/m4/ax_matlab_version.m4
+++ b/m4/ax_matlab_version.m4
@@ -22,6 +22,9 @@ AC_REQUIRE([AX_MATLAB])
 AC_MSG_CHECKING([for MATLAB version])
 if test "x$MATLAB_VERSION" != "x"; then
   case $MATLAB_VERSION in
+    *2017a | *2017A)
+      MATLAB_VERSION="9.2"
+      ;;
     *2016b | *2016B)
       MATLAB_VERSION="9.1"
       ;;
diff --git a/matlab/@dynTimeIndex/dynTimeIndex.m b/matlab/@dynTimeIndex/dynTimeIndex.m
deleted file mode 100644
index 323122c4b..000000000
--- a/matlab/@dynTimeIndex/dynTimeIndex.m
+++ /dev/null
@@ -1,61 +0,0 @@
-function t = dynTimeIndex() % --*-- Unitary tests --*--
-
-% t = dynTimeIndex()
-%
-% Constructor for the dynTimeIndex class.
-%
-% INPUTS:
-%  None.
-%
-% OUTPUTS:
-%  * t, dynTimeIndex object.
-%
-% DESCRIPTION:
-%  The dynTimeIndex object is used to shift backward or forward dseries objects. For instance, if ts
-%  is a dseries object and t is a dynTimeIndex object then the following expressions are equivalent:
-%
-%      us = ts.lag()
-%      us = ts.lag(1)
-%      us = lag(ts,1)
-%      us = ts(t-1)
-%
-%  This class has only one member: t = int8(0) when instantiated.
-
-% Copyright (C) 2013 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/>.
-
-t = struct();
-
-t.index = int8(0);
-
-t = class(t,'dynTimeIndex');
-
-%@test:1
-%$ % Instantiate a dynTimeIndex object
-%$ try
-%$     u = dynTimeIndex();
-%$     t(1) = 1;
-%$ catch
-%$     t(1) = 0;
-%$ end
-%$
-%$ if t(1)
-%$   t(2) = isa(u,'dynTimeIndex');
-%$ end
-%$
-%$ T = all(t);
-%@eof:1
\ No newline at end of file
diff --git a/matlab/@dynTimeIndex/minus.m b/matlab/@dynTimeIndex/minus.m
deleted file mode 100644
index dff65f42d..000000000
--- a/matlab/@dynTimeIndex/minus.m
+++ /dev/null
@@ -1,62 +0,0 @@
-function C = minus(A,B) % --*-- Unitary tests --*--
-
-% C = minus(A,B)
-%
-% Overloads binary minus operator.
-%
-% INPUTS:
-%  * A, dynTimeIndex object.
-%  * B, integer scalar.
-%
-% OUTPUTS:
-%  * C, dynTimeIndex object.
-%
-% EXAMPLE:
-%
-%  >> t = dynTimeIndex();
-%  >> t.index
-%
-%  ans =
-%
-%      0
-%
-%  >> s = t-1;
-%  >> s.index
-%
-%  ans =
-%
-%      -1
-%
-
-% Copyright (C) 2013 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 ~(isa(A,'dynTimeIndex') || isint(B))
-    error(['dynTimeIndex::plus: Input arguments ''' inputname(1) ''' and ''' inputname(2) ''' must be a dynTimeIndex object and an integer!'])
-end
-
-C = struct();
-C.index = A.index-B;
-C = class(C,'dynTimeIndex');
-
-%@test:1
-%$ a = dynTimeIndex();
-%$ b = a-1;
-%$ t(1) = isa(b,'dynTimeIndex');
-%$ t(2) = isequal(b.index,-int8(1));
-%$ T = all(t);
-%@eof:1
\ No newline at end of file
diff --git a/matlab/@dynTimeIndex/mpower.m b/matlab/@dynTimeIndex/mpower.m
deleted file mode 100644
index c4077caaa..000000000
--- a/matlab/@dynTimeIndex/mpower.m
+++ /dev/null
@@ -1,74 +0,0 @@
-function C = mpower(A,B) % --*-- Unitary tests --*--
-
-% C = mpower(A,B)
-%
-% Overloads binary mpower operator (^).
-%
-% INPUTS :
-%  * A, dynTimeIndex object.
-%  * B, integer scalar.
-%
-% OUTPUTS :
-%  * C, dynTimeIndex object.
-%
-% EXAMPLE 1 :
-%
-%  >> B = dynTimeIndex()-1;
-%  >> B
-%  B = <dynTimeIndex: -1>
-%  >> B^4
-%  ans = <dynTimeIndex: -4>
-%  >>
-%
-%  EXAMPLE 2 :
-%  This method can be used to apply the lead and lag methods an arbitrary number of times to a dseries object. For instance, if 
-%  ts is a dseries object, and if we define
-% 
-%  >> B = dynTimeIndex()-1;
-%  >> F = dynTimeIndex()+1;
-%
-%  B and F can be used as lag and lead operators and the following syntax:
-%
-%  >> us = ts(F^2);
-%
-%  is equivalent to
-%
-%  >> us = ts.lead(2)
-%
-%  or
-%
-%  >> us = ts.lead.lead
-%
-
-% Copyright (C) 2013 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 ~(isa(A,'dynTimeIndex') || isint(B))
-    error(['dynTimeIndex::mpower: Input arguments ''' inputname(1) ''' and ''' inputname(2) ''' must be a dynTimeIndex object and an integer!'])
-end
-
-C = struct();
-C.index = A.index*B;
-C = class(C,'dynTimeIndex');
-
-%@test:1
-%$ a = dynTimeIndex()+1;
-%$ b = a^2;
-%$ t(1) = isa(b,'dynTimeIndex');
-%$ t(2) = isequal(b.index,int8(2));
-%$ T = all(t);
-%@eof:1
\ No newline at end of file
diff --git a/matlab/@dynTimeIndex/plus.m b/matlab/@dynTimeIndex/plus.m
deleted file mode 100644
index 7b4752db9..000000000
--- a/matlab/@dynTimeIndex/plus.m
+++ /dev/null
@@ -1,62 +0,0 @@
-function C = plus(A,B) % --*-- Unitary tests --*--
-
-% C = plus(A,B)
-%
-% Overloads binary plus operator.
-%
-% INPUTS:
-%  * A, dynTimeIndex object.
-%  * B, integer scalar.
-%
-% OUTPUTS:
-%  * C, dynTimeIndex object.
-%
-% EXAMPLE:
-%
-%  >> t = dynTimeIndex();
-%  >> t.index
-%
-%  ans =
-%
-%      0
-%
-%  >> s = t+1;
-%  >> s.index
-%
-%  ans =
-%
-%      1
-%
-
-% Copyright (C) 2013 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 ~(isa(A,'dynTimeIndex') || isint(B))
-    error(['dynTimeIndex::plus: Input arguments ''' inputname(1) ''' and ''' inputname(2) ''' must be a dynTimeIndex object and an integer!'])
-end
-
-C = struct();
-C.index = A.index+B;
-C = class(C,'dynTimeIndex');
-
-%@test:1
-%$ a = dynTimeIndex();
-%$ b = a+1;
-%$ t(1) = isa(b,'dynTimeIndex');
-%$ t(2) = isequal(b.index,int8(1));
-%$ T = all(t);
-%@eof:1
\ No newline at end of file
diff --git a/matlab/@dynTimeIndex/subsref.m b/matlab/@dynTimeIndex/subsref.m
deleted file mode 100644
index 6c8aa79d4..000000000
--- a/matlab/@dynTimeIndex/subsref.m
+++ /dev/null
@@ -1,54 +0,0 @@
-function B = subsref(A,S) % --*-- Unitary tests --*--
-
-% B = subsref(A,S)
-%
-% Overloads the subsref method for dynTimeIndex class. This method only allows to get
-% the value of the field `index`.
-    
-% Copyright (C) 2013 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 length(S)>1
-    error('dynTimeIndex::subsref: Something is wrong in your syntax!')
-end
-
-if isequal(S.type,'.')
-    if isequal(S.subs,'index')
-        B = builtin('subsref', A, S(1));
-    else
-        error(['dynTimeIndex::subsref: ' S.subs  ' is not a known member!'])
-    end
-else
-    error('dynTimeIndex::subsref: Something is wrong in your syntax!')
-end
-
-%@test:1
-%$ % Instantiate a dynTimeIndex object
-%$ u = dynTimeIndex();
-%$ try
-%$    v = u.index;
-%$    t(1) = 1;
-%$ catch
-%$    t(1) = 0;
-%$ end
-%$
-%$ if t(1)
-%$    t(2) = isequal(v,int8(0));
-%$ end
-%$
-%$ T = all(t);
-%@eof:1
\ No newline at end of file
diff --git a/matlab/AHessian.m b/matlab/AHessian.m
index 561c380a0..f9d9db6e0 100644
--- a/matlab/AHessian.m
+++ b/matlab/AHessian.m
@@ -8,7 +8,7 @@ function [AHess, DLIK, LIK] = AHessian(T,R,Q,H,P,Y,DT,DYss,DOm,DH,DP,start,mf,ka
 % NOTE: the derivative matrices (DT,DR ...) are 3-dim. arrays with last
 % dimension equal to the number of structural parameters
 
-% Copyright (C) 2011-2016 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -26,123 +26,123 @@ function [AHess, DLIK, LIK] = AHessian(T,R,Q,H,P,Y,DT,DYss,DOm,DH,DP,start,mf,ka
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-    k = size(DT,3);                                 % number of structural parameters
-    smpl = size(Y,2);                               % Sample size.
-    pp   = size(Y,1);                               % Maximum number of observed variables.
-    mm   = size(T,2);                               % Number of state variables.
-    a    = zeros(mm,1);                             % State vector.
-    Om   = R*Q*transpose(R);                        % Variance of R times the vector of structural innovations.
-    t    = 0;                                       % Initialization of the time index.
-    oldK = 0;
-    notsteady   = 1;                                % Steady state flag.
-    F_singular  = 1;
+k = size(DT,3);                                 % number of structural parameters
+smpl = size(Y,2);                               % Sample size.
+pp   = size(Y,1);                               % Maximum number of observed variables.
+mm   = size(T,2);                               % Number of state variables.
+a    = zeros(mm,1);                             % State vector.
+Om   = R*Q*transpose(R);                        % Variance of R times the vector of structural innovations.
+t    = 0;                                       % Initialization of the time index.
+oldK = 0;
+notsteady   = 1;                                % Steady state flag.
+F_singular  = 1;
 
 lik  = zeros(smpl,1);                           % Initialization of the vector gathering the densities.
 LIK  = Inf;                                     % Default value of the log likelihood.
-if nargout > 1,
+if nargout > 1
     DLIK  = zeros(k,1);                             % Initialization of the score.
 end
-    AHess  = zeros(k,k);                             % Initialization of the Hessian
-    Da    = zeros(mm,k);                             % State vector.
-    Dv = zeros(length(mf),k);
-    
+AHess  = zeros(k,k);                             % Initialization of the Hessian
+Da    = zeros(mm,k);                             % State vector.
+Dv = zeros(length(mf),k);
+
 %     for ii = 1:k
-%         DOm = DR(:,:,ii)*Q*transpose(R) + R*DQ(:,:,ii)*transpose(R) + R*Q*transpose(DR(:,:,ii)); 
+%         DOm = DR(:,:,ii)*Q*transpose(R) + R*DQ(:,:,ii)*transpose(R) + R*Q*transpose(DR(:,:,ii));
 %     end
-    
-    while notsteady && t<smpl
-        t  = t+1;
-        v  = Y(:,t)-a(mf);
-        F  = P(mf,mf) + H;
-        if rcond(F) < kalman_tol
-            if ~all(abs(F(:))<kalman_tol)
-                return
-            else
-                a = T*a;
-                P = T*P*transpose(T)+Om;
-            end
+
+while notsteady && t<smpl
+    t  = t+1;
+    v  = Y(:,t)-a(mf);
+    F  = P(mf,mf) + H;
+    if rcond(F) < kalman_tol
+        if ~all(abs(F(:))<kalman_tol)
+            return
         else
-            F_singular = 0;
-            iF     = inv(F);
-            K      = P(:,mf)*iF;
-            lik(t) = log(det(F))+transpose(v)*iF*v;
-
-            [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K);
-            
-            		for ii = 1:k
-                        Dv(:,ii)   = -Da(mf,ii) - DYss(mf,ii);
-                        Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
-                        if t>=start && nargout > 1
-                            DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
-                        end
-                    end
-                    vecDPmf = reshape(DP(mf,mf,:),[],k);
-%                     iPmf = inv(P(mf,mf));
-                    if t>=start
-                        AHess = AHess + Dv'*iF*Dv + .5*(vecDPmf' * kron(iF,iF) * vecDPmf);
-                    end
-            a      = T*(a+K*v);                   
-            P      = T*(P-K*P(mf,:))*transpose(T)+Om;
-            DP     = DP1;
+            a = T*a;
+            P = T*P*transpose(T)+Om;
         end
-        notsteady = max(max(abs(K-oldK))) > riccati_tol;
-        oldK = K;
-    end
+    else
+        F_singular = 0;
+        iF     = inv(F);
+        K      = P(:,mf)*iF;
+        lik(t) = log(det(F))+transpose(v)*iF*v;
 
-    if F_singular
-        error('The variance of the forecast error remains singular until the end of the sample')
-    end
+        [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K);
 
-    
-    if t < smpl
-        t0 = t+1;
-        while t < smpl
-            t = t+1;
-            v = Y(:,t)-a(mf);
-                  	for ii = 1:k
-                        Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
-                        Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
-                if t>=start && nargout >1
-                   DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
-                end
-                    end
-             if t>=start
-                AHess = AHess + Dv'*iF*Dv; 
-             end   
-            a = T*(a+K*v);
-        lik(t) = transpose(v)*iF*v;
-        end
-        AHess = AHess + .5*(smpl-t0+1)*(vecDPmf' * kron(iF,iF) * vecDPmf);
-        if nargout > 1
         for ii = 1:k
-%             DLIK(ii,1)  = DLIK(ii,1) + (smpl-t0+1)*trace( iF*DF(:,:,ii) );
+            Dv(:,ii)   = -Da(mf,ii) - DYss(mf,ii);
+            Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
+            if t>=start && nargout > 1
+                DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
+            end
         end
+        vecDPmf = reshape(DP(mf,mf,:),[],k);
+        %                     iPmf = inv(P(mf,mf));
+        if t>=start
+            AHess = AHess + Dv'*iF*Dv + .5*(vecDPmf' * kron(iF,iF) * vecDPmf);
         end
-        lik(t0:smpl) = lik(t0:smpl) + log(det(F));
-%         for ii = 1:k;
-%             for jj = 1:ii
-%              H(ii,jj) = trace(iPmf*(.5*DP(mf,mf,ii)*iPmf*DP(mf,mf,jj) + Dv(:,ii)*Dv(:,jj)'));
-%             end
-%         end
-    end    
-    
-AHess = -AHess;  
-if nargout > 1,
+        a      = T*(a+K*v);
+        P      = T*(P-K*P(mf,:))*transpose(T)+Om;
+        DP     = DP1;
+    end
+    notsteady = max(max(abs(K-oldK))) > riccati_tol;
+    oldK = K;
+end
+
+if F_singular
+    error('The variance of the forecast error remains singular until the end of the sample')
+end
+
+
+if t < smpl
+    t0 = t+1;
+    while t < smpl
+        t = t+1;
+        v = Y(:,t)-a(mf);
+        for ii = 1:k
+            Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
+            Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
+            if t>=start && nargout >1
+                DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
+            end
+        end
+        if t>=start
+            AHess = AHess + Dv'*iF*Dv;
+        end
+        a = T*(a+K*v);
+        lik(t) = transpose(v)*iF*v;
+    end
+    AHess = AHess + .5*(smpl-t0+1)*(vecDPmf' * kron(iF,iF) * vecDPmf);
+    if nargout > 1
+        for ii = 1:k
+            %             DLIK(ii,1)  = DLIK(ii,1) + (smpl-t0+1)*trace( iF*DF(:,:,ii) );
+        end
+    end
+    lik(t0:smpl) = lik(t0:smpl) + log(det(F));
+    %         for ii = 1:k;
+    %             for jj = 1:ii
+    %              H(ii,jj) = trace(iPmf*(.5*DP(mf,mf,ii)*iPmf*DP(mf,mf,jj) + Dv(:,ii)*Dv(:,jj)'));
+    %             end
+    %         end
+end
+
+AHess = -AHess;
+if nargout > 1
     DLIK = DLIK/2;
 end
 % adding log-likelihhod constants
 lik = (lik + pp*log(2*pi))/2;
 
 LIK = sum(lik(start:end)); % Minus the log-likelihood.
-% end of main function    
-    
+                           % end of main function
+
 function [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K)
 
-            k      = size(DT,3);
-            tmp    = P-K*P(mf,:);
+k      = size(DT,3);
+tmp    = P-K*P(mf,:);
 
 for ii = 1:k
-    DF(:,:,ii)  = DP(mf,mf,ii) + DH(:,:,ii); 
+    DF(:,:,ii)  = DP(mf,mf,ii) + DH(:,:,ii);
     DiF(:,:,ii) = -iF*DF(:,:,ii)*iF;
     DK(:,:,ii)  = DP(:,mf,ii)*iF + P(:,mf)*DiF(:,:,ii);
     Dtmp        = DP(:,:,ii) - DK(:,:,ii)*P(mf,:) - K*DP(mf,:,ii);
@@ -150,6 +150,3 @@ for ii = 1:k
 end
 
 % end of computeDKalman
-
-
-            
\ No newline at end of file
diff --git a/matlab/AIM/SPAimerr.m b/matlab/AIM/SPAimerr.m
index 2894a89a7..646747928 100644
--- a/matlab/AIM/SPAimerr.m
+++ b/matlab/AIM/SPAimerr.m
@@ -1,4 +1,4 @@
-function e = SPAimerr(c);
+function e = SPAimerr(c)
 % e = aimerr(c);
 %
 % Interpret the return codes generated by the aim routines.
@@ -29,7 +29,7 @@ function e = SPAimerr(c);
 % Journal of Economic Dynamics and Control, 2010, vol. 34, issue 3,
 % pages 472-489
 
-    if(c==1)  e='Aim: unique solution.';
+if(c==1)  e='Aim: unique solution.';
 elseif(c==2)  e='Aim: roots not correctly computed by real_schur.';
 elseif(c==3)  e='Aim: too many big roots.';
 elseif(c==35) e='Aim: too many big roots, and q(:,right) is singular.';
diff --git a/matlab/AIM/SPAmalg.m b/matlab/AIM/SPAmalg.m
index 41307b445..c371a91b0 100644
--- a/matlab/AIM/SPAmalg.m
+++ b/matlab/AIM/SPAmalg.m
@@ -1,5 +1,5 @@
 function [b,rts,ia,nexact,nnumeric,lgroots,aimcode] = ...
-                        SPAmalg(h,neq,nlag,nlead,condn,uprbnd)
+    SPAmalg(h,neq,nlag,nlead,condn,uprbnd)
 %  [b,rts,ia,nexact,nnumeric,lgroots,aimcode] = ...
 %                       SPAmalg(h,neq,nlag,nlead,condn,uprbnd)
 %
@@ -8,9 +8,9 @@ function [b,rts,ia,nexact,nnumeric,lgroots,aimcode] = ...
 %  roots.  This procedure will fail if the companion matrix is
 %  defective and does not have a linearly independent set of
 %  eigenvectors associated with the big roots.
-% 
+%
 %  Input arguments:
-% 
+%
 %    h         Structural coefficient matrix (neq,neq*(nlag+1+nlead)).
 %    neq       Number of equations.
 %    nlag      Number of lags.
@@ -19,9 +19,9 @@ function [b,rts,ia,nexact,nnumeric,lgroots,aimcode] = ...
 %              by numeric_shift and reduced_form.
 %    uprbnd    Inclusive upper bound for the modulus of roots
 %              allowed in the reduced form.
-% 
+%
 %  Output arguments:
-% 
+%
 %    b         Reduced form coefficient matrix (neq,neq*nlag).
 %    rts       Roots returned by eig.
 %    ia        Dimension of companion matrix (number of non-trivial
@@ -57,7 +57,7 @@ function [b,rts,ia,nexact,nnumeric,lgroots,aimcode] = ...
 % pages 472-489
 
 b=[];rts=[];ia=[];nexact=[];nnumeric=[];lgroots=[];aimcode=[];
-if(nlag<1 || nlead<1) 
+if(nlag<1 || nlead<1)
     error('Aim_eig: model must have at least one lag and one lead');
 end
 % Initialization.
@@ -66,26 +66,26 @@ bcols=neq*nlag;q=zeros(qrows,qcols);rts=zeros(qcols,1);
 [h,q,iq,nexact]=SPExact_shift(h,q,iq,qrows,qcols,neq);
 if (iq>qrows)
     aimcode = 61;
-    return;
+    return
 end
 [h,q,iq,nnumeric]=SPNumeric_shift(h,q,iq,qrows,qcols,neq,condn);
 if (iq>qrows)
     aimcode = 62;
-    return;
+    return
 end
 [a,ia,js] = SPBuild_a(h,qcols,neq);
 if (ia ~= 0)
-    if any(any(isnan(a))) || any(any(isinf(a))) 
+    if any(any(isnan(a))) || any(any(isinf(a)))
         disp('A is NAN or INF')
-        aimcode=63; 
-        return 
-    end 
+        aimcode=63;
+        return
+    end
     [w,rts,lgroots,flag_trouble]=SPEigensystem(a,uprbnd,min(length(js),qrows-iq+1));
-    if flag_trouble==1; 
-        disp('Problem in SPEIG'); 
+    if flag_trouble==1
+        disp('Problem in SPEIG');
         aimcode=64;
         return
-    end 
+    end
     q = SPCopy_w(q,w,js,iq,qrows);
 end
 test=nexact+nnumeric+lgroots;
diff --git a/matlab/AIM/SPBuild_a.m b/matlab/AIM/SPBuild_a.m
index eb12473a8..5701d3bf1 100644
--- a/matlab/AIM/SPBuild_a.m
+++ b/matlab/AIM/SPBuild_a.m
@@ -41,9 +41,9 @@ hs(:,left) = -hs(:,right)\hs(:,left);
 a = zeros(qcols,qcols);
 
 if(qcols > neq)
-  eyerows = 1:qcols-neq;
-  eyecols = neq+1:qcols;
-  a(eyerows,eyecols) = eye(qcols-neq);
+    eyerows = 1:qcols-neq;
+    eyecols = neq+1:qcols;
+    a(eyerows,eyecols) = eye(qcols-neq);
 end
 hrows      = qcols-neq+1:qcols;
 a(hrows,:) = hs(:,left);
@@ -51,14 +51,14 @@ a(hrows,:) = hs(:,left);
 %  Delete inessential lags and build index array js.  js indexes the
 %  columns in the big transition matrix that correspond to the
 %  essential lags in the model.  They are the columns of q that will
-%  get the unstable left eigenvectors. 
+%  get the unstable left eigenvectors.
 
 js       = 1:qcols;
 zerocols = sum(abs(a)) == 0;
 while( any(zerocols) )
-  a(:,zerocols) = [];
-  a(zerocols,:) = [];
-  js(zerocols)  = [];
-  zerocols = sum(abs(a)) == 0;
+    a(:,zerocols) = [];
+    a(zerocols,:) = [];
+    js(zerocols)  = [];
+    zerocols = sum(abs(a)) == 0;
 end
 ia = length(js);
diff --git a/matlab/AIM/SPCopy_w.m b/matlab/AIM/SPCopy_w.m
index 714a1e274..82dafe40a 100644
--- a/matlab/AIM/SPCopy_w.m
+++ b/matlab/AIM/SPCopy_w.m
@@ -2,7 +2,7 @@ function  q = SPCopy_w(q,w,js,iq,qrows)
 % q = SPCopy_w(q,w,js,iq,qrows)
 %
 %  Copy the eigenvectors corresponding to the largest roots into the
-%  remaining empty rows and columns js of q 
+%  remaining empty rows and columns js of q
 
 % Author: Gary Anderson
 % Original file downloaded from:
@@ -30,7 +30,7 @@ function  q = SPCopy_w(q,w,js,iq,qrows)
 
 
 if(iq < qrows)
-   lastrows = iq+1:qrows;
-   wrows    = 1:length(lastrows);
-   q(lastrows,js) = w(:,wrows)';
+    lastrows = iq+1:qrows;
+    wrows    = 1:length(lastrows);
+    q(lastrows,js) = w(:,wrows)';
 end
diff --git a/matlab/AIM/SPEigensystem.m b/matlab/AIM/SPEigensystem.m
index 16855401a..61dd46069 100644
--- a/matlab/AIM/SPEigensystem.m
+++ b/matlab/AIM/SPEigensystem.m
@@ -30,7 +30,7 @@ function [w,rts,lgroots,flag_trouble] = SPEigensystem(a,uprbnd,rowsLeft)
 % Journal of Economic Dynamics and Control, 2010, vol. 34, issue 3,
 % pages 472-489
 
-opts.disp=0; 
+opts.disp=0;
 % next block is commented out because eigs() intermitently returns different rts
 %try
 %    [w,d]   = eigs(a',rowsLeft,'LM',opts);
@@ -39,24 +39,24 @@ opts.disp=0;
 %    [mag,k] = sort(-mag);
 %    rts     = rts(k);
 %catch
-    %disp('Catch in SPE');
-    %pause(0.5);
-    %aStr=datestr(clock);
-    %eval(['save ' regexprep(aStr,' ','')  ' a']);
-    try
-        [w,d]=eig(a');
-    catch
-        lasterr
-        w=[];rts=[];lgroots=[];
-        flag_trouble=1;
-        return
-    end
-    rts     = diag(d);
-    mag     = abs(rts);
-    [mag,k] = sort(-mag);
-    rts     = rts(k);
+%disp('Catch in SPE');
+%pause(0.5);
+%aStr=datestr(clock);
+%eval(['save ' regexprep(aStr,' ','')  ' a']);
+try
+    [w,d]=eig(a');
+catch
+    lasterr
+    w=[];rts=[];lgroots=[];
+    flag_trouble=1;
+    return
+end
+rts     = diag(d);
+mag     = abs(rts);
+[mag,k] = sort(-mag);
+rts     = rts(k);
 %end
-flag_trouble=0; 
+flag_trouble=0;
 
 %ws=SPSparse(w);
 ws=sparse(w);
@@ -65,7 +65,7 @@ ws       = ws(:,k);
 %  Given a complex conjugate pair of vectors W = [w1,w2], there is a
 %  nonsingular matrix D such that W*D = real(W) + imag(W).  That is to
 %  say, W and real(W)+imag(W) span the same subspace, which is all
-%  that aim cares about. 
+%  that aim cares about.
 
 ws = real(ws) + imag(ws);
 
diff --git a/matlab/AIM/SPExact_shift.m b/matlab/AIM/SPExact_shift.m
index c9034e319..5ba49aa11 100644
--- a/matlab/AIM/SPExact_shift.m
+++ b/matlab/AIM/SPExact_shift.m
@@ -36,12 +36,11 @@ right  = qcols+1:qcols+neq;
 zerorows = find( sum(abs( hs(:,right)' ))==0 );
 
 while( any(zerorows) && iq <= qrows )
-   nz = length(zerorows);
-   q(iq+1:iq+nz,:) = hs(zerorows,left);
-   hs(zerorows,:)   = SPShiftright(hs(zerorows,:),neq);
-   iq     = iq + nz;
-   nexact = nexact + nz;
-   zerorows = find( sum(abs( hs(:,right)' ))==0 );
+    nz = length(zerorows);
+    q(iq+1:iq+nz,:) = hs(zerorows,left);
+    hs(zerorows,:)   = SPShiftright(hs(zerorows,:),neq);
+    iq     = iq + nz;
+    nexact = nexact + nz;
+    zerorows = find( sum(abs( hs(:,right)' ))==0 );
 end
 h=full(hs);
-
diff --git a/matlab/AIM/SPNumeric_shift.m b/matlab/AIM/SPNumeric_shift.m
index cc1e1825f..27049ca0c 100644
--- a/matlab/AIM/SPNumeric_shift.m
+++ b/matlab/AIM/SPNumeric_shift.m
@@ -37,14 +37,14 @@ right    = qcols+1:qcols+neq;
 zerorows = find( abs(diag(R)) <= condn );
 
 while( any(zerorows) && iq <= qrows )
-   h=sparse(h);
-   Q=sparse(Q);
-   h = Q'*h;
-   nz = length(zerorows);
-   q(iq+1:iq+nz,:) = h(zerorows,left);
-   h(zerorows,:)   = SPShiftright( h(zerorows,:), neq );
-   iq       = iq + nz;
-   nnumeric = nnumeric + nz;
-   [Q,R,E] = qr( full(h(:,right)) );
-   zerorows = find( abs(diag(R)) <= condn );
+    h=sparse(h);
+    Q=sparse(Q);
+    h = Q'*h;
+    nz = length(zerorows);
+    q(iq+1:iq+nz,:) = h(zerorows,left);
+    h(zerorows,:)   = SPShiftright( h(zerorows,:), neq );
+    iq       = iq + nz;
+    nnumeric = nnumeric + nz;
+    [Q,R,E] = qr( full(h(:,right)) );
+    zerorows = find( abs(diag(R)) <= condn );
 end
diff --git a/matlab/AIM/SPObstruct.m b/matlab/AIM/SPObstruct.m
index 8620ca1b9..9d9206501 100644
--- a/matlab/AIM/SPObstruct.m
+++ b/matlab/AIM/SPObstruct.m
@@ -2,7 +2,7 @@ function scof = SPObstruct(cof,cofb,neq,nlag,nlead)
 % scof = SPObstruct(cof,cofb,neq,nlag,nlead)
 %
 % Construct the coefficients in the observable structure.
-%    
+%
 %   Input arguments:
 %
 %            cof    structural coefficients
@@ -51,17 +51,17 @@ qs=sparse(q);
 qs(1:rc,1:cc) = sparse(cofb);
 qcols = neq*(nlag+nlead);
 
-if( nlead > 1 ) 
-   for i = 1:nlead-1
-      rows = i*neq + (1:neq);
-      qs(rows,:) = SPShiftright( qs((rows-neq),:), neq );
-   end
+if( nlead > 1 )
+    for i = 1:nlead-1
+        rows = i*neq + (1:neq);
+        qs(rows,:) = SPShiftright( qs((rows-neq),:), neq );
+    end
 end
 
 l = (1: neq*nlag);
 r = (neq*nlag+1: neq*(nlag+nlead));
 
- qs(:,l) = - qs(:,r) \ qs(:,l);
+qs(:,l) = - qs(:,r) \ qs(:,l);
 
 minus =              1:       neq*(nlag+1);
 plus  = neq*(nlag+1)+1: neq*(nlag+1+nlead);
diff --git a/matlab/AIM/SPReduced_form.m b/matlab/AIM/SPReduced_form.m
index 3d5c88990..e7d60a180 100644
--- a/matlab/AIM/SPReduced_form.m
+++ b/matlab/AIM/SPReduced_form.m
@@ -1,4 +1,4 @@
-function [nonsing,b] = SPReduced_form(q,qrows,qcols,bcols,neq,condn);
+function [nonsing,b] = SPReduced_form(q,qrows,qcols,bcols,neq,condn)
 % [nonsing,b] = SPReduced_form(q,qrows,qcols,bcols,neq,b,condn);
 %
 % Compute reduced-form coefficient matrix, b.
@@ -38,7 +38,7 @@ if(nonsing)
     b = qs(1:neq,1:bcols);
     b = full(b);
 else  %rescale by dividing row by maximal qr element
-    %'inverse condition number small, rescaling '
+      %'inverse condition number small, rescaling '
     themax=max(abs(qs(:,right)),[],2);
     oneover = diag(1 ./ themax);
     nonsing = rcond(full(oneover *qs(:,right))) > condn;
@@ -48,4 +48,3 @@ else  %rescale by dividing row by maximal qr element
         b = full(b);
     end
 end
-
diff --git a/matlab/AIM/SPShiftright.m b/matlab/AIM/SPShiftright.m
index 8299ce516..704908484 100644
--- a/matlab/AIM/SPShiftright.m
+++ b/matlab/AIM/SPShiftright.m
@@ -3,7 +3,7 @@ function [y] = SPShiftright(x,n)
 % [y] = shiftright(x,n)
 %
 %  Shift the rows of x to the right by n columns, leaving zeros in the
-%  first n columns. 
+%  first n columns.
 
 % Original author: Gary Anderson
 % Original file downloaded from:
diff --git a/matlab/AIM/dynAIMsolver1.m b/matlab/AIM/dynAIMsolver1.m
index 2e23e0222..52a2ae6f9 100644
--- a/matlab/AIM/dynAIMsolver1.m
+++ b/matlab/AIM/dynAIMsolver1.m
@@ -1,20 +1,20 @@
 function [dr,aimcode,rts]=dynAIMsolver1(jacobia_,M_,dr)
 % function [dr,aimcode]=dynAIMsolver1(jacobia_,M_,dr)
-% Maps Dynare jacobia to AIM 1st order model solver designed and developed by Gary ANderson 
+% Maps Dynare jacobia to AIM 1st order model solver designed and developed by Gary ANderson
 % and derives the solution for gy=dr.hgx and gu=dr.hgu from the AIM outputs
-% AIM System is given as a sum: 
-% i.e. for i=-$...+&   SUM(Hi*xt+i)= £*zt, t = 0, . . . ,?
+% AIM System is given as a sum:
+% i.e. for i=-$...+&   SUM(Hi*xt+i)= £*zt, t = 0, . . . ,?
 % and its input as single array of matrices: [H-$...  Hi ... H+&]
-% and its solution as xt=SUM( Bi*xt+i) + @*£*zt for i=-$...-1 
-% with the output in form bb=[B-$...  Bi ... B-1] and @=inv(Ho+H1*B-1) 
-% Dynare jacobian = [fy'-$...  fy'i ... fy'+&  fu'] 
-% where [fy'-$...  fy'i ... fy'+&]=[H-$...  Hi ... H+&] and fu'= £
+% and its solution as xt=SUM( Bi*xt+i) + @*£*zt for i=-$...-1
+% with the output in form bb=[B-$...  Bi ... B-1] and @=inv(Ho+H1*B-1)
+% Dynare jacobian = [fy'-$...  fy'i ... fy'+&  fu']
+% where [fy'-$...  fy'i ... fy'+&]=[H-$...  Hi ... H+&] and fu'= £
 %
 % INPUTS
-%   jacobia_   [matrix]           1st order derivative of the model 
+%   jacobia_   [matrix]           1st order derivative of the model
 %   dr         [matlab structure] Decision rules for stochastic simulations.
-%   M_         [matlab structure] Definition of the model.           
-%    
+%   M_         [matlab structure] Definition of the model.
+%
 % OUTPUTS
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   aimcode    [integer]          1: the model defines variables uniquely
@@ -31,22 +31,22 @@ function [dr,aimcode,rts]=dynAIMsolver1(jacobia_,M_,dr)
 %      (c==63) e='Aim: A is NAN or INF.';
 %      (c==64) e='Aim: Problem in SPEIG.';
 %      else    e='Aimerr: return code not properly specified';
-%    
+%
 % SPECIAL REQUIREMENTS
-% Dynare use: 
+% Dynare use:
 %       1) the lognormal block in DR1 is being invoked for some models and changing
 %       values of ghx and ghy. We need to return the AIM output
 %       values before that block and run the block with the current returned values
-%       of gy (i.e. dr.ghx) and gu (dr.ghu) if it is needed even when the AIM is used  
+%       of gy (i.e. dr.ghx) and gu (dr.ghu) if it is needed even when the AIM is used
 %       (it does not depend on mjdgges output).
-%       
-%       2) passing in aa={Q'|1}*jacobia_ can produce ~ one order closer  
-%       results to the Dynare solutiion then when if plain jacobia_ is passed, 
-%       i.e. diff < e-14 for aa and diff < *e-13 for jacobia_ if Q' is used.  
 %
-% GP July 2008 
+%       2) passing in aa={Q'|1}*jacobia_ can produce ~ one order closer
+%       results to the Dynare solutiion then when if plain jacobia_ is passed,
+%       i.e. diff < e-14 for aa and diff < *e-13 for jacobia_ if Q' is used.
+%
+% GP July 2008
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -69,8 +69,8 @@ lags=M_.maximum_endo_lag; % no of lags and leads
 leads=M_.maximum_endo_lead;
 klen=(leads+lags+1);  % total lenght
 theAIM_H=zeros(neq, neq*klen); % alloc space
-lli=M_.lead_lag_incidence';  
-% "sparse" the compact jacobia into AIM H aray of matrices 
+lli=M_.lead_lag_incidence';
+% "sparse" the compact jacobia into AIM H aray of matrices
 % without exogenous shoc
 theAIM_H(:,find(lli(:)))=jacobia_(:,nonzeros(lli(:)));
 condn  = 1.e-10;%SPAmalg uses this in zero tests
@@ -102,7 +102,7 @@ if aimcode==1 %if OK
         col_order=[((i-1)*neq)+dr.order_var' col_order];
     end
     bb_ord= bb(dr.order_var,col_order); % derive ordered gy
-    
+
     % variables are present in the state space at the lag at which they
     % appear and at all smaller lags. The are ordered from smaller to
     % higher lag (reversed order of M_.lead_lag_incidence rows for lagged
@@ -117,7 +117,7 @@ if aimcode==1 %if OK
                   %theH0= theAIM_H (:,lags*neq+1: (lags+1)*neq);
                   %    theHP= theAIM_H (:,(M_.maximum_endo_lag+1)*neq+1: (M_.maximum_endo_lag+2)*neq);
                   %theHP= theAIM_H (:,(lags+1)*neq+1: (lags+2)*neq);
-        theAIM_Psi= - jacobia_(:, size(nonzeros(lli(:)))+1:end);% 
+        theAIM_Psi= - jacobia_(:, size(nonzeros(lli(:)))+1:end);%
                                                                 %? = inv(H0 + H1B1)
                                                                 %phi= (theH0+theHP*sparse(bb(:,(lags-1)*neq+1:end)))\eye( neq);
                                                                 %AIM_ghu=phi*theAIM_Psi;
@@ -137,8 +137,8 @@ else
     if aimcode < 1 || aimcode > 5  % too big exception, use mjdgges
         error('Error in AIM: aimcode=%d ; %s', aimcode, err);
     end
-    %    if aimcode > 5 
+    %    if aimcode > 5
     %        disp(['Error in AIM: aimcode=' sprintf('%d : %s',aimcode, err)]);
     %        aimcode=5;
-    %    end  
+    %    end
 end
diff --git a/matlab/AIM_first_order_solver.m b/matlab/AIM_first_order_solver.m
index fb3a99dc6..893deefb0 100644
--- a/matlab/AIM_first_order_solver.m
+++ b/matlab/AIM_first_order_solver.m
@@ -51,7 +51,7 @@ function [dr,info]=AIM_first_order_solver(jacobia,M,dr,qz_criterium)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,35 +67,34 @@ function [dr,info]=AIM_first_order_solver(jacobia,M,dr,qz_criterium)
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
-    info = 0;
-    
-    [dr,aimcode]=dynAIMsolver1(jacobia,M,dr);
 
-    if aimcode ~=1
-        info(1) = convertAimCodeToInfo(aimCode); %convert to be in the 100 range
-        info(2) = 1.0e+8;
-        return
+info = 0;
+
+[dr,aimcode]=dynAIMsolver1(jacobia,M,dr);
+
+if aimcode ~=1
+    info(1) = convertAimCodeToInfo(aimCode); %convert to be in the 100 range
+    info(2) = 1.0e+8;
+    return
+end
+A = kalman_transition_matrix(dr,M.nstatic+(1:M.nspred), 1:M.nspred,...
+                             M.exo_nbr);
+dr.eigval = eig(A);
+disp(dr.eigval)
+nd = size(dr.kstate,1);
+nba = nd-sum( abs(dr.eigval) < qz_criterium );
+
+nsfwrd = M.nsfwrd;
+
+if nba ~= nsfwrd
+    temp = sort(abs(dr.eigval));
+    if nba > nsfwrd
+        temp = temp(nd-nba+1:nd-nsfwrd)-1-qz_criterium;
+        info(1) = 3;
+    elseif nba < nsfwrd
+        temp = temp(nd-nsfwrd+1:nd-nba)-1-qz_criterium;
+        info(1) = 4;
     end
-    A = kalman_transition_matrix(dr,M.nstatic+(1:M.nspred), 1:M.nspred,...
-                                 M.exo_nbr);
-    dr.eigval = eig(A);
-    disp(dr.eigval)
-    nd = size(dr.kstate,1);
-    nba = nd-sum( abs(dr.eigval) < qz_criterium );
-
-    nsfwrd = M.nsfwrd;
-
-    if nba ~= nsfwrd
-        temp = sort(abs(dr.eigval));
-        if nba > nsfwrd
-            temp = temp(nd-nba+1:nd-nsfwrd)-1-qz_criterium;
-            info(1) = 3;
-        elseif nba < nsfwrd;
-            temp = temp(nd-nsfwrd+1:nd-nba)-1-qz_criterium;
-            info(1) = 4;
-        end
-        info(2) = temp'*temp;
-        return
-    end
-
+    info(2) = temp'*temp;
+    return
+end
diff --git a/matlab/CheckPath.m b/matlab/CheckPath.m
index c83005513..002c9bd17 100644
--- a/matlab/CheckPath.m
+++ b/matlab/CheckPath.m
@@ -2,7 +2,7 @@ function [DirectoryName, info] = CheckPath(type,dname)
 % Creates the subfolder "./M_.dname/type" if it does not exist yet.
 %
 % INPUTS
-%    type   [string]    Name of the subfolder. 
+%    type   [string]    Name of the subfolder.
 %    dname  [string]    Name of the directory
 %
 % OUTPUTS
@@ -12,7 +12,7 @@ function [DirectoryName, info] = CheckPath(type,dname)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2013 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/CutSample.m b/matlab/CutSample.m
index 5ec0881a8..1582ec883 100644
--- a/matlab/CutSample.m
+++ b/matlab/CutSample.m
@@ -16,7 +16,7 @@ function CutSample(M_, options_, estim_params_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2015 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -66,7 +66,7 @@ if (TotalNumberOfMhFiles-1)-(FirstMhFile+1)+1 > 0
 elseif TotalNumberOfMhFiles == 1
     record.KeepedDraws.Distribution = [];
 elseif TotalNumberOfMhFiles == 2 && FirstMhFile > 1
-    record.KeepedDraws.Distribution = [MAX_nruns-FirstLine+1 ; record.MhDraws(end,3)];  
+    record.KeepedDraws.Distribution = [MAX_nruns-FirstLine+1 ; record.MhDraws(end,3)];
 end
 
 % Save updated mh-history file.
diff --git a/matlab/DsgeSmoother.m b/matlab/DsgeSmoother.m
index f9e459e00..997904afc 100644
--- a/matlab/DsgeSmoother.m
+++ b/matlab/DsgeSmoother.m
@@ -1,8 +1,8 @@
 function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,decomp,trend_addition,state_uncertainty,M_,oo_,options_,bayestopt_] = DsgeSmoother(xparam1,gend,Y,data_index,missing_value,M_,oo_,options_,bayestopt_,estim_params_)
-% Estimation of the smoothed variables and innovations. 
-% 
-% INPUTS 
-%   o xparam1       [double]   (p*1) vector of (estimated) parameters. 
+% Estimation of the smoothed variables and innovations.
+%
+% INPUTS
+%   o xparam1       [double]   (p*1) vector of (estimated) parameters.
 %   o gend          [integer]  scalar specifying the number of observations ==> varargin{1}.
 %   o data          [double]   (n*T) matrix of data.
 %   o data_index    [cell]      1*smpl cell of column vectors of indices.
@@ -12,7 +12,7 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,de
 %   o options_      [structure] describing the options
 %   o bayestopt_    [structure] describing the priors
 %   o estim_params_ [structure] characterizing parameters to be estimated
-%  
+%
 % OUTPUTS
 %   o alphahat      [double]  (m*T) matrix, smoothed endogenous variables (a_{t|T})  (decision-rule order)
 %   o etahat        [double]  (r*T) matrix, smoothed structural shocks (r>=n is the number of shocks).
@@ -29,36 +29,36 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,de
 %                       matrices (meaningless for periods 1:d) (decision-rule order)
 %   o decomp        (K*m*r*(T+K)) 4D array of shock decomposition of k-step ahead
 %                       filtered variables (decision-rule order)
-%   o trend_addition [double] (n*T) pure trend component; stored in options_.varobs order         
+%   o trend_addition [double] (n*T) pure trend component; stored in options_.varobs order
 %   o state_uncertainty [double] (K,K,T) array, storing the uncertainty
 %                                   about the smoothed state (decision-rule order)
 %   o M_            [structure] decribing the model
 %   o oo_           [structure] storing the results
 %   o options_      [structure] describing the options
 %   o bayestopt_    [structure] describing the priors
-%  
+%
 % Notes:
 %   m:  number of endogenous variables (M_.endo_nbr)
 %   T:  number of Time periods (options_.nobs)
 %   r:  number of strucural shocks (M_.exo_nbr)
 %   n:  number of observables (length(options_.varobs))
 %   K:  maximum forecast horizon (max(options_.nk))
-% 
+%
 %   To get variables that are stored in decision rule order in order of declaration
 %   as in M_.endo_names, ones needs code along the lines of:
 %   variables_declaration_order(dr.order_var,:) = alphahat
-% 
-%   Defines bayestopt_.mf = bayestopt_.smoother_mf (positions of observed variables 
-%   and requested smoothed variables in decision rules (decision rule order)) and 
+%
+%   Defines bayestopt_.mf = bayestopt_.smoother_mf (positions of observed variables
+%   and requested smoothed variables in decision rules (decision rule order)) and
 %   passes it back via global variable
-% 
-% ALGORITHM 
-%   Diffuse Kalman filter (Durbin and Koopman)       
+%
+% ALGORITHM
+%   Diffuse Kalman filter (Durbin and Koopman)
 %
 % SPECIAL REQUIREMENTS
 %   None
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -97,7 +97,7 @@ end
 %------------------------------------------------------------------------------
 % 2. call model setup & reduction program
 %------------------------------------------------------------------------------
-oldoo.restrict_var_list = oo_.dr.restrict_var_list; 
+oldoo.restrict_var_list = oo_.dr.restrict_var_list;
 oldoo.restrict_columns = oo_.dr.restrict_columns;
 oo_.dr.restrict_var_list = bayestopt_.smoother_var_list;
 oo_.dr.restrict_columns = bayestopt_.smoother_restrict_columns;
@@ -133,8 +133,8 @@ mf    = bayestopt_.mf;
 % ------------------------------------------------------------------------------
 %  3. Initial condition of the Kalman filter
 % ------------------------------------------------------------------------------
-% 
-%  Here, Pinf and Pstar are determined. If the model is stationary, determine 
+%
+%  Here, Pinf and Pstar are determined. If the model is stationary, determine
 %  Pstar as the solution of the Lyapunov equation and set Pinf=[] (Notation follows
 %  Koopman/Durbin (2003), Journal of Time Series Analysis 24(1))
 %
@@ -169,7 +169,7 @@ elseif options_.lik_init == 3           % Diffuse Kalman filter
         kalman_algo = 3;
     else
         if ~all(all(abs(H-diag(diag(H)))<1e-14))% ie, the covariance matrix is diagonal...
-            %Augment state vector (follows Section 6.4.3 of DK (2012))
+                                                %Augment state vector (follows Section 6.4.3 of DK (2012))
             expanded_state_vector_for_univariate_filter=1;
             T  = blkdiag(T,zeros(vobs));
             np    = size(T,1);
@@ -240,30 +240,32 @@ if kalman_algo == 1 || kalman_algo == 3
 end
 
 if kalman_algo == 2 || kalman_algo == 4
-        if ~all(all(abs(H-diag(diag(H)))<1e-14))% ie, the covariance matrix is diagonal...
-            if ~expanded_state_vector_for_univariate_filter
-                %Augment state vector (follows Section 6.4.3 of DK (2012))
-                expanded_state_vector_for_univariate_filter=1;
-                Z   = [Z, eye(vobs)];
-                ST  = blkdiag(ST,zeros(vobs));
-                np  = size(ST,1);
-                Q   = blkdiag(Q,H);
-                R1  = blkdiag(R,eye(vobs));
-                if kalman_algo == 4
-                    %recompute Schur state space transformation with
-                    %expanded state space
-                    [Pstar,Pinf] = compute_Pinf_Pstar(mf,ST,R1,Q,options_.qz_criterium);
-                else
-                    Pstar = blkdiag(Pstar,H);
-                    Pinf  = blkdiag(Pinf,zeros(vobs));                    
-                end
-                %now reset H to 0
-                H   = zeros(vobs,vobs);
+    if ~all(all(abs(H-diag(diag(H)))<1e-14))% ie, the covariance matrix is diagonal...
+        if ~expanded_state_vector_for_univariate_filter
+            %Augment state vector (follows Section 6.4.3 of DK (2012))
+            expanded_state_vector_for_univariate_filter=1;
+            Z   = [Z, eye(vobs)];
+            ST  = blkdiag(ST,zeros(vobs));
+            np  = size(ST,1);
+            Q   = blkdiag(Q,H);
+            R1  = blkdiag(R,eye(vobs));
+            if kalman_algo == 4
+                %recompute Schur state space transformation with
+                %expanded state space
+                [Pstar,Pinf] = compute_Pinf_Pstar(mf,ST,R1,Q,options_.qz_criterium);
             else
-                %do nothing, state vector was already expanded
+                Pstar = blkdiag(Pstar,H);
+                if ~isempty(Pinf)
+                    Pinf  = blkdiag(Pinf,zeros(vobs));
+                end
             end
+            %now reset H to 0
+            H   = zeros(vobs,vobs);
+        else
+            %do nothing, state vector was already expanded
         end
-        
+    end
+
     [alphahat,epsilonhat,etahat,ahat,P,aK,PK,decomp,state_uncertainty] = missing_DiffuseKalmanSmootherH3_Z(ST, ...
                                                       Z,R1,Q,diag(H), ...
                                                       Pinf,Pstar,data1,vobs,np,smpl,data_index, ...
@@ -280,7 +282,7 @@ if expanded_state_vector_for_univariate_filter && (kalman_algo == 2 || kalman_al
     ahat = ahat(k,:);
     aK = aK(:,k,:,:);
     epsilonhat=etahat(end-vobs+1:end,:);
-    etahat=etahat(1:end-vobs,:);    
+    etahat=etahat(1:end-vobs,:);
     if ~isempty(PK)
         PK = PK(:,k,k,:);
     end
diff --git a/matlab/GetAllPosteriorDraws.m b/matlab/GetAllPosteriorDraws.m
index 88e80f918..0408da509 100644
--- a/matlab/GetAllPosteriorDraws.m
+++ b/matlab/GetAllPosteriorDraws.m
@@ -5,18 +5,18 @@ function Draws = GetAllPosteriorDraws(column, FirstMhFile, FirstLine, TotalNumbe
 %
 % INPUTS
 %    column:               column
-%    FirstMhFile:          first mh file 
+%    FirstMhFile:          first mh file
 %    FirstLine:            first line
-%    TotalNumberOfMhFile:  total number of mh file 
+%    TotalNumberOfMhFile:  total number of mh file
 %    NumberOfDraws:        number of draws
 
 % OUTPUTS
 %    Draws:                draws from posterior distribution
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2011 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,7 +55,7 @@ if nblck>1 && nargin<6
                 iline = 1;
             end
         end
-    else 
+    else
         for blck = 1:nblck
             iline=iline0;
             for file = FirstMhFile:TotalNumberOfMhFile
diff --git a/matlab/GetOneDraw.m b/matlab/GetOneDraw.m
index 82d4c088f..f8e2a0d63 100644
--- a/matlab/GetOneDraw.m
+++ b/matlab/GetOneDraw.m
@@ -5,15 +5,15 @@ function [xparams, logpost] = GetOneDraw(type)
 % INPUTS
 %    type:      [string]       'posterior': draw from MCMC draws
 %                              'prior': draw from prior
-%        
+%
 % OUTPUTS
 %    xparams:   vector of estimated parameters (drawn from posterior or prior distribution)
 %    logpost:   log of the posterior density of this parameter vector
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2015 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/GetPosteriorMeanVariance.m b/matlab/GetPosteriorMeanVariance.m
index d1e293587..22d9e6004 100644
--- a/matlab/GetPosteriorMeanVariance.m
+++ b/matlab/GetPosteriorMeanVariance.m
@@ -1,6 +1,6 @@
 function [mean,variance] = GetPosteriorMeanVariance(M,drop)
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -16,38 +16,38 @@ function [mean,variance] = GetPosteriorMeanVariance(M,drop)
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
-    MetropolisFolder = CheckPath('metropolis',M.dname);
-    FileName = M.fname;
-    BaseName = [MetropolisFolder filesep FileName];
-    load_last_mh_history_file(MetropolisFolder, FileName);
-    NbrDraws = sum(record.MhDraws(:,1));
-    NbrFiles = sum(record.MhDraws(:,2));
-    NbrBlocks = record.Nblck;
-    mean = 0;
-    variance = 0;
-    
-    NbrKeptDraws = 0;
-    for i=1:NbrBlocks
-        NbrDrawsCurrentBlock = 0;
-        for j=1:NbrFiles
-            o = load([BaseName '_mh' int2str(j) '_blck' int2str(i),'.mat']);
-            NbrDrawsCurrentFile = size(o.x2,1);
-            if NbrDrawsCurrentBlock + NbrDrawsCurrentFile <= drop*NbrDraws
-                NbrDrawsCurrentBlock = NbrDrawsCurrentBlock + NbrDrawsCurrentFile;
-                continue
-            elseif NbrDrawsCurrentBlock < drop*NbrDraws
-                FirstDraw = ceil(drop*NbrDraws - NbrDrawsCurrentBlock + 1);
-                x2 = o.x2(FirstDraw:end,:);
-            else
-                x2 = o.x2;
-            end
-            NbrKeptDrawsCurrentFile = size(x2,1);
-            %recursively compute mean and variance
-            mean = (NbrKeptDraws*mean + sum(x2)')/(NbrKeptDraws+NbrKeptDrawsCurrentFile);
-            x2Demeaned = bsxfun(@minus,x2,mean');
-            variance = (NbrKeptDraws*variance + x2Demeaned'*x2Demeaned)/(NbrKeptDraws+NbrKeptDrawsCurrentFile);
+
+MetropolisFolder = CheckPath('metropolis',M.dname);
+FileName = M.fname;
+BaseName = [MetropolisFolder filesep FileName];
+load_last_mh_history_file(MetropolisFolder, FileName);
+NbrDraws = sum(record.MhDraws(:,1));
+NbrFiles = sum(record.MhDraws(:,2));
+NbrBlocks = record.Nblck;
+mean = 0;
+variance = 0;
+
+NbrKeptDraws = 0;
+for i=1:NbrBlocks
+    NbrDrawsCurrentBlock = 0;
+    for j=1:NbrFiles
+        o = load([BaseName '_mh' int2str(j) '_blck' int2str(i),'.mat']);
+        NbrDrawsCurrentFile = size(o.x2,1);
+        if NbrDrawsCurrentBlock + NbrDrawsCurrentFile <= drop*NbrDraws
             NbrDrawsCurrentBlock = NbrDrawsCurrentBlock + NbrDrawsCurrentFile;
-            NbrKeptDraws = NbrKeptDraws + NbrKeptDrawsCurrentFile;
+            continue
+        elseif NbrDrawsCurrentBlock < drop*NbrDraws
+            FirstDraw = ceil(drop*NbrDraws - NbrDrawsCurrentBlock + 1);
+            x2 = o.x2(FirstDraw:end,:);
+        else
+            x2 = o.x2;
         end
+        NbrKeptDrawsCurrentFile = size(x2,1);
+        %recursively compute mean and variance
+        mean = (NbrKeptDraws*mean + sum(x2)')/(NbrKeptDraws+NbrKeptDrawsCurrentFile);
+        x2Demeaned = bsxfun(@minus,x2,mean');
+        variance = (NbrKeptDraws*variance + x2Demeaned'*x2Demeaned)/(NbrKeptDraws+NbrKeptDrawsCurrentFile);
+        NbrDrawsCurrentBlock = NbrDrawsCurrentBlock + NbrDrawsCurrentFile;
+        NbrKeptDraws = NbrKeptDraws + NbrKeptDrawsCurrentFile;
     end
+end
diff --git a/matlab/GetPosteriorParametersStatistics.m b/matlab/GetPosteriorParametersStatistics.m
index a7c910621..6bea8d66a 100644
--- a/matlab/GetPosteriorParametersStatistics.m
+++ b/matlab/GetPosteriorParametersStatistics.m
@@ -1,22 +1,22 @@
 function oo_ = GetPosteriorParametersStatistics(estim_params_, M_, options_, bayestopt_, oo_, pnames)
 % This function prints and saves posterior estimates after the mcmc
-% (+updates of oo_ & TeX output). 
-% 
-% INPUTS 
-%   estim_params_    [structure] 
+% (+updates of oo_ & TeX output).
+%
+% INPUTS
+%   estim_params_    [structure]
 %   M_               [structure]
 %   options_         [structure]
 %   bayestopt_       [structure]
 %   oo_              [structure]
 %   pnames           [char]        Array of char, names of the prior shapes available
-%  
-% OUTPUTS 
-%   oo_              [structure]  
+%
+% OUTPUTS
+%   oo_              [structure]
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,7 +34,7 @@ function oo_ = GetPosteriorParametersStatistics(estim_params_, M_, options_, bay
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 %if ~options_.mh_replic && options_.load_mh_file
-%   load([M_.fname '_results.mat'],'oo_'); 
+%   load([M_.fname '_results.mat'],'oo_');
 %end
 
 TeX     = options_.TeX;
@@ -48,7 +48,7 @@ nx      = nvx+nvn+ncx+ncn+np;
 
 MetropolisFolder = CheckPath('metropolis',M_.dname);
 OutputFolder = CheckPath('Output',M_.dname);
-FileName = M_.fname;  
+FileName = M_.fname;
 
 load_last_mh_history_file(MetropolisFolder,FileName);
 
@@ -108,14 +108,14 @@ if np
                 [post_mean, post_median, post_var, hpd_interval, post_deciles, ...
                  density] = posterior_moments(Draws,1,options_.mh_conf_sig);
                 name = bayestopt_.name{ip};
-                oo_ = Filloo(oo_,name,type,post_mean,hpd_interval,post_median,post_var,post_deciles,density);                
+                oo_ = Filloo(oo_,name,type,post_mean,hpd_interval,post_median,post_var,post_deciles,density);
             end
         end
         disp(sprintf(pformat,header_width,name,bayestopt_.p1(ip),...
                      post_mean, ...
                      hpd_interval, ...
                      pnames(bayestopt_.pshape(ip)+1,:), ...
-                     bayestopt_.p2(ip)));    
+                     bayestopt_.p2(ip)));
         if TeX
             k = estim_params_.param_vals(i,1);
             name = deblank(M_.param_names_tex(k,:));
@@ -163,7 +163,7 @@ if nvx
         end
         disp(sprintf(pformat,header_width,name,bayestopt_.p1(ip),post_mean,hpd_interval,...
                      pnames(bayestopt_.pshape(ip)+1,:),bayestopt_.p2(ip)));
-        if TeX,
+        if TeX
             name = deblank(M_.exo_names_tex(k,:));
             TeXCore(fid,name,deblank(pnames(bayestopt_.pshape(ip)+1,:)),bayestopt_.p1(ip),...
                     bayestopt_.p2(ip),post_mean,sqrt(post_var),hpd_interval);
@@ -171,7 +171,7 @@ if nvx
         ip = ip+1;
     end
     if TeX
-        TeXEnd(fid,2,'standard deviation of structural shocks');        
+        TeXEnd(fid,2,'standard deviation of structural shocks');
     end
 end
 if nvn
@@ -213,7 +213,7 @@ if nvn
         ip = ip+1;
     end
     if TeX
-        TeXEnd(fid,3,'standard deviation of measurement errors');        
+        TeXEnd(fid,3,'standard deviation of measurement errors');
     end
 end
 if ncx
@@ -311,15 +311,15 @@ if ncn
         end
         disp(sprintf(pformat, header_width,name,bayestopt_.p1(ip),post_mean,hpd_interval, ...
                      pnames(bayestopt_.pshape(ip)+1,:),bayestopt_.p2(ip)));
-        if TeX,
+        if TeX
             name = ['(',deblank(M_.endo_names_tex(k1,:)) ',' deblank(M_.endo_names_tex(k2,:)),')'];
             TeXCore(fid,name,deblank(pnames(bayestopt_.pshape(ip)+1,:)),bayestopt_.p1(ip),...
-                    bayestopt_.p2(ip),post_mean,sqrt(post_var),hpd_interval);            
+                    bayestopt_.p2(ip),post_mean,sqrt(post_var),hpd_interval);
         end
         ip = ip+1;
     end
     if TeX
-        TeXEnd(fid,5,'correlation of measurement errors');        
+        TeXEnd(fid,5,'correlation of measurement errors');
     end
 end
 
@@ -359,7 +359,7 @@ fid = fidTeX;
 
 
 function TeXCore(fid,name,shape,priormean,priorstd,postmean,poststd,hpd)
-fprintf(fid,['$%s$ & %s & %7.3f & %6.4f & %7.3f& %6.4f & %7.4f & %7.4f \\\\ \n'],... 
+fprintf(fid,['$%s$ & %s & %7.3f & %6.4f & %7.3f& %6.4f & %7.4f & %7.4f \\\\ \n'],...
         name,...
         shape,...
         priormean,...
@@ -371,7 +371,7 @@ fprintf(fid,['$%s$ & %s & %7.3f & %6.4f & %7.3f& %6.4f & %7.4f & %7.4f \\\\ \n']
 
 
 function TeXEnd(fid,fnum,title)
-fprintf(fid,'\\end{longtable}\n ');    
+fprintf(fid,'\\end{longtable}\n ');
 fprintf(fid,'\\end{center}\n');
 fprintf(fid,'%% End of TeX file.\n');
 fclose(fid);
diff --git a/matlab/MakeAllFigures.m b/matlab/MakeAllFigures.m
index 89f35dac6..6c3de53ab 100644
--- a/matlab/MakeAllFigures.m
+++ b/matlab/MakeAllFigures.m
@@ -1,6 +1,6 @@
 function MakeAllFigures(NumberOfPlots,Caption,FigureProperties,Info)
 
-% Copyright (C) 2005-2009 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -19,11 +19,11 @@ function MakeAllFigures(NumberOfPlots,Caption,FigureProperties,Info)
 
 global M_ options_
 
-FigHandle = figure('Name',FigureProperties.Name);  
+FigHandle = figure('Name',FigureProperties.Name);
 
 NAMES = cell(NumberOfPlots,1);
 if options_.TeX
-    TeXNAMES = cell(NumberOfPlots,1); 
+    TeXNAMES = cell(NumberOfPlots,1);
 end
 
 if NumberOfPlots == 9
@@ -53,7 +53,7 @@ elseif NumberOfPlots == 2
 elseif NumberOfPlots == 1
     nr = 1;
     nc = 1;
-end  
+end
 
 for plt = 1:NumberOfPlots
     eval(['NumberOfCurves = Info.Box' int2str(plt) '.Number;'])
@@ -138,7 +138,7 @@ for plt = 1:NumberOfPlots
             set(hh,'Color','r','LineStyle','-','LineWidth',2)
             %
             %
-        end  
+        end
     end
     axis([xmin xmax ymin ymax])
     title(NAMES{plt})
@@ -150,14 +150,14 @@ if Info.SaveFormat.Eps
     if isempty(Info.SaveFormat.Name)
         eval(['print -depsc2 ' M_.fname Info.SaveFormat.GenericName int2str(Info.SaveFormat.Number) '.eps']);
     else
-        eval(['print -depsc2 ' M_.fname Info.SaveFormat.GenericName Info.SaveFormat.Name '.eps']);  
+        eval(['print -depsc2 ' M_.fname Info.SaveFormat.GenericName Info.SaveFormat.Name '.eps']);
     end
 end
 if Info.SaveFormat.Pdf && ~isoctave
     if isempty(Info.SaveFormat.Name)
         eval(['print -dpdf ' M_.fname Info.SaveFormat.GenericName int2str(Info.SaveFormat.Number)]);
     else
-        eval(['print -dpdf ' M_.fname Info.SaveFormat.GenericName Info.SaveFormat.Name]);  
+        eval(['print -dpdf ' M_.fname Info.SaveFormat.GenericName Info.SaveFormat.Name]);
     end
 end
 if Info.SaveFormat.Fig && ~isoctave
diff --git a/matlab/PlotPosteriorDistributions.m b/matlab/PlotPosteriorDistributions.m
index 2ae183793..84ff775ea 100644
--- a/matlab/PlotPosteriorDistributions.m
+++ b/matlab/PlotPosteriorDistributions.m
@@ -4,19 +4,19 @@ function oo_ = PlotPosteriorDistributions(estim_params_, M_, options_, bayestopt
 % plots posterior distributions
 %
 % INPUTS
-%    estim_params_   [structure] 
+%    estim_params_   [structure]
 %    M_              [structure]
-%    options_        [structure] 
+%    options_        [structure]
 %    bayestopt_      [structure]
 %    oo_             [structure]
-%    
+%
 % OUTPUTS
-%    oo_             [structure]  
-%    
+%    oo_             [structure]
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2016 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,7 +49,7 @@ nn = sqrt(MaxNumberOfPlotPerFigure);
 
 figurename = 'Priors and posteriors';
 
-if TeX && any(strcmp('eps',cellstr(options_.graph_format)))    
+if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
     fidTeX = fopen([OutputDirectoryName '/' M_.fname '_PriorsAndPosteriors.tex'],'w');
     fprintf(fidTeX,'%% TeX eps-loader file generated by PlotPosteriorDistributions.m (Dynare).\n');
     fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
@@ -63,7 +63,7 @@ for i=1:npar
     subplotnum = subplotnum+1;
     if subplotnum == 1
         figunumber = figunumber+1;
-        hfig=dyn_figure(options_,'Name',figurename);
+        hfig=dyn_figure(options_.nodisplay,'Name',figurename);
     end
     [nam,texnam] = get_the_name(i,TeX,M_,estim_params_,options_);
     if subplotnum == 1
@@ -78,9 +78,9 @@ for i=1:npar
         end
     end
     [x2,f2,abscissa,dens,binf2,bsup2] = draw_prior_density(i,bayestopt_);
-    top2 = max(f2); 
+    top2 = max(f2);
     if i <= nvx
-        name = deblank(M_.exo_names(estim_params_.var_exo(i,1),:));  
+        name = deblank(M_.exo_names(estim_params_.var_exo(i,1),:));
         x1 = oo_.posterior_density.shocks_std.(name)(:,1);
         f1 = oo_.posterior_density.shocks_std.(name)(:,2);
         oo_.prior_density.shocks_std.(name)(:,1) = x2;
@@ -96,18 +96,18 @@ for i=1:npar
         oo_.prior_density.measurement_errors_std.(name)(:,2) = f2;
         if ~options_.mh_posterior_mode_estimation
             pmod = oo_.posterior_mode.measurement_errors_std.(name);
-        end     
+        end
     elseif i <= nvx+nvn+ncx
         j = i - (nvx+nvn);
         k1 = estim_params_.corrx(j,1);
         k2 = estim_params_.corrx(j,2);
-        name = [deblank(M_.exo_names(k1,:)) '_' deblank(M_.exo_names(k2,:))];  
+        name = [deblank(M_.exo_names(k1,:)) '_' deblank(M_.exo_names(k2,:))];
         x1 = oo_.posterior_density.shocks_corr.(name)(:,1);
         f1 = oo_.posterior_density.shocks_corr.(name)(:,2);
         oo_.prior_density.shocks_corr.(name)(:,1) = x2;
         oo_.prior_density.shocks_corr.(name)(:,2) = f2;
         if ~options_.mh_posterior_mode_estimation
-            pmod = oo_.posterior_mode.shocks_corr.(name);  
+            pmod = oo_.posterior_mode.shocks_corr.(name);
         end
     elseif i <= nvx+nvn+ncx+ncn
         j = i - (nvx+nvn+ncx);
@@ -151,13 +151,13 @@ for i=1:npar
     title(nam,'Interpreter','none');
     hold off;
     drawnow
-    if subplotnum == MaxNumberOfPlotPerFigure || i == npar;
-        dyn_saveas(hfig,[OutputDirectoryName '/' M_.fname '_PriorsAndPosteriors' int2str(figunumber)],options_);
+    if subplotnum == MaxNumberOfPlotPerFigure || i == npar
+        dyn_saveas(hfig,[OutputDirectoryName '/' M_.fname '_PriorsAndPosteriors' int2str(figunumber)],options_.nodisplay,options_.graph_format);
         if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fprintf(fidTeX,'\\begin{figure}[H]\n');
             for j = 1:size(NAMES,1)
                 fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(j,:)),deblank(TeXNAMES(j,:)));
-            end    
+            end
             fprintf(fidTeX,'\\centering\n');
             fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s/%s_PriorsAndPosteriors%s}\n',options_.figures.textwidth*min(subplotnum/nn,1),OutputDirectoryName,M_.fname,int2str(figunumber));
             fprintf(fidTeX,'\\caption{Priors and posteriors.}');
diff --git a/matlab/PosteriorIRF.m b/matlab/PosteriorIRF.m
index 8b086c5b9..157a5e3a1 100644
--- a/matlab/PosteriorIRF.m
+++ b/matlab/PosteriorIRF.m
@@ -16,7 +16,7 @@ function PosteriorIRF(type)
 % functions associated with it(the _core1 and _core2).
 % See also the comments posterior_sampler.m funtion.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -178,7 +178,7 @@ if strcmpi(type,'posterior')
     end
 end
 
-if ~strcmpi(type,'prior'),
+if ~strcmpi(type,'prior')
     localVars.x=x;
 end
 
@@ -202,16 +202,16 @@ localVars.ifil2=ifil2;
 localVars.MhDirectoryName=MhDirectoryName;
 
 % Like sequential execution!
-if isnumeric(options_.parallel),
+if isnumeric(options_.parallel)
     [fout] = PosteriorIRF_core1(localVars,1,B,0);
     nosaddle = fout.nosaddle;
 else
     % Parallel execution!
     [nCPU, totCPU, nBlockPerCPU] = distributeJobs(options_.parallel, 1, B);
-    for j=1:totCPU-1,
+    for j=1:totCPU-1
         nfiles = ceil(nBlockPerCPU(j)/MAX_nirfs_dsge);
         NumberOfIRFfiles_dsge(j+1) =NumberOfIRFfiles_dsge(j)+nfiles;
-        if MAX_nirfs_dsgevar,
+        if MAX_nirfs_dsgevar
             nfiles = ceil(nBlockPerCPU(j)/MAX_nirfs_dsgevar);
         else
             nfiles=0;
@@ -235,12 +235,17 @@ else
     % which files have to be copied to run remotely
     NamFileInput(1,:) = {'',[M_.fname '_static.m']};
     NamFileInput(2,:) = {'',[M_.fname '_dynamic.m']};
-    if options_.steadystate_flag,
-        NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate.m']};
+    NamFileInput(3,:) = {'',[M_.fname '_set_auxiliary_variables.m']};
+    if options_.steadystate_flag
+        if options_.steadystate_flag == 1
+            NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate.m']};
+        else
+            NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate2.m']};
+        end
     end
     [fout] = masterParallel(options_.parallel, 1, B,NamFileInput,'PosteriorIRF_core1', localVars, globalVars, options_.parallel_info);
     nosaddle=0;
-    for j=1:length(fout),
+    for j=1:length(fout)
         nosaddle = nosaddle + fout(j).nosaddle;
     end
 
@@ -363,101 +368,101 @@ end
 % PosteriorIRF_core2.m function.
 
 if ~options_.nograph && ~options_.no_graph.posterior
-% Save the local variables.
-localVars=[];
+    % Save the local variables.
+    localVars=[];
 
-Check=options_.TeX;
-if (Check)
-    localVars.varlist_TeX=varlist_TeX;
-end
-
-
-localVars.nvar=nvar;
-localVars.MeanIRF=MeanIRF;
-localVars.tit=tit;
-localVars.nn=nn;
-localVars.MAX_nirfs_dsgevar=MAX_nirfs_dsgevar;
-localVars.HPDIRF=HPDIRF;
-localVars.varlist=varlist;
-localVars.MaxNumberOfPlotPerFigure=MaxNumberOfPlotPerFigure;
-if options_.dsge_var
-    localVars.HPDIRFdsgevar=HPDIRFdsgevar;
-    localVars.MeanIRFdsgevar = MeanIRFdsgevar;
-end
-
-% The files .TeX are genereted in sequential way always!
-
-% The files .TeX are generated in sequential way always!
-subplotnum = 0;
-tit_TeX(M_.exo_names_orig_ord,:) = M_.exo_names_tex;
-if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
-    fidTeX = fopen([DirectoryName filesep M_.fname '_BayesianIRF.tex'],'w');
-    fprintf(fidTeX,'%% TeX eps-loader file generated by PosteriorIRF.m (Dynare).\n');
-    fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
-    fprintf(fidTeX,' \n');
-    titTeX(M_.exo_names_orig_ord,:) = M_.exo_names_tex;
-
-    for ii=irf_shocks_indx
-        figunumber = 0;
-
-        for jj=1:nvar
-            if max(abs(MeanIRF(:,jj,ii))) >= options_.impulse_responses.plot_threshold
-                subplotnum = subplotnum+1;
-                
-                if subplotnum == 1 
-                    fprintf(fidTeX,'\\begin{figure}[H]\n');    
-                end
-                name = deblank(varlist(jj,:));
-                texname = deblank(varlist_TeX(jj,:));
-                fprintf(fidTeX,['\\psfrag{%s}[1][][0.5][0]{%s}\n'],name,['$' texname '$']);
-            end
-            if subplotnum == MaxNumberOfPlotPerFigure || (jj == nvar  && subplotnum> 0)
-                figunumber = figunumber+1;
-                
-                fprintf(fidTeX,'\\centering \n');
-                fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s/%s_Bayesian_IRF_%s_%d}\n',options_.figures.textwidth*min(subplotnum/nn,1),DirectoryName,M_.fname,deblank(tit(ii,:)),figunumber);
-                if options_.relative_irf
-                    fprintf(fidTeX,['\\caption{Bayesian relative IRF.}']);
-                else
-                    fprintf(fidTeX,'\\caption{Bayesian IRF: Orthogonalized shock to $%s$.}\n',deblank(tit_TeX(ii,:)));
-                end
-                fprintf(fidTeX,'\\label{Fig:BayesianIRF:%s:%d}\n',deblank(tit(ii,:)),figunumber);
-                fprintf(fidTeX,'\\end{figure}\n');
-                fprintf(fidTeX,' \n');
-                
-                subplotnum = 0;
-            end        
-        end
+    Check=options_.TeX;
+    if (Check)
+        localVars.varlist_TeX=varlist_TeX;
     end
-    fprintf(fidTeX,'%% End of TeX file.\n');
-    fclose(fidTeX);
-end
-
-% The others file format are generated in parallel by PosteriorIRF_core2!
 
 
-% Comment for testing!
-if ~isoctave
-    if isnumeric(options_.parallel)  || (M_.exo_nbr*ceil(size(varlist,1)/MaxNumberOfPlotPerFigure))<8,
-        [fout] = PosteriorIRF_core2(localVars,1,M_.exo_nbr,0);
-    else
-        isRemoteOctave = 0;
-        for indPC=1:length(options_.parallel),
-            isRemoteOctave = isRemoteOctave + (findstr(options_.parallel(indPC).MatlabOctavePath, 'octave'));
+    localVars.nvar=nvar;
+    localVars.MeanIRF=MeanIRF;
+    localVars.tit=tit;
+    localVars.nn=nn;
+    localVars.MAX_nirfs_dsgevar=MAX_nirfs_dsgevar;
+    localVars.HPDIRF=HPDIRF;
+    localVars.varlist=varlist;
+    localVars.MaxNumberOfPlotPerFigure=MaxNumberOfPlotPerFigure;
+    if options_.dsge_var
+        localVars.HPDIRFdsgevar=HPDIRFdsgevar;
+        localVars.MeanIRFdsgevar = MeanIRFdsgevar;
+    end
+
+    % The files .TeX are genereted in sequential way always!
+
+    % The files .TeX are generated in sequential way always!
+    subplotnum = 0;
+    tit_TeX(M_.exo_names_orig_ord,:) = M_.exo_names_tex;
+    if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
+        fidTeX = fopen([DirectoryName filesep M_.fname '_BayesianIRF.tex'],'w');
+        fprintf(fidTeX,'%% TeX eps-loader file generated by PosteriorIRF.m (Dynare).\n');
+        fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
+        fprintf(fidTeX,' \n');
+        titTeX(M_.exo_names_orig_ord,:) = M_.exo_names_tex;
+
+        for ii=irf_shocks_indx
+            figunumber = 0;
+
+            for jj=1:nvar
+                if max(abs(MeanIRF(:,jj,ii))) >= options_.impulse_responses.plot_threshold
+                    subplotnum = subplotnum+1;
+
+                    if subplotnum == 1
+                        fprintf(fidTeX,'\\begin{figure}[H]\n');
+                    end
+                    name = deblank(varlist(jj,:));
+                    texname = deblank(varlist_TeX(jj,:));
+                    fprintf(fidTeX,['\\psfrag{%s}[1][][0.5][0]{%s}\n'],name,['$' texname '$']);
+                end
+                if subplotnum == MaxNumberOfPlotPerFigure || (jj == nvar  && subplotnum> 0)
+                    figunumber = figunumber+1;
+
+                    fprintf(fidTeX,'\\centering \n');
+                    fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s/%s_Bayesian_IRF_%s_%d}\n',options_.figures.textwidth*min(subplotnum/nn,1),DirectoryName,M_.fname,deblank(tit(ii,:)),figunumber);
+                    if options_.relative_irf
+                        fprintf(fidTeX,['\\caption{Bayesian relative IRF.}']);
+                    else
+                        fprintf(fidTeX,'\\caption{Bayesian IRF: Orthogonalized shock to $%s$.}\n',deblank(tit_TeX(ii,:)));
+                    end
+                    fprintf(fidTeX,'\\label{Fig:BayesianIRF:%s:%d}\n',deblank(tit(ii,:)),figunumber);
+                    fprintf(fidTeX,'\\end{figure}\n');
+                    fprintf(fidTeX,' \n');
+
+                    subplotnum = 0;
+                end
+            end
         end
-        if isRemoteOctave
+        fprintf(fidTeX,'%% End of TeX file.\n');
+        fclose(fidTeX);
+    end
+
+    % The others file format are generated in parallel by PosteriorIRF_core2!
+
+
+    % Comment for testing!
+    if ~isoctave
+        if isnumeric(options_.parallel)  || (M_.exo_nbr*ceil(size(varlist,1)/MaxNumberOfPlotPerFigure))<8
             [fout] = PosteriorIRF_core2(localVars,1,M_.exo_nbr,0);
         else
-            globalVars = struct('M_',M_, ...
-                'options_', options_);
+            isRemoteOctave = 0;
+            for indPC=1:length(options_.parallel)
+                isRemoteOctave = isRemoteOctave + (findstr(options_.parallel(indPC).MatlabOctavePath, 'octave'));
+            end
+            if isRemoteOctave
+                [fout] = PosteriorIRF_core2(localVars,1,M_.exo_nbr,0);
+            else
+                globalVars = struct('M_',M_, ...
+                                    'options_', options_);
 
-            [fout] = masterParallel(options_.parallel, 1, M_.exo_nbr,NamFileInput,'PosteriorIRF_core2', localVars, globalVars, options_.parallel_info);
+                [fout] = masterParallel(options_.parallel, 1, M_.exo_nbr,NamFileInput,'PosteriorIRF_core2', localVars, globalVars, options_.parallel_info);
+            end
         end
+    else
+        [fout] = PosteriorIRF_core2(localVars,1,M_.exo_nbr,0);
     end
-else
-    [fout] = PosteriorIRF_core2(localVars,1,M_.exo_nbr,0);
-end
-% END parallel code!
+    % END parallel code!
 
 end
 
diff --git a/matlab/PosteriorIRF_core1.m b/matlab/PosteriorIRF_core1.m
index 37f98209b..561104f67 100644
--- a/matlab/PosteriorIRF_core1.m
+++ b/matlab/PosteriorIRF_core1.m
@@ -23,7 +23,7 @@ function myoutput=PosteriorIRF_core1(myinputs,fpar,B,whoiam, ThisMatlab)
 % SPECIAL REQUIREMENTS.
 %   None.
 %
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,7 +43,7 @@ function myoutput=PosteriorIRF_core1(myinputs,fpar,B,whoiam, ThisMatlab)
 
 global options_ estim_params_ oo_ M_ bayestopt_ dataset_ dataset_info
 
-if nargin<4,
+if nargin<4
     whoiam=0;
 end
 
@@ -55,7 +55,7 @@ irun =myinputs.irun;
 irun2=myinputs.irun2;
 npar=myinputs.npar;
 type=myinputs.type;
-if ~strcmpi(type,'prior'),
+if ~strcmpi(type,'prior')
     x=myinputs.x;
 end
 
@@ -102,7 +102,7 @@ end
 RemoteFlag = 0;
 
 if whoiam
-    if Parallel(ThisMatlab).Local==0,
+    if Parallel(ThisMatlab).Local==0
         RemoteFlag =1;
     end
     prct0={0,whoiam,Parallel(ThisMatlab)};
@@ -165,7 +165,7 @@ while fpar<B
         elseif info(1) == 5
             errordef = 'Rank condition  is not satisfied';
         end
-        if strcmpi(type,'prior'),
+        if strcmpi(type,'prior')
             disp(['PosteriorIRF :: Dynare is unable to solve the model (' errordef ')'])
             continue
         else
@@ -240,9 +240,9 @@ while fpar<B
         else
             stock_irf_bvardsge(:,:,:,IRUN) = reshape(tmp_dsgevar,options_.irf,dataset_.vobs,M_.exo_nbr);
             instr = [MhDirectoryName '/' M_.fname '_irf_bvardsge' ...
-                     int2str(NumberOfIRFfiles_dsgevar) '.mat stock_irf_bvardsge;'];,
+                     int2str(NumberOfIRFfiles_dsgevar) '.mat stock_irf_bvardsge;'];
             eval(['save ' instr]);
-            if RemoteFlag==1,
+            if RemoteFlag==1
                 OutputFileName_bvardsge = [OutputFileName_bvardsge; {[MhDirectoryName filesep], [M_.fname '_irf_bvardsge' int2str(NumberOfIRFfiles_dsgevar) '.mat']}];
             end
             NumberOfIRFfiles_dsgevar = NumberOfIRFfiles_dsgevar+1;
@@ -259,14 +259,14 @@ while fpar<B
                          int2str(NumberOfIRFfiles_dsgevar) '.mat stock_irf_bvardsge;'];
                 eval(['save ' instr]);
                 NumberOfIRFfiles_dsgevar = NumberOfIRFfiles_dsgevar+1;
-                if RemoteFlag==1,
+                if RemoteFlag==1
                     OutputFileName_bvardsge = [OutputFileName_bvardsge; {[MhDirectoryName filesep], [M_.fname '_irf_bvardsge' int2str(NumberOfIRFfiles_dsgevar) '.mat']}];
                 end
                 irun = 0;
             end
         end
         save([MhDirectoryName '/' M_.fname '_irf_dsge' int2str(NumberOfIRFfiles_dsge) '.mat'],'stock_irf_dsge');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_dsge = [OutputFileName_dsge; {[MhDirectoryName filesep], [M_.fname '_irf_dsge' int2str(NumberOfIRFfiles_dsge) '.mat']}];
         end
         NumberOfIRFfiles_dsge = NumberOfIRFfiles_dsge+1;
@@ -278,7 +278,7 @@ while fpar<B
         end
         stock = stock_param;
         save([MhDirectoryName '/' M_.fname '_param_irf' int2str(ifil2) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_param = [OutputFileName_param; {[MhDirectoryName filesep], [M_.fname '_param_irf' int2str(ifil2) '.mat']}];
         end
         ifil2 = ifil2 + 1;
diff --git a/matlab/PosteriorIRF_core2.m b/matlab/PosteriorIRF_core2.m
index 295f6d5eb..09e003c43 100644
--- a/matlab/PosteriorIRF_core2.m
+++ b/matlab/PosteriorIRF_core2.m
@@ -2,10 +2,10 @@ function myoutput=PosteriorIRF_core2(myinputs,fpar,npar,whoiam,ThisMatlab)
 % function myoutput=PosteriorIRF_core2(myinputs,fpar,npar,whoiam, ThisMatlab)
 % Generates the Posterior IRFs plot from the IRFs generated in
 % PosteriorIRF_core1
-% 
+%
 % PARALLEL CONTEXT
 % Performs in parallel execution a portion of the PosteriorIRF.m code.
-% For more information, see the comment in posterior_sampler_core.m 
+% For more information, see the comment in posterior_sampler_core.m
 % function.
 %
 % INPUTS
@@ -30,7 +30,7 @@ function myoutput=PosteriorIRF_core2(myinputs,fpar,npar,whoiam,ThisMatlab)
 % SPECIAL REQUIREMENTS.
 %   None.
 %
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,7 +49,7 @@ function myoutput=PosteriorIRF_core2(myinputs,fpar,npar,whoiam,ThisMatlab)
 
 global options_  M_
 
-if nargin<4,
+if nargin<4
     whoiam=0;
 end
 
@@ -85,8 +85,8 @@ end
 DirectoryName = CheckPath('Output',M_.dname);
 
 RemoteFlag = 0;
-if whoiam,
-    if Parallel(ThisMatlab).Local==0,
+if whoiam
+    if Parallel(ThisMatlab).Local==0
         RemoteFlag =1;
     end
     prct0={0,whoiam,Parallel(ThisMatlab)};
@@ -96,16 +96,16 @@ end
 OutputFileName={};
 
 subplotnum = 0;
-for i=fpar:npar,
+for i=fpar:npar
     figunumber = 0;
 
     for j=1:nvar
         if max(abs(MeanIRF(:,j,i))) >= options_.impulse_responses.plot_threshold
             subplotnum = subplotnum+1;
             if subplotnum == 1 && options_.relative_irf
-                hh = dyn_figure(options_,'Name',['Relative response to orthogonalized shock to ' tit(i,:)]);
+                hh = dyn_figure(options_.nodisplay,'Name',['Relative response to orthogonalized shock to ' tit(i,:)]);
             elseif subplotnum == 1 && ~options_.relative_irf
-                hh = dyn_figure(options_,'Name',['Orthogonalized shock to ' tit(i,:)]);
+                hh = dyn_figure(options_.nodisplay,'Name',['Orthogonalized shock to ' tit(i,:)]);
             end
 
             set(0,'CurrentFigure',hh)
@@ -135,7 +135,7 @@ for i=fpar:npar,
                     plot(1:options_.irf,HPDIRFdsgevar(:,1,j,i),'--k','linewidth',1)
                     plot(1:options_.irf,HPDIRFdsgevar(:,2,j,i),'--k','linewidth',1)
                 end
-                 % plot([1 options_.irf],[0 0],'-r','linewidth',0.5);
+                % plot([1 options_.irf],[0 0],'-r','linewidth',0.5);
                 box on
                 axis tight
                 xlim([1 options_.irf]);
@@ -152,17 +152,17 @@ for i=fpar:npar,
 
         if subplotnum == MaxNumberOfPlotPerFigure || (j == nvar  && subplotnum> 0)
             figunumber = figunumber+1;
-            dyn_saveas(hh,[DirectoryName '/'  M_.fname '_Bayesian_IRF_' deblank(tit(i,:)) '_' int2str(figunumber)],options_);
-            if RemoteFlag==1,
+            dyn_saveas(hh,[DirectoryName '/'  M_.fname '_Bayesian_IRF_' deblank(tit(i,:)) '_' int2str(figunumber)],options_.nodisplay,options_.graph_format);
+            if RemoteFlag==1
                 OutputFileName = [OutputFileName; {[DirectoryName,filesep], [M_.fname '_Bayesian_IRF_' deblank(tit(i,:)) '_' int2str(figunumber) '.*']}];
             end
             subplotnum = 0;
         end
     end% loop over selected endo_var
-    if whoiam,
+    if whoiam
         fprintf('Done! \n');
         waitbarString = [ 'Exog. shocks ' int2str(i) '/' int2str(npar) ' done.'];
-%         fMessageStatus((i-fpar+1)/(npar-fpar+1),whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab));
+        %         fMessageStatus((i-fpar+1)/(npar-fpar+1),whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab));
         dyn_waitbar((i-fpar+1)/(npar-fpar+1),[],waitbarString);
     end
 end% loop over exo_var
diff --git a/matlab/ReshapeMatFiles.m b/matlab/ReshapeMatFiles.m
index 1ad90fce1..1d127a67b 100644
--- a/matlab/ReshapeMatFiles.m
+++ b/matlab/ReshapeMatFiles.m
@@ -18,14 +18,14 @@ function ReshapeMatFiles(type, type2)
 %                      posterior
 %                      gsa
 %                      prior
-%    
+%
 % OUTPUTS:
-%    none              
+%    none
 %
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2011 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,15 +44,15 @@ function ReshapeMatFiles(type, type2)
 
 global M_ options_
 
-if nargin==1, 
+if nargin==1
     MhDirectoryName = [ CheckPath('metropolis',M_.dname) filesep ];
 else
     if strcmpi(type2,'posterior')
         MhDirectoryName = [CheckPath('metropolis',M_.dname) filesep ];
     elseif strcmpi(type2,'gsa')
-        if options_.opt_gsa.morris==1,
+        if options_.opt_gsa.morris==1
             MhDirectoryName = [CheckPath('gsa/screen',M_.dname) filesep ];
-        elseif options_.opt_gsa.morris==2,
+        elseif options_.opt_gsa.morris==2
             MhDirectoryName = [CheckPath('gsa/identif',M_.dname) filesep ];
         elseif options_.opt_gsa.pprior
             MhDirectoryName = [CheckPath(['gsa' filesep 'prior'],M_.dname) filesep ];
@@ -61,17 +61,17 @@ else
         end
     else
         MhDirectoryName = [CheckPath('prior',M_.dname) filesep ];
-    end  
+    end
 end
 switch type
   case 'irf_dsge'
     CAPtype  = 'IRF_DSGE';
     TYPEsize = [ options_.irf , size(options_.varlist,1) , M_.exo_nbr ];
-    TYPEarray = 4;    
+    TYPEarray = 4;
   case 'irf_bvardsge'
     CAPtype  = 'IRF_BVARDSGE';
     TYPEsize = [ options_.irf , length(options_.varobs) , M_.exo_nbr ];
-    TYPEarray = 4;      
+    TYPEarray = 4;
   case 'smooth'
     CAPtype  = 'SMOOTH';
     TYPEsize = [ M_.endo_nbr , options_.nobs ];
@@ -134,7 +134,7 @@ switch TYPEarray
                 eval(['idx = idx + size(stock_' type ',4);'])
             end
             %eval(['STOCK_' CAPtype ' = sort(STOCK_' CAPtype ',4);'])
-            save([MhDirectoryName M_.fname '_' CAPtype 's' int2str(NumberOfTYPEfiles-foffset+1) '.mat'],['STOCK_' CAPtype]);  
+            save([MhDirectoryName M_.fname '_' CAPtype 's' int2str(NumberOfTYPEfiles-foffset+1) '.mat'],['STOCK_' CAPtype]);
         end
     else
         load([MhDirectoryName M_.fname '_' type '1.mat']);
@@ -176,7 +176,7 @@ switch TYPEarray
         load([MhDirectoryName M_.fname '_' type '1.mat']);
         %eval(['STOCK_' CAPtype ' = sort(stock_' type ',3);'])
         eval(['STOCK_' CAPtype ' = stock_' type ';'])
-        save([MhDirectoryName M_.fname '_' CAPtype 's' int2str(1) '.mat'],['STOCK_' CAPtype ]);      
+        save([MhDirectoryName M_.fname '_' CAPtype 's' int2str(1) '.mat'],['STOCK_' CAPtype ]);
     end
     % Original file format may be useful in some cases...
     % for file = 1:NumberOfTYPEfiles
diff --git a/matlab/TaRB_optimizer_wrapper.m b/matlab/TaRB_optimizer_wrapper.m
index 4d29add34..948266a23 100644
--- a/matlab/TaRB_optimizer_wrapper.m
+++ b/matlab/TaRB_optimizer_wrapper.m
@@ -3,15 +3,15 @@ function [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff]  = TaRB_optimiz
 % Wrapper function for target function used in TaRB algorithm; reassembles
 % full parameter vector before calling target function
 %
-% INPUTS 
-%   o optpar            [double]   (p_opt*1) vector of subset of parameters to be considered 
-%   o par_vector        [double]   (p*1) full vector of parameters 
+% INPUTS
+%   o optpar            [double]   (p_opt*1) vector of subset of parameters to be considered
+%   o par_vector        [double]   (p*1) full vector of parameters
 %   o parameterindices  [double]   (p_opt*1) index of optpar entries in
 %                                   par_vector
 %   o TargetFun         [char]      string specifying the name of the objective
 %                                   function (posterior kernel).
 %   o varargin          [structure] other inputs of target function
-% 
+%
 % OUTPUTS
 %   o fval       [scalar]   value of (minus) the likelihood.
 %   o info       [double]  (p*2) error code vector
@@ -20,8 +20,9 @@ function [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff]  = TaRB_optimiz
 %   o Hess       [double]  (p*p) asymptotic Hessian matrix.
 %   o SteadyState [double]  Vector of doubles, steady state level for the endogenous variables.
 %   o trend_coeff [double]  Matrix of doubles, coefficients of the deterministic trend in the measurement equation
-% 
-% Copyright (C) 2015-16 Dynare Team
+%
+
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,4 +41,3 @@ function [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff]  = TaRB_optimiz
 
 par_vector(parameterindices,:)=optpar; %reassemble parameter
 [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff] = feval(TargetFun,par_vector,varargin{:}); %call target function
-
diff --git a/matlab/Tracing.m b/matlab/Tracing.m
index 7d0e947c9..d3ba8c0be 100644
--- a/matlab/Tracing.m
+++ b/matlab/Tracing.m
@@ -2,19 +2,19 @@ function [] = Tracing()
 % DESCRIPTION
 % This function is used to test the correct execution of a matlab section
 % on remote machine.
-% 
+%
 % If no error happen the function simply create a file.
 %
 % INPUTS
 % ...
-% 
+%
 % OUTPUTS
 % ...
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2010 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/UnivariateSpectralDensity.m b/matlab/UnivariateSpectralDensity.m
index fa0a9e22c..41b67c403 100644
--- a/matlab/UnivariateSpectralDensity.m
+++ b/matlab/UnivariateSpectralDensity.m
@@ -1,15 +1,15 @@
 function [oo_] = UnivariateSpectralDensity(M_,oo_,options_,var_list)
 % This function computes the theoretical spectral density of each
-% endogenous variable declared in var_list. Results are stored in 
-% oo_.SpectralDensity and may be plotted. Plots are saved into the 
-% graphs-folder. 
-% 
+% endogenous variable declared in var_list. Results are stored in
+% oo_.SpectralDensity and may be plotted. Plots are saved into the
+% graphs-folder.
+%
 % INPUTS
 %   M_                  [structure]    Dynare's model structure
 %   oo_                 [structure]    Dynare's results structure
 %   options_            [structure]    Dynare's options structure
 %   var_list            [integer]      Vector of indices for a subset of variables.
-%    
+%
 % OUTPUTS
 %   oo_                 [structure]    Dynare's results structure,
 %                                       containing the subfield
@@ -17,9 +17,9 @@ function [oo_] = UnivariateSpectralDensity(M_,oo_,options_,var_list)
 %                                       and density, which are of size nvar*ngrid.
 %
 
-% Adapted from th_autocovariances.m.  
+% Adapted from th_autocovariances.m.
 
-% Copyright (C) 2006-2015 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -38,7 +38,7 @@ function [oo_] = UnivariateSpectralDensity(M_,oo_,options_,var_list)
 
 
 if options_.order > 1
-    disp('UnivariateSpectralDensity :: I Cannot compute the theoretical spectral density') 
+    disp('UnivariateSpectralDensity :: I Cannot compute the theoretical spectral density')
     disp('with a second order approximation of the DSGE model!')
     disp('Please set order = 1. I abort')
     return
@@ -102,7 +102,7 @@ if ~isempty(u)
     ivar = oo_.dr.order_var(iky);
 end
 
-iky = iv(ivar);  
+iky = iv(ivar);
 aa = ghx(iky,:);
 bb = ghu(iky,:);
 ngrid = options_.hp_ngrid; %number of grid points
@@ -112,7 +112,7 @@ tneg  = exp(-sqrt(-1)*freqs); %negative frequencies
 if options_.one_sided_hp_filter
     error('UnivariateSpectralDensity:: spectral density estimate not available with one-sided HP filter')
 elseif options_.hp_filter == 0 && ~options_.bandpass.indicator %do not filter
-   filter_gain=ones(ngrid,1);
+    filter_gain=ones(ngrid,1);
 elseif ~(options_.hp_filter == 0 && ~options_.bandpass.indicator) && options_.bandpass.indicator %filter with bandpass
     filter_gain = zeros(1,ngrid);
     lowest_periodicity=options_.bandpass.passband(2);
@@ -122,7 +122,7 @@ elseif ~(options_.hp_filter == 0 && ~options_.bandpass.indicator) && options_.ba
     filter_gain(freqs<=-2*pi/lowest_periodicity+2*pi & freqs>=-2*pi/highest_periodicity+2*pi)=1;
 elseif ~(options_.hp_filter == 0 && ~options_.bandpass.indicator) && ~options_.bandpass.indicator %filter with HP-filter
     lambda = options_.hp_filter;
-    filter_gain = 4*lambda*(1 - cos(freqs)).^2 ./ (1 + 4*lambda*(1 - cos(freqs)).^2);    
+    filter_gain = 4*lambda*(1 - cos(freqs)).^2 ./ (1 + 4*lambda*(1 - cos(freqs)).^2);
 end
 
 mathp_col = NaN(ngrid,length(ivar)^2);
@@ -134,12 +134,12 @@ for ig = 1:ngrid
     g_omega = [aa*tneg(ig) bb]*f_omega*[aa'*tpos(ig); bb']; % selected variables
     f_hp = filter_gain(ig)^2*g_omega; % spectral density of selected filtered series
     mathp_col(ig,:) = (f_hp(:))';    % store as matrix row
-end;
+end
 
 f = zeros(nvar,ngrid);
 for i=1:nvar
     f(i,:) = real(mathp_col(:,(i-1)*nvar+i)); %read out spectral density
-end  
+end
 
 oo_.SpectralDensity.freqs=freqs;
 oo_.SpectralDensity.density=f;
@@ -159,12 +159,12 @@ if options_.nograph == 0
     end
 
     for i= 1:nvar
-        hh = dyn_figure(options_,'Name',['Spectral Density of ' deblank(M_.endo_names(ivar(i),:)) '.']);
+        hh = dyn_figure(options_.nodisplay,'Name',['Spectral Density of ' deblank(M_.endo_names(ivar(i),:)) '.']);
         plot(freqs,f(i,:),'-k','linewidth',2)
         xlabel('0 \leq \omega \leq \pi')
         ylabel('f(\omega)')
         box on
-        axis tight        
-        dyn_saveas(hh,[M_.fname ,filesep,'graphs', filesep, 'SpectralDensity_' deblank(M_.endo_names(ivar(i),:))],options_)
+        axis tight
+        dyn_saveas(hh,[M_.fname ,filesep,'graphs', filesep, 'SpectralDensity_' deblank(M_.endo_names(ivar(i),:))],options_.nodisplay,options_.graph_format)
     end
 end
diff --git a/matlab/WriteShockDecomp2Excel.m b/matlab/WriteShockDecomp2Excel.m
new file mode 100644
index 000000000..5417e5250
--- /dev/null
+++ b/matlab/WriteShockDecomp2Excel.m
@@ -0,0 +1,126 @@
+function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions,opts_decomp)
+%function WriteShockDecomp2Excel(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
+% Saves the results from the shock_decomposition command to xls
+%
+% Inputs
+%   z               [n_var*(nshock+2)*nperiods]     shock decomposition array, see shock_decomposition.m for details
+%   shock_names     [endo_nbr*string length]        shock names from M_.exo_names
+%   endo_names      [exo_nbr*string length]         variable names from M_.endo_names
+%   i_var           [n_var*1]                       vector indices of requested variables in M_.endo_names and z
+%   initial_date    [dseries object]                first period of decomposition to plot
+%   DynareModel     [structure]                     Dynare model structure
+%   DynareOptions   [structure]                     Dynare options structure
+
+% Copyright (C) 2016-2017 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/>.
+
+SteadyState=[];
+fig_mode='';
+fig_mode1='';
+fig_name='';
+screen_shocks=0;
+use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+if use_shock_groups
+    shock_groups = DynareModel.shock_groups.(use_shock_groups);
+    shock_ind = fieldnames(shock_groups);
+end
+
+% number of components equals number of shocks + 1 (initial conditions)
+comp_nbr = size(z,2)-1;
+
+if nargin==8
+    if isfield(opts_decomp,'steady_state')
+        SteadyState = opts_decomp.steady_state;
+    end
+    if isfield(opts_decomp,'fig_mode') && ~isempty(opts_decomp.fig_mode)
+        fig_mode = opts_decomp.fig_mode;
+        fig_mode1 = ['_' fig_mode];
+        fig_mode = [fig_mode '_'];
+    end
+    if isfield(opts_decomp,'screen_shocks')
+        if use_shock_groups
+            screen_shocks=0;
+        elseif comp_nbr>18
+            screen_shocks = opts_decomp.screen_shocks;
+        end
+    end
+    if isfield(opts_decomp,'fig_name')
+        fig_name = opts_decomp.fig_name;
+        %         fig_name = ['_' fig_name];
+        fig_name1 = [fig_name];
+        fig_name = [fig_name '_'];
+    end
+    if screen_shocks
+        fig_name1 = [fig_name1 '_screen'];
+        fig_name = [fig_name 'screen_'];
+    end
+end
+
+
+gend = size(z,3);
+if isempty(initial_date)
+    x = 1:gend;
+else
+    freq = initial_date.freq;
+    initial_period = initial_date.time(1) + (initial_date.time(2)-1)/freq;
+    x = initial_period:(1/freq):initial_period+(gend-1)/freq;
+end
+
+
+nvar = length(i_var);
+
+labels = char(char(shock_names),'Initial values');
+if ~(screen_shocks && comp_nbr>18)
+    screen_shocks=0;
+end
+comp_nbr0=comp_nbr;
+%%plot decomposition
+for j=1:nvar
+    d0={};
+    z1 = squeeze(z(i_var(j),:,:));
+    if screen_shocks
+        [junk, isort] = sort(mean(abs(z1(1:end-2,:)')), 'descend');
+        labels = char(char(shock_names(isort(1:16),:)),'Others', 'Initial values');
+        zres = sum(z1(isort(17:end),:),1);
+        z1 = [z1(isort(1:16),:); zres; z1(comp_nbr0:end,:)];
+        comp_nbr=18;
+    end
+
+    d0(1,:)=[{'Decomposition'} cellstr(labels(1:comp_nbr,:))' {'Smoot Var'}];
+    d0=[d0; num2cell([x' z1'])];
+    LastRow=size(d0,1);
+    if use_shock_groups
+        d0(LastRow+2,1)={'Legend.'};
+        d0(LastRow+2,2)={'Shocks include:'};
+        d0(LastRow+3:LastRow+3+comp_nbr-1,1)=cellstr(labels(1:comp_nbr,:));
+        for ic=1:comp_nbr
+            group_members = shock_groups.(shock_ind{ic}).shocks;
+            d0(LastRow+2+ic,2:1+length(group_members))=group_members;
+        end
+    end
+
+    warning off
+    if ~ismac
+        [STATUS,MESSAGE] = xlswrite([DynareModel.fname,'_shock_decomposition',fig_mode,fig_name1],d0,deblank(endo_names(i_var(j),:)));
+    else
+        [STATUS] = xlwrite([DynareModel.fname,'_shock_decomposition',fig_mode,fig_name1],d0,deblank(endo_names(i_var(j),:)));
+    end
+    warning on
+
+    clear d0
+
+end
diff --git a/matlab/add_filter_subtitle.m b/matlab/add_filter_subtitle.m
index 652587517..4b0a63ede 100644
--- a/matlab/add_filter_subtitle.m
+++ b/matlab/add_filter_subtitle.m
@@ -1,7 +1,24 @@
 function title=add_filter_subtitle(title,options_)
 
+% Copyright (C) 2015-2017 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 ~options_.hp_filter && ~options_.one_sided_hp_filter  && ~options_.bandpass.indicator %do not filter
-    %nothing to add here
+                                                                                         %nothing to add here
 elseif ~options_.hp_filter && ~options_.one_sided_hp_filter && options_.bandpass.indicator
     title = [title ' (Bandpass filter, (' ...
              num2str(options_.bandpass.passband(1)),' ',num2str(options_.bandpass.passband(2)), '))'];
@@ -10,6 +27,6 @@ elseif options_.hp_filter && ~options_.one_sided_hp_filter  && ~options_.bandpas
              num2str(options_.hp_filter) ')'];
 elseif ~options_.hp_filter && options_.one_sided_hp_filter && ~options_.bandpass.indicator
     title = [title ' (One-sided HP filter, lambda = ' ...
-             num2str(options_.one_sided_hp_filter) ')'];    
+             num2str(options_.one_sided_hp_filter) ')'];
 end
 end
\ No newline at end of file
diff --git a/matlab/add_path_to_mex_files.m b/matlab/add_path_to_mex_files.m
index 38da0d345..13140bba5 100644
--- a/matlab/add_path_to_mex_files.m
+++ b/matlab/add_path_to_mex_files.m
@@ -1,6 +1,6 @@
 function mexpath = add_path_to_mex_files(dynareroot, modifypath)
-    
-% Copyright (C) 2015-2016 Dynare Team
+
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -20,9 +20,13 @@ function mexpath = add_path_to_mex_files(dynareroot, modifypath)
 if nargin<2
     modifypath = true;
 end
-    
+
 if exist('OCTAVE_VERSION')
-    mexpath = {[dynareroot '../mex/octave/']};
+    if ispc() && strcmpi(computer(), 'i686-w64-mingw32')
+        mexpath = {[dynareroot '../mex/octave32/']};
+    else
+        mexpath = {[dynareroot '../mex/octave/']};
+    end
     if modifypath
         addpath(mexpath{1});
     end
@@ -48,7 +52,7 @@ else
                 end
             end
         else
-            tmp = [dynareroot '../mex/matlab/win64-7.8-9.1/'];
+            tmp = [dynareroot '../mex/matlab/win64-7.8-9.2/'];
             if exist(tmp, 'dir')
                 mexpath = tmp;
                 if modifypath
diff --git a/matlab/annualized_shock_decomposition.m b/matlab/annualized_shock_decomposition.m
new file mode 100644
index 000000000..4972edb30
--- /dev/null
+++ b/matlab/annualized_shock_decomposition.m
@@ -0,0 +1,333 @@
+function [z, endo_names, endo_names_tex, steady_state, i_var, oo_] = annualized_shock_decomposition(oo_, M_, options_, i_var, t0, t1, realtime_, vintage_, steady_state, q2a, cumfix)
+% function oo_ = annualized_shock_decomposition(oo_,t0,options_.nobs);
+% Computes annualized shocks contribution to a simulated trajectory. The fields set are
+% oo_.annualized_shock_decomposition, oo_.annualized_realtime_shock_decomposition,
+% oo_.annualized_realtime_conditional_shock_decomposition and oo_.annualized_realtime_forecast_shock_decomposition.
+% Subfields are arrays n_var by nshock+2 by nperiods. The
+% first nshock columns store the respective shock contributions, column n+1
+% stores the role of the initial conditions, while column n+2 stores the
+% value of the smoothed variables.  Both the variables and shocks are stored
+% in the order of endo_names and M_.exo_names, respectively.
+%
+% INPUTS
+%    oo_:          [structure] Storage of results
+%    M_:           [structure] Storage of model
+%    opts:         [structure] options for shock decomp
+%    i_var:        [array] index of vars
+%    t0:           [integer]  first period
+%    t1:           [integer] last period
+%    realtime_:    [integer]
+%    vintage_:     [integer]
+%    steady_state: [array] steady state value of quarterly (log-) level vars
+%    q2a:          [structure] info on q2a
+%
+% OUTPUTS
+%    z:              [matrix] shock decomp to plot
+%    endo_names:     [char] updated var names
+%    endo_names_tex: [char] updated TeX var names
+%    steady_state:   [array] updated stady state of vars
+%    i_var:          [integer array] updated var indices to plot
+%    oo_:            [structure]  Storage of results
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2017 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/>.
+
+opts = options_.plot_shock_decomp;
+nvar = length(i_var);
+GYTREND0 = q2a.GYTREND0;
+var_type = q2a.type;
+islog    = q2a.islog;
+aux      = q2a.aux;
+aux0 = aux;
+cumfix      = q2a.cumfix;
+% usual shock decomp
+if isstruct(oo_)
+    %     z = oo_.shock_decomposition;
+    myopts=options_;
+    myopts.plot_shock_decomp.type='qoq';
+    myopts.plot_shock_decomp.realtime=0;
+    [z, junk] = plot_shock_decomposition(M_,oo_,myopts,[]);
+else
+    z = oo_;
+end
+z = z(i_var,:,:);
+mytype=var_type;
+if isfield(q2a,'name')
+    mytxt = q2a.name;
+    mytex = q2a.name;
+    if isfield(q2a,'tex_name')
+        mytex = q2a.tex_name;
+    end
+    if mytype==2
+        gtxt = ['PHI' mytxt]; % inflation rate
+        gtex = ['{\pi(' mytex ')}'];
+    elseif mytype
+        gtxt = ['G' mytxt]; % inflation rate
+        gtex = ['{g(' mytex ')}'];
+    end
+    if isfield(q2a,'gname')
+        gtxt = q2a.gname;
+    end
+    if isfield(q2a,'tex_gname')
+        gtex = q2a.tex_gname;
+    end
+    mytype=0;
+end
+if isstruct(aux)
+    if ischar(aux.y)
+        myopts=options_;
+        myopts.plot_shock_decomp.type='qoq';
+        myopts.plot_shock_decomp.realtime=0;
+        [y_aux, steady_state_aux] = plot_shock_decomposition(M_,oo_,myopts,aux.y);
+        aux.y=y_aux;
+        aux.yss=steady_state_aux;
+    end
+    yaux=aux.y;
+end
+if mytype==2
+    gtxt = 'PHI'; % inflation rate
+    gtex = '\pi';
+elseif mytype
+    gtxt = 'G'; % growth rate
+    gtex = 'g';
+end
+steady_state=steady_state(i_var);
+% endo_names = M_.endo_names(i_var,:);
+% endo_names_tex = M_.endo_names_tex(i_var,:);
+nterms = size(z,2);
+nfrcst = opts.forecast/4;
+
+for j=1:nvar
+    if j>1
+        endo_names = char(endo_names,[deblank(M_.endo_names(i_var(j),:)) '_A']);
+        endo_names_tex = char(endo_names_tex,['{' deblank(M_.endo_names_tex(i_var(j),:)) '}^A']);
+        gendo_names = char(gendo_names,[gtxt endo_names(j,:)]);
+        gendo_names_tex = char(gendo_names_tex,[gtex '(' deblank(endo_names_tex(j,:)) ')']);
+    else
+        if nvar==1 && ~mytype
+            endo_names = mytxt;
+            endo_names_tex = mytex;
+            gendo_names = gtxt;
+            gendo_names_tex = gtex;
+        else
+            endo_names = [deblank(M_.endo_names(i_var(j),:)) '_A'];
+            endo_names_tex = ['{' deblank(M_.endo_names_tex(i_var(j),:)) '}^A'];
+            gendo_names = [gtxt endo_names(j,:)];
+            gendo_names_tex = [gtex '(' deblank(endo_names_tex(j,:)) ')'];
+        end
+    end
+    for k =1:nterms
+        if isstruct(aux)
+            aux.y = squeeze(yaux(j,k,min((t0-3):-4:1):end));
+        end
+        [za(j,k,:), steady_state_a(j,1), gza(j,k,:), steady_state_ga(j,1)] = ...
+            quarterly2annual(squeeze(z(j,k,min((t0-3):-4:1):end)),steady_state(j),GYTREND0,var_type,islog,aux);
+    end
+    ztmp=squeeze(za(j,:,:));
+    if cumfix==0
+        zscale = sum(ztmp(1:end-1,:))./ztmp(end,:);
+        ztmp(1:end-1,:) = ztmp(1:end-1,:)./repmat(zscale,[nterms-1,1]);
+    else
+        zres = ztmp(end,:)-sum(ztmp(1:end-1,:));
+        ztmp(end-1,:) = ztmp(end-1,:) + zres;
+    end
+    gztmp=squeeze(gza(j,:,:));
+    if cumfix==0
+        gscale = sum(gztmp(1:end-1,:))./ gztmp(end,:);
+        gztmp(1:end-1,:) = gztmp(1:end-1,:)./repmat(gscale,[nterms-1,1]);
+    else
+        gres = gztmp(end,:) - sum(gztmp(1:end-1,:));
+        gztmp(end-1,:) = gztmp(end-1,:)+gres;
+    end
+    za(j,:,:) = ztmp;
+    gza(j,:,:) = gztmp;
+end
+
+if q2a.plot ==1
+    z=gza;
+    endo_names = gendo_names;
+    endo_names_tex = gendo_names_tex;
+elseif q2a.plot == 2
+    z=za;
+else
+    z=cat(1,za,gza);
+    endo_names = char(endo_names,gendo_names);
+    endo_names_tex = char(endo_names_tex,gendo_names_tex);
+end
+% if isstruct(oo_)
+%     oo_.annualized_shock_decomposition=z;
+% end
+
+% realtime
+if realtime_ && isstruct(oo_) && isfield(oo_, 'realtime_shock_decomposition')
+    init=1;
+    for i=t0:4:t1
+        yr=floor(i/4);
+        za=[];
+        gza=[];
+        myopts=options_;
+        myopts.plot_shock_decomp.type='qoq';
+        myopts.plot_shock_decomp.realtime=1;
+        myopts.plot_shock_decomp.vintage=i;
+        [z, steady_state_aux] = plot_shock_decomposition(M_,oo_,myopts,[]);
+        z = z(i_var,:,:);
+        if isstruct(aux)
+            if ischar(aux0.y)
+                [y_aux, steady_state_aux] = plot_shock_decomposition(M_,oo_,myopts,aux0.y);
+                aux.y=y_aux;
+                aux.yss=steady_state_aux;
+            end
+            yaux=aux.y;
+        end
+        nterms = size(z,2);
+
+        %     z = oo_.realtime_shock_decomposition.(['time_' int2str(i)]);
+        %     z = z(i_var,:,:);
+
+        for j=1:nvar
+            for k =nterms:-1:1
+                %             if k<nterms
+                %                 ztmp = squeeze(sum(z(j,[1:k-1,k+1:end-1],t0-4:end)));
+                %             else
+                ztmp = squeeze(z(j,k,min((t0-3):-4:1):end));
+                %             end
+                if isstruct(aux)
+                    aux.y = squeeze(yaux(j,k,min((t0-3):-4:1):end));
+                end
+                [za(j,k,:), steady_state_a(j,1), gza(j,k,:), steady_state_ga(j,1)] = ...
+                    quarterly2annual(ztmp,steady_state(j),GYTREND0,var_type,islog,aux);
+                %             if k<nterms
+                %                 za(j,k,:) = za(j,end,:) - za(j,k,:);
+                %                 gza(j,k,:) = gza(j,end,:) - gza(j,k,:);
+                %             end
+
+            end
+
+            ztmp=squeeze(za(j,:,:));
+
+            if cumfix==0
+                zscale = sum(ztmp(1:end-1,:))./ztmp(end,:);
+                ztmp(1:end-1,:) = ztmp(1:end-1,:)./repmat(zscale,[nterms-1,1]);
+            else
+                zres = ztmp(end,:)-sum(ztmp(1:end-1,:));
+                ztmp(end-1,:) = ztmp(end-1,:) + zres;
+            end
+
+            gztmp=squeeze(gza(j,:,:));
+            if cumfix==0
+                gscale = sum(gztmp(1:end-1,:))./ gztmp(end,:);
+                gztmp(1:end-1,:) = gztmp(1:end-1,:)./repmat(gscale,[nterms-1,1]);
+            else
+                gres = gztmp(end,:) - sum(gztmp(1:end-1,:));
+                gztmp(end-1,:) = gztmp(end-1,:)+gres;
+            end
+
+            za(j,:,:) = ztmp;
+            gza(j,:,:) = gztmp;
+        end
+
+        if q2a.plot ==1
+            z=gza;
+        elseif q2a.plot == 2
+            z=za;
+        else
+            z=cat(1,za,gza);
+        end
+
+        if init==1
+            oo_.annualized_realtime_shock_decomposition.pool = z;
+        else
+            oo_.annualized_realtime_shock_decomposition.pool(:,:,yr) = z(:,:,end-nfrcst);
+        end
+        oo_.annualized_realtime_shock_decomposition.(['yr_' int2str(yr)]) = z;
+
+        if opts.forecast
+            oo_.annualized_realtime_forecast_shock_decomposition.(['yr_' int2str(yr)]) = z(:,:,end-nfrcst:end);
+            if init>nfrcst
+                oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-nfrcst)]) = ...
+                    oo_.annualized_realtime_shock_decomposition.pool(:,:,yr-nfrcst:end) - ...
+                    oo_.annualized_realtime_forecast_shock_decomposition.(['yr_' int2str(yr-nfrcst)]);
+                % fix others
+                oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-nfrcst)])(:,end-1,:) = ...
+                    oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-nfrcst)])(:,end-1,:) + ...
+                    oo_.annualized_realtime_forecast_shock_decomposition.(['yr_' int2str(yr-nfrcst)])(:,end,:);
+                % fix total
+                oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-nfrcst)])(:,end,:) = ...
+                    oo_.annualized_realtime_shock_decomposition.pool(:,end,yr-nfrcst:end);
+                if i==t1
+                    for my_forecast_=(nfrcst-1):-1:1
+                        oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-my_forecast_)]) = ...
+                            oo_.annualized_realtime_shock_decomposition.pool(:,:,yr-my_forecast_:yr) - ...
+                            oo_.annualized_realtime_forecast_shock_decomposition.(['yr_' int2str(yr-my_forecast_)])(:,:,1:my_forecast_+1);
+                        oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-my_forecast_)])(:,end-1,:) = ...
+                            oo_.annualized_realtime_forecast_shock_decomposition.(['yr_' int2str(yr-my_forecast_)])(:,end,1:my_forecast_+1);
+                        oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(yr-my_forecast_)])(:,end,:) = ...
+                            oo_.annualized_realtime_shock_decomposition.pool(:,end,yr-my_forecast_:yr);
+                    end
+                end
+            end
+        end
+        % ztmp=oo_.realtime_shock_decomposition.pool(:,:,21:29)-oo_.realtime_forecast_shock_decomposition.time_21;
+
+
+
+        init=init+1;
+    end
+
+
+    switch realtime_
+
+      case 0
+        z = oo_.annualized_shock_decomposition;
+
+      case 1 % realtime
+        if vintage_
+            z = oo_.annualized_realtime_shock_decomposition.(['yr_' int2str(floor(vintage_/4))]);
+        else
+            z = oo_.annualized_realtime_shock_decomposition.pool;
+        end
+
+      case 2 % conditional
+        if vintage_
+            z = oo_.annualized_realtime_conditional_shock_decomposition.(['yr_' int2str(floor(vintage_/4))]);
+        else
+            error();
+        end
+
+      case 3 % forecast
+        if vintage_
+            z = oo_.annualized_realtime_forecast_shock_decomposition.(['yr_' int2str(floor(vintage_/4))]);
+        else
+            error()
+        end
+    end
+end
+
+if q2a.plot ==0
+    i_var=1:2*nvar;
+    steady_state = [steady_state_a;steady_state_ga];
+else
+    i_var=1:nvar;
+    if q2a.plot ==1
+        steady_state = steady_state_ga;
+    else
+        steady_state = steady_state_a;
+    end
+end
diff --git a/matlab/autoregressive_process_specification.m b/matlab/autoregressive_process_specification.m
index 7cc34db27..6f73b7e05 100644
--- a/matlab/autoregressive_process_specification.m
+++ b/matlab/autoregressive_process_specification.m
@@ -2,48 +2,48 @@ function [InnovationVariance,AutoregressiveParameters] = autoregressive_process_
 % This function computes the parameters of an AR(p) process from the variance and the autocorrelation function
 % (the first p terms) of this process.
 %
-% INPUTS 
+% INPUTS
 %  [1] Variance                 [double]  scalar, variance of the variable.
 %  [2] Rho                      [double]  p*1 vector, the autocorelation function: \rho(1), \rho(2), ..., \rho(p).
 %  [3] p                        [double]  scalar, the number of lags in the AR process.
 %
-% OUTPUTS 
+% OUTPUTS
 %  [1] InnovationVariance       [double]  scalar, the variance of the innovation.
 %  [2] AutoregressiveParameters [double]  p*1 vector of autoregressive parameters.
 %
-% NOTES 
+% NOTES
 %
 % The AR(p) model for {y_t} is:
-%   
-%           y_t = \phi_1 * y_{t-1} +  \phi_2 * y_{t-2} + ... +  \phi_p * y_{t-p} + e_t    
+%
+%           y_t = \phi_1 * y_{t-1} +  \phi_2 * y_{t-2} + ... +  \phi_p * y_{t-p} + e_t
 %
 % Let \gamma(0) and \rho(1), ..., \rho(2) be the variance and the autocorrelation function of {y_t}. This function
-% compute the variance of {e_t} and the \phi_i (i=1,...,p) from the variance and the autocorrelation function of {y_t}. 
+% compute the variance of {e_t} and the \phi_i (i=1,...,p) from the variance and the autocorrelation function of {y_t}.
 % We know that:
-%    
+%
 %    \gamma(0) = \phi_1 \gamma(1) + ... + \phi_p \gamma(p) + \sigma^2
 %
 % where \sigma^2 is the variance of {e_t}. Equivalently we have:
 %
-%    \sigma^2 = \gamma(0) (1-\rho(1)\phi_1 - ... - \rho(p)\phi_p)     
+%    \sigma^2 = \gamma(0) (1-\rho(1)\phi_1 - ... - \rho(p)\phi_p)
 %
 % We also have for any integer  h>0:
-% 
+%
 %    \rho(h) = \phi_1 \rho(h-1) + ... + \phi_p \rho(h-p)
 %
 % We can write the equations for \rho(1), ..., \rho(p) using matrices. Let R be the p*p autocorelation
-% matrix and v be the p*1 vector gathering the first p terms of the autocorrelation function. We have: 
+% matrix and v be the p*1 vector gathering the first p terms of the autocorrelation function. We have:
 %
 %           v = R*PHI
-%    
+%
 % where PHI is a p*1 vector with the autoregressive parameters of the AR(p) process. We can recover the autoregressive
 % parameters by inverting the autocorrelation matrix: PHI = inv(R)*v.
-% 
+%
 % This function first computes the vector PHI by inverting R and computes the variance of the innovation by evaluating
 %
 %           \sigma^2 = \gamma(0)*(1-PHI'*v)
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/backward/backward_model_forecast.m b/matlab/backward/backward_model_forecast.m
new file mode 100644
index 000000000..0c23abaef
--- /dev/null
+++ b/matlab/backward/backward_model_forecast.m
@@ -0,0 +1,122 @@
+function forecasts = backward_model_forecast(initialcondition, listofvariables, periods, withuncertainty)
+
+% Returns unconditional forecasts.
+%
+% INPUTS 
+% - initialcondition    [dseries]             Initial conditions for the endogenous variables.
+% - periods             [integer]             scalar, the number of (forecast) periods.
+% - withuncertainty     [logical]             scalar, returns confidence bands if true.
+%
+% OUTPUTS 
+% - forecast            [dseries]   
+
+% Copyright (C) 2017 Dynare Team
+%
+% This file is part of Dynare.
+%
+% Dynare is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version.
+%
+% Dynare is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+
+global M_ options_ oo_
+
+% Check that the model is actually backward
+if M_.maximum_lead
+    error(['backward_model_irf:: The specified model is not backward looking!'])
+end
+
+% Initialize returned argument.
+forecasts = struct();
+
+% Set defaults.
+if nargin<2
+    listofvariables = cellstr(M_.endo_names);
+    periods = 8;
+    withuncertainty = false;
+end
+
+if nargin<3
+    periods = 8;
+    withuncertainty = false;
+end
+
+if nargin<4
+    withuncertainty = false;
+end
+
+% Get full list of endogenous variables
+endo_names = cellstr(M_.endo_names);
+
+% Get vector of indices for the selected endogenous variables.
+n = length(listofvariables);
+idy = zeros(n,1);
+for i=1:n
+    j = strmatch(listofvariables{i}, endo_names, 'exact');
+    if isempty(j)
+        error('backward_model_forecast:: Variable %s is unknown!', listofvariables{i})
+    else
+        idy(i) = j;
+    end
+end
+
+% Set the number of simulations (if required).
+if withuncertainty
+    B = 1000;
+end
+
+% Get the covariance matrix of the shocks.
+if withuncertainty
+    Sigma = M_.Sigma_e + 1e-14*eye(M_.exo_nbr);
+    sigma = transpose(chol(Sigma));
+end
+
+% Set initial condition.
+if isdates(initialcondition)
+    if isempty(M_.endo_histval)
+        error('backward_model_irf: histval block for setting initial condition is missing!')
+    end
+    initialcondition = dseries(transpose(M_.endo_histval), initialcondition, endo_names, cellstr(M_.endo_names_tex));
+end
+
+% Put initial conditions in a vector of doubles
+initialconditions = transpose(initialcondition{endo_names{:}}.data);
+
+% Compute forecast without shock 
+innovations = zeros(periods+max(M_.maximum_exo_lag, 1), M_.exo_nbr);
+if M_.maximum_exo_lag
+    if isempty(M_.exo_histval)
+        error('You need to set the past values for the exogenous variables!')
+    else
+        innovations(1:M_.maximum_exo_lag, :) = M_.exo_histval;
+    end
+end
+
+oo__0 = simul_backward_model(initialconditions, periods, options_, M_, oo_, innovations);
+forecasts.pointforecast = dseries(transpose(oo__0.endo_simul(idy,:)), initialcondition.init, listofvariables);
+
+if withuncertainty
+    % Preallocate an array gathering the simulations.
+    ArrayOfForectasts = zeros(n, periods+1, B);
+    for i=1:B
+        innovations(max(M_.maximum_exo_lag, 1)+1:end,:) = transpose(sigma*randn(M_.exo_nbr, periods));
+        oo__ = simul_backward_model(initialconditions, periods, options_, M_, oo_, innovations);     
+        ArrayOfForecasts(:,:,i) = oo__.endo_simul(idy,:); 
+    end
+    % Compute mean (over future uncertainty) forecast.
+    forecasts.meanforecast = dseries(transpose(mean(ArrayOfForecasts, 3)), initialcondition.init, listofvariables);
+    forecasts.medianforecast = dseries(transpose(median(ArrayOfForecasts, 3)), initialcondition.init, listofvariables);
+    forecasts.stdforecast = dseries(transpose(std(ArrayOfForecasts, 1,3)), initialcondition.init, listofvariables);
+    % Compute lower and upper 95% confidence bands
+    ArrayOfForecasts = sort(ArrayOfForecasts, 3);
+    forecasts.lb = dseries(transpose(ArrayOfForecasts(:,:,round(0.025*B))), initialcondition.init, listofvariables);
+    forecasts.ub = dseries(transpose(ArrayOfForecasts(:,:,round(0.975*B))), initialcondition.init, listofvariables);
+end
\ No newline at end of file
diff --git a/matlab/backward/backward_model_inversion.m b/matlab/backward/backward_model_inversion.m
new file mode 100644
index 000000000..6acbcc606
--- /dev/null
+++ b/matlab/backward/backward_model_inversion.m
@@ -0,0 +1,121 @@
+function [endogenousvariables, exogenousvariables] = backward_model_inversion(constraints, exogenousvariables, initialconditions, endo_names, exo_names, freeinnovations, DynareModel, DynareOptions, DynareOutput)
+
+% INPUTS
+% - constraints         [dseries]        with N constrained endogenous variables from t1 to t2.
+% - exogenousvariables  [dseries]        with Q exogenous variables.
+% - initialconditions   [dseries]        with M endogenous variables starting before t1 (M initialcond must contain at least the state variables).
+% - endo_names          [cell]           list of endogenous variable names.
+% - exo_names           [cell]           list of exogenous variable names.
+% - freeinstruments     [cell]           list of exogenous variable names used to control the constrained endogenous variables.
+%
+% OUTPUTS
+% - endogenous          [dseries]
+% - exogenous           [dseries]
+%
+% REMARKS
+
+% Copyright (C) 2017 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/>.
+
+% Get indices for the calibrated and free innovations.
+freeinnovations_id = zeros(length(freeinnovations), 1);
+if length(freeinnovations)<DynareModel.exo_nbr
+    for i=1:length(freeinnovations)
+        freeinnovations_id(i) = strmatch(freeinnovations{i}, exo_names, 'exact');
+    end
+    calibratedinnovations_id = setdiff(transpose(1:length(exo_names)), freeinnovations_id);
+else
+    freeinnovations_id = transpose(1:length(exo_names));
+    calibratedinnovations_id = [];
+end
+
+nxfree = length(freeinnovations_id);
+nxcalb = length(calibratedinnovations_id);
+
+% Get indices for the the controlled and free endogenous variables.
+controlledendogenousvariables_id = zeros(length(freeinnovations), 1);
+if length(freeinnovations)<DynareModel.endo_nbr
+    for i=1:length(freeinnovations)
+        controlledendogenousvariables_id(i) = strmatch(constraints.name{i}, endo_names, 'exact');
+    end
+    freeendogenousvariables_id = setdiff(transpose(1:length(endo_names)), controlledendogenousvariables_id);
+else
+    controlledendogenousvariables_id = transpose(1:length(endo_names));
+    freeendogenousvariables_id = [];
+end
+
+nyfree = length(freeendogenousvariables_id);
+nyctrl = length(controlledendogenousvariables_id);
+
+% Get indices of variables appearing at time t-1.
+iy1 = find(DynareModel.lead_lag_incidence(1,:)>0);
+
+% Get indices of variables appearing at time t.
+iy0 = find(DynareModel.lead_lag_incidence(2,:)>0);
+
+% Set indices for trust_region algorithm.
+idx = 1:DynareModel.endo_nbr;
+jdx = 1:(nyfree+nxfree);
+
+% Build structure to be passed to the objective function.
+ModelInversion.nyfree = nyfree;
+ModelInversion.nyctrl = nyctrl;
+ModelInversion.nxfree = nxfree;
+ModelInversion.nxcalb = nxcalb;
+ModelInversion.y_constrained_id = vec(DynareModel.lead_lag_incidence(2,controlledendogenousvariables_id));
+ModelInversion.y_free_id = vec(DynareModel.lead_lag_incidence(2,freeendogenousvariables_id));
+ModelInversion.x_free_id = freeinnovations_id;
+ModelInversion.J_id = [ModelInversion.y_free_id ; sum(DynareModel.lead_lag_incidence(:)>0)+ModelInversion.x_free_id];
+
+% Get the name of the dynamic model routines.
+model_dynamic = str2func([DynareModel.fname,'_dynamic']);
+model_dtransf = str2func('dynamic_backward_model_for_inversion');
+
+% Initialization of vector y (free endogenous variables and free innovations).
+y = NaN(nyfree+nxfree);
+
+% Initialization of the returned simulations (endogenous variables).
+Y = NaN(DynareModel.endo_nbr, nobs(constraints)+1);
+initialconditions
+constraints.dates(1)
+Y(:,1) = initialconditions(constraints.dates(1)-1).data(1:DynareModel.endo_nbr);
+for i=1:nyctrl
+    Y(controlledendogenousvariables_id(i),2:end) = transpose(constraints.data(:,i));
+end
+
+% Initialization of the returned simulations (exogenous variables).
+X = exogenousvariables{exo_names{:}}(constraints.dates(1)-max(1,DynareModel.maximum_exo_lag):constraints.dates(end)).data;
+
+% Inversion of the model, solvers for the free endogenous and exogenous variables (call a Newton-like algorithm in each period).
+for it = 2:nobs(constraints)+1
+    % Set the lagged values of the endogenous variables.
+    ylag = Y(iy1,it-1);
+    % Set the current values of the constrained endogenous variables.
+    ycur = Y(controlledendogenousvariables_id,it);
+    % Vector z gather the free endogenous variables (initialized with lagged
+    % values) and the free exogenous variables (initialized with 0).
+    z = [Y(freeendogenousvariables_id,it-1); zeros(nxfree, 1)];
+    % Solves for z.
+    z = dynare_solve(model_dtransf, z, DynareOptions, model_dynamic, ylag, ycur, X, DynareModel.params, DynareOutput.steady_state, it+DynareModel.maximum_exo_lag, ModelInversion);
+    % Update the matrix of exogenous variables.
+    X(it,freeinnovations_id) = z(nyfree+1:end);
+    % Update the matrix of endogenous variables.
+    Y(freeendogenousvariables_id,it) = z(1:nyfree);
+end
+
+endogenousvariables = dseries(Y', constraints.dates(1)-1, endo_names);
+exogenousvariables = dseries(X(max(DynareModel.maximum_exo_lag,1)+1:end,:), constraints.dates(1), exo_names);
\ No newline at end of file
diff --git a/matlab/backward/backward_model_irf.m b/matlab/backward/backward_model_irf.m
new file mode 100644
index 000000000..043568351
--- /dev/null
+++ b/matlab/backward/backward_model_irf.m
@@ -0,0 +1,119 @@
+function irfs = backward_model_irf(initialcondition, listofshocks, listofvariables, varargin)
+
+% Returns impulse response functions.
+%
+% INPUTS 
+% - initialcondition    [dseries,dates]       Initial conditions for the endogenous variables, or period 0.
+% - listofshocks        [cell of strings]     The innovations for which the IRFs need to be computed.  
+% - listofvariables     [cell of strings]     The endogenous variables which will be returned.  
+% - periods             [integer]             scalar, the number of periods.
+%
+% OUTPUTS 
+% - irfs                [struct of dseries]   
+%
+% REMARKS 
+% The names of the fields in the returned structure are given by the name
+% of the innovations listed in the second input argument. Each field gather
+% the associated paths for endogenous variables listed in the third input 
+% argument. 
+
+
+% Copyright (C) 2017 Dynare Team
+%
+% This file is part of Dynare.
+%
+% Dynare is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version.
+%
+% Dynare is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+
+global M_ options_ oo_
+
+% Check that the model is actually backward
+if M_.maximum_lead
+    error(['simul_model_irf:: The specified model is not backward looking!'])
+end
+
+% Set default value for the fourth input argument.
+if nargin<4
+    periods = 40;
+    notransform = true;
+else
+    periods = varargin{1};
+end
+
+% Set default value for the last input argument (no transformation).
+if nargin<5
+    notransform = true;
+else
+    notransform = false;
+    transform = varargin{2};
+end
+
+% Get list of all exogenous variables in a cell of strings
+exo_names = cellstr(M_.exo_names);
+
+% Get the list of all exogenous variables in a cell of strings
+endo_names = cellstr(M_.endo_names);
+
+% Set initial condition.
+if isdates(initialcondition)
+    if isempty(M_.endo_histval)
+        error('backward_model_irf: histval block for setting initial condition is missing!')
+    end
+    initialcondition = dseries(transpose(M_.endo_histval), initialcondition, endo_names, cellstr(M_.endo_names_tex));
+end
+
+% Get the covariance matrix of the shocks.
+Sigma = M_.Sigma_e + 1e-14*eye(M_.exo_nbr);
+sigma = transpose(chol(Sigma));
+
+% Put initial conditions in a vector of doubles
+initialconditions = transpose(initialcondition{endo_names{:}}.data);
+
+% Initialization of the returned argument. Each will be a dseries object containing the IRFS for the endogenous variables listed in the third input argument.
+irfs = struct();
+
+% Get the covariance matrix of the shocks.
+Sigma = M_.Sigma_e + 1e-14*eye(M_.exo_nbr);
+sigma = transpose(chol(Sigma));
+
+% Put initial conditions in a vector of doubles
+initialconditions = transpose(initialcondition{endo_names{:}}.data);
+
+% Compute the IRFs (loop over innovations).
+for i=1:length(listofshocks)
+    % Get transition paths induced by the initial condition.
+    innovations = zeros(periods+M_.maximum_exo_lag, M_.exo_nbr);
+    if ~isempty(M_.exo_histval)
+        innovations(1:M_.maximum_exo_lag,:) = M_.exo_histval;
+    end
+    oo__0 = simul_backward_model(initialconditions, periods, options_, M_, oo_, innovations);
+    % Add the shock.
+    j = strmatch(listofshocks{i}, exo_names);
+    if isempty(j)
+        error('backward_model_irf: Exogenous variable %s is unknown!', listofshocks{i})
+    end
+    innovations(1+M_.maximum_exo_lag,:) = transpose(sigma(:,j));
+    oo__1 = simul_backward_model(initialconditions, periods, options_, M_, oo_, innovations);
+    % Transform the endogenous variables
+    if notransform
+        endo_simul__0 = oo__0.endo_simul;
+        endo_simul__1 = oo__1.endo_simul;
+    else
+        endo_simul__0 = feval(transform, oo__0.endo_simul);
+        endo_simul__1 = feval(transform, oo__1.endo_simul);
+    end
+    % Instantiate a dseries object (with all the endogenous variables)
+    allirfs = dseries(transpose(endo_simul__1-endo_simul__0), initialcondition.init, cellstr(M_.endo_names), cellstr(M_.endo_names_tex));
+    % Extract a sub-dseries object
+    irfs.(listofshocks{i}) = allirfs{listofvariables{:}};
+end
\ No newline at end of file
diff --git a/matlab/backward/dynamic_backward_model_for_inversion.m b/matlab/backward/dynamic_backward_model_for_inversion.m
new file mode 100644
index 000000000..540e2f732
--- /dev/null
+++ b/matlab/backward/dynamic_backward_model_for_inversion.m
@@ -0,0 +1,39 @@
+function [r, J] = dynamic_backward_model_for_inversion(z, dynamicmodel, ylag, ycur, x, params, steady_state, it_, ModelInversion)
+
+% Copyright (C) 2017 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/>.
+
+% Set up y
+y = zeros(length(ylag)+ModelInversion.nyfree+ModelInversion.nyctrl,1);
+y(1:length(ylag)) = ylag;
+
+y(ModelInversion.y_constrained_id) = ycur;
+if ModelInversion.nyfree
+    y(ModelInversion.y_free_id) = z(1:ModelInversion.nyfree);
+end
+
+% Update x
+x(it_, ModelInversion.x_free_id) = transpose(z(ModelInversion.nyfree+(1:ModelInversion.nxfree)));
+
+if nargout>1
+    [r, Jacobian] = feval(dynamicmodel, y, x, params, steady_state, it_);
+else
+    r = feval(dynamicmodel, y, x, params, steady_state, it_);
+    return
+end
+
+J = Jacobian(:,ModelInversion.J_id);
\ No newline at end of file
diff --git a/matlab/backward/dynamic_backward_model_for_simulation.m b/matlab/backward/dynamic_backward_model_for_simulation.m
new file mode 100644
index 000000000..4947aa669
--- /dev/null
+++ b/matlab/backward/dynamic_backward_model_for_simulation.m
@@ -0,0 +1,40 @@
+function [r, J] = dynamic_backward_model_for_simulation(z, dynamicmodel, ylag, x, params, steady_state, it_)
+
+% Copyright (C) 2017 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/>.
+
+% Get indices of the variables appearing at time t.
+% NOTE: It is assumed that all variables appear at time t in the model.
+idy = length(ylag)+(1:length(z));
+
+% Build y vector to be passed to the dynamic model.
+y = zeros(length(ylag)+length(z), 1);
+y(1:length(ylag)) = ylag;
+y(idy) = z;
+
+if nargout>1
+    % Compute residuals and jacobian of the full dynamic model.
+    [r, Jacobian] = feval(dynamicmodel, y, x, params, steady_state, it_);
+else
+    % Compute residuals and return.
+    r = feval(dynamicmodel, y, x, params, steady_state, it_);
+    return
+end
+
+% If the jacobian is computed, remove the columns related to the innovations
+% and the variables appearing at time t-1.
+J = Jacobian(:,idy);
\ No newline at end of file
diff --git a/matlab/simul_backward_linear_model.m b/matlab/backward/simul_backward_linear_model.m
similarity index 97%
rename from matlab/simul_backward_linear_model.m
rename to matlab/backward/simul_backward_linear_model.m
index c4ed4fe26..44555449f 100644
--- a/matlab/simul_backward_linear_model.m
+++ b/matlab/backward/simul_backward_linear_model.m
@@ -34,7 +34,7 @@ function DynareOutput = simul_backward_linear_model(initial_conditions, sample_s
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -84,9 +84,9 @@ A0inv = inv(jacob(:,jdx));
 A1 = jacob(:,nonzeros(DynareModel.lead_lag_incidence(1,:)));
 B = jacob(:,end-number_of_shocks+1:end);
 
-% Simulations 
+% Simulations
 for it = 2:sample_size+1
-    Y(:,it) = -A0inv*(cst + A1*Y(iy1,it-1) + B*DynareOutput.exo_simul(it,:)'); 
+    Y(:,it) = -A0inv*(cst + A1*Y(iy1,it-1) + B*DynareOutput.exo_simul(it,:)');
 end
 
 DynareOutput.endo_simul = Y;
\ No newline at end of file
diff --git a/matlab/simul_backward_model.m b/matlab/backward/simul_backward_model.m
similarity index 82%
rename from matlab/simul_backward_model.m
rename to matlab/backward/simul_backward_model.m
index 90c0f5c74..32486e651 100644
--- a/matlab/simul_backward_model.m
+++ b/matlab/backward/simul_backward_model.m
@@ -1,4 +1,4 @@
-function DynareOutput = simul_backward_linear_model(initial_conditions, sample_size, DynareOptions, DynareModel, DynareOutput, innovations)
+function DynareOutput = simul_backward_model(initial_conditions, sample_size, DynareOptions, DynareModel, DynareOutput, innovations)
 
 %@info:
 %! @deftypefn {Function File} {@var{DynareOutput} =} simul_backward_nonlinear_model (@var{sample_size},@var{DynareOptions}, @var{DynareModel}, @var{DynareOutput})
@@ -34,7 +34,7 @@ function DynareOutput = simul_backward_linear_model(initial_conditions, sample_s
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -76,10 +76,14 @@ if nargin<6
       otherwise
         error(['simul_backward_nonlinear_model:: ' DynareOption.bnlms.innovation_distribution ' distribution for the structural innovations is not (yet) implemented!'])
     end
-
     % Put the simulated innovations in DynareOutput.exo_simul.
-    DynareOutput.exo_simul = zeros(sample_size+1,number_of_shocks);
+    DynareOutput.exo_simul = zeros(sample_size, number_of_shocks);
     DynareOutput.exo_simul(2:end,positive_var_indx) = DynareOutput.bnlms.shocks;
+    if isfield(DynareModel,'exo_histval') && ~isempty(DynareModel.exo_histval)
+        DynareOutput.exo_simul = [M_.exo_histval; DynareOutput.exo_simul];
+    else
+        DynareOutput.exo_simul = [zeros(1,number_of_shocks); DynareOutput.exo_simul];
+    end
 else
     number_of_shocks = size(innovations,2);
     DynareOutput.exo_simul = innovations;
@@ -87,9 +91,8 @@ end
 
 if DynareOptions.linear
     DynareOutput = simul_backward_linear_model(initial_conditions, sample_size, DynareOptions, ...
-                                DynareModel, DynareOutput, innovations);
+                                               DynareModel, DynareOutput, innovations);
 else
     DynareOutput = simul_backward_nonlinear_model(initial_conditions, sample_size, DynareOptions, ...
-                                DynareModel, DynareOutput, innovations);
-end    
-    
\ No newline at end of file
+                                                  DynareModel, DynareOutput, innovations);
+end
diff --git a/matlab/simul_backward_nonlinear_model.m b/matlab/backward/simul_backward_nonlinear_model.m
similarity index 60%
rename from matlab/simul_backward_nonlinear_model.m
rename to matlab/backward/simul_backward_nonlinear_model.m
index 99dd3932b..fadf6ee3f 100644
--- a/matlab/simul_backward_nonlinear_model.m
+++ b/matlab/backward/simul_backward_nonlinear_model.m
@@ -1,40 +1,27 @@
 function DynareOutput = simul_backward_nonlinear_model(initial_conditions, sample_size, DynareOptions, DynareModel, DynareOutput, innovations)
 
-%@info:
-%! @deftypefn {Function File} {@var{DynareOutput} =} simul_backward_nonlinear_model (@var{sample_size},@var{DynareOptions}, @var{DynareModel}, @var{DynareOutput})
-%! @anchor{@simul_backward_nonlinear_model}
-%! @sp 1
-%! Simulates a stochastic non linear backward looking model with arbitrary precision (a deterministic solver is used).
-%! @sp 2
-%! @strong{Inputs}
-%! @sp 1
-%! @table @ @var
-%! @item sample_size
-%! Scalar integer, size of the sample to be generated.
-%! @item DynareOptions
-%! Matlab/Octave structure (Options used by Dynare).
-%! @item DynareDynareModel
-%! Matlab/Octave structure (Description of the model).
-%! @item DynareOutput
-%! Matlab/Octave structure (Results reported by Dynare).
-%! @end table
-%! @sp 1
-%! @strong{Outputs}
-%! @sp 1
-%! @table @ @var
-%! @item DynareOutput
-%! Matlab/Octave structure (Results reported by Dynare).
-%! @end table
-%! @sp 2
-%! @strong{This function is called by:}
-%! @sp 2
-%! @strong{This function calls:}
-%! @ref{dynTime}
-%!
-%! @end deftypefn
-%@eod:
+% Simulates a stochastic non linear backward looking model with arbitrary precision (a deterministic solver is used).
+%
+% INPUTS
+% - initial_conditions  [double]      n*1 vector, initial conditions for the endogenous variables.
+% - sample_size         [integer]     scalar, number of periods for the simulation.
+% - DynareOptions       [struct]      Dynare's options_ global structure.
+% - DynareModel         [struct]      Dynare's M_ global structure.
+% - DynareOutput        [struct]      Dynare's oo_ global structure.
+% - innovations         [double]      T*q matrix, innovations to be used for the simulation.
+%
+% OUTPUTS
+% - DynareOutput        [struct]      Dynare's oo_ global structure.
+%
+% REMARKS
+% [1] The innovations used for the simulation are saved in DynareOutput.exo_simul, and the resulting paths for the endogenous
+%     variables are saved in DynareOutput.endo_simul.
+% [2] The last input argument is not mandatory. If absent we use random draws and rescale them with the informations provided
+%     through the shocks block.
+% [3] If the first input argument is empty, the endogenous variables are initialized with 0, or if available with the informations
+%     provided thrtough the histval block.
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -77,13 +64,16 @@ if nargin<6
     % Put the simulated innovations in DynareOutput.exo_simul.
     DynareOutput.exo_simul = zeros(sample_size,number_of_shocks);
     DynareOutput.exo_simul(:,positive_var_indx) = DynareOutput.bnlms.shocks;
-    DynareOutput.exo_simul = [zeros(1,number_of_shocks); DynareOutput.exo_simul];
+    if isfield(DynareModel,'exo_histval') && ~ isempty(DynareModel.exo_histval)
+        DynareOutput.exo_simul = [M_.exo_histval; DynareOutput.exo_simul];
+    else
+        DynareOutput.exo_simul = [zeros(1,number_of_shocks); DynareOutput.exo_simul];
+    end
 else
     DynareOutput.exo_simul = innovations;
 end
 
 % Get usefull vector of indices.
-ny0 = nnz(DynareModel.lead_lag_incidence(2,:));
 ny1 = nnz(DynareModel.lead_lag_incidence(1,:));
 iy1 = find(DynareModel.lead_lag_incidence(1,:)>0);
 idx = 1:DynareModel.endo_nbr;
@@ -92,6 +82,7 @@ hdx = 1:ny1;
 
 % Get the name of the dynamic model routine.
 model_dynamic = str2func([DynareModel.fname,'_dynamic']);
+model_dynamic_s = str2func('dynamic_backward_model_for_simulation');
 
 % initialization of vector y.
 y = NaN(length(idx)+ny1,1);
@@ -99,7 +90,7 @@ y = NaN(length(idx)+ny1,1);
 % initialization of the returned simulations.
 DynareOutput.endo_simul = NaN(DynareModel.endo_nbr,sample_size+1);
 if isempty(initial_conditions)
-    if isfield(DynareModel,'endo_histval')
+    if isfield(DynareModel,'endo_histval') && ~isempty(DynareModel.endo_histval)
         DynareOutput.endo_simul(:,1:DynareModel.maximum_lag) = DynareModel.endo_histval;
     else
         warning('simul_backward_nonlinear_model:: Initial condition is zero for all variables! If the model is nonlinear, the model simulation may fail with the default initialization')
@@ -110,16 +101,12 @@ else
 end
 Y = DynareOutput.endo_simul;
 
+
 % Simulations (call a Newton-like algorithm for each period).
 for it = 2:sample_size+1
-    y(jdx) = Y(:,it-1);                       % A good guess for the initial conditions is the previous values for the endogenous variables.
-    y(hdx) = y(jdx(iy1));                     % Set lagged variables.
-    z = trust_region(model_dynamic, y, idx, jdx, 1, DynareOptions.gstep, ...
-                    DynareOptions.solve_tolf,DynareOptions.solve_tolx, ...
-                    DynareOptions.simul.maxit,DynareOptions.debug, ...
-                    DynareOutput.exo_simul, DynareModel.params, ...
-                    DynareOutput.steady_state, it);
-    Y(:,it) = z(jdx);
+    ylag = Y(iy1,it-1);                   % Set lagged variables.
+    y = Y(:,it-1);                        % A good guess for the initial conditions is the previous values for the endogenous variables.
+    Y(:,it) = dynare_solve(model_dynamic_s, y, DynareOptions, model_dynamic, ylag, DynareOutput.exo_simul, DynareModel.params, DynareOutput.steady_state, it+(DynareModel.maximum_exo_lag-1));
 end
 
 DynareOutput.endo_simul = Y;
\ No newline at end of file
diff --git a/matlab/basic_plan.m b/matlab/basic_plan.m
index c7b4cb360..ae7d6bcbf 100644
--- a/matlab/basic_plan.m
+++ b/matlab/basic_plan.m
@@ -14,7 +14,7 @@ function plan = basic_plan(plan, exogenous, expectation_type, date, value)
 %  plan                   [structure]        Returns a structure containing the updated forecast scenario.
 %
 %
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,60 +31,60 @@ function plan = basic_plan(plan, exogenous, expectation_type, date, value)
 % 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(expectation_type) || size(expectation_type,1) ~= 1
-      error(['in basic_plan the third argument should be a string containing the simulation type (''perfect_foresight'' or ''surprise'')']);
-  end
-  exogenous = strtrim(exogenous);
-  ix = find(strcmp(exogenous, plan.exo_names));
-  if  isempty(ix)
-      error(['in basic_plan the second argument ' exogenous ' is not an exogenous variable']);
-  end;
-  sdate = length(date);
-  if sdate > 1
-      if date(1) < plan.date(1) || date(end) > plan.date(end)
-          error(['in basic_plan the fourth argument (date='  date ') must lay inside the plan.date ' plan.date]);
-      end
-  else
-      if date < plan.date(1) || date > plan.date(end)
-          error(['in basic_plan the fourth argument (date='  date ') must lay iside the plan.date ' plan.date]);
-      end
-  end
-  if length(date) ~= length(value)
-      error(['in basic_plan the number of dates (' int2str(length(date)) ') is not equal to the numbers of shock (' int2str(length(value)) ') for exogenous variable ' exogenous]);
-  end
-  if ~isempty(plan.options_cond_fcst_.controlled_varexo)
-      common_var = find(ix == plan.options_cond_fcst_.controlled_varexo);
-      if ~isempty(common_var)
-          common_date = intersect(date, plan.constrained_date_{common_var});
-          if ~isempty(common_date)
-              [date_, i_date] = setdiff(date, common_date);
-              value = value(i_date);
-              if common_date.length > 1
-                  the_dates = [cell2mat(strings(common_date(1))) ':' cell2mat(strings(common_date(end)))];
-              else
-                  the_dates = cell2mat(strings(common_date));
-              end
-              warning(['Impossible case: ' plan.exo_names{plan.options_cond_fcst_.controlled_varexo(common_var)} ' is used both as a shock and as an endogenous variable to control the path of ' plan.endo_names{plan.constrained_vars_(common_var)} ' at the dates ' the_dates]);
-              warning('This shock will not be considered');
-          end
-      end
-  end
-  if isempty(plan.shock_vars_)
-      plan.shock_vars_ = ix;
-      if strcmp(expectation_type, 'perfect_foresight')
-          plan.shock_perfect_foresight_ = 1;
-      else
-          plan.shock_perfect_foresight_ = 0;
-      end
-  else
-      plan.shock_vars_ = [plan.shock_vars_ ; ix];
-      if strcmp(expectation_type, 'perfect_foresight')
-          plan.shock_perfect_foresight_ = [plan.shock_perfect_foresight_ ; 1];
-      else
-          plan.shock_perfect_foresight_ = [plan.shock_perfect_foresight_ ; 0];
-      end
-  end
-  plan.shock_date_{length(plan.shock_date_) + 1} = date;
-  plan.shock_str_date_{length(plan.shock_str_date_) + 1} = strings(date);
-  plan.shock_int_date_{length(plan.shock_int_date_) + 1} = date - plan.date(1) + 1;
-  plan.shock_paths_{length(plan.shock_paths_) + 1} = value;
+if ~ischar(expectation_type) || size(expectation_type,1) ~= 1
+    error(['in basic_plan the third argument should be a string containing the simulation type (''perfect_foresight'' or ''surprise'')']);
+end
+exogenous = strtrim(exogenous);
+ix = find(strcmp(exogenous, plan.exo_names));
+if  isempty(ix)
+    error(['in basic_plan the second argument ' exogenous ' is not an exogenous variable']);
+end
+sdate = length(date);
+if sdate > 1
+    if date(1) < plan.date(1) || date(end) > plan.date(end)
+        error(['in basic_plan the fourth argument (date='  date ') must lay inside the plan.date ' plan.date]);
+    end
+else
+    if date < plan.date(1) || date > plan.date(end)
+        error(['in basic_plan the fourth argument (date='  date ') must lay iside the plan.date ' plan.date]);
+    end
+end
+if length(date) ~= length(value)
+    error(['in basic_plan the number of dates (' int2str(length(date)) ') is not equal to the numbers of shock (' int2str(length(value)) ') for exogenous variable ' exogenous]);
+end
+if ~isempty(plan.options_cond_fcst_.controlled_varexo)
+    common_var = find(ix == plan.options_cond_fcst_.controlled_varexo);
+    if ~isempty(common_var)
+        common_date = intersect(date, plan.constrained_date_{common_var});
+        if ~isempty(common_date)
+            [date_, i_date] = setdiff(date, common_date);
+            value = value(i_date);
+            if common_date.length > 1
+                the_dates = [cell2mat(strings(common_date(1))) ':' cell2mat(strings(common_date(end)))];
+            else
+                the_dates = cell2mat(strings(common_date));
+            end
+            warning(['Impossible case: ' plan.exo_names{plan.options_cond_fcst_.controlled_varexo(common_var)} ' is used both as a shock and as an endogenous variable to control the path of ' plan.endo_names{plan.constrained_vars_(common_var)} ' at the dates ' the_dates]);
+            warning('This shock will not be considered');
+        end
+    end
+end
+if isempty(plan.shock_vars_)
+    plan.shock_vars_ = ix;
+    if strcmp(expectation_type, 'perfect_foresight')
+        plan.shock_perfect_foresight_ = 1;
+    else
+        plan.shock_perfect_foresight_ = 0;
+    end
+else
+    plan.shock_vars_ = [plan.shock_vars_ ; ix];
+    if strcmp(expectation_type, 'perfect_foresight')
+        plan.shock_perfect_foresight_ = [plan.shock_perfect_foresight_ ; 1];
+    else
+        plan.shock_perfect_foresight_ = [plan.shock_perfect_foresight_ ; 0];
+    end
+end
+plan.shock_date_{length(plan.shock_date_) + 1} = date;
+plan.shock_str_date_{length(plan.shock_str_date_) + 1} = strings(date);
+plan.shock_int_date_{length(plan.shock_int_date_) + 1} = date - plan.date(1) + 1;
+plan.shock_paths_{length(plan.shock_paths_) + 1} = value;
diff --git a/matlab/bksup0.m b/matlab/bksup0.m
index c304b42a4..b801e40e2 100644
--- a/matlab/bksup0.m
+++ b/matlab/bksup0.m
@@ -4,14 +4,14 @@ function d = bksup0(c,ny,jcf,iyf,icf,periods)
 % INPUTS
 %    ny:             number of endogenous variables
 %    jcf:            variables index forward
-%    
+%
 % OUTPUTS
 %    d:              vector of backsubstitution results
 %
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/bksup1.m b/matlab/bksup1.m
index a6bcb3b9f..4e6fb733c 100644
--- a/matlab/bksup1.m
+++ b/matlab/bksup1.m
@@ -5,14 +5,14 @@ function d = bksup1(c,ny,jcf,iyf,periods)
 % INPUTS
 %    ny:             number of endogenous variables
 %    jcf:            variables index forward
-%    
+%
 % OUTPUTS
 %    d:              vector of backsubstitution results
 %
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2010 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,4 +40,3 @@ for i = 2:periods
 end
 
 d = c(:,jcf) ;
-
diff --git a/matlab/bksupk.m b/matlab/bksupk.m
index 33f9c18b0..64de63b8b 100644
--- a/matlab/bksupk.m
+++ b/matlab/bksupk.m
@@ -15,7 +15,7 @@ function d1 = bksupk(ny,fid,jcf,icc1)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2011 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -68,7 +68,7 @@ while i <= options_.periods
     c = fread(fid,[jcf,ny],'float64')' ;
 
     d1(ir) = c(:,jcf)-c(:,icf)*d1(irf) ;
-    ir = ir-ny ;                        
+    ir = ir-ny ;
     irf = irf-ny ;
     i = i+1;
 end
diff --git a/matlab/bseastr.m b/matlab/bseastr.m
index 2ab688e0b..c8b2de0fc 100644
--- a/matlab/bseastr.m
+++ b/matlab/bseastr.m
@@ -1,6 +1,6 @@
 function x = bseastr(s1,s2)
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,16 +33,15 @@ for im = 1:m
             for i = 1:min(length(key),length(temp))
                 if temp(i) > key(i)
                     h = mid - 1 ;
-                    break 
+                    break
                 else
                     l = mid + 1 ;
-                    break 
+                    break
                 end
             end
         else
             x(im) = mid ;
-            break 
+            break
         end
     end
 end
-
diff --git a/matlab/bvar_density.m b/matlab/bvar_density.m
index b147834ed..5c75f18f8 100644
--- a/matlab/bvar_density.m
+++ b/matlab/bvar_density.m
@@ -12,7 +12,7 @@ function bvar_density(maxnlags)
 %    none
 
 % Copyright (C) 2003-2007 Christopher Sims
-% Copyright (C) 2007-2016 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -37,16 +37,16 @@ for nlags = 1:maxnlags
     [ny, nx, posterior, prior] = bvar_toolbox(nlags);
     oo_.bvar.posterior{nlags}=posterior;
     oo_.bvar.prior{nlags}=prior;
-    
+
     posterior_int = matrictint(posterior.S, posterior.df, posterior.XXi);
     prior_int = matrictint(prior.S, prior.df, prior.XXi);
-    
+
     lik_nobs = posterior.df - prior.df;
-    
+
     log_dnsty = posterior_int - prior_int - 0.5*ny*lik_nobs*log(2*pi);
-    
+
     oo_.bvar.log_marginal_data_density(nlags)=log_dnsty;
-    
+
     skipline()
     fprintf('The marginal log density of the BVAR(%g) model is equal to %10.4f\n', ...
             nlags, log_dnsty);
@@ -61,7 +61,7 @@ function w = matrictint(S, df, XXi)
 % S:   parameter of inverse-Wishart distribution
 % df:  number of degrees of freedom of inverse-Wishart distribution
 % XXi: first component of VCV matrix of matrix-normal distribution
-% 
+%
 % Computes the integral over (Phi, Sigma) of:
 %
 % det(Sigma)^(-k/2)*exp(-0.5*Tr((Phi-PhiHat)'*(XXi)^(-1)*(Phi-PhiHat)*Sigma^(-1)))*
diff --git a/matlab/bvar_forecast.m b/matlab/bvar_forecast.m
index 9b22ff679..55fdf9ce9 100644
--- a/matlab/bvar_forecast.m
+++ b/matlab/bvar_forecast.m
@@ -11,7 +11,7 @@ function bvar_forecast(nlags)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2007-2013 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,7 +54,7 @@ p = 0;
 % Loop counter initialization
 d = 0;
 while d <= options_.bvar_replic
-    
+
     Sigma = rand_inverse_wishart(ny, posterior.df, S_inv_upper_chol);
 
     % Option 'lower' of chol() not available in old versions of
@@ -62,15 +62,15 @@ while d <= options_.bvar_replic
     Sigma_lower_chol = chol(Sigma)';
 
     Phi = rand_matrix_normal(k, ny, posterior.PhiHat, Sigma_lower_chol, XXi_lower_chol);
-    
+
     % All the eigenvalues of the companion matrix have to be on or inside the unit circle
-    Companion_matrix(1:ny,:) = Phi(1:ny*nlags,:)'; 
+    Companion_matrix(1:ny,:) = Phi(1:ny*nlags,:)';
     test = (abs(eig(Companion_matrix)));
     if any(test>1.0000000000001)
         p = p+1;
     end
     d = d+1;
-    
+
     % Without shocks
     lags_data = forecast_data.initval;
     for t = 1:options_.forecast
@@ -80,7 +80,7 @@ while d <= options_.bvar_replic
         lags_data(end,:) = y;
         sims_no_shock(t, :, d) = y;
     end
-    
+
     % With shocks
     lags_data = forecast_data.initval;
     for t = 1:options_.forecast
@@ -120,19 +120,19 @@ dyn_graph=dynare_graph_init(sprintf('BVAR forecasts (nlags = %d)', nlags), ny, {
 
 for i = 1:ny
     dyn_graph=dynare_graph(dyn_graph,[ sims_no_shock_median(:, i) ...
-                   sims_no_shock_up_conf(:, i) sims_no_shock_down_conf(:, i) ...
-                   sims_with_shocks_up_conf(:, i) sims_with_shocks_down_conf(:, i) ], ...
-                 options_.varobs{i});
+                        sims_no_shock_up_conf(:, i) sims_no_shock_down_conf(:, i) ...
+                        sims_with_shocks_up_conf(:, i) sims_with_shocks_down_conf(:, i) ], ...
+                           options_.varobs{i});
 end
 
-dyn_saveas(dyn_graph.fh,[OutputDirectoryName '/' M_.fname '_BVAR_forecast_',num2str(nlags)],options_)
+dyn_saveas(dyn_graph.fh,[OutputDirectoryName '/' M_.fname '_BVAR_forecast_',num2str(nlags)],options_.nodisplay,options_.graph_format)
 
 % Compute RMSE
 
 if ~isempty(forecast_data.realized_val)
-    
+
     sq_err_cumul = zeros(1, ny);
-    
+
     lags_data = forecast_data.initval;
     for t = 1:size(forecast_data.realized_val, 1)
         X = [ reshape(flipdim(lags_data, 1)', 1, ny*nlags) forecast_data.realized_xdata(t, :) ];
@@ -141,14 +141,14 @@ if ~isempty(forecast_data.realized_val)
         lags_data(end,:) = y;
         sq_err_cumul = sq_err_cumul + (y - forecast_data.realized_val(t, :)) .^ 2;
     end
-    
+
     rmse = sqrt(sq_err_cumul / size(forecast_data.realized_val, 1));
-    
+
     fprintf('RMSE of BVAR(%d):\n', nlags);
-    
+
     for i = 1:length(options_.varobs)
         fprintf('%s: %10.4f\n', options_.varobs{i}, rmse(i));
-    end 
+    end
 end
 
 % Store results
diff --git a/matlab/bvar_irf.m b/matlab/bvar_irf.m
index 17228b5c4..5f017aa7d 100644
--- a/matlab/bvar_irf.m
+++ b/matlab/bvar_irf.m
@@ -11,7 +11,7 @@ function bvar_irf(nlags,identification)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2007-2012 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,7 +54,7 @@ p = 0;
 sampled_irfs = NaN(ny, ny, options_.irf, options_.bvar_replic);
 
 for draw=1:options_.bvar_replic
-    
+
     % Get a covariance matrix from an inverted Wishart distribution.
     Sigma = rand_inverse_wishart(ny, posterior.df, S_inv_upper_chol);
     Sigma_upper_chol = chol(Sigma);
@@ -62,10 +62,10 @@ for draw=1:options_.bvar_replic
 
     % Get the Autoregressive matrices from a matrix variate distribution.
     Phi = rand_matrix_normal(k, ny, posterior.PhiHat, Sigma_lower_chol, XXi_lower_chol);
-    
+
     % Form the companion matrix.
-    Companion_matrix(1:ny,:) = transpose(Phi(1:ny*nlags,:)); 
-    
+    Companion_matrix(1:ny,:) = transpose(Phi(1:ny*nlags,:));
+
     % All the eigenvalues of the companion matrix have to be on or
     % inside the unit circle to rule out explosive time series.
     test = (abs(eig(Companion_matrix)));
@@ -78,7 +78,7 @@ for draw=1:options_.bvar_replic
     elseif strcmpi(identification,'SquareRoot')
         StructuralMat = sqrtm(Sigma);
     end
-    
+
     % Build the IRFs...
     lags_data = zeros(ny,ny*nlags) ;
     sampled_irfs(:,:,1,draw) = Sigma_lower_chol ;
@@ -88,7 +88,7 @@ for draw=1:options_.bvar_replic
         lags_data(:,ny+1:end) = lags_data(:,1:end-ny) ;
         lags_data(:,1:ny) = sampled_irfs(:,:,t,draw) ;
     end
-    
+
 end
 
 if p > 0
@@ -106,7 +106,7 @@ sort_idx = round((0.5 + [-options_.bvar.conf_sig, options_.bvar.conf_sig, .0]/2)
 
 posterior_down_conf_irfs = sorted_irfs(:,:,:,sort_idx(1));
 posterior_up_conf_irfs = sorted_irfs(:,:,:,sort_idx(2));
-posterior_median_irfs = sorted_irfs(:,:,:,sort_idx(3));   
+posterior_median_irfs = sorted_irfs(:,:,:,sort_idx(3));
 
 number_of_columns = fix(sqrt(ny));
 number_of_rows = ceil(ny / number_of_columns) ;
diff --git a/matlab/bvar_toolbox.m b/matlab/bvar_toolbox.m
index 76c95ef9d..4393e21ac 100644
--- a/matlab/bvar_toolbox.m
+++ b/matlab/bvar_toolbox.m
@@ -29,7 +29,7 @@ function [ny, nx, posterior, prior, forecast_data] = bvar_toolbox(nlags)
 %                     forecasting, of size options_.forecast*nx (actually only
 %                     contains "1" values for the constant term if nx ~= 0)
 %                   - realized_val: only non-empty if options_.nobs doesn't point
-%                     to the end of sample    
+%                     to the end of sample
 %                     In that case, contains values of endogenous variables after
 %                     options_.nobs and up to the end of the sample
 %                   - realized_xdata: contains values of exogenous variables after
@@ -42,7 +42,7 @@ function [ny, nx, posterior, prior, forecast_data] = bvar_toolbox(nlags)
 %    - bvar_prior_{tau,decay,lambda,mu,omega,flat,train}
 
 % Copyright (C) 2003-2007 Christopher Sims
-% Copyright (C) 2007-2012 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ options_ = set_default_option(options_, 'nobs', size(dataset,1)-options_.first_o
 
 if (options_.first_obs+options_.nobs-1)> size(dataset,1)
     fprintf('Incorrect or missing specification of the number of observations. nobs can be at most %4u\n',size(dataset,1)-options_.first_obs+1);
-    error('Inconsistent number of observations.') 
+    error('Inconsistent number of observations.')
 end
 
 % Parameters for prior
@@ -160,7 +160,7 @@ function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
 %function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
 % ydum, xdum:   dummy observation data that implement the prior
 % breaks:       vector of points in the dummy data after which new dummy obs's start
-%                   Set breaks=T+[0;breaks], ydata=[ydata;ydum], xdum=[xdata;xdum], where 
+%                   Set breaks=T+[0;breaks], ydata=[ydata;ydum], xdum=[xdata;xdum], where
 %                   actual data matrix has T rows, in preparing input for rfvar3
 % nv,nx,lags: VAR dimensions
 % mnprior.tight:Overall tightness of Minnesota prior
@@ -175,8 +175,8 @@ function [ydum,xdum,breaks]=varprior(nv,nx,lags,mnprior,vprior)
 %                   taken to include the sum-of-coefficients and co-persistence components
 %                   that are implemented directly in rfvar3.m.  The diagonal prior on v, combined
 %                   with sum-of-coefficients and co-persistence components and with the unit own-first-lag
-%                   prior mean generates larger prior variances for own than for cross-effects even in 
-%                   this formulation, but here there is no way to shrink toward a set of unconstrained 
+%                   prior mean generates larger prior variances for own than for cross-effects even in
+%                   this formulation, but here there is no way to shrink toward a set of unconstrained
 %                   univariate AR's.
 
 % Original file downloaded from:
@@ -228,9 +228,9 @@ function var=rfvar3(ydata,lags,xdata,breaks,lambda,mu)
 %          discontinuities in the data (e.g. war years) and for the possibility of
 %          adding dummy observations to implement a prior.  This must be a column vector.
 %          Note that a single dummy observation becomes lags+1 rows of the data matrix,
-%          with a break separating it from the rest of the data.  The function treats the 
+%          with a break separating it from the rest of the data.  The function treats the
 %          first lags observations at the top and after each "break" in ydata and xdata as
-%          initial conditions. 
+%          initial conditions.
 % lambda:  weight on "co-persistence" prior dummy observations.  This expresses
 %          belief that when data on *all* y's are stable at their initial levels, they will
 %          tend to persist at that level.  lambda=5 is a reasonable first try.  With lambda<0,
@@ -243,7 +243,7 @@ function var=rfvar3(ydata,lags,xdata,breaks,lambda,mu)
 %          one of these for each variable.  A reasonable first guess is mu=2.
 %      The program assumes that the first lags rows of ydata and xdata are real data, not dummies.
 %      Dummy observations should go at the end, if any.  If pre-sample x's are not available,
-%      repeating the initial xdata(lags+1,:) row or copying xdata(lags+1:2*lags,:) into 
+%      repeating the initial xdata(lags+1,:) row or copying xdata(lags+1:2*lags,:) into
 %      xdata(1:lags,:) are reasonable subsititutes.  These values are used in forming the
 %      persistence priors.
 
@@ -280,7 +280,7 @@ for is = 1:length(smpl)
 end
 X = [X(:,:) xdata(smpl,:)];
 y = ydata(smpl,:);
-% Everything now set up with input data for y=Xb+e 
+% Everything now set up with input data for y=Xb+e
 
 % Add persistence dummies
 if lambda ~= 0 || mu > 0
diff --git a/matlab/cartesian_product_of_sets.m b/matlab/cartesian_product_of_sets.m
index 8901886ff..9fbe37c07 100644
--- a/matlab/cartesian_product_of_sets.m
+++ b/matlab/cartesian_product_of_sets.m
@@ -5,7 +5,7 @@ function cprod = cartesian_product_of_sets(varargin)
 %! @deftypefn {Function File} {@var{cprod} =} cartesian_product_of_sets (@var{a},@var{b}, ...)
 %! @anchor{cartesian_product_of_sets}
 %! @sp 1
-%! Computes A_1 * A_2 * .... * A_n with a generic set A_i = {e_1,e_2,e_3,...} where e_i is a string 
+%! Computes A_1 * A_2 * .... * A_n with a generic set A_i = {e_1,e_2,e_3,...} where e_i is a string
 %! or a number. It is assumed that each element e_i is unique in set A_i.
 %! @sp 2
 %! @strong{Inputs}
@@ -31,7 +31,7 @@ function cprod = cartesian_product_of_sets(varargin)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/cellofchar2mfile.m b/matlab/cellofchar2mfile.m
index 6cfce7c5f..6160f5a47 100644
--- a/matlab/cellofchar2mfile.m
+++ b/matlab/cellofchar2mfile.m
@@ -2,14 +2,14 @@ function cellofchar2mfile(fname, c, cname)
 
 % Write a cell of char in a matlab script.
 %
-% INPUTS 
+% INPUTS
 % - fname [string] name of the file where c is to be saved.
 % - c     [cell]   a two dimensional cell of char.
 %
-% OUTPUTS 
+% OUTPUTS
 % None.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/check.m b/matlab/check.m
index a0e7aa1bb..f97a758f4 100644
--- a/matlab/check.m
+++ b/matlab/check.m
@@ -40,7 +40,7 @@ function [eigenvalues_,result,info] = check(M, options, oo)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2001-2013 Dynare Team
+% Copyright (C) 2001-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/check_dsge_var_model.m b/matlab/check_dsge_var_model.m
index 8b16ec09d..fb06d42ee 100644
--- a/matlab/check_dsge_var_model.m
+++ b/matlab/check_dsge_var_model.m
@@ -2,7 +2,7 @@ function check_dsge_var_model(Model, EstimatedParameters, BayesInfo)
 
 % Check if the dsge model can be estimated with the DSGE-VAR approach.
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/check_for_calibrated_covariances.m b/matlab/check_for_calibrated_covariances.m
index b6d960c2b..7bf00e6a4 100644
--- a/matlab/check_for_calibrated_covariances.m
+++ b/matlab/check_for_calibrated_covariances.m
@@ -12,7 +12,7 @@ function estim_params=check_for_calibrated_covariances(xparam1,estim_params,M)
 % Notes: M is local to this function and not updated when calling
 % set_all_parameters
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,7 +42,7 @@ calibrated_covariance_pos=covariance_pos(~ismember(covariance_pos,correlation_po
 if any(calibrated_covariance_pos)
     [rows, columns]=ind2sub(size(M.Sigma_e),calibrated_covariance_pos); %find linear indices of lower triangular covariance entries
     estim_params.calibrated_covariances.position=[calibrated_covariance_pos;sub2ind(size(M.Sigma_e),columns,rows)]; %get linear entries of upper triangular parts
-    estim_params.calibrated_covariances.cov_value=Sigma_e_calibrated(estim_params.calibrated_covariances.position);  
+    estim_params.calibrated_covariances.cov_value=Sigma_e_calibrated(estim_params.calibrated_covariances.position);
 end
 
 correlation_pos_ME=find(tril(M.Correlation_matrix_ME,-1)); %off-diagonal elements set by correlations after accounting for estimation
@@ -50,6 +50,5 @@ calibrated_covariance_pos_ME=covariance_pos_ME(~ismember(covariance_pos_ME,corre
 if any(calibrated_covariance_pos_ME)
     [rows, columns]=ind2sub(size(M.H),calibrated_covariance_pos_ME); %find linear indices of lower triangular covariance entries
     estim_params.calibrated_covariances_ME.position=[calibrated_covariance_pos_ME;sub2ind(size(M.H),columns,rows)]; %get linear entries of upper triangular parts
-    estim_params.calibrated_covariances_ME.cov_value=H_calibrated(estim_params.calibrated_covariances_ME.position);  
+    estim_params.calibrated_covariances_ME.cov_value=H_calibrated(estim_params.calibrated_covariances_ME.position);
 end
-
diff --git a/matlab/check_list_of_variables.m b/matlab/check_list_of_variables.m
index e9fb3be3b..7bf05e478 100644
--- a/matlab/check_list_of_variables.m
+++ b/matlab/check_list_of_variables.m
@@ -1,20 +1,20 @@
 function varlist = check_list_of_variables(options_, M_, varlist)
 % This function defines, if necessary, the list of endogenous variables
-% for which the posterior statistics have to be computed. 
-% 
+% for which the posterior statistics have to be computed.
 %
-% INPUTS 
+%
+% INPUTS
 %
 %   options_        [structure]    Dynare structure.
 %   M_              [structure]    Dynare structure (related to model definition).
 %   varlist         [string]       Array of strings with name of the endogenous variables.
-%    
-% OUTPUTS 
-%   varlist         [string] 
-%        
+%
+% OUTPUTS
+%   varlist         [string]
+%
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2014 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,8 +33,8 @@ function varlist = check_list_of_variables(options_, M_, varlist)
 
 %get uniques
 
-[junk1,junk2,index_uniqes] = varlist_indices(varlist,M_.endo_names);
-varlist=varlist(index_uniqes,:);
+[junk1,junk2,index_uniques] = varlist_indices(varlist,M_.endo_names);
+varlist=varlist(index_uniques,:);
 
 msg = 0;
 if options_.dsge_var && options_.bayesian_irf
@@ -63,7 +63,7 @@ if ~isempty(varlist) && ~isempty(options_.endo_vars_for_moment_computations_in_e
     error('You cannot use the consider_all_endogenous or consider_all_observed options when listing variables after the estimation command')
 elseif isempty(varlist) && ~isempty(options_.endo_vars_for_moment_computations_in_estimation)
     if strcmp(options_.endo_vars_for_moment_computations_in_estimation,'all_endogenous_variables')
-        varlist = M_.endo_names(1:M_.orig_endo_nbr, :);    
+        varlist = M_.endo_names(1:M_.orig_endo_nbr, :);
     elseif strcmp(options_.endo_vars_for_moment_computations_in_estimation,'only_observed_variables')
         varlist = char(options_.varobs');
     else
@@ -106,7 +106,7 @@ elseif isempty(varlist) && isempty(options_.endo_vars_for_moment_computations_in
     end
     if ~isempty(cas)
         string = [ cas , ' will be computed for the ' num2str(M_.endo_nbr)  ' endogenous variables'];
-        string = [ string ' of your model, this can be very long....']; 
+        string = [ string ' of your model, this can be very long....'];
         format_text(string, 10)
         if options_.nointeractive
             % Default behaviour is to consider all the endogenous variables.
diff --git a/matlab/check_matlab_path.m b/matlab/check_matlab_path.m
index 3817def6b..8f0d187c3 100644
--- a/matlab/check_matlab_path.m
+++ b/matlab/check_matlab_path.m
@@ -1,6 +1,6 @@
 function check_matlab_path(change_path_flag)
-    
-% Copyright (C) 2015-2016 Dynare Team
+
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -82,7 +82,7 @@ else
                     warning(msg);
                     skipline()
                     rmpath(DYNARE_PATH)
-                    addpath(DYNARE_PATH)    
+                    addpath(DYNARE_PATH)
                 end
                 warning on backtrace
             end
@@ -90,7 +90,7 @@ else
     else
         % Check that the user did not put all the subfolders in the path.
         % => If DYNARE_PATH/qz is in the path while mjdgges dll is available
-        % it most likely means that user wrongly put all subfolders in the 
+        % it most likely means that user wrongly put all subfolders in the
         % matlab's path!
         mexpath = add_path_to_mex_files([DYNARE_PATH filesep], false);
         MATLAB_PATH = path2cell(MATLAB_PATH);
@@ -107,40 +107,40 @@ else
 end
 
 function q = path2cell(p)
-    % Converts the output of path() to a cell 
-    s = strfind(p,pathsep);
-    n = length(s)+1;
-    q = cell(n,1);
-    q(1) = {p(1:s(1)-1)};
-    q(n) = {p(s(end)+1:end)};
-    for i=2:n-1
-        q(i) = {p(s(i-1)+1:s(i)-1)}; 
-    end
-    
+% Converts the output of path() to a cell
+s = strfind(p,pathsep);
+n = length(s)+1;
+q = cell(n,1);
+q(1) = {p(1:s(1)-1)};
+q(n) = {p(s(end)+1:end)};
+for i=2:n-1
+    q(i) = {p(s(i-1)+1:s(i)-1)};
+end
+
 function flist = getallroutinenames(p, excludedsubfolders)
-    if nargin<2
-        excludedsubfolders = {};
-    end
-    flist={};
-    %get m-files in this directory
-    dd = dir([p,filesep '*.m']);
-    temp=struct2cell(dd);
-    flist=[flist temp(1,:)];
-    %deal with subdirectories
-    dlist=getalldirectories(p,excludedsubfolders); %first call with excluded directories
-    for ii=1:length(dlist)
-        flist=[flist getallroutinenames([ p filesep dlist{ii}])]; %recursive calls without subfolders
-    end
-    
+if nargin<2
+    excludedsubfolders = {};
+end
+flist={};
+%get m-files in this directory
+dd = dir([p,filesep '*.m']);
+temp=struct2cell(dd);
+flist=[flist temp(1,:)];
+%deal with subdirectories
+dlist=getalldirectories(p,excludedsubfolders); %first call with excluded directories
+for ii=1:length(dlist)
+    flist=[flist getallroutinenames([ p filesep dlist{ii}])]; %recursive calls without subfolders
+end
+
 
 function dlist = getalldirectories(p,excluded_directories)
-    if nargin<2
-        excluded_directories = {};
-    end
-    dd = dir(p);
-    dir_result=struct2cell(dd);
-    directory_indicator=cell2mat(dir_result(4,:));
-    dlist = dir_result(1,directory_indicator==1 & ~strcmp('.',dir_result(1,:)) & ~strcmp('..',dir_result(1,:)) & ~ismember(dir_result(1,:),excluded_directories));
+if nargin<2
+    excluded_directories = {};
+end
+dd = dir(p);
+dir_result=struct2cell(dd);
+directory_indicator=cell2mat(dir_result(4,:));
+dlist = dir_result(1,directory_indicator==1 & ~strcmp('.',dir_result(1,:)) & ~strcmp('..',dir_result(1,:)) & ~ismember(dir_result(1,:),excluded_directories));
 
 function n = position(i, currentpath)
-    n = length(strfind(currentpath(1:i), pathsep));
\ No newline at end of file
+n = length(strfind(currentpath(1:i), pathsep));
\ No newline at end of file
diff --git a/matlab/check_model.m b/matlab/check_model.m
index 60cf7cba1..1abc89db1 100644
--- a/matlab/check_model.m
+++ b/matlab/check_model.m
@@ -1,6 +1,6 @@
 function check_model(DynareModel)
 
-% Copyright (C) 2005-2012 Dynare Team
+% Copyright (C) 2005-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/check_posterior_analysis_data.m b/matlab/check_posterior_analysis_data.m
index b1d25b3d1..75aa78a7f 100644
--- a/matlab/check_posterior_analysis_data.m
+++ b/matlab/check_posterior_analysis_data.m
@@ -1,13 +1,13 @@
 function [info,description] = check_posterior_analysis_data(type,M_)
 % function [info,description] = check_posterior_analysis_data(type,M_)
-% Checks the status of posterior analysis and in particular if files need to be 
+% Checks the status of posterior analysis and in particular if files need to be
 % created or updated; called by posterior_analysis.m
-% 
+%
 % Inputs:
 %   type        [string]        name of the posterior moment considered
 %   M_          [structure]     Dynare model structure
-% 
-% Outputs: 
+%
+% Outputs:
 %   info        [scalar]        return code
 %                                   info = 1; % select_posterior_draws has to be called first.
 %                                   info = 2; % _posterior_draws files have to be updated.
@@ -17,7 +17,7 @@ function [info,description] = check_posterior_analysis_data(type,M_)
 %                                   info = 6; % Ok (nothing to do ;-)
 %   description [string]        Message corresponding to info
 
-% Copyright (C) 2008-2015 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -99,7 +99,7 @@ else
     number_of_the_last_post_data_file = length(pdfinfo);
     name_of_the_last_post_data_file = ...
         [ pwd filesep MetropolisFolder filesep ...
-          M_.fname '_' ... 
+          M_.fname '_' ...
           generic_post_data_file_name ...
           int2str(number_of_the_last_post_data_file) ...
           '.mat' ];
@@ -108,7 +108,7 @@ else
         info = 5; % posterior data files have to be updated.
         if nargout>1
             description = 'posterior data files have to be updated.';
-        end            
+        end
     else
         info = 6; % Ok (nothing to do ;-)
         if nargout>1
diff --git a/matlab/check_posterior_sampler_options.m b/matlab/check_posterior_sampler_options.m
index 299b4b3f6..4683639f3 100644
--- a/matlab/check_posterior_sampler_options.m
+++ b/matlab/check_posterior_sampler_options.m
@@ -13,7 +13,7 @@ function [posterior_sampler_options, options_] = check_posterior_sampler_options
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,347 +32,347 @@ function [posterior_sampler_options, options_] = check_posterior_sampler_options
 
 
 init=0;
-if isempty(posterior_sampler_options),
+if isempty(posterior_sampler_options)
     init=1;
 end
 
-if init,
+if init
     % set default options and user defined options
     posterior_sampler_options.posterior_sampling_method = options_.posterior_sampler_options.posterior_sampling_method;
     posterior_sampler_options.bounds = bounds;
-    
+
     switch posterior_sampler_options.posterior_sampling_method
-        
-        case 'random_walk_metropolis_hastings'
-            posterior_sampler_options.parallel_bar_refresh_rate=50;
-            posterior_sampler_options.serial_bar_refresh_rate=3;
-            posterior_sampler_options.parallel_bar_title='RWMH';
-            posterior_sampler_options.serial_bar_title='RW Metropolis-Hastings';
-            
-            % default options
-            posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.rwmh);
-            
-            % user defined options
-            if ~isempty(options_.posterior_sampler_options.sampling_opt)
-                options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
-                for i=1:rows(options_list)
-                    switch options_list{i,1}
-                        
-                        case 'proposal_distribution'
-                            if ~(strcmpi(options_list{i,2}, 'rand_multivariate_student') || ...
-                                    strcmpi(options_list{i,2}, 'rand_multivariate_normal'))
-                                error(['initial_estimation_checks:: the proposal_distribution option to estimation takes either ' ...
-                                    'rand_multivariate_student or rand_multivariate_normal as options']);
-                            else
-                                posterior_sampler_options.proposal_distribution=options_list{i,2};
-                            end
-                            
-                            
-                        case 'student_degrees_of_freedom'
-                            if options_list{i,2} <= 0
-                                error('initial_estimation_checks:: the student_degrees_of_freedom takes a positive integer argument');
-                            else
-                                posterior_sampler_options.student_degrees_of_freedom=options_list{i,2};
-                            end
-                            
-                        case 'use_mh_covariance_matrix'
-                            % indicates to use the covariance matrix from previous iterations to
-                            % define the covariance of the proposal distribution
-                            % default = 0
-                            posterior_sampler_options.use_mh_covariance_matrix = options_list{i,2};
-                            options_.use_mh_covariance_matrix = options_list{i,2};
-                        case 'scale_file'
-                            % load optimal_mh_scale parameter if previous run was with mode_compute=6
-                            % will overwrite jscale from set_prior.m
-                            if exist(options_list{i,2},'file') || exist([options_list{i,2},'.mat'],'file')
-                                tmp = load(options_list{i,2},'Scale');
-                                global bayestopt_
-                                bayestopt_.mh_jscale = tmp.Scale;
-                                options_.mh_jscale = tmp.Scale;
-                                bayestopt_.jscale = ones(size(bounds.lb,1),1)*tmp.Scale;
-%                                 options_.mh_init_scale = 2*options_.mh_jscale;
-                            else
-                                error('initial_estimation_checks:: The specified mh_scale_file does not exist.')
-                            end
-                        case 'save_tmp_file'
-                            posterior_sampler_options.save_tmp_file = options_list{i,2};
-                        otherwise
-                            warning(['rwmh_sampler: Unknown option (' options_list{i,1} ')!'])
-                    end
-                end
-            end
-            
-        case 'tailored_random_block_metropolis_hastings'
-            posterior_sampler_options.parallel_bar_refresh_rate=5;
-            posterior_sampler_options.serial_bar_refresh_rate=1;
-            posterior_sampler_options.parallel_bar_title='TaRB-MH';
-            posterior_sampler_options.serial_bar_title='TaRB Metropolis-Hastings';
-            
-            % default options
-            posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.tarb);
-            
-            % user defined options
-            if ~isempty(options_.posterior_sampler_options.sampling_opt)
-                options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
-                for i=1:rows(options_list)
-                    
-                    switch options_list{i,1}
-                        
-                        case 'proposal_distribution'
-                            if ~(strcmpi(options_list{i,2}, 'rand_multivariate_student') || ...
-                                    strcmpi(options_list{i,2}, 'rand_multivariate_normal'))
-                                error(['initial_estimation_checks:: the proposal_distribution option to estimation takes either ' ...
-                                    'rand_multivariate_student or rand_multivariate_normal as options']);
-                            else
-                                posterior_sampler_options.proposal_distribution=options_list{i,2};
-                            end
-                            
-                            
-                        case 'student_degrees_of_freedom'
-                            if options_list{i,2} <= 0
-                                error('initial_estimation_checks:: the student_degrees_of_freedom takes a positive integer argument');
-                            else
-                                posterior_sampler_options.student_degrees_of_freedom=options_list{i,2};
-                            end
-                            
-                        case 'mode_compute'
-                            posterior_sampler_options.mode_compute=options_list{i,2};
-                            
-                        case 'optim'
-                            posterior_sampler_options.optim_opt=options_list{i,2};
 
-                        case 'new_block_probability'
-                            if options_list{i,2}<0 || options_list{i,2}>1
-                                error('check_posterior_sampler_options:: The tarb new_block_probability must be between 0 and 1!')
-                            else
-                                posterior_sampler_options.new_block_probability=options_list{i,2};
-                            end
-                        case 'scale_file'
-                            % load optimal_mh_scale parameter if previous run was with mode_compute=6
-                            % will overwrite jscale from set_prior.m
-                            if exist(options_list{i,2},'file') || exist([options_list{i,2},'.mat'],'file')
-                                tmp = load(options_list{i,2},'Scale');
-                                global bayestopt_
-                                bayestopt_.mh_jscale = tmp.Scale;
-                                options_.mh_jscale = tmp.Scale;
-                                bayestopt_.jscale = ones(size(bounds.lb,1),1)*tmp.Scale;
-%                                 options_.mh_init_scale = 2*options_.mh_jscale;
-                            else
-                                error('initial_estimation_checks:: The specified scale_file does not exist.')
-                            end
-                        case 'save_tmp_file'
-                            posterior_sampler_options.save_tmp_file = options_list{i,2};
-    
-                        otherwise
-                            warning(['tarb_sampler: Unknown option (' options_list{i,1} ')!'])
-                            
-                    end
-                    
-                end
-                
-            end
-            
-        case 'independent_metropolis_hastings'
-            posterior_sampler_options.parallel_bar_refresh_rate=50;
-            posterior_sampler_options.serial_bar_refresh_rate=3;
-            posterior_sampler_options.parallel_bar_title='IMH';
-            posterior_sampler_options.serial_bar_title='Ind. Metropolis-Hastings';
-            
-            % default options
-            posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.imh);
-            
-            % user defined options
-            if ~isempty(options_.posterior_sampler_options.sampling_opt)
-                options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
-                for i=1:rows(options_list)
-                    switch options_list{i,1}
-                        
-                        case 'proposal_distribution'
-                            if ~(strcmpi(options_list{i,2}, 'rand_multivariate_student') || ...
-                                    strcmpi(options_list{i,2}, 'rand_multivariate_normal'))
-                                error(['initial_estimation_checks:: the proposal_distribution option to estimation takes either ' ...
-                                    'rand_multivariate_student or rand_multivariate_normal as options']);
-                            else
-                                posterior_sampler_options.proposal_distribution=options_list{i,2};
-                            end
-                            
-                            
-                        case 'student_degrees_of_freedom'
-                            if options_list{i,2} <= 0
-                                error('initial_estimation_checks:: the student_degrees_of_freedom takes a positive integer argument');
-                            else
-                                posterior_sampler_options.student_degrees_of_freedom=options_list{i,2};
-                            end
-                            
-                        case 'use_mh_covariance_matrix'
-                            % indicates to use the covariance matrix from previous iterations to
-                            % define the covariance of the proposal distribution
-                            % default = 0
-                            posterior_sampler_options.use_mh_covariance_matrix = options_list{i,2};
-                            options_.use_mh_covariance_matrix = options_list{i,2};
-                            
-                        case 'save_tmp_file'
-                            posterior_sampler_options.save_tmp_file = options_list{i,2};
+      case 'random_walk_metropolis_hastings'
+        posterior_sampler_options.parallel_bar_refresh_rate=50;
+        posterior_sampler_options.serial_bar_refresh_rate=3;
+        posterior_sampler_options.parallel_bar_title='RWMH';
+        posterior_sampler_options.serial_bar_title='RW Metropolis-Hastings';
 
-                        otherwise
-                            warning(['imh_sampler: Unknown option (' options_list{i,1} ')!'])
-                    end
-                end
-            end
-            
-            
-        case 'slice'
-            posterior_sampler_options.parallel_bar_refresh_rate=1;
-            posterior_sampler_options.serial_bar_refresh_rate=1;
-            posterior_sampler_options.parallel_bar_title='SLICE';
-            posterior_sampler_options.serial_bar_title='SLICE';
-            
-            % default options
-            posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.slice);
-            
-            % user defined options
-            if ~isempty(options_.posterior_sampler_options.sampling_opt)
-                options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
-                for i=1:rows(options_list)
-                    switch options_list{i,1}
-                        case 'rotated'
-                            % triggers rotated slice iterations using a covariance
-                            % matrix from initial burn-in iterations
-                            % must be associated with:
-                            % <use_mh_covariance_matrix> or <slice_initialize_with_mode>
-                            % default  = 0
-                            posterior_sampler_options.rotated = options_list{i,2};
-                            
-                        case 'mode'
-                            % for multimodal posteriors, provide the list of modes as a
-                            % matrix, ordered by column, i.e. [x1 x2 x3] for three
-                            % modes x1 x2 x3
-                            % MR note: not sure this is possible with the
-                            % read_key_value_string ???
-                            % if this is not possible <mode_files> does to job in any case
-                            % This will automatically trigger <rotated>
-                            % default = []
-                            tmp_mode = options_list{i,2};
-                            for j=1:size(tmp_mode,2),
-                                posterior_sampler_options.mode(j).m = tmp_mode(:,j);
-                            end
-                            
-                        case 'mode_files'
-                            % for multimodal posteriors provide the name of
-                            % a file containing a variable array xparams = [nparam * nmodes]
-                            % one column per mode. With this info, the code will automatically
-                            % set the <mode> option. 
-                            % This will automatically trigger <rotated>
-                            % default = []
-                            posterior_sampler_options.mode_files = options_list{i,2};
-                            
-                        case 'slice_initialize_with_mode'
-                            % the default for slice is to set mode_compute = 0 in the
-                            % preprocessor and start the chain(s) from a random location in the prior.
-                            % This option first runs the optimizer and then starts the
-                            % chain from the mode. Associated with optios <rotated>, it will
-                            % use invhess from the mode to perform rotated slice
-                            % iterations.
-                            % default = 0
-                            posterior_sampler_options.slice_initialize_with_mode = options_list{i,2};
-                            
-                        case 'initial_step_size'
-                            % sets the initial size of the interval in the STEPPING-OUT PROCEDURE
-                            % the initial_step_size must be a real number in [0, 1],
-                            % and it sets the size as a proportion of the prior bounds,
-                            % i.e. the size will be initial_step_size*(UB-LB)
-                            % slice sampler requires prior_truncation > 0!
-                            % default = 0.8
-                            if options_list{i,2}<=0 || options_list{i,2}>=1
-                                error('check_posterior_sampler_options:: slice initial_step_size must be between 0 and 1')
-                            else
-                                posterior_sampler_options.initial_step_size=options_list{i,2};
-                            end
-                        case 'use_mh_covariance_matrix'
-                            % in association with <rotated> indicates to use the
-                            % covariance matrix from previous iterations to define the
-                            % rotated slice
-                            % default = 0
-                            posterior_sampler_options.use_mh_covariance_matrix = options_list{i,2};
-                            options_.use_mh_covariance_matrix = options_list{i,2};
+        % default options
+        posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.rwmh);
 
-                        case 'save_tmp_file'
-                            posterior_sampler_options.save_tmp_file = options_list{i,2};
-                            
-                        otherwise
-                            warning(['slice_sampler: Unknown option (' options_list{i,1} ')!'])
+        % user defined options
+        if ~isempty(options_.posterior_sampler_options.sampling_opt)
+            options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
+            for i=1:rows(options_list)
+                switch options_list{i,1}
+
+                  case 'proposal_distribution'
+                    if ~(strcmpi(options_list{i,2}, 'rand_multivariate_student') || ...
+                         strcmpi(options_list{i,2}, 'rand_multivariate_normal'))
+                        error(['initial_estimation_checks:: the proposal_distribution option to estimation takes either ' ...
+                               'rand_multivariate_student or rand_multivariate_normal as options']);
+                    else
+                        posterior_sampler_options.proposal_distribution=options_list{i,2};
                     end
+
+
+                  case 'student_degrees_of_freedom'
+                    if options_list{i,2} <= 0
+                        error('initial_estimation_checks:: the student_degrees_of_freedom takes a positive integer argument');
+                    else
+                        posterior_sampler_options.student_degrees_of_freedom=options_list{i,2};
+                    end
+
+                  case 'use_mh_covariance_matrix'
+                    % indicates to use the covariance matrix from previous iterations to
+                    % define the covariance of the proposal distribution
+                    % default = 0
+                    posterior_sampler_options.use_mh_covariance_matrix = options_list{i,2};
+                    options_.use_mh_covariance_matrix = options_list{i,2};
+                  case 'scale_file'
+                    % load optimal_mh_scale parameter if previous run was with mode_compute=6
+                    % will overwrite jscale from set_prior.m
+                    if exist(options_list{i,2},'file') || exist([options_list{i,2},'.mat'],'file')
+                        tmp = load(options_list{i,2},'Scale');
+                        global bayestopt_
+                        bayestopt_.mh_jscale = tmp.Scale;
+                        options_.mh_jscale = tmp.Scale;
+                        bayestopt_.jscale = ones(size(bounds.lb,1),1)*tmp.Scale;
+                        %                                 options_.mh_init_scale = 2*options_.mh_jscale;
+                    else
+                        error('initial_estimation_checks:: The specified mh_scale_file does not exist.')
+                    end
+                  case 'save_tmp_file'
+                    posterior_sampler_options.save_tmp_file = options_list{i,2};
+                  otherwise
+                    warning(['rwmh_sampler: Unknown option (' options_list{i,1} ')!'])
                 end
             end
-            
-            % slice posterior sampler does not require mode or hessian to run
-            % needs to be set to 1 to skip parts in dynare_estimation_1.m
-            % requiring posterior maximization/calibrated smoother before MCMC
-            options_.mh_posterior_mode_estimation=1;
-            
-            if ~ posterior_sampler_options.slice_initialize_with_mode
+        end
+
+      case 'tailored_random_block_metropolis_hastings'
+        posterior_sampler_options.parallel_bar_refresh_rate=5;
+        posterior_sampler_options.serial_bar_refresh_rate=1;
+        posterior_sampler_options.parallel_bar_title='TaRB-MH';
+        posterior_sampler_options.serial_bar_title='TaRB Metropolis-Hastings';
+
+        % default options
+        posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.tarb);
+
+        % user defined options
+        if ~isempty(options_.posterior_sampler_options.sampling_opt)
+            options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
+            for i=1:rows(options_list)
+
+                switch options_list{i,1}
+
+                  case 'proposal_distribution'
+                    if ~(strcmpi(options_list{i,2}, 'rand_multivariate_student') || ...
+                         strcmpi(options_list{i,2}, 'rand_multivariate_normal'))
+                        error(['initial_estimation_checks:: the proposal_distribution option to estimation takes either ' ...
+                               'rand_multivariate_student or rand_multivariate_normal as options']);
+                    else
+                        posterior_sampler_options.proposal_distribution=options_list{i,2};
+                    end
+
+
+                  case 'student_degrees_of_freedom'
+                    if options_list{i,2} <= 0
+                        error('initial_estimation_checks:: the student_degrees_of_freedom takes a positive integer argument');
+                    else
+                        posterior_sampler_options.student_degrees_of_freedom=options_list{i,2};
+                    end
+
+                  case 'mode_compute'
+                    posterior_sampler_options.mode_compute=options_list{i,2};
+
+                  case 'optim'
+                    posterior_sampler_options.optim_opt=options_list{i,2};
+
+                  case 'new_block_probability'
+                    if options_list{i,2}<0 || options_list{i,2}>1
+                        error('check_posterior_sampler_options:: The tarb new_block_probability must be between 0 and 1!')
+                    else
+                        posterior_sampler_options.new_block_probability=options_list{i,2};
+                    end
+                  case 'scale_file'
+                    % load optimal_mh_scale parameter if previous run was with mode_compute=6
+                    % will overwrite jscale from set_prior.m
+                    if exist(options_list{i,2},'file') || exist([options_list{i,2},'.mat'],'file')
+                        tmp = load(options_list{i,2},'Scale');
+                        global bayestopt_
+                        bayestopt_.mh_jscale = tmp.Scale;
+                        options_.mh_jscale = tmp.Scale;
+                        bayestopt_.jscale = ones(size(bounds.lb,1),1)*tmp.Scale;
+                        %                                 options_.mh_init_scale = 2*options_.mh_jscale;
+                    else
+                        error('initial_estimation_checks:: The specified scale_file does not exist.')
+                    end
+                  case 'save_tmp_file'
+                    posterior_sampler_options.save_tmp_file = options_list{i,2};
+
+                  otherwise
+                    warning(['tarb_sampler: Unknown option (' options_list{i,1} ')!'])
+
+                end
+
+            end
+
+        end
+
+      case 'independent_metropolis_hastings'
+        posterior_sampler_options.parallel_bar_refresh_rate=50;
+        posterior_sampler_options.serial_bar_refresh_rate=3;
+        posterior_sampler_options.parallel_bar_title='IMH';
+        posterior_sampler_options.serial_bar_title='Ind. Metropolis-Hastings';
+
+        % default options
+        posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.imh);
+
+        % user defined options
+        if ~isempty(options_.posterior_sampler_options.sampling_opt)
+            options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
+            for i=1:rows(options_list)
+                switch options_list{i,1}
+
+                  case 'proposal_distribution'
+                    if ~(strcmpi(options_list{i,2}, 'rand_multivariate_student') || ...
+                         strcmpi(options_list{i,2}, 'rand_multivariate_normal'))
+                        error(['initial_estimation_checks:: the proposal_distribution option to estimation takes either ' ...
+                               'rand_multivariate_student or rand_multivariate_normal as options']);
+                    else
+                        posterior_sampler_options.proposal_distribution=options_list{i,2};
+                    end
+
+
+                  case 'student_degrees_of_freedom'
+                    if options_list{i,2} <= 0
+                        error('initial_estimation_checks:: the student_degrees_of_freedom takes a positive integer argument');
+                    else
+                        posterior_sampler_options.student_degrees_of_freedom=options_list{i,2};
+                    end
+
+                  case 'use_mh_covariance_matrix'
+                    % indicates to use the covariance matrix from previous iterations to
+                    % define the covariance of the proposal distribution
+                    % default = 0
+                    posterior_sampler_options.use_mh_covariance_matrix = options_list{i,2};
+                    options_.use_mh_covariance_matrix = options_list{i,2};
+
+                  case 'save_tmp_file'
+                    posterior_sampler_options.save_tmp_file = options_list{i,2};
+
+                  otherwise
+                    warning(['imh_sampler: Unknown option (' options_list{i,1} ')!'])
+                end
+            end
+        end
+
+
+      case 'slice'
+        posterior_sampler_options.parallel_bar_refresh_rate=1;
+        posterior_sampler_options.serial_bar_refresh_rate=1;
+        posterior_sampler_options.parallel_bar_title='SLICE';
+        posterior_sampler_options.serial_bar_title='SLICE';
+
+        % default options
+        posterior_sampler_options = add_fields_(posterior_sampler_options,options_.posterior_sampler_options.slice);
+
+        % user defined options
+        if ~isempty(options_.posterior_sampler_options.sampling_opt)
+            options_list = read_key_value_string(options_.posterior_sampler_options.sampling_opt);
+            for i=1:rows(options_list)
+                switch options_list{i,1}
+                  case 'rotated'
+                    % triggers rotated slice iterations using a covariance
+                    % matrix from initial burn-in iterations
+                    % must be associated with:
+                    % <use_mh_covariance_matrix> or <slice_initialize_with_mode>
+                    % default  = 0
+                    posterior_sampler_options.rotated = options_list{i,2};
+
+                  case 'mode'
+                    % for multimodal posteriors, provide the list of modes as a
+                    % matrix, ordered by column, i.e. [x1 x2 x3] for three
+                    % modes x1 x2 x3
+                    % MR note: not sure this is possible with the
+                    % read_key_value_string ???
+                    % if this is not possible <mode_files> does to job in any case
+                    % This will automatically trigger <rotated>
+                    % default = []
+                    tmp_mode = options_list{i,2};
+                    for j=1:size(tmp_mode,2)
+                        posterior_sampler_options.mode(j).m = tmp_mode(:,j);
+                    end
+
+                  case 'mode_files'
+                    % for multimodal posteriors provide the name of
+                    % a file containing a variable array xparams = [nparam * nmodes]
+                    % one column per mode. With this info, the code will automatically
+                    % set the <mode> option.
+                    % This will automatically trigger <rotated>
+                    % default = []
+                    posterior_sampler_options.mode_files = options_list{i,2};
+
+                  case 'slice_initialize_with_mode'
+                    % the default for slice is to set mode_compute = 0 in the
+                    % preprocessor and start the chain(s) from a random location in the prior.
+                    % This option first runs the optimizer and then starts the
+                    % chain from the mode. Associated with optios <rotated>, it will
+                    % use invhess from the mode to perform rotated slice
+                    % iterations.
+                    % default = 0
+                    posterior_sampler_options.slice_initialize_with_mode = options_list{i,2};
+
+                  case 'initial_step_size'
+                    % sets the initial size of the interval in the STEPPING-OUT PROCEDURE
+                    % the initial_step_size must be a real number in [0, 1],
+                    % and it sets the size as a proportion of the prior bounds,
+                    % i.e. the size will be initial_step_size*(UB-LB)
+                    % slice sampler requires prior_truncation > 0!
+                    % default = 0.8
+                    if options_list{i,2}<=0 || options_list{i,2}>=1
+                        error('check_posterior_sampler_options:: slice initial_step_size must be between 0 and 1')
+                    else
+                        posterior_sampler_options.initial_step_size=options_list{i,2};
+                    end
+                  case 'use_mh_covariance_matrix'
+                    % in association with <rotated> indicates to use the
+                    % covariance matrix from previous iterations to define the
+                    % rotated slice
+                    % default = 0
+                    posterior_sampler_options.use_mh_covariance_matrix = options_list{i,2};
+                    options_.use_mh_covariance_matrix = options_list{i,2};
+
+                  case 'save_tmp_file'
+                    posterior_sampler_options.save_tmp_file = options_list{i,2};
+
+                  otherwise
+                    warning(['slice_sampler: Unknown option (' options_list{i,1} ')!'])
+                end
+            end
+        end
+
+        % slice posterior sampler does not require mode or hessian to run
+        % needs to be set to 1 to skip parts in dynare_estimation_1.m
+        % requiring posterior maximization/calibrated smoother before MCMC
+        options_.mh_posterior_mode_estimation=1;
+
+        if ~ posterior_sampler_options.slice_initialize_with_mode
             % by default, slice sampler should trigger
             % mode_compute=0 and
             % mh_replic=100 (much smaller than the default mh_replic=20000 of RWMH)
-                options_.mode_compute = 0;
-                options_.cova_compute = 0;
-            else
-                if (isequal(options_.mode_compute,0) && isempty(options_.mode_file) )
-                    skipline()
-                    disp('check_posterior_sampler_options:: You have specified the option "slice_initialize_with_mode"')
-                    disp('check_posterior_sampler_options:: to initialize the slice sampler using mode information')
-                    disp('check_posterior_sampler_options:: but no mode file nor posterior maximization is selected,')
-                    error('check_posterior_sampler_options:: The option "slice_initialize_with_mode" is inconsistent with mode_compute=0 or empty mode_file.')
-                else
-                    options_.mh_posterior_mode_estimation=0;
-                end
-            end
-            
-            if any(isinf(bounds.lb)) || any(isinf(bounds.ub)),
+            options_.mode_compute = 0;
+            options_.cova_compute = 0;
+        else
+            if (isequal(options_.mode_compute,0) && isempty(options_.mode_file) )
                 skipline()
-                disp('some priors are unbounded and prior_trunc is set to zero')
-                error('The option "slice" is inconsistent with prior_trunc=0.')
-            end
-            
-            % moreover slice must be associated to:
-            %     options_.mh_posterior_mode_estimation = 0;
-            % this is done below, but perhaps preprocessing should do this?
-            
-            if ~isempty(posterior_sampler_options.mode)
-                % multimodal case
-                posterior_sampler_options.rotated = 1;
-                posterior_sampler_options.WR=[];
-            end
-            %     posterior_sampler_options = set_default_option(posterior_sampler_options,'mode_files',[]);
-            
-            
-            posterior_sampler_options.W1=posterior_sampler_options.initial_step_size*(bounds.ub-bounds.lb);
-            if options_.load_mh_file,
-                posterior_sampler_options.slice_initialize_with_mode = 0;
+                disp('check_posterior_sampler_options:: You have specified the option "slice_initialize_with_mode"')
+                disp('check_posterior_sampler_options:: to initialize the slice sampler using mode information')
+                disp('check_posterior_sampler_options:: but no mode file nor posterior maximization is selected,')
+                error('check_posterior_sampler_options:: The option "slice_initialize_with_mode" is inconsistent with mode_compute=0 or empty mode_file.')
             else
-                if ~posterior_sampler_options.slice_initialize_with_mode,
-                    posterior_sampler_options.invhess=[];
-                end
+                options_.mh_posterior_mode_estimation=0;
             end
-            
-            if ~isempty(posterior_sampler_options.mode_files), % multimodal case
-                modes = posterior_sampler_options.mode_files; % these can be also mean files from previous parallel slice chains
-                load(modes, 'xparams')
-                if size(xparams,2)<2,
-                    error(['check_posterior_sampler_options:: Variable xparams loaded in file <' modes '> has size [' int2str(size(xparams,1)) 'x' int2str(size(xparams,2)) ']: it must contain at least two columns, to allow multi-modal sampling.'])
-                end
-                for j=1:size(xparams,2),
-                    mode(j).m=xparams(:,j);
-                end
-                posterior_sampler_options.mode = mode;
-                posterior_sampler_options.rotated = 1;
-                posterior_sampler_options.WR=[];
+        end
+
+        if any(isinf(bounds.lb)) || any(isinf(bounds.ub))
+            skipline()
+            disp('some priors are unbounded and prior_trunc is set to zero')
+            error('The option "slice" is inconsistent with prior_trunc=0.')
+        end
+
+        % moreover slice must be associated to:
+        %     options_.mh_posterior_mode_estimation = 0;
+        % this is done below, but perhaps preprocessing should do this?
+
+        if ~isempty(posterior_sampler_options.mode)
+            % multimodal case
+            posterior_sampler_options.rotated = 1;
+            posterior_sampler_options.WR=[];
+        end
+        %     posterior_sampler_options = set_default_option(posterior_sampler_options,'mode_files',[]);
+
+
+        posterior_sampler_options.W1=posterior_sampler_options.initial_step_size*(bounds.ub-bounds.lb);
+        if options_.load_mh_file
+            posterior_sampler_options.slice_initialize_with_mode = 0;
+        else
+            if ~posterior_sampler_options.slice_initialize_with_mode
+                posterior_sampler_options.invhess=[];
             end
-            
-        otherwise
-            error('check_posterior_sampler_options:: Unknown posterior_sampling_method option %s ',posterior_sampler_options.posterior_sampling_method);
+        end
+
+        if ~isempty(posterior_sampler_options.mode_files) % multimodal case
+            modes = posterior_sampler_options.mode_files; % these can be also mean files from previous parallel slice chains
+            load(modes, 'xparams')
+            if size(xparams,2)<2
+                error(['check_posterior_sampler_options:: Variable xparams loaded in file <' modes '> has size [' int2str(size(xparams,1)) 'x' int2str(size(xparams,2)) ']: it must contain at least two columns, to allow multi-modal sampling.'])
+            end
+            for j=1:size(xparams,2)
+                mode(j).m=xparams(:,j);
+            end
+            posterior_sampler_options.mode = mode;
+            posterior_sampler_options.rotated = 1;
+            posterior_sampler_options.WR=[];
+        end
+
+      otherwise
+        error('check_posterior_sampler_options:: Unknown posterior_sampling_method option %s ',posterior_sampler_options.posterior_sampling_method);
     end
-    
+
     return
 end
 
@@ -386,7 +386,7 @@ if ~strcmp(posterior_sampler_options.posterior_sampling_method,'slice')
     end
 end
 
-if options_.load_mh_file && posterior_sampler_options.use_mh_covariance_matrix,
+if options_.load_mh_file && posterior_sampler_options.use_mh_covariance_matrix
     [junk, invhess] = compute_mh_covariance_matrix;
     posterior_sampler_options.invhess = invhess;
 end
@@ -396,10 +396,8 @@ end
 % check specific options for slice sampler
 if strcmp(posterior_sampler_options.posterior_sampling_method,'slice')
     invhess = posterior_sampler_options.invhess;
-    
-    if posterior_sampler_options.rotated,
-        if isempty(posterior_sampler_options.mode_files) && isempty(posterior_sampler_options.mode), % rotated unimodal
-            
+    if posterior_sampler_options.rotated
+        if isempty(posterior_sampler_options.mode_files) && isempty(posterior_sampler_options.mode) % rotated unimodal
             if ~options_.cova_compute && ~(options_.load_mh_file && posterior_sampler_options.use_mh_covariance_matrix)
                 skipline()
                 disp('check_posterior_sampler_options:: I cannot start rotated slice sampler because')
@@ -418,16 +416,14 @@ if strcmp(posterior_sampler_options.posterior_sampling_method,'slice')
             posterior_sampler_options.V1=V1;
             posterior_sampler_options.WR=sqrt(diag(D))*3;
         end
+    else
+        if ~options_.load_mh_file && ~posterior_sampler_options.slice_initialize_with_mode
+            posterior_sampler_options.invhess=[];
+        end
     end
-    
     % needs to be re-set to zero otherwise posterior analysis is filtered
     % out in dynare_estimation_1.m
     options_.mh_posterior_mode_estimation = 0;
-    
-    
-else
-    
-    
 end
 
 return
@@ -438,6 +434,3 @@ fnam = fieldnames(sampler_options);
 for j=1:length(fnam)
     posterior_sampler_options.(fnam{j}) = sampler_options.(fnam{j});
 end
-
-
-
diff --git a/matlab/check_prior_analysis_data.m b/matlab/check_prior_analysis_data.m
index 8d74ba943..e0570cc68 100644
--- a/matlab/check_prior_analysis_data.m
+++ b/matlab/check_prior_analysis_data.m
@@ -1,13 +1,13 @@
 function [info,description] = check_prior_analysis_data(type,M_)
 % function [info,description] = check_prior_analysis_data(type,M_)
-% Checks the status of prior analysis and in particular if files need to be 
+% Checks the status of prior analysis and in particular if files need to be
 % created or updated; called by prior_analysis.m
-% 
+%
 % Inputs:
 %   type        [string]        name of the posterior moment considered
 %   M_          [structure]     Dynare model structure
-% 
-% Outputs: 
+%
+% Outputs:
 %   info        [scalar]        return code
 %                                   info = 1; % prior_sampler has to be called first.
 %                                   info = 2; % _prior_draws files have to be updated.
@@ -18,7 +18,7 @@ function [info,description] = check_prior_analysis_data(type,M_)
 %   description [string]        Message corresponding to info
 
 
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,7 +40,7 @@ if nargout>1
     description = '';
 end
 
-%% Get informations about prior draws files. 
+%% Get informations about prior draws files.
 if ~exist([ M_.dname '/prior/draws'],'dir')
     disp('check_prior_analysis_data:: Can''t find any prior draws file!')
     return
@@ -65,7 +65,7 @@ else
         end
         return
     else
-        info = 3; % Nothing to do!  
+        info = 3; % Nothing to do!
         if nargout>1
             description = 'prior draws files are up to date.';
         end
@@ -98,9 +98,9 @@ else
     name_of_the_last_prior_data_file = pdinfo(end).name;
     pdfdate = pdinfo(end).datenum;
     % /!\ REMARK /!\
-    % The user can change the model or the value of a calibrated 
-    % parameter without changing the prior. In this case the (prior) 
-    % moments should be computed. But this case cannot be detected!!! 
+    % The user can change the model or the value of a calibrated
+    % parameter without changing the prior. In this case the (prior)
+    % moments should be computed. But this case cannot be detected!!!
     if pdfdate<date_of_the_last_prior_draw_file
         info = 5; % prior data files have to be updated.
         if nargout>1
diff --git a/matlab/check_prior_bounds.m b/matlab/check_prior_bounds.m
index 5214ce010..9c982ff4d 100644
--- a/matlab/check_prior_bounds.m
+++ b/matlab/check_prior_bounds.m
@@ -5,12 +5,12 @@ function check_prior_bounds(xparam1,bounds,M_,estim_params_,options_,bayestopt_)
 %   -xparam1        [double]    vector of parameters to be estimated (initial values)
 %   -bounds         [vector]    vector containing the lower and upper
 %   bounds
-%   -M_             [structure] characterizing the model. 
+%   -M_             [structure] characterizing the model.
 %   -estim_params_  [structure] characterizing parameters to be estimated
 %   -options_       [structure] characterizing the options
 %   -bayestopt_     [structure] characterizing priors
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/chol_SE.m b/matlab/chol_SE.m
index 0ec5a900b..48b70edf4 100644
--- a/matlab/chol_SE.m
+++ b/matlab/chol_SE.m
@@ -1,17 +1,17 @@
 function [R,indef, E, P]=chol_SE(A,pivoting)
 % [R,indef, E, P]=chol_SE(A,pivoting)
-% Performs a (modified) Cholesky factorization of the form 
-% 
+% Performs a (modified) Cholesky factorization of the form
+%
 %     P'*A*P  + E = R'*R
-% 
+%
 % As detailed in Schnabel/Eskow (1990), the factorization has 2 phases:
 %   Phase 1: While A can still be positive definite, pivot on the maximum diagonal element.
 %            Check that the standard Cholesky update would result in a positive diagonal
-%            at the current iteration. If so, continue with the normal Cholesky update. 
-%            Otherwise switch to phase 2. 
-%            If A is safely positive definite, stage 1 is never left, resulting in 
-%            the standard Cholesky decomposition. 
-%            
+%            at the current iteration. If so, continue with the normal Cholesky update.
+%            Otherwise switch to phase 2.
+%            If A is safely positive definite, stage 1 is never left, resulting in
+%            the standard Cholesky decomposition.
+%
 %    Phase 2: Pivot on the minimum of the negatives of the lower Gershgorin bound
 %            estimates. To prevent negative diagonals, compute the amount to add to the
 %            pivot element and add this. Then, do the Cholesky update and update the estimates of the
@@ -21,39 +21,40 @@ function [R,indef, E, P]=chol_SE(A,pivoting)
 %   -   During factorization, L=R' is stored in the lower triangle of the original matrix A,
 %       miminizing the memory requirements
 %   -   Conforming with the original Schnabel/Eskow (1990) algorithm:
-%            - at each iteration the updated Gershgorin bounds are estimated instead of recomputed, 
+%            - at each iteration the updated Gershgorin bounds are estimated instead of recomputed,
 %              reducing the computational requirements from o(n^3) to o (n^2)
 %           -  For the last 2 by 2 submatrix, an eigenvalue-based decomposition is used
-%   -   While pivoting is not necessary, it improves the size of E, the add-on on to the diagonal. But this comes at 
+%   -   While pivoting is not necessary, it improves the size of E, the add-on on to the diagonal. But this comes at
 %       the cost of introduding a permutation.
-% 
 %
-% Inputs  
-%   A           [n*n]     Matrix to be factorized
-%   pivoting    [scalar]  dummy whether pivoting is used
-% 
-% Outputs  
-%   R           [n*n]     originally stored in lower triangular portion of A, including the main diagonal
 %
-%   E           [n*1]     Elements added to the diagonal of A
-%   P           [n*1]     record of how the rows and columns of the matrix were permuted while
-%                         performing the decomposition
+% INPUTS
+%  - A           [n*n]     Matrix to be factorized
+%  - pivoting    [scalar]  dummy whether pivoting is used
+%
+% OUTPUTS
+%  - R           [n*n]     originally stored in lower triangular portion of A, including the main diagonal
+%
+%  - E           [n*1]     Elements added to the diagonal of A
+%  - P           [n*1]     record of how the rows and columns of the matrix were permuted while
+%                          performing the decomposition
 %
 % REFERENCES:
-%   This implementation is based on 
+%   This implementation is based on
 %
 %       Robert B. Schnabel and Elizabeth Eskow. 1990. "A New Modified Cholesky
 %       Factorization," SIAM Journal of Scientific Statistical Computating,
 %       11, 6: 1136-58.
-% 
+%
 %       Elizabeth Eskow and Robert B. Schnabel 1991. "Algorithm 695 - Software for a New Modified Cholesky
 %       Factorization," ACM Transactions on Mathematical Software, Vol 17, No 3: 306-312
-% 
-% 
+%
+%
 % Author: Johannes Pfeifer based on Eskow/Schnabel (1991)
-% 
+
 % Copyright (C) 2015 Johannes Pfeifer
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
@@ -148,7 +149,7 @@ for j = 1:n-1
                 % Swap elements of the permutation vector
                 itemp = P(j);
                 P(j) = P(imaxd);
-                P(imaxd) = itemp;          
+                P(imaxd) = itemp;
             end
         end
         % check to see whether the normal Cholesky update for this
@@ -183,13 +184,13 @@ for j = 1:n-1
             g=gersh_nested(A,j,n);
         end
     end
-    
+
     % PHASE 2
     if ~phase1
         if j ~= n-1
             if pivoting
                 % Find the minimum negative Gershgorin bound
-                [tmp,iming] = min(g(j:n)); 
+                [tmp,iming] = min(g(j:n));
                 iming=iming+j-1;
                 % Pivot to the top the row and column with the
                 % minimum negative Gershgorin bound
@@ -229,9 +230,9 @@ for j = 1:n-1
             end
             % Calculate delta and add to the diagonal. delta=max{0,-A(j,j) + max{normj,taugam},delta_previous}
             % where normj=sum of |A(i,j)|,for i=1,n, delta_previous is the delta computed at the previous iter and taugam is tau1*gamma.
-                       
+
             normj=sum(abs(A(j+1:n,j)));
-            
+
             delta = max([0;delta;-A(j,j)+normj;-A(j,j)+taugam]); % get adjustment based on formula on bottom of p. 309 of Eskow/Schnabel (1991)
 
             E(j) =  delta;
@@ -259,9 +260,9 @@ for j = 1:n-1
             % Find eigenvalues of final 2 by 2 submatrix
             % Find delta such that:
             % 1.  the l2 condition number of the final 2X2 submatrix + delta*I <= tau2
-            % 2. delta >= previous delta, 
+            % 2. delta >= previous delta,
             % 3. min(eigvals) + delta >= tau2 * gamma, where min(eigvals) is the smallest eigenvalue of the final 2X2 submatrix
-            
+
             A(n-1,n)=A(n,n-1); %set value above diagonal for computation of eigenvalues
             eigvals  = eig(A(n-1:n,n-1:n));
             delta    = max([ 0 ; delta ; -min(eigvals)+tau2*max((max(eigvals)-min(eigvals))/(1-tau1),gammma) ]); %Formula 5.3.2 of Schnabel/Eskow (1990)
@@ -272,7 +273,7 @@ for j = 1:n-1
                 E(n-1) = delta;
                 E(n) = delta;
             end
-            
+
             % Final update
             A(n-1,n-1) = sqrt(A(n-1,n-1));
             A(n,n-1) = A(n,n-1)/A(n-1,n-1);
@@ -293,17 +294,16 @@ function  g=gersh_nested(A,j,n)
 
 g=zeros(n,1);
 for ii = j:n
-    if ii == 1;
+    if ii == 1
         sum_up_to_i = 0;
     else
         sum_up_to_i = sum(abs(A(ii,j:(ii-1))));
-    end;
-    if ii == n;
+    end
+    if ii == n
         sum_after_i = 0;
     else
         sum_after_i = sum(abs(A((ii+1):n,ii)));
-    end;
+    end
     g(ii) = sum_up_to_i + sum_after_i- A(ii,ii);
 end
 end
-
diff --git a/matlab/clear_persistent_variables.m b/matlab/clear_persistent_variables.m
index e2fe5666f..c3250fb4d 100644
--- a/matlab/clear_persistent_variables.m
+++ b/matlab/clear_persistent_variables.m
@@ -2,7 +2,7 @@ function clear_persistent_variables(folder, writelistofroutinestobecleared)
 
 % Clear all the functions with persistent variables in directory folder (and subdirectories).
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,5 +58,5 @@ if writelistofroutinestobecleared
     return
 end
 
-list_of_functions_to_be_cleared;    
+list_of_functions_to_be_cleared;
 clear(list_of_functions{:});
\ No newline at end of file
diff --git a/matlab/cli/prior.m b/matlab/cli/prior.m
index 9e0445066..703297d73 100644
--- a/matlab/cli/prior.m
+++ b/matlab/cli/prior.m
@@ -11,7 +11,7 @@ function varargout = prior(varargin)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,7 +42,7 @@ if isempty(varargin) || ( isequal(length(varargin), 1) && isequal(varargin{1},'h
     return
 end
 
-global options_ M_ estim_params_ bayestopt_ oo_ 
+global options_ M_ estim_params_ bayestopt_ oo_
 
 donesomething = false;
 
@@ -53,11 +53,11 @@ end
 
 if (size(estim_params_.var_endo,1) || size(estim_params_.corrn,1))
     % Prior over measurement errors are defined...
-   if ((isfield(options_,'varobs') && isempty(options_.varobs)) || ~isfield(options_,'varobs'))
-       % ... But the list of observed variabled is not yet defined.
-       warning('Prior detected on measurement erros, but no list of observed variables (varobs is missing)!')
-       return
-   end
+    if ((isfield(options_,'varobs') && isempty(options_.varobs)) || ~isfield(options_,'varobs'))
+        % ... But the list of observed variabled is not yet defined.
+        warning('Prior detected on measurement erros, but no list of observed variables (varobs is missing)!')
+        return
+    end
 end
 
 % Fill or update bayestopt_ structure
@@ -103,6 +103,9 @@ if ismember('simulate', varargin) % Prior simulations (BK).
     disp(['mjdgges crash share                   = ' num2str(results.dll.problem_share)])
     disp(['Steady state problem share            = ' num2str(results.ss.problem_share)])
     disp(['Complex steady state  share           = ' num2str(results.ss.complex_share)])
+    if options_.loglinear
+        disp(['Nonpositive steady state share        = ' num2str(results.ss.nonpositive_share)])
+    end
     disp(['Analytical steady state problem share = ' num2str(results.ass.problem_share)])
     skipline(2)
     donesomething = true;
@@ -114,7 +117,7 @@ if ismember('optimize', varargin) % Prior optimization.
 end
 
 if ismember('moments', varargin) % Prior simulations (2nd order moments).
-    % Set estimated parameters to the prior mode...
+                                 % Set estimated parameters to the prior mode...
     xparam1 = BayesOptions.p5;
     % ... Except for uniform priors (use the prior mean)!
     k = find(isnan(xparam1));
diff --git a/matlab/collect_latex_files.m b/matlab/collect_latex_files.m
index 5c4f2b7d6..45902f1ba 100644
--- a/matlab/collect_latex_files.m
+++ b/matlab/collect_latex_files.m
@@ -1,14 +1,14 @@
 function collect_latex_files
 % function collect_LaTeX_Files;
 % Creates TeX-File embedding all eps-loaders created for current mod-file
-% 
+%
 % Inputs: none
-% 
-% Notes: 
+%
+% Notes:
 %   - The packages loaded enable pdflatex to run
 %   - The _dynamic and _static TeX-model files are not included as they are standalone TeX-files
 
-% Copyright (C) 2015-16 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -45,11 +45,11 @@ TeX_Files=dir([M_.fname,'*.tex']);
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder) && ...
-        ~strcmp(TeX_Files(ii).name,[M_.fname,'_dynamic.tex']) && ...
-        ~strcmp(TeX_Files(ii).name,[M_.fname,'_static.tex']) && ...
-        ~strcmp(TeX_Files(ii).name,[M_.fname,'_original.tex']) && ...
-        ~strcmp(TeX_Files(ii).name,[M_.fname,'_TeX_binder.tex'])
-        fprintf(fid,'%s \n',['\include{',f_name,'}']);    
+            ~strcmp(TeX_Files(ii).name,[M_.fname,'_dynamic.tex']) && ...
+            ~strcmp(TeX_Files(ii).name,[M_.fname,'_static.tex']) && ...
+            ~strcmp(TeX_Files(ii).name,[M_.fname,'_original.tex']) && ...
+            ~strcmp(TeX_Files(ii).name,[M_.fname,'_TeX_binder.tex'])
+        fprintf(fid,'%s \n',['\include{',f_name,'}']);
     end
 end
 
@@ -58,7 +58,7 @@ TeX_Files=dir([M_.dname filesep 'Output' filesep  M_.fname '*.tex']);
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder)
-        fprintf(fid,'%s \n',['\include{', M_.dname '/Output' '/',f_name,'}']);    
+        fprintf(fid,'%s \n',['\include{', M_.dname '/Output' '/',f_name,'}']);
     end
 end
 
@@ -67,7 +67,7 @@ TeX_Files=dir([M_.dname filesep 'graphs' filesep  M_.fname '*.tex']);
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder)
-        fprintf(fid,'%s \n',['\include{', M_.dname '/graphs' '/',f_name,'}']);    
+        fprintf(fid,'%s \n',['\include{', M_.dname '/graphs' '/',f_name,'}']);
     end
 end
 
@@ -76,7 +76,7 @@ TeX_Files=dir([M_.dname filesep 'identification' filesep  M_.fname '*.tex']);
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder)
-        fprintf(fid,'%s \n',['\include{', M_.dname '/identification' '/',f_name,'}']);    
+        fprintf(fid,'%s \n',['\include{', M_.dname '/identification' '/',f_name,'}']);
     end
 end
 
@@ -86,7 +86,7 @@ TeX_Files=dir([M_.dname filesep 'identification' filesep 'Output' filesep M_.fna
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder)
-        fprintf(fid,'%s \n',['\include{', M_.dname '/identification/Output' '/',f_name,'}']);    
+        fprintf(fid,'%s \n',['\include{', M_.dname '/identification/Output' '/',f_name,'}']);
     end
 end
 
@@ -95,7 +95,7 @@ TeX_Files=dir([M_.dname filesep 'gsa' filesep  M_.fname '*.tex']);
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder)
-        fprintf(fid,'%s \n',['\include{', M_.dname '/gsa' '/',f_name,'}']);    
+        fprintf(fid,'%s \n',['\include{', M_.dname '/gsa' '/',f_name,'}']);
     end
 end
 
@@ -104,7 +104,7 @@ TeX_Files=dir([M_.dname filesep 'gsa' filesep 'Output' filesep  M_.fname '*.tex'
 for ii=1:length(TeX_Files)
     [pathstr,f_name,ext] = fileparts(TeX_Files(ii).name);
     if ~strcmp(TeX_Files(ii).name,f_name_binder)
-        fprintf(fid,'%s \n',['\include{', M_.dname '/gsa/Output' '/',f_name,'}']);    
+        fprintf(fid,'%s \n',['\include{', M_.dname '/gsa/Output' '/',f_name,'}']);
     end
 end
 
diff --git a/matlab/compute_Pinf_Pstar.m b/matlab/compute_Pinf_Pstar.m
index 2fbae5b33..d847ffacc 100644
--- a/matlab/compute_Pinf_Pstar.m
+++ b/matlab/compute_Pinf_Pstar.m
@@ -1,36 +1,36 @@
 function [Pstar,Pinf] = compute_Pinf_Pstar(mf,T,R,Q,qz_criterium, restrict_columns)
 % function [Z,ST,QT,R1,Pstar,Pinf] = schur_statespace_transformation(mf,T,R,Q,qz_criterium, restrict_columns)
 % Kitagawa transformation of state space system with a quasi-triangular
-% transition matrix with unit roots at the top, but excluding zero columns of the transition matrix. 
+% transition matrix with unit roots at the top, but excluding zero columns of the transition matrix.
 % Computation of Pstar and Pinf for Durbin and Koopman Diffuse filter
 %
-% The transformed state space is 
+% The transformed state space is
 %     y = [ss; z; x];
 %     s = static variables (zero columns of T)
 %     z = unit roots
 %     x = stable roots
 %     ss = s - z = stationarized static variables
-% 
-% INPUTS 
+%
+% INPUTS
 %   mf           [integer]    vector of indices of observed variables in
 %                             state vector
 %   T            [double]     matrix of transition
 %   R            [double]     matrix of structural shock effects
 %   Q            [double]     matrix of covariance of structural shocks
-%   qz_criterium [double]     numerical criterium for unit roots   
-%  
-% OUTPUTS 
+%   qz_criterium [double]     numerical criterium for unit roots
+%
+% OUTPUTS
 %   Pstar        [double]     matrix of covariance of stationary part
 %   Pinf         [double]     matrix of covariance initialization for
-%                             nonstationary part    
-%    
-% ALGORITHM 
+%                             nonstationary part
+%
+% ALGORITHM
 %   Real Schur transformation of transition equation
 %
 % SPECIAL REQUIREMENTS
 %   None
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,7 +49,7 @@ function [Pstar,Pinf] = compute_Pinf_Pstar(mf,T,R,Q,qz_criterium, restrict_colum
 
 np = size(T,1);
 
-% perform Kitagawa transformation 
+% perform Kitagawa transformation
 [QT,ST] = schur(T);
 e1 = abs(ordeig(ST)) > 2-qz_criterium;
 [QT,ST] = ordschur(QT,ST,e1);
@@ -105,11 +105,10 @@ end
 Pinf = zeros(np,np);
 Pinf(1:nk,1:nk) = eye(nk);
 for k = 1:nk
-    if norm(QT(mf,k)) < 1e-8
+    if norm(QT(mf,:)*ST(:,k)) < 1e-8
         Pinf(k,k) = 0;
     end
 end
 
 Pinf = QT*Pinf*QT';
 Pstar = QT*Pstar*QT';
-
diff --git a/matlab/compute_mh_covariance_matrix.m b/matlab/compute_mh_covariance_matrix.m
index 8b62a2afe..d7885c7f9 100644
--- a/matlab/compute_mh_covariance_matrix.m
+++ b/matlab/compute_mh_covariance_matrix.m
@@ -1,21 +1,21 @@
 function [posterior_mean,posterior_covariance,posterior_mode,posterior_kernel_at_the_mode] = compute_mh_covariance_matrix()
 % Estimation of the posterior covariance matrix, posterior mean, posterior mode and evaluation of the posterior kernel at the
 % estimated mode, using the draws from a metropolis-hastings. The estimated posterior mode and covariance matrix are saved in
-% a file <M_.fname>_mh_mode.mat. 
-% 
-% INPUTS 
+% a file <M_.fname>_mh_mode.mat.
+%
+% INPUTS
 %   None.
-%  
+%
 % OUTPUTS
 %   o  posterior_mean                [double]  (n*1) vector, posterior expectation of the parameters.
 %   o  posterior_covariance          [double]  (n*n) matrix, posterior covariance of the parameters (computed from previous metropolis hastings).
-%   o  posterior_mode                [double]  (n*1) vector, posterior mode of the parameters. 
+%   o  posterior_mode                [double]  (n*1) vector, posterior mode of the parameters.
 %   o  posterior_kernel_at_the_mode  [double]  scalar.
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -62,7 +62,7 @@ offset = 0;
 for b=1:nblck
     first_line = FirstLine;
     for n = FirstMhFile:TotalNumberOfMhFiles
-        load([ BaseName '_mh' int2str(n) '_blck' int2str(b) '.mat'],'x2','logpo2'); 
+        load([ BaseName '_mh' int2str(n) '_blck' int2str(b) '.mat'],'x2','logpo2');
         [tmp,idx] = max(logpo2);
         if tmp>posterior_kernel_at_the_mode
             posterior_kernel_at_the_mode = tmp;
diff --git a/matlab/compute_model_moments.m b/matlab/compute_model_moments.m
index 1c89a5e07..50c1d0072 100644
--- a/matlab/compute_model_moments.m
+++ b/matlab/compute_model_moments.m
@@ -4,14 +4,14 @@ function moments=compute_model_moments(dr,M_,options_)
 %    dr:        structure describing model solution
 %    M_:   structure of Dynare options
 %     options_
-%    
+%
 % OUTPUTS
 %    moments: a cell array containing requested moments
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/compute_moments_varendo.m b/matlab/compute_moments_varendo.m
index f2e267440..c072f9c10 100644
--- a/matlab/compute_moments_varendo.m
+++ b/matlab/compute_moments_varendo.m
@@ -2,21 +2,21 @@ function oo_ = compute_moments_varendo(type,options_,M_,oo_,var_list_)
 % Computes the second order moments (autocorrelation function, covariance
 % matrix and variance decomposition) distributions for all the endogenous variables selected in
 % var_list_. The results are saved in oo_
-%  
+%
 % INPUTS:
 %   type            [string]       'posterior' or 'prior'
 %   options_        [structure]    Dynare structure.
 %   M_              [structure]    Dynare structure (related to model definition).
 %   oo_             [structure]    Dynare structure (results).
 %   var_list_       [string]       Array of string with endogenous variable names.
-%    
+%
 % OUTPUTS
 %   oo_             [structure]    Dynare structure (results).
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2008-2010 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,7 +31,7 @@ function oo_ = compute_moments_varendo(type,options_,M_,oo_,var_list_)
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
 fprintf('Estimation::compute_moments_varendo: I''m computing endogenous moments (this may take a while)... ');
@@ -129,7 +129,7 @@ if M_.exo_nbr > 1
         headers = char(' ',headers);
         lh = size(deblank(var_list_),2)+2;
         dyntable(options_,title,headers,deblank(var_list_),100* ...
-            temp,lh,8,2);
+                 temp,lh,8,2);
         if options_.TeX
             headers=M_.exo_names_tex;
             headers = char(' ',headers);
@@ -166,7 +166,7 @@ if M_.exo_nbr > 1
             headers = char(' ',headers);
             lh = size(deblank(var_list_),2)+2;
             dyntable(options_,title_print,headers,deblank(var_list_),100* ...
-                temp(:,:,step_iter),lh,8,2);
+                     temp(:,:,step_iter),lh,8,2);
             if options_.TeX
                 headers=M_.exo_names_tex;
                 headers = char(' ',headers);
diff --git a/matlab/compute_overall_acceptance_ratio.m b/matlab/compute_overall_acceptance_ratio.m
index d3b323eb3..90db1d374 100644
--- a/matlab/compute_overall_acceptance_ratio.m
+++ b/matlab/compute_overall_acceptance_ratio.m
@@ -1,6 +1,6 @@
 function overallacceptanceratio = compute_overall_acceptance_ratio(MetropolisFolder, ModelName)
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -16,7 +16,7 @@ function overallacceptanceratio = compute_overall_acceptance_ratio(MetropolisFol
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 BaseName = [MetropolisFolder filesep ModelName];
 mh_history_files = dir([BaseName '_mh_history_*.mat']);
 
@@ -24,12 +24,12 @@ n = length(mh_history_files);
 
 load([BaseName '_mh_history_' num2str(0)]);
 TotalNumberOfDraws = record.MhDraws(end,1);
-TotalNumberOfAcceptedProposals = record.AcceptanceRatio*record.MhDraws(end,1);  
+TotalNumberOfAcceptedProposals = record.AcceptanceRatio*record.MhDraws(end,1);
 
 for i=2:n
     load([BaseName '_mh_history_' num2str(i-1)]);
     TotalNumberOfDraws = TotalNumberOfDraws + record.MhDraws(end,1);
-    TotalNumberOfAcceptedProposals = TotalNumberOfAcceptedProposals + record.AcceptanceRatio*record.MhDraws(end,1);  
+    TotalNumberOfAcceptedProposals = TotalNumberOfAcceptedProposals + record.AcceptanceRatio*record.MhDraws(end,1);
 end
 
 overallacceptanceratio = TotalNumberOfAcceptedProposals/TotalNumberOfDraws;
\ No newline at end of file
diff --git a/matlab/compute_trend_coefficients.m b/matlab/compute_trend_coefficients.m
index 9686867e2..d9bd3441a 100644
--- a/matlab/compute_trend_coefficients.m
+++ b/matlab/compute_trend_coefficients.m
@@ -18,7 +18,7 @@ function [trend_addition, trend_coeff]=compute_trend_coefficients(M_,DynareOptio
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2016 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/conditional_variance_decomposition.m b/matlab/conditional_variance_decomposition.m
index 3ecf74410..177684ce6 100644
--- a/matlab/conditional_variance_decomposition.m
+++ b/matlab/conditional_variance_decomposition.m
@@ -1,14 +1,14 @@
 function ConditionalVarianceDecomposition = conditional_variance_decomposition(StateSpaceModel, Steps, SubsetOfVariables,sigma_e_is_diagonal)
 % This function computes the conditional variance decomposition of a given state space model
 % for a subset of endogenous variables.
-% 
-% INPUTS 
+%
+% INPUTS
 %   StateSpaceModel     [structure]   Specification of the state space model.
 %   Steps               [integer]     1*h vector of dates.
 %   SubsetOfVariables   [integer]     1*q vector of indices.
-%    
-% OUTPUTS 
-%   ConditionalVarianceDecomposition  [double] [n h p] array, where 
+%
+% OUTPUTS
+%   ConditionalVarianceDecomposition  [double] [n h p] array, where
 %                                                    n is equal to length(SubsetOfVariables)
 %                                                    h is the number of Steps
 %                                                    p is the number of state innovations and
@@ -16,7 +16,7 @@ function ConditionalVarianceDecomposition = conditional_variance_decomposition(S
 %
 % [1] In this version, absence of measurement errors is assumed...
 
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -77,7 +77,7 @@ for h = 1:length(Steps)
     SumOfVariances(:,h) = sum(ConditionalVariance(:,h,:),3);
 end
 
-ConditionalVarianceDecomposition = zeros(NumberOfVariables,length(Steps),number_of_state_innovations); 
+ConditionalVarianceDecomposition = zeros(NumberOfVariables,length(Steps),number_of_state_innovations);
 for i=1:number_of_state_innovations
     for h = 1:length(Steps)
         ConditionalVarianceDecomposition(:,h,i) = squeeze(ConditionalVariance(:,h,i))./SumOfVariances(:,h);
diff --git a/matlab/conditional_variance_decomposition_mc_analysis.m b/matlab/conditional_variance_decomposition_mc_analysis.m
index 67b42d0b0..c320554eb 100644
--- a/matlab/conditional_variance_decomposition_mc_analysis.m
+++ b/matlab/conditional_variance_decomposition_mc_analysis.m
@@ -9,7 +9,7 @@ function oo_ = ...
 %   dname                   [string]            directory name where to save
 %   fname                   [string]            name of the mod-file
 %   Steps                   [integers]          horizons at which to conduct decomposition
-%   exonames                [string]            (n_exo*char_length) character array with names of exogenous variables        
+%   exonames                [string]            (n_exo*char_length) character array with names of exogenous variables
 %   exo                     [string]            name of current exogenous
 %                                               variable
 %   var_list                [string]            (n_endo*char_length) character array with name
@@ -23,7 +23,7 @@ function oo_ = ...
 % OUTPUTS
 %   oo_          [structure]        Dynare structure where the results are saved.
 
-% Copyright (C) 2009-2015 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -106,7 +106,7 @@ for i=1:length(Steps)
         p_density(:,:,i) = pp_density;
     else
         [pp_mean, pp_median, pp_var, hpd_interval, pp_deciles] = ...
-            posterior_moments(tmp(:,i),0,mh_conf_sig);        
+            posterior_moments(tmp(:,i),0,mh_conf_sig);
     end
     p_mean(i) = pp_mean;
     p_median(i) = pp_median;
diff --git a/matlab/convergence_diagnostics/McMCDiagnostics.m b/matlab/convergence_diagnostics/McMCDiagnostics.m
index fb4f41262..a3fa70fd9 100644
--- a/matlab/convergence_diagnostics/McMCDiagnostics.m
+++ b/matlab/convergence_diagnostics/McMCDiagnostics.m
@@ -1,14 +1,14 @@
 function oo_ = McMCDiagnostics(options_, estim_params_, M_, oo_)
 % function McMCDiagnostics
-% Computes convergence tests 
-% 
-% INPUTS 
+% Computes convergence tests
+%
+% INPUTS
 %   options_         [structure]
 %   estim_params_    [structure]
 %   M_               [structure]
 %
-% OUTPUTS 
-%   oo_              [structure] 
+% OUTPUTS
+%   oo_              [structure]
 %
 % SPECIAL REQUIREMENTS
 %   none
@@ -16,7 +16,7 @@ function oo_ = McMCDiagnostics(options_, estim_params_, M_, oo_)
 % PARALLEL CONTEXT
 % See the comment in posterior_sampler.m funtion.
 
-% Copyright (C) 2005-2016 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -82,12 +82,12 @@ param_name_tex=[];
 for jj=1:npar
     if options_.TeX
         [par_name_temp,par_name_tex_temp]=get_the_name(jj,options_.TeX,M_,estim_params_,options_);
-        param_name = strvcat(param_name,par_name_temp);        
+        param_name = strvcat(param_name,par_name_temp);
         par_name_tex_temp = strrep(par_name_tex_temp,'$','');
         param_name_tex = strvcat(param_name_tex,par_name_tex_temp);
     else
         [par_name_temp]=get_the_name(jj,options_.TeX,M_,estim_params_,options_);
-        param_name = strvcat(param_name,par_name_temp);            
+        param_name = strvcat(param_name,par_name_temp);
     end
     Draws = GetAllPosteriorDraws(jj,FirstMhFile,FirstLine,TotalNumberOfMhFiles,NumberOfDraws);
     Draws = reshape(Draws,[NumberOfDraws nblck]);
@@ -101,7 +101,7 @@ end
 my_title='MCMC Inefficiency factors per block';
 IFAC_header='Parameter';
 IFAC_header_tex='Parameter';
-for j=1:nblck,
+for j=1:nblck
     IFAC_header = char(IFAC_header,['Block ' int2str(j)]);
     IFAC_header_tex = char(IFAC_header_tex,['Block~' int2str(j)]);
 end
@@ -130,7 +130,7 @@ end
 if nblck == 1 % Brooks and Gelman tests need more than one block
     convergence_diagnostics_geweke=zeros(npar,4+2*length(options_.convergence.geweke.taper_steps));
     if any(options_.convergence.geweke.geweke_interval<0) || any(options_.convergence.geweke.geweke_interval>1) || length(options_.convergence.geweke.geweke_interval)~=2 ...
-        || (options_.convergence.geweke.geweke_interval(2)-options_.convergence.geweke.geweke_interval(1)<0)
+            || (options_.convergence.geweke.geweke_interval(2)-options_.convergence.geweke.geweke_interval(1)<0)
         fprintf('\nCONVERGENCE DIAGNOSTICS: Invalid option for geweke_interval. Using the default of [0.2 0.5].\n')
         options_.convergence.geweke.geweke_interval=[0.2 0.5];
     end
@@ -139,9 +139,9 @@ if nblck == 1 % Brooks and Gelman tests need more than one block
     first_obs_end_sample = first_obs_begin_sample+round(options_.convergence.geweke.geweke_interval(2)*NumberOfDraws*(1-options_.mh_drop));
     param_name=[];
     if options_.TeX
-        param_name_tex=[];    
+        param_name_tex=[];
     end
-    for jj=1:npar        
+    for jj=1:npar
         if options_.TeX
             [param_name_temp, param_name_tex_temp]= get_the_name(jj,options_.TeX,M_,estim_params_,options_);
             param_name_tex = strvcat(param_name_tex,strrep(param_name_tex_temp,'$',''));
@@ -152,7 +152,7 @@ if nblck == 1 % Brooks and Gelman tests need more than one block
         end
     end
     fprintf('\nGeweke (1992) Convergence Tests, based on means of draws %d to %d vs %d to %d.\n',first_obs_begin_sample,last_obs_begin_sample,first_obs_end_sample,NumberOfDraws);
-    fprintf('p-values are for Chi2-test for equality of means.\n');    
+    fprintf('p-values are for Chi2-test for equality of means.\n');
     Geweke_header=char('Parameter', 'Post. Mean', 'Post. Std', 'p-val No Taper');
     for ii=1:length(options_.convergence.geweke.taper_steps)
         Geweke_header=char(Geweke_header,['p-val ' num2str(options_.convergence.geweke.taper_steps(ii)),'% Taper']);
@@ -168,12 +168,12 @@ if nblck == 1 % Brooks and Gelman tests need more than one block
         end
         [results_vec, results_struct] = geweke_moments(param_draws,options_);
         convergence_diagnostics_geweke(jj,:)=results_vec;
-    
+
         param_draws1 = param_draws(first_obs_begin_sample:last_obs_begin_sample,:);
         param_draws2 = param_draws(first_obs_end_sample:end,:);
         [results_vec1] = geweke_moments(param_draws1,options_);
         [results_vec2] = geweke_moments(param_draws2,options_);
-        
+
         results_struct = geweke_chi2_test(results_vec1,results_vec2,results_struct,options_);
         eval(['oo_.convergence.geweke.',param_name(jj,:),'=results_struct;'])
         datamat(jj,:)=[results_struct.posteriormean,results_struct.posteriorstd,results_struct.prob_chi2_test];
@@ -183,29 +183,29 @@ if nblck == 1 % Brooks and Gelman tests need more than one block
     if options_.TeX
         Geweke_tex_header=char('Parameter', 'Mean', 'Std', 'No\ Taper');
         additional_header={[' & \multicolumn{2}{c}{Posterior} & \multicolumn{',num2str(1+length(options_.convergence.geweke.taper_steps)),'}{c}{p-values} \\'],
-            ['\cmidrule(r{.75em}){2-3} \cmidrule(r{.75em}){4-',num2str(4+length(options_.convergence.geweke.taper_steps)),'}']};
+                           ['\cmidrule(r{.75em}){2-3} \cmidrule(r{.75em}){4-',num2str(4+length(options_.convergence.geweke.taper_steps)),'}']};
         for ii=1:length(options_.convergence.geweke.taper_steps)
             Geweke_tex_header=char(Geweke_tex_header,[num2str(options_.convergence.geweke.taper_steps(ii)),'\%%\ Taper']);
         end
         headers = char(Geweke_tex_header);
         lh = size(param_name_tex,2)+2;
         my_title=sprintf('Geweke (1992) Convergence Tests, based on means of draws %d to %d vs %d to %d. p-values are for $\\\\chi^2$-test for equality of means.',first_obs_begin_sample,last_obs_begin_sample,first_obs_end_sample,NumberOfDraws);
-        dyn_latex_table(M_,options_,my_title,'geweke',headers,param_name_tex,datamat,lh,12,4,additional_header);    
+        dyn_latex_table(M_,options_,my_title,'geweke',headers,param_name_tex,datamat,lh,12,4,additional_header);
     end
     skipline(2);
-    
+
     if options_.convergence.rafterylewis.indicator
         if any(options_.convergence.rafterylewis.qrs<0) || any(options_.convergence.rafterylewis.qrs>1) || length(options_.convergence.rafterylewis.qrs)~=3 ...
-            || (options_.convergence.rafterylewis.qrs(1)-options_.convergence.rafterylewis.qrs(2)<=0)
+                || (options_.convergence.rafterylewis.qrs(1)-options_.convergence.rafterylewis.qrs(2)<=0)
             fprintf('\nCONVERGENCE DIAGNOSTICS: Invalid option for raftery_lewis_qrs. Using the default of [0.025 0.005 0.95].\n')
             options_.convergence.rafterylewis.qrs=[0.025 0.005 0.95];
-        end        
+        end
         Raftery_Lewis_q=options_.convergence.rafterylewis.qrs(1);
         Raftery_Lewis_r=options_.convergence.rafterylewis.qrs(2);
         Raftery_Lewis_s=options_.convergence.rafterylewis.qrs(3);
         oo_.Raftery_Lewis = raftery_lewis(x2,Raftery_Lewis_q,Raftery_Lewis_r,Raftery_Lewis_s);
         oo_.Raftery_Lewis.parameter_names=param_name;
-        my_title=sprintf('Raftery/Lewis (1992) Convergence Diagnostics, based on quantile q=%4.3f with precision r=%4.3f with probability s=%4.3f.',Raftery_Lewis_q,Raftery_Lewis_r,Raftery_Lewis_s);     
+        my_title=sprintf('Raftery/Lewis (1992) Convergence Diagnostics, based on quantile q=%4.3f with precision r=%4.3f with probability s=%4.3f.',Raftery_Lewis_q,Raftery_Lewis_r,Raftery_Lewis_s);
         headers = char('Variables','M (burn-in)','N (req. draws)','N+M (total draws)','k (thinning)');
 
         raftery_data_mat=[oo_.Raftery_Lewis.M_burn,oo_.Raftery_Lewis.N_prec,oo_.Raftery_Lewis.N_total,oo_.Raftery_Lewis.k_thin];
@@ -217,15 +217,15 @@ if nblck == 1 % Brooks and Gelman tests need more than one block
             labels_Raftery_Lewis_tex=char(param_name_tex,'Maximum');
             lh = size(labels_Raftery_Lewis_tex,2)+2;
             dyn_latex_table(M_,options_,my_title,'raftery_lewis',headers,labels_Raftery_Lewis_tex,raftery_data_mat,lh,10,0);
-        end      
+        end
     end
-       
-    return;
+
+    return
 end
 
 Origin = 1000;
-StepSize = ceil((NumberOfDraws-Origin)/100);% So that the computational time does not 
-ALPHA = 0.2;                                % increase too much with the number of simulations. 
+StepSize = ceil((NumberOfDraws-Origin)/100);% So that the computational time does not
+ALPHA = 0.2;                                % increase too much with the number of simulations.
 time = 1:NumberOfDraws;
 xx = Origin:StepSize:NumberOfDraws;
 NumberOfLines = length(xx);
@@ -262,7 +262,7 @@ localVars.M_ = M_;
 
 
 % Like sequential execution!
-if isnumeric(options_.parallel),
+if isnumeric(options_.parallel)
     fout = McMCDiagnostics_core(localVars,1,npar,0);
     UDIAG = fout.UDIAG;
     clear fout
@@ -273,21 +273,21 @@ else
         ModelName = [ModelName '_bvar'];
     end
     NamFileInput={[M_.dname '/metropolis/'],[ModelName '_mh*_blck*.mat']};
-    
+
     [fout, nBlockPerCPU, totCPU] = masterParallel(options_.parallel, 1, npar,NamFileInput,'McMCDiagnostics_core', localVars, [], options_.parallel_info);
     UDIAG = fout(1).UDIAG;
-    for j=2:totCPU,
+    for j=2:totCPU
         UDIAG = cat(3,UDIAG ,fout(j).UDIAG);
     end
 end
 
 UDIAG(:,[2 4 6],:) = UDIAG(:,[2 4 6],:)/nblck;
 skipline()
-clear pmet temp moyenne CSUP CINF csup cinf n linea iter tmp;    
+clear pmet temp moyenne CSUP CINF csup cinf n linea iter tmp;
 pages = floor(npar/3);
-k = 0;  
+k = 0;
 for i = 1:pages
-    h=dyn_figure(options_,'Name','MCMC univariate convergence diagnostic (Brooks and Gelman,1998)');
+    h=dyn_figure(options_.nodisplay,'Name','MCMC univariate convergence diagnostic (Brooks and Gelman,1998)');
     boxplot = 1;
     for j = 1:3 % Loop over parameters
         k = k+1;
@@ -296,12 +296,12 @@ for i = 1:pages
             if crit == 1
                 plt1 = UDIAG(:,1,k);
                 plt2 = UDIAG(:,2,k);
-                namnam  = [nam , ' (Interval)']; 
+                namnam  = [nam , ' (Interval)'];
             elseif crit == 2
                 plt1 = UDIAG(:,3,k);
                 plt2 = UDIAG(:,4,k);
                 namnam  = [nam , ' (m2)'];
-            elseif crit == 3    
+            elseif crit == 3
                 plt1 = UDIAG(:,5,k);
                 plt2 = UDIAG(:,6,k);
                 namnam  = [nam , ' (m3)'];
@@ -325,12 +325,12 @@ for i = 1:pages
             boxplot = boxplot + 1;
         end
     end
-    dyn_saveas(h,[OutputFolder '/' ModelName '_udiag' int2str(i)],options_);
+    dyn_saveas(h,[OutputFolder '/' ModelName '_udiag' int2str(i)],options_.nodisplay,options_.graph_format);
     if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         fprintf(fidTeX,'\\begin{figure}[H]\n');
         for jj = 1:size(NAMES,1)
             fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(jj,:)),deblank(TEXNAMES(jj,:)));
-        end    
+        end
         fprintf(fidTeX,'\\centering \n');
         fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s_udiag%s}\n',options_.figures.textwidth*min((boxplot-1)/3,1),[OutputFolder '/' ModelName],int2str(i));
         fprintf(fidTeX,'\\caption{Univariate convergence diagnostics for the Metropolis-Hastings.\n');
@@ -346,11 +346,11 @@ if reste
     if reste == 1
         nr = 3;
         nc = 1;
-    elseif reste == 2;
+    elseif reste == 2
         nr = 2;
         nc = 3;
     end
-    h = dyn_figure(options_,'Name','MCMC univariate convergence diagnostic (Brooks and Gelman, 1998)');
+    h = dyn_figure(options_.nodisplay,'Name','MCMC univariate convergence diagnostic (Brooks and Gelman, 1998)');
     boxplot = 1;
     for j = 1:reste
         k = k+1;
@@ -359,12 +359,12 @@ if reste
             if crit == 1
                 plt1 = UDIAG(:,1,k);
                 plt2 = UDIAG(:,2,k);
-                namnam  = [nam , ' (Interval)']; 
+                namnam  = [nam , ' (Interval)'];
             elseif crit == 2
                 plt1 = UDIAG(:,3,k);
                 plt2 = UDIAG(:,4,k);
                 namnam  = [nam , ' (m2)'];
-            elseif crit == 3    
+            elseif crit == 3
                 plt1 = UDIAG(:,5,k);
                 plt2 = UDIAG(:,6,k);
                 namnam  = [nam , ' (m3)'];
@@ -388,12 +388,12 @@ if reste
             boxplot = boxplot + 1;
         end
     end
-    dyn_saveas(h,[ OutputFolder '/' ModelName '_udiag' int2str(pages+1)],options_);
+    dyn_saveas(h,[ OutputFolder '/' ModelName '_udiag' int2str(pages+1)],options_.nodisplay,options_.graph_format);
     if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         fprintf(fidTeX,'\\begin{figure}[H]\n');
-        for jj = 1:size(NAMES,1);
+        for jj = 1:size(NAMES,1)
             fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(jj,:)),deblank(TEXNAMES(jj,:)));
-        end    
+        end
         fprintf(fidTeX,'\\centering \n');
         fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s_udiag%s}\n',options_.figures.textwidth*min((boxplot-1)/nc,1),[OutputFolder '/' ModelName],int2str(pages+1));
         if reste == 2
@@ -435,7 +435,7 @@ for b = 1:nblck
 end
 clear logpo2;
 tmp(:,2) = kron(transpose(1:nblck),ones(NumberOfDraws,1));
-tmp(:,3) = kron(ones(nblck,1),time'); 
+tmp(:,3) = kron(ones(nblck,1),time');
 tmp = sortrows(tmp,1);
 ligne   = 0;
 for iter  = Origin:StepSize:NumberOfDraws
@@ -454,25 +454,25 @@ for iter  = Origin:StepSize:NumberOfDraws
     for i=1:nblck
         pmet = temp(find(temp(:,2)==i));
         MDIAG(ligne,2) = MDIAG(ligne,2) + pmet(csup,1)-pmet(cinf,1);
-        moyenne = mean(pmet,1); %% Within mean. 
+        moyenne = mean(pmet,1); %% Within mean.
         MDIAG(ligne,4) = MDIAG(ligne,4) + sum((pmet(:,1)-moyenne).^2)/(n-1);
         MDIAG(ligne,6) = MDIAG(ligne,6) + sum(abs(pmet(:,1)-moyenne).^3)/(n-1);
     end
 end
-MDIAG(:,[2 4 6],:) = MDIAG(:,[2 4 6],:)/nblck;  
+MDIAG(:,[2 4 6],:) = MDIAG(:,[2 4 6],:)/nblck;
 
-h = dyn_figure(options_,'Name','Multivariate convergence diagnostic');
+h = dyn_figure(options_.nodisplay,'Name','Multivariate convergence diagnostic');
 boxplot = 1;
 for crit = 1:3
     if crit == 1
         plt1 = MDIAG(:,1);
         plt2 = MDIAG(:,2);
-        namnam  = 'Interval'; 
+        namnam  = 'Interval';
     elseif crit == 2
         plt1 = MDIAG(:,3);
         plt2 = MDIAG(:,4);
         namnam  = 'm2';
-    elseif crit == 3    
+    elseif crit == 3
         plt1 = MDIAG(:,5);
         plt2 = MDIAG(:,6);
         namnam  = 'm3';
@@ -493,13 +493,13 @@ for crit = 1:3
     title(namnam,'Interpreter','none');
     boxplot = boxplot + 1;
 end
-dyn_saveas(h,[ OutputFolder '/' ModelName '_mdiag'],options_);
+dyn_saveas(h,[ OutputFolder '/' ModelName '_mdiag'],options_.nodisplay,options_.graph_format);
 
 if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
     fprintf(fidTeX,'\\begin{figure}[H]\n');
     for jj = 1:3
         fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(jj,:)),' ');
-    end    
+    end
     fprintf(fidTeX,'\\centering \n');
     fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s_mdiag}\n',[OutputFolder '/' ModelName]);
     fprintf(fidTeX,'\\caption{Multivariate convergence diagnostics for the Metropolis-Hastings.\n');
@@ -512,4 +512,3 @@ if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
     fprintf(fidTeX,'%% End Of TeX file.');
     fclose(fidTeX);
 end
-
diff --git a/matlab/convergence_diagnostics/McMCDiagnostics_core.m b/matlab/convergence_diagnostics/McMCDiagnostics_core.m
index af41566c9..283e6ada1 100644
--- a/matlab/convergence_diagnostics/McMCDiagnostics_core.m
+++ b/matlab/convergence_diagnostics/McMCDiagnostics_core.m
@@ -2,12 +2,12 @@ function myoutput = McMCDiagnostics_core(myinputs,fpar,npar,whoiam, ThisMatlab)
 % function myoutput = McMCDiagnostics_core(myinputs,fpar,npar,whoiam, ThisMatlab)
 % Computes the Brooks/Gelman (1998) convergence diagnostics, both the
 % parameteric and the non-parameteric versions
-% 
+%
 % PARALLEL CONTEXT
 % Core functionality for MCMC Diagnostics, which can be parallelized.
 % See also the comment in posterior_sampler_core.m funtion.
-% 
-% 
+%
+%
 % INPUTS
 %   See See the comment in posterior_sampler_core.m funtion.
 
@@ -25,15 +25,15 @@ function myoutput = McMCDiagnostics_core(myinputs,fpar,npar,whoiam, ThisMatlab)
 %
 % ALGORITHM
 %   Computes part of the convergence diagnostics, the rest is computed in McMCDiagnostics.m .
-%   The methodology and terminology is based on: Brooks/Gelman (1998): General 
-%   Methods for Monitoring Convergence of Iterative Simulations, Journal of Computational 
+%   The methodology and terminology is based on: Brooks/Gelman (1998): General
+%   Methods for Monitoring Convergence of Iterative Simulations, Journal of Computational
 %   and Graphical Statistics, Volume 7, Number 4, Pages 434-455
-% 
+%
 %
 % SPECIAL REQUIREMENTS.
 %   None.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,7 +50,7 @@ function myoutput = McMCDiagnostics_core(myinputs,fpar,npar,whoiam, ThisMatlab)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin<4,
+if nargin<4
     whoiam=0;
 end
 
@@ -71,7 +71,7 @@ M_=myinputs.M_;
 if whoiam
     Parallel=myinputs.Parallel;
 end
-if ~exist('MetropolisFolder'),
+if ~exist('MetropolisFolder')
     MetropolisFolder = CheckPath('metropolis',M_.dname);
 end
 
@@ -81,16 +81,16 @@ UDIAG = zeros(NumberOfLines,6,npar-fpar+1);
 
 if whoiam
     waitbarString = ['Please wait... McMCDiagnostics (' int2str(fpar) 'of' int2str(npar) ')...'];
-    if Parallel(ThisMatlab).Local,
+    if Parallel(ThisMatlab).Local
         waitbarTitle=['Local '];
     else
         waitbarTitle=[Parallel(ThisMatlab).ComputerName];
     end
     fMessageStatus(0,whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab));
 end
-for j=fpar:npar,
+for j=fpar:npar
     if isoctave
-        if (whoiam==0),
+        if (whoiam==0)
             printf('    Parameter %d...  ',j);
         end
     else
@@ -131,13 +131,13 @@ for j=fpar:npar,
         end
     end
     if isoctave
-        if (whoiam==0),
+        if (whoiam==0)
             printf('Done! \n');
         end
     else
         fprintf('Done! \n');
     end
-    if whoiam,
+    if whoiam
         waitbarString = [ 'Parameter ' int2str(j) '/' int2str(npar) ' done.'];
         fMessageStatus((j-fpar+1)/(npar-fpar+1),whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab))
     end
diff --git a/matlab/convergence_diagnostics/geweke_chi2_test.m b/matlab/convergence_diagnostics/geweke_chi2_test.m
index 7ed383139..8acf67399 100644
--- a/matlab/convergence_diagnostics/geweke_chi2_test.m
+++ b/matlab/convergence_diagnostics/geweke_chi2_test.m
@@ -2,7 +2,7 @@ function results_struct = geweke_chi2_test(results1,results2,results_struct,opti
 % results_struct = geweke_chi2_test(results1,results2,results_struct,options)
 % PURPOSE: computes Geweke's chi-squared test for two sets of MCMC sample draws
 %
-% INPUTS 
+% INPUTS
 %   results1         [1 by (4+n_taper*2) vector] vector with post. mean,
 %                           std, NSE_iid, RNE_iid, and tapered NSE and RNE
 %                           for chain part 1
@@ -12,7 +12,7 @@ function results_struct = geweke_chi2_test(results1,results2,results_struct,opti
 %   results_struct   [structure] results structure generated by geweke_moments
 %   Dynareoptions    [structure]
 %
-% OUTPUTS 
+% OUTPUTS
 %   results_struct   [structure]  containing the following fields:
 %       pooled_mean               Pooled mean of the chain parts, weighted
 %                                   with precision
@@ -26,7 +26,7 @@ function results_struct = geweke_chi2_test(results1,results2,results_struct,opti
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,26 +49,25 @@ function results_struct = geweke_chi2_test(results1,results2,results_struct,opti
 % J.M. Bernardo, A.P. Dawid, and A.F.M. Smith (eds.) Proceedings of
 % the Fourth Valencia International Meeting on Bayesian Statistics,
 % pp. 169-194, Oxford University Press
-% Geweke (1999): `Using simulation methods for Bayesian econometric models: 
+% Geweke (1999): `Using simulation methods for Bayesian econometric models:
 % Inference, development and communication', Econometric Reviews, 18(1),
 % 1-73
 
-% written by: Johannes Pfeifer, 
-% based on code by James P. LeSage, who in turn 
-% drew on MATLAB programs written by Siddartha Chib 
+% written by: Johannes Pfeifer,
+% based on code by James P. LeSage, who in turn
+% drew on MATLAB programs written by Siddartha Chib
 
-for k=1:length(options.convergence.geweke.taper_steps)+1;
-  NSE=[results1(:,3+(k-1)*2) results2(:,3+(k-1)*2)];
-  means=[results1(:,1) results2(:,1)];
-  diff_Means=means(:,1)-means(:,2);
-  sum_of_weights=sum(1./(NSE.^2),2);
-  pooled_mean=sum(means./(NSE.^2),2)./sum_of_weights;
-  pooled_NSE=1./sqrt(sum_of_weights);
-
-  test_stat=diff_Means.^2./sum(NSE.^2,2); 
-  p = 1-chi2cdf(test_stat,1);
-  results_struct.pooled_mean(:,k) = pooled_mean;
-  results_struct.pooled_nse(:,k) = pooled_NSE;
-  results_struct.prob_chi2_test(:,k) = p;
-end;
+for k=1:length(options.convergence.geweke.taper_steps)+1
+    NSE=[results1(:,3+(k-1)*2) results2(:,3+(k-1)*2)];
+    means=[results1(:,1) results2(:,1)];
+    diff_Means=means(:,1)-means(:,2);
+    sum_of_weights=sum(1./(NSE.^2),2);
+    pooled_mean=sum(means./(NSE.^2),2)./sum_of_weights;
+    pooled_NSE=1./sqrt(sum_of_weights);
 
+    test_stat=diff_Means.^2./sum(NSE.^2,2);
+    p = 1-chi2cdf(test_stat,1);
+    results_struct.pooled_mean(:,k) = pooled_mean;
+    results_struct.pooled_nse(:,k) = pooled_NSE;
+    results_struct.prob_chi2_test(:,k) = p;
+end
diff --git a/matlab/convergence_diagnostics/geweke_moments.m b/matlab/convergence_diagnostics/geweke_moments.m
index 242a9d550..61c22979f 100644
--- a/matlab/convergence_diagnostics/geweke_moments.m
+++ b/matlab/convergence_diagnostics/geweke_moments.m
@@ -1,13 +1,13 @@
 function [results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
 %[results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
-% PURPOSE: computes Gewke's convergence diagnostics NSE and RNE 
+% PURPOSE: computes Gewke's convergence diagnostics NSE and RNE
 %          (numerical std error and relative numerical efficiencies)
 
-% INPUTS 
-%   draws            [ndraws by 1 vector] 
+% INPUTS
+%   draws            [ndraws by 1 vector]
 %   Dynareoptions    [structure]
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   results_vec
 %   results_struct   [structure]  containing the following fields:
 %          posteriormean= posterior parameter mean
@@ -22,7 +22,7 @@ function [results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,16 +44,16 @@ function [results_vec, results_struct] = geweke_moments(draws,Dynareoptions)
 % J.M. Bernardo, A.P. Dawid, and A.F.M. Smith (eds.) Proceedings of
 % the Fourth Valencia International Meeting on Bayesian Statistics,
 % pp. 169-194, Oxford University Press
-% Geweke (1999): `Using simulation methods for Bayesian econometric models: 
+% Geweke (1999): `Using simulation methods for Bayesian econometric models:
 % Inference, development and communication', Econometric Reviews, 18(1),
 % 1-73
 % -----------------------------------------------------------------
 
-% written by: Johannes Pfeifer, 
-% based on code by James P. LeSage, who in turn 
-% drew on MATLAB programs written by Siddartha Chib 
+% written by: Johannes Pfeifer,
+% based on code by James P. LeSage, who in turn
+% drew on MATLAB programs written by Siddartha Chib
+
 
-  
 ndraw = size(draws,1);
 n_groups=100;
 taper_steps=Dynareoptions.convergence.geweke.taper_steps;
@@ -64,10 +64,10 @@ n_draws_used = ns*n_groups; %effective number of draws used after rounding down
 
 window_means= zeros(n_groups,1);
 window_uncentered_variances= zeros(n_groups,1);
-for ig=1:n_groups;
+for ig=1:n_groups
     window_means(ig,1)=sum(draws((ig-1)*ns+1:ig*ns,1))/ns;
-    window_uncentered_variances(ig,1)=sum(draws((ig-1)*ns+1:ig*ns,1).^2)/ns;        
-end; %for ig
+    window_uncentered_variances(ig,1)=sum(draws((ig-1)*ns+1:ig*ns,1).^2)/ns;
+end %for ig
 total_mean=mean(window_means);
 total_variance=mean(window_uncentered_variances)-total_mean^2;
 
@@ -88,9 +88,9 @@ results_struct.rne_iid = results_vec(1,4);
 %get autocovariance of grouped means
 centered_window_means=window_means-total_mean;
 autocov_grouped_means=zeros(n_groups,1);
-for lag=0:n_groups-1;
+for lag=0:n_groups-1
     autocov_grouped_means(lag+1)=centered_window_means(lag+1:n_groups,1)'*centered_window_means(1:n_groups-lag,1)/100;
-end;
+end
 
 % numerical standard error with tapered autocovariance functions
 for taper_index=1:length(taper_steps)
@@ -105,5 +105,4 @@ for taper_index=1:length(taper_steps)
 
     eval(['results_struct.nse_taper_',num2str(taper),'= NSE_taper;']);
     eval(['results_struct.rne_taper_',num2str(taper),'= total_variance/(n_draws_used*NSE_taper^2);']);
-end; % end of for mm loop
-
+end % end of for mm loop
diff --git a/matlab/convergence_diagnostics/mcmc_ifac.m b/matlab/convergence_diagnostics/mcmc_ifac.m
index 3688153f9..32b72bcee 100644
--- a/matlab/convergence_diagnostics/mcmc_ifac.m
+++ b/matlab/convergence_diagnostics/mcmc_ifac.m
@@ -1,71 +1,71 @@
-function Ifac = mcmc_ifac(X, Nc)
-% function Ifac = mcmc_ifac(X, Nc)
-% Compute inefficiency factor of a MCMC sample X based on a Parzen Window
-%
-% INPUTS
-%   X:       time series
-%   Nc:      # of lags
-%
-% OUTPUTS
-%   Ifac:       inefficiency factor of MCMC sample
-%
-% SPECIAL REQUIREMENTS
-%   none
-% ALGORITHM:
-%   Inefficiency factors are computed as
-%   \[
-%       Ifac = 1 + 2\sum\limits_{i=1}^{Nc} {\hat \rho(i)} 
-%   \]
-%   where $\hat \rho(i)$ denotes the autocorrelation at lag i and the terms
-%   of the sum are truncated using a Parzen window.
-%   
-%   For inefficiency factors, see Section 6.1 of Paolo Giordani, Michael Pitt, and Robert Kohn (2011): 
-%   "Bayesian Inference for Time Series State Space Models" in : John Geweke, Gary Koop,
-%   Herman van Dijk (editors): "The Oxford Handbook of Bayesian
-%   Econometrics", Oxford University Press
-%
-%   The Parzen-Window is given by
-%  \[
-%   k(x) = \left\{ {\begin{array}{*{20}{c}}
-%        {1 - 6{x^2} + 6|x|^3} \text{ for } 0 \leqslant |x| \leqslant \frac{1}{2}} \\
-%        {2(1-|x|^3) \text{ for } \frac{1}{2} \leqslant |x| \leqslant 1} \\
-%        {0 \text{ otherwise}}
-%        \end{array}} \right.
-%  \]
-% See Donald W.K Andrews (1991): "Heteroskedasticity and autocorrelation
-% consistent covariance matrix estimation", Econometrica, 59(3), p. 817-858
-
-
-% Copyright (C) 2015-16 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/>.
-
-Nc = floor(min(Nc, length(X)/2));
-if mod(Nc,2),
-    Nc=Nc-1;
-end
-AcorrXSIM = dyn_autocorr(X(:), Nc);
-%
-%Calculate the Parzen Weight
-Parzen=zeros(Nc+1,1);
-for i=1: Nc/2+1
-    Parzen(i)=1 - 6*(i/Nc)^2+ 6*(i/Nc)^3;
-end
-for i=(Nc/2)+1: Nc+1
-    Parzen(i)=2 * (1-(i/Nc))^3;
-end
-Parzen=Parzen';
-Ifac= 1+2*sum(Parzen(:).* AcorrXSIM);
+function Ifac = mcmc_ifac(X, Nc)
+% function Ifac = mcmc_ifac(X, Nc)
+% Compute inefficiency factor of a MCMC sample X based on a Parzen Window
+%
+% INPUTS
+%   X:       time series
+%   Nc:      # of lags
+%
+% OUTPUTS
+%   Ifac:       inefficiency factor of MCMC sample
+%
+% SPECIAL REQUIREMENTS
+%   none
+% ALGORITHM:
+%   Inefficiency factors are computed as
+%   \[
+%       Ifac = 1 + 2\sum\limits_{i=1}^{Nc} {\hat \rho(i)}
+%   \]
+%   where $\hat \rho(i)$ denotes the autocorrelation at lag i and the terms
+%   of the sum are truncated using a Parzen window.
+%
+%   For inefficiency factors, see Section 6.1 of Paolo Giordani, Michael Pitt, and Robert Kohn (2011):
+%   "Bayesian Inference for Time Series State Space Models" in : John Geweke, Gary Koop,
+%   Herman van Dijk (editors): "The Oxford Handbook of Bayesian
+%   Econometrics", Oxford University Press
+%
+%   The Parzen-Window is given by
+%  \[
+%   k(x) = \left\{ {\begin{array}{*{20}{c}}
+%        {1 - 6{x^2} + 6|x|^3} \text{ for } 0 \leqslant |x| \leqslant \frac{1}{2}} \\
+%        {2(1-|x|^3) \text{ for } \frac{1}{2} \leqslant |x| \leqslant 1} \\
+%        {0 \text{ otherwise}}
+%        \end{array}} \right.
+%  \]
+% See Donald W.K Andrews (1991): "Heteroskedasticity and autocorrelation
+% consistent covariance matrix estimation", Econometrica, 59(3), p. 817-858
+
+
+% Copyright (C) 2015-2017 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/>.
+
+Nc = floor(min(Nc, length(X)/2));
+if mod(Nc,2)
+    Nc=Nc-1;
+end
+AcorrXSIM = dyn_autocorr(X(:), Nc);
+%
+%Calculate the Parzen Weight
+Parzen=zeros(Nc+1,1);
+for i=1: Nc/2+1
+    Parzen(i)=1 - 6*(i/Nc)^2+ 6*(i/Nc)^3;
+end
+for i=(Nc/2)+1: Nc+1
+    Parzen(i)=2 * (1-(i/Nc))^3;
+end
+Parzen=Parzen';
+Ifac= 1+2*sum(Parzen(:).* AcorrXSIM);
diff --git a/matlab/convergence_diagnostics/raftery_lewis.m b/matlab/convergence_diagnostics/raftery_lewis.m
index c2a162d87..ab0e51cb7 100644
--- a/matlab/convergence_diagnostics/raftery_lewis.m
+++ b/matlab/convergence_diagnostics/raftery_lewis.m
@@ -1,15 +1,15 @@
 function  [raftery_lewis] = raftery_lewis(runs,q,r,s)
 % function  raftery_lewis = raftery_lewis(runs,q,r,s)
-% Computes the convergence diagnostics of Raftery and Lewis (1992), i.e. the 
-% number of draws needed in MCMC to estimate the posterior cdf of the q-quantile 
+% Computes the convergence diagnostics of Raftery and Lewis (1992), i.e. the
+% number of draws needed in MCMC to estimate the posterior cdf of the q-quantile
 % within an accuracy r with probability s
-% 
+%
 % Inputs:
-%   - draws [n_draws by n_var]      double matrix of draws from the sampler 
+%   - draws [n_draws by n_var]      double matrix of draws from the sampler
 %   - q     [scalar]                quantile of the quantity of interest
-%   - r     [scalar]                level of desired precision 
+%   - r     [scalar]                level of desired precision
 %   - s     [scalar]                probability associated with r
-% 
+%
 % Output:
 %   raftery_lewis   [structure]     containing the fields:
 %   - M_burn    [n_draws by 1]      number of draws required for burn-in
@@ -21,7 +21,7 @@ function  [raftery_lewis] = raftery_lewis(runs,q,r,s)
 %                                   iterations due to dependence in chain
 %   - N_min     [scalar]            # draws if the chain is white noise
 %   - N_total   [n_draws by 1]      nburn + nprec
-% 
+%
 
 % ---------------------------------------------------------------------
 % NOTES:   Example values of q, r, s:
@@ -30,23 +30,23 @@ function  [raftery_lewis] = raftery_lewis(runs,q,r,s)
 %
 %  - The result is quite sensitive to r, being proportional to the
 %       inverse of r^2.
-%  - For epsilon (closeness of probabilities to equilibrium values), 
+%  - For epsilon (closeness of probabilities to equilibrium values),
 %       Raftery/Lewis use 0.001 and argue that the results
 %       are quite robust to changes in this value
 %
 % ---------------------------------------------------------------------
-% REFERENCES: 
+% REFERENCES:
 % Raftery, Adrien E./Lewis, Steven (1992a): "How many iterations in the Gibbs sampler?"
-%   in: Bernardo/Berger/Dawid/Smith (eds.): Bayesian Statistics, Vol. 4, Clarendon Press: Oxford, 
-%   pp. 763-773.   
-% Raftery, Adrien E./Lewis, Steven (1992b): "Comment: One long run with diagnostics: 
-%   Implementation strategies for Markov chain Monte Carlo." Statistical Science, 
-%   7(4), pp. 493-497.  
+%   in: Bernardo/Berger/Dawid/Smith (eds.): Bayesian Statistics, Vol. 4, Clarendon Press: Oxford,
+%   pp. 763-773.
+% Raftery, Adrien E./Lewis, Steven (1992b): "Comment: One long run with diagnostics:
+%   Implementation strategies for Markov chain Monte Carlo." Statistical Science,
+%   7(4), pp. 493-497.
 %
 % ----------------------------------------------------
 
 % Copyright (C) 2016 Benjamin Born and Johannes Pfeifer
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -80,42 +80,42 @@ thinned_chain  = zeros(n_runs,1);
 Phi   = norminv((s+1)/2); %note the missing ^{-1} at the Phi in equation top page 5, see RL (1995)
 raftery_lewis.N_min  = fix(Phi^2*(1-q)*q/r^2+1);
 
-for nv = 1:n_vars % big loop over variables    
+for nv = 1:n_vars % big loop over variables
     if q > 0 && q < 1
         work = (runs(:,nv) <= quantile(runs(:,nv),q));
     else
-        error('Quantile must be between 0 and 1'); 
-    end;
-    
-    k_thin_current_var = 1; 
-    bic = 1; 
+        error('Quantile must be between 0 and 1');
+    end
+
+    k_thin_current_var = 1;
+    bic = 1;
     epss = 0.001;
     % Find thinning factor for which first-order Markov Chain is preferred to second-order one
     while(bic > 0)
-        thinned_chain=work(1:k_thin_current_var:n_runs,1); 
+        thinned_chain=work(1:k_thin_current_var:n_runs,1);
         [g2, bic] = first_vs_second_order_MC_test(thinned_chain);
         k_thin_current_var = k_thin_current_var+1;
-    end;
-    
+    end
+
     k_thin_current_var = k_thin_current_var-1; %undo last step
-    
-    %compute transition probabilities 
+
+    %compute transition probabilities
     transition_matrix = zeros(2,2);
     for i1 = 2:size(thinned_chain,1)
         transition_matrix(thinned_chain(i1-1)+1,thinned_chain(i1)+1) = transition_matrix(thinned_chain(i1-1)+1,thinned_chain(i1)+1)+1;
-    end;
+    end
     alpha = transition_matrix(1,2)/(transition_matrix(1,1)+transition_matrix(1,2)); %prob of going from 1 to 2
     beta = transition_matrix(2,1)/(transition_matrix(2,1)+transition_matrix(2,2));  %prob of going from 2 to 1
 
     kmind=k_thin_current_var;
     [g2, bic]=independence_chain_test(thinned_chain);
-    
+
     while(bic > 0)
-        thinned_chain=work(1:kmind:n_runs,1); 
+        thinned_chain=work(1:kmind:n_runs,1);
         [g2, bic] = independence_chain_test(thinned_chain);
         kmind = kmind+1;
-    end;
-    
+    end
+
     m_star  = log((alpha + beta)*epss/max(alpha,beta))/log(abs(1 - alpha - beta)); %equation bottom page 4
     raftery_lewis.M_burn(nv) = fix((m_star+1)*k_thin_current_var);
     n_star  = (2 - (alpha + beta))*alpha*beta*(Phi^2)/((alpha + beta)^3 * r^2); %equation top page 5
@@ -124,35 +124,35 @@ for nv = 1:n_vars % big loop over variables
     raftery_lewis.k_ind(nv)  = max(fix(raftery_lewis.I_stat(nv)+1),kmind);
     raftery_lewis.k_thin(nv) = k_thin_current_var;
     raftery_lewis.N_total(nv)= raftery_lewis.M_burn(nv)+raftery_lewis.N_prec(nv);
-end;
+end
 
 end
 
 function [g2, bic] = first_vs_second_order_MC_test(d)
 %conducts a test of first vs. second order Markov Chain via BIC criterion
 n_obs=size(d,1);
-g2 = 0; 
+g2 = 0;
 tran=zeros(2,2,2);
 for t_iter=3:n_obs     % count state transitions
     tran(d(t_iter-2,1)+1,d(t_iter-1,1)+1,d(t_iter,1)+1)=tran(d(t_iter-2,1)+1,d(t_iter-1,1)+1,d(t_iter,1)+1)+1;
-end;
+end
 % Compute the log likelihood ratio statistic for second-order MC vs first-order MC. G2 statistic of Bishop, Fienberg and Holland (1975)
 for ind_1 = 1:2
     for ind_2 = 1:2
         for ind_3 = 1:2
             if tran(ind_1,ind_2,ind_3) ~= 0
                 fitted = (tran(ind_1,ind_2,1) + tran(ind_1,ind_2,2))*(tran(1,ind_2,ind_3) + tran(2,ind_2,ind_3))/...
-                    (tran(1,ind_2,1) + tran(1,ind_2,2) + tran(2,ind_2,1) + tran(2,ind_2,2));
+                         (tran(1,ind_2,1) + tran(1,ind_2,2) + tran(2,ind_2,1) + tran(2,ind_2,2));
                 focus = tran(ind_1,ind_2,ind_3);
                 g2 = g2 + log(focus/fitted)*focus;
             end
-        end;       % end of for i3
-    end;        % end of for i2
-end;         % end of for i1
-g2 = g2*2;
-bic = g2 - log(n_obs-2)*2;
+        end       % end of for i3
+    end        % end of for i2
+end         % end of for i1
+    g2 = g2*2;
+    bic = g2 - log(n_obs-2)*2;
 
-end
+    end
 
 
 function [g2, bic] = independence_chain_test(d)
@@ -161,19 +161,19 @@ n_obs=size(d,1);
 trans = zeros(2,2);
 for ind_1 = 2:n_obs
     trans(d(ind_1-1)+1,d(ind_1)+1)=trans(d(ind_1-1)+1,d(ind_1)+1)+1;
-end;
-dcm1 = n_obs - 1;  
+end
+dcm1 = n_obs - 1;
 g2 = 0;
 % Compute the log likelihood ratio statistic for second-order MC vs first-order MC. G2 statistic of Bishop, Fienberg and Holland (1975)
 for ind_1 = 1:2
     for ind_2 = 1:2
         if trans(ind_1,ind_2) ~= 0
-            fitted = ((trans(ind_1,1) + trans(ind_1,2))*(trans(1,ind_2) + trans(2,ind_2)))/dcm1; 
+            fitted = ((trans(ind_1,1) + trans(ind_1,2))*(trans(1,ind_2) + trans(2,ind_2)))/dcm1;
             focus = trans(ind_1,ind_2);
             g2 = g2 + log(focus/fitted)*focus;
-        end;
-    end;
-end;
-g2 = g2*2; 
+        end
+    end
+end
+g2 = g2*2;
 bic = g2 - log(dcm1);
 end
diff --git a/matlab/convertAimCodeToInfo.m b/matlab/convertAimCodeToInfo.m
index 2aaf05be7..2320c7f65 100644
--- a/matlab/convertAimCodeToInfo.m
+++ b/matlab/convertAimCodeToInfo.m
@@ -19,7 +19,7 @@ function [info] = convertAimCodeToInfo(aimCode)
 % OUTPUTS
 %   info        [integer]    Code to be used to print error in print_info.m
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,7 +55,7 @@ switch aimCode
     info = 161;
   case 62
     info = 162;
-  case 63; 
+  case 63
     info = 163;
   case 64
     info = 164;
diff --git a/matlab/convert_dyn_45_to_44.m b/matlab/convert_dyn_45_to_44.m
index ba3dbc671..3f0561b58 100644
--- a/matlab/convert_dyn_45_to_44.m
+++ b/matlab/convert_dyn_45_to_44.m
@@ -13,7 +13,7 @@ function oo_ = convert_dyn_45_to_44(M_, options_, oo_,bayestopt_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,7 +40,7 @@ if isfield(oo_,'PointForecast')
                 oo_.MeanForecast.(moment_names{moment_iter}).(var_names{var_iter})=...
                     [oo_.SmoothedVariables.(moment_names{moment_iter}).(var_names{var_iter})(:,end)*ones(M_.maximum_endo_lag,1)  oo_.MeanForecast.(moment_names{moment_iter}).(var_names{var_iter})];
                 oo_.PointForecast.(moment_names{moment_iter}).(var_names{var_iter})=...
-                    [oo_.SmoothedVariables.(moment_names{moment_iter}).(var_names{var_iter})(:,end)*ones(M_.maximum_endo_lag,1) oo_.PointForecast.(moment_names{moment_iter}).(var_names{var_iter})];                
+                    [oo_.SmoothedVariables.(moment_names{moment_iter}).(var_names{var_iter})(:,end)*ones(M_.maximum_endo_lag,1) oo_.PointForecast.(moment_names{moment_iter}).(var_names{var_iter})];
             else
                 oo_.MeanForecast.(moment_names{moment_iter}).(var_names{var_iter})=...
                     [oo_.SmoothedVariables.(moment_names{moment_iter}).(var_names{var_iter})(end)*ones(M_.maximum_endo_lag,1); oo_.MeanForecast.(moment_names{moment_iter}).(var_names{var_iter})];
@@ -106,7 +106,7 @@ if isfield(oo_,'UpdatedVariables')
     for ii=1:length(names)
         %make sure Bayesian fields are not affected
         if ~strcmp(names{ii},'Mean') && ~strcmp(names{ii},'Median') && ~strcmp(names{ii},'deciles') ...
-                && ~strcmp(names{ii},'Var') && ~strcmp(names{ii},'HPDinf') && ~strcmp(names{ii},'HPDsup') 
+                && ~strcmp(names{ii},'Var') && ~strcmp(names{ii},'HPDinf') && ~strcmp(names{ii},'HPDsup')
             current_var_index=find(strmatch(names{ii},deblank(M_.endo_names),'exact'));
             if  options_.loglinear == 1 %logged steady state must be used
                 constant_current_variable=log(oo_.dr.ys(current_var_index));
@@ -127,7 +127,7 @@ if isfield(oo_,'FilteredVariables')
     for ii=1:length(names)
         %make sure Bayesian fields are not affected
         if ~strcmp(names{ii},'Mean') && ~strcmp(names{ii},'Median') && ~strcmp(names{ii},'deciles') ...
-                && ~strcmp(names{ii},'Var') && ~strcmp(names{ii},'HPDinf') && ~strcmp(names{ii},'HPDsup') 
+                && ~strcmp(names{ii},'Var') && ~strcmp(names{ii},'HPDinf') && ~strcmp(names{ii},'HPDsup')
             current_var_index=find(strmatch(names{ii},deblank(M_.endo_names),'exact'));
             if  options_.loglinear == 1 %logged steady state must be used
                 constant_current_variable=log(oo_.dr.ys(current_var_index));
@@ -147,11 +147,11 @@ end
 if ~isempty(options_.nk) && options_.nk ~= 0 && ~isempty(bayestopt_)
     if ~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.pshape> 0) && options_.load_mh_file)) %no Bayesian estimation
         positions_in_decision_order=oo_.dr.inv_order_var(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list));
-            if  options_.loglinear == 1 %logged steady state must be used
-                constant_all_variables=log(oo_.dr.ys(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list)));
-            elseif options_.loglinear == 0 %unlogged steady state must be used
-                constant_all_variables=oo_.dr.ys(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list));
-            end
+        if  options_.loglinear == 1 %logged steady state must be used
+            constant_all_variables=log(oo_.dr.ys(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list)));
+        elseif options_.loglinear == 0 %unlogged steady state must be used
+            constant_all_variables=oo_.dr.ys(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list));
+        end
         if ~(options_.selected_variables_only && ~(options_.forecast > 0)) %happens only when selected_variables_only is not used
             oo_.FilteredVariablesKStepAhead(:,positions_in_decision_order,:)=oo_.FilteredVariablesKStepAhead-constant_all_variables;
             if ~isempty(PK) %get K-step ahead variances
@@ -182,11 +182,11 @@ end
 
 %Deal with OSR
 if ~isempty(M_.osr.variable_weights)
-   evalin('base','optim_weights_=M_.osr.variable_weights')
+    evalin('base','optim_weights_=M_.osr.variable_weights')
 end
 if ~isempty(M_.osr.variable_indices)
-   evalin('base','obj_var_=M_.osr.variable_indices')
+    evalin('base','obj_var_=M_.osr.variable_indices')
 end
 if ~isempty(M_.osr.param_names)
-   evalin('base','osr_params_=char(M_.osr.param_names)')
+    evalin('base','osr_params_=char(M_.osr.param_names)')
 end
diff --git a/matlab/convert_oo_.m b/matlab/convert_oo_.m
index ef5f72280..914cc0adb 100644
--- a/matlab/convert_oo_.m
+++ b/matlab/convert_oo_.m
@@ -15,7 +15,7 @@ function oo_ = convert_oo_(M_, options_, oo_, from_ver, to_ver)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -63,7 +63,7 @@ else
 end
 
 if strcmp(from_ver, to_ver)
-    return;
+    return
 end
 
 if ver_greater_than(to_ver, from_ver)
@@ -81,5 +81,5 @@ else
 end
 
 eval(['oo_ = convert_dyn_' strrep(new_from_ver, '.', '') '_to_' ...
-                           strrep(to_ver, '.', '') '(M_, options_, oo_);']);
+      strrep(to_ver, '.', '') '(M_, options_, oo_);']);
 end
diff --git a/matlab/correlation_mc_analysis.m b/matlab/correlation_mc_analysis.m
index 6eba19485..7b3d63848 100644
--- a/matlab/correlation_mc_analysis.m
+++ b/matlab/correlation_mc_analysis.m
@@ -2,7 +2,7 @@ function oo_ = correlation_mc_analysis(SampleSize,type,dname,fname,vartan,nvar,v
 % This function analyses the (posterior or prior) distribution of the
 % endogenous variables correlation function.
 
-% Copyright (C) 2008-2013 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -137,7 +137,7 @@ end
 
 function oo_ = fill_output_structure(var1,var2,type,oo_,moment,lag,result)
 switch moment
-  case {'Mean','Median','Variance','HPDinf','HPDsup'} 
+  case {'Mean','Median','Variance','HPDinf','HPDsup'}
     oo_.([type,  'TheoreticalMoments']).dsge.correlation.(moment).(var1).(var2)(lag,1) = result;
   case {'deciles','density'}
     oo_.([type, 'TheoreticalMoments']).dsge.correlation.(moment).(var1).(var2)(lag,1) = {result};
diff --git a/matlab/cosn.m b/matlab/cosn.m
index 8fcf7fb79..b64245e7b 100644
--- a/matlab/cosn.m
+++ b/matlab/cosn.m
@@ -1,4 +1,4 @@
-function [co, b, yhat] = cosn(H);
+function [co, b, yhat] = cosn(H)
 
 % function co = cosn(H);
 % computes the cosine of the angle between the H(:,1) and its
@@ -7,7 +7,7 @@ function [co, b, yhat] = cosn(H);
 % Not the same as multiple correlation coefficient since the means are not
 % zero
 %
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,15 +28,12 @@ y = H(:,1);
 X = H(:,2:end);
 
 b=(X\y);
-if any(isnan(b)) || any(isinf(b)),
+if any(isnan(b)) || any(isinf(b))
     b=0;
 end
 yhat =  X*b;
-if rank(yhat),
+if rank(yhat)
     co = abs(y'*yhat/sqrt((y'*y)*(yhat'*yhat)));
 else
     co=0;
 end
-
-
-
diff --git a/matlab/covariance_mc_analysis.m b/matlab/covariance_mc_analysis.m
index 60753407b..ebf3602a2 100644
--- a/matlab/covariance_mc_analysis.m
+++ b/matlab/covariance_mc_analysis.m
@@ -1,7 +1,7 @@
 function oo_ = covariance_mc_analysis(NumberOfSimulations,type,dname,fname,vartan,nvar,var1,var2,mh_conf_sig,oo_,options_)
 % This function analyses the (posterior or prior) distribution of the
 % endogenous variables' covariance matrix.
-% 
+%
 % INPUTS
 %   NumberOfSimulations     [integer]           scalar, number of simulations.
 %   type                    [string]            'prior' or 'posterior'
@@ -14,12 +14,12 @@ function oo_ = covariance_mc_analysis(NumberOfSimulations,type,dname,fname,varta
 %   mh_conf_sig             [double]            2 by 1 vector with upper
 %                                               and lower bound of HPD intervals
 %   oo_                     [structure]         Dynare structure where the results are saved.
-%   options_                [structure]         Dynare options structure 
+%   options_                [structure]         Dynare options structure
 %
 % OUTPUTS
 %   oo_                     [structure]        Dynare structure where the results are saved.
 
-% Copyright (C) 2008-2015 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -64,7 +64,7 @@ var1=deblank(var1);
 var2=deblank(var2);
 
 if isfield(oo_,[ TYPE 'TheoreticalMoments'])
-    temporary_structure = oo_.([TYPE, 'TheoreticalMoments']); 
+    temporary_structure = oo_.([TYPE, 'TheoreticalMoments']);
     if isfield(temporary_structure,'dsge')
         temporary_structure = oo_.([TYPE, 'TheoreticalMoments']).dsge;
         if isfield(temporary_structure,'covariance')
@@ -104,17 +104,17 @@ for file = 1:length(ListOfFiles)
         temp=Covariance_matrix(:,cov_pos)./(sqrt(Covariance_matrix(:,var_pos_1)).*sqrt(Covariance_matrix(:,var_pos_2)));
         temp(Covariance_matrix(:,cov_pos)==0)=0; %filter out 0 correlations that would result in 0/0
         tmp_corr_mat(i1:i2)=temp;
-    end    
+    end
     i1 = i2+1;
 end
 
 if options_.estimation.moments_posterior_density.indicator
     [p_mean, p_median, p_var, hpd_interval, p_deciles, density] = ...
-            posterior_moments(tmp,1,mh_conf_sig);
+        posterior_moments(tmp,1,mh_conf_sig);
     oo_.([TYPE, 'TheoreticalMoments']).dsge.covariance.density.(var1).(var2) = density;
 else
     [p_mean, p_median, p_var, hpd_interval, p_deciles] = ...
-                    posterior_moments(tmp,0,mh_conf_sig);
+        posterior_moments(tmp,0,mh_conf_sig);
 end
 oo_.([TYPE, 'TheoreticalMoments']).dsge.covariance.Mean.(var1).(var2) = p_mean;
 oo_.([TYPE, 'TheoreticalMoments']).dsge.covariance.Median.(var1).(var2) = p_median;
diff --git a/matlab/csolve.m b/matlab/csolve.m
index 3af47243e..e45a4b2ff 100644
--- a/matlab/csolve.m
+++ b/matlab/csolve.m
@@ -12,7 +12,7 @@ function [x,rc] = csolve(FUN,x,gradfun,crit,itmax,varargin)
 %           the equation is solved.
 % itmax:    the solver stops when this number of iterations is reached, with rc=4
 % varargin: in this position the user can place any number of additional arguments, all
-%           of which are passed on to FUN and gradfun (when it is non-empty) as a list of 
+%           of which are passed on to FUN and gradfun (when it is non-empty) as a list of
 %           arguments following x.
 % rc:       0 means normal solution, 1 and 3 mean no solution despite extremely fine adjustments
 %           in step length (very likely a numerical problem, or a discontinuity). 4 means itmax
@@ -22,7 +22,7 @@ function [x,rc] = csolve(FUN,x,gradfun,crit,itmax,varargin)
 % http://sims.princeton.edu/yftp/optimize/mfiles/csolve.m
 
 % Copyright (C) 1993-2007 Christopher Sims
-% Copyright (C) 2007-2011 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -60,7 +60,7 @@ if isempty(varargin)
     f0=feval(FUN,x);
 else
     f0=feval(FUN,x,varargin{:});
-end   
+end
 af0=sum(abs(f0));
 af00=af0;
 itct=0;
@@ -122,7 +122,7 @@ while ~done
                 factor=factor^.6;
                 shrink=1;
             end
-            if abs(lambda*(1-factor))*dxSize > .1*delta;
+            if abs(lambda*(1-factor))*dxSize > .1*delta
                 lambda = factor*lambda;
             elseif (lambda > 0) && (factor==.6) %i.e., we've only been shrinking
                 lambda=-.3;
@@ -162,7 +162,7 @@ while ~done
     if itct >= itmax
         done=1;
         rc=4;
-    elseif af0<crit;
+    elseif af0<crit
         done=1;
         rc=0;
     end
diff --git a/matlab/cubature_with_gaussian_weight.m b/matlab/cubature_with_gaussian_weight.m
index ecc69230d..da93fbe55 100644
--- a/matlab/cubature_with_gaussian_weight.m
+++ b/matlab/cubature_with_gaussian_weight.m
@@ -29,12 +29,12 @@ function [nodes, weights] = cubature_with_gaussian_weight(d,n,method)
 %! The routine returns nodes and associated weights to compute a multivariate integral of the form:
 %!
 %! \int_D f(x)*\exp(-<x,x>) dx
-%! 
-%! 
+%!
+%!
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012-2013 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -52,7 +52,7 @@ function [nodes, weights] = cubature_with_gaussian_weight(d,n,method)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 % AUTHOR(S) stephane DOT adjemian AT univ DASH lemans DOT fr
-    
+
 % Set default.
 if nargin<3 || isempty(method)
     method = 'Stroud';
@@ -90,7 +90,7 @@ if strcmp(method,'Stroud') &&  isequal(n,5)
     nodes = zeros(d,m);
     weights = zeros(m,1);
     % Set the weight for the first node (0)
-    weights(1) = A; 
+    weights(1) = A;
     skip = 1;
     % Set the remaining nodes and associated weights.
     nodes(:,skip+(1:d)) = r*eye(d);
@@ -117,20 +117,20 @@ end
 
 
 function v = e(n,i)
-    v = zeros(n,1);
-    v(i) = 1;
-    
+v = zeros(n,1);
+v(i) = 1;
+
 function m = ee(n,i,j)
-    m = zeros(n,4);
-    m(:,1) =  e(n,i)+e(n,j);
-    m(:,2) =  e(n,i)-e(n,j);
-    m(:,3) = -m(:,2);
-    m(:,4) = -m(:,1);
-    
+m = zeros(n,4);
+m(:,1) =  e(n,i)+e(n,j);
+m(:,2) =  e(n,i)-e(n,j);
+m(:,3) = -m(:,2);
+m(:,4) = -m(:,1);
+
 %@test:1
 %$ % Set problem
 %$ d = 4;
-%$ 
+%$
 %$ t = zeros(5,1);
 %$
 %$ % Call the tested routine
@@ -289,7 +289,7 @@ function m = ee(n,i,j)
 %@test:5
 %$ % Set problem
 %$ d = 5;
-%$ 
+%$
 %$ t = zeros(6,1);
 %$
 %$ % Call the tested routine
@@ -333,7 +333,7 @@ function m = ee(n,i,j)
 %@test:6
 %$ % Set problem
 %$ d = 3;
-%$ 
+%$
 %$ t = zeros(4,1);
 %$
 %$ % Call the tested routine
diff --git a/matlab/cycle_reduction.m b/matlab/cycle_reduction.m
index 019c39a19..be8fdb3e8 100644
--- a/matlab/cycle_reduction.m
+++ b/matlab/cycle_reduction.m
@@ -43,7 +43,7 @@ function [X, info] = cycle_reduction(A0, A1, A2, cvg_tol, ch) % --*-- Unitary te
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -76,7 +76,7 @@ id0 = 1:n;
 id2 = id0+n;
 
 cont = 1;
-while cont 
+while cont
     tmp = ([A0; A2]/A1)*[A0 A2];
     A1 = A1 - tmp(id0,id2) - tmp(id2,id0);
     A0 = -tmp(id0,id0);
@@ -97,7 +97,7 @@ while cont
             info(2) = log(norm(A1,1));
         end
         return
-    end        
+    end
     it = it + 1;
 end
 
@@ -125,8 +125,8 @@ end
 %$
 %$ % Solve the equation with the cycle reduction algorithm
 %$ try
-%$     t=cputime; X1 = cycle_reduction(C,B,A,1e-7); elapsedtime = cputime-t;
-%$     disp(['cputime for cycle reduction algorithm is: ' num2str(elapsedtime) ' (n=' int2str(n) ').'])
+%$     tic; X1 = cycle_reduction(C,B,A,1e-7); elapsedtime = toc;
+%$     disp(['Elapsed time for cycle reduction algorithm is: ' num2str(elapsedtime) ' (n=' int2str(n) ').'])
 %$     t(1) = 1;
 %$ catch
 %$     % nothing to do here.
@@ -134,8 +134,8 @@ end
 %$
 %$ % Solve the equation with the logarithmic reduction algorithm
 %$ try
-%$     t=cputime; X2 = logarithmic_reduction(A,B,C,1e-16,100); elapsedtime = cputime-t;
-%$     disp(['cputime for logarithmic reduction algorithm is: ' num2str(elapsedtime) ' (n=' int2str(n) ').'])
+%$     tic; X2 = logarithmic_reduction(A,B,C,1e-16,100); elapsedtime = toc;
+%$     disp(['Elapsed time for logarithmic reduction algorithm is: ' num2str(elapsedtime) ' (n=' int2str(n) ').'])
 %$     t(2) = 1;
 %$ catch
 %$     % nothing to do here.
diff --git a/matlab/datatomfile.m b/matlab/datatomfile.m
index 4c7abec23..76928c77f 100644
--- a/matlab/datatomfile.m
+++ b/matlab/datatomfile.m
@@ -1,20 +1,23 @@
-function datatomfile (s,var_list, names)
-% function datatomfile (s,var_list)
-% This optional command saves the simulation results in a text file. The name of each
-% variable preceeds the corresponding results. This command must follow SIMUL.
-% 
+function datatomfile (s, var_list, names)
+
+% This command saves the simulation results in a text file. The name of each
+% variable preceeds the corresponding results. This command must follow SIMUL
+% or STOCH_SIMUL commands.
+%
 % INPUTS
-%    s:              data file name
-%    var_list:       vector of selected endogenous variables
-%    names:          vector of strings (alternative names for the endogenous variables in the data file)
+%  - s:              data file name
+%  - var_list:       vector of selected endogenous variables
+%  - names:          vector of strings (alternative names for the endogenous variables in the data file)
 %
 % OUTPUTS
-%    none
+% none
 %
-% SPECIAL REQUIREMENTS
-%    none
+% REMARKS
+% Only the first argument is mandatory. If only one input argument is
+% provided, all the variables as defined in M_.endo_names will be saved in
+% the generated m file.
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,7 +36,7 @@ function datatomfile (s,var_list, names)
 
 global M_ oo_
 
-% Open the data file. 
+% Open the data file.
 sm=[s,'.m'];
 fid=fopen(sm,'w') ;
 
@@ -62,8 +65,8 @@ for i=1:n
     end
 end
 stack = dbstack;
-    fprintf(fid,'%% Dataset generated by %s.\n',stack(2).file);
-    fprintf(fid,['%% ' datestr(now,0) '\n']);
+fprintf(fid,'%% Dataset generated by %s.\n',stack(2).file);
+fprintf(fid,['%% ' datestr(now,0) '\n']);
 % Save the selected data.
 for i = 1:n
     fprintf(fid,[strtrim(names(i,:)), ' = ['],'\n') ;
@@ -75,4 +78,3 @@ end
 
 % Close the data file.
 fclose(fid) ;
-
diff --git a/matlab/dcompare.m b/matlab/dcompare.m
index 6efc5ae27..d50541f12 100644
--- a/matlab/dcompare.m
+++ b/matlab/dcompare.m
@@ -1,6 +1,6 @@
 function dcompare(s1)
 
-% Copyright (C) 2001-2011 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -52,5 +52,3 @@ z = mean(mean(abs(x(j,i)-y(j,i)))) ;
 disp (['The mean absolute difference between set ' s1(1,:) 'and set ' s1(2,:)]) ;
 disp (['is : ' num2str(z)]) ;
 return ;
-
-
diff --git a/matlab/delete_mh_history_files.m b/matlab/delete_mh_history_files.m
index 64b720ec9..084f3e783 100644
--- a/matlab/delete_mh_history_files.m
+++ b/matlab/delete_mh_history_files.m
@@ -1,6 +1,6 @@
 function info = delete_mh_history_files(MetropolisFolder, ModelName)
-    
-% Copyright (C) 2013 Dynare Team
+
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/discretionary_policy.m b/matlab/discretionary_policy.m
index d12af30bd..e021e3375 100644
--- a/matlab/discretionary_policy.m
+++ b/matlab/discretionary_policy.m
@@ -1,6 +1,6 @@
 function info = discretionary_policy(var_list)
 
-% Copyright (C) 2007-2011 Dynare Team
+% Copyright (C) 2007-2015 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/discretionary_policy_1.m b/matlab/discretionary_policy_1.m
index 931d3b596..8f8bf6b8a 100644
--- a/matlab/discretionary_policy_1.m
+++ b/matlab/discretionary_policy_1.m
@@ -1,6 +1,6 @@
 function [dr,ys,info]=discretionary_policy_1(oo_,Instruments)
 
-% Copyright (C) 2007-2016 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,7 +39,7 @@ if isfield(M_,'orig_model')
     M_.maximum_lag = orig_model.maximum_lag;
     M_.maximum_endo_lag = orig_model.maximum_endo_lag;
 else
-	M_.orig_model = M_;
+    M_.orig_model = M_;
 end
 
 beta = get_optimal_policy_discount_factor(M_.params,M_.param_names);
@@ -53,10 +53,10 @@ if isfield(M_,'orig_model')
     MaxLead = orig_model.maximum_lead;
     MaxLag = orig_model.maximum_lag;
 else
-	endo_names = M_.endo_names;
-	endo_nbr = M_.endo_nbr;
-	MaxLag=M_.maximum_lag;
-	MaxLead=M_.maximum_lead;
+    endo_names = M_.endo_names;
+    endo_nbr = M_.endo_nbr;
+    MaxLag=M_.maximum_lag;
+    MaxLead=M_.maximum_lead;
     lead_lag_incidence = M_.lead_lag_incidence;
 end
 
@@ -64,7 +64,7 @@ end
 if options_.steadystate_flag
     % explicit steady state file
     [junk,M_.params,info] = evaluate_steady_state_file(oo_.steady_state,[oo_.exo_steady_state; oo_.exo_det_steady_state],M_, ...
-                                                   options_,0);
+                                                      options_,0);
 end
 [U,Uy,W] = feval([M_.fname,'_objective_static'],zeros(endo_nbr,1),[], M_.params);
 if any(any(Uy~=0))
@@ -96,32 +96,34 @@ eq_nbr= size(jacobia_,1);
 instr_nbr=endo_nbr-eq_nbr;
 
 if instr_nbr==0
-    error('discretionary_policy:: There are no available instruments, because the model has as many equations as variables.') 
+    error('discretionary_policy:: There are no available instruments, because the model has as many equations as variables.')
+end
+if size(Instruments,1)< instr_nbr
+    error('discretionary_policy:: There are fewer declared instruments than omitted equations.')
+elseif size(Instruments,1)> instr_nbr
+    error('discretionary_policy:: There are more declared instruments than omitted equations.')    
 end
-if size(Instruments,1)~= instr_nbr
-   error('discretionary_policy:: There are more declared instruments than omitted equations.') 
-end 
 
 instr_id=nan(instr_nbr,1);
 for j=1:instr_nbr
-	vj=deblank(Instruments(j,:));
-	vj_id=strmatch(vj,endo_names,'exact');
-	if ~isempty(vj_id)
-		instr_id(j)=vj_id;
-	else
-		error([mfilename,':: instrument ',vj,' not found'])
-	end
+    vj=deblank(Instruments(j,:));
+    vj_id=strmatch(vj,endo_names,'exact');
+    if ~isempty(vj_id)
+        instr_id(j)=vj_id;
+    else
+        error([mfilename,':: instrument ',vj,' not found'])
+    end
 end
 
 Indices={'lag','0','lead'};
 iter=1;
 for j=1:numel(Indices)
     eval(['A',Indices{j},'=zeros(eq_nbr,endo_nbr);'])
-	if strcmp(Indices{j},'0')||(strcmp(Indices{j},'lag') && MaxLag)||(strcmp(Indices{j},'lead') && MaxLead)
-	    [junk,row,col]=find(lead_lag_incidence(iter,:));
-	    eval(['A',Indices{j},'(:,row)=jacobia_(:,col);'])
-		iter=iter+1;
-	end
+    if strcmp(Indices{j},'0')||(strcmp(Indices{j},'lag') && MaxLag)||(strcmp(Indices{j},'lead') && MaxLead)
+        [junk,row,col]=find(lead_lag_incidence(iter,:));
+        eval(['A',Indices{j},'(:,row)=jacobia_(:,col);'])
+        iter=iter+1;
+    end
 end
 B=jacobia_(:,nnz(iyv)+1:end);
 
@@ -131,17 +133,17 @@ solve_maxit = options_.dp.maxit;
 discretion_tol = options_.discretionary_tol;
 
 if ~isempty(Hold)
-	[H,G,info]=discretionary_policy_engine(Alag,A0,Alead,B,W,instr_id,beta,solve_maxit,discretion_tol,qz_criterium,Hold);
+    [H,G,info]=discretionary_policy_engine(Alag,A0,Alead,B,W,instr_id,beta,solve_maxit,discretion_tol,qz_criterium,Hold);
 else
-	[H,G,info]=discretionary_policy_engine(Alag,A0,Alead,B,W,instr_id,beta,solve_maxit,discretion_tol,qz_criterium);
+    [H,G,info]=discretionary_policy_engine(Alag,A0,Alead,B,W,instr_id,beta,solve_maxit,discretion_tol,qz_criterium);
 end
 
 if info
     dr=[];
     return
 else
-	Hold=H; %save previous solution
-	% Hold=[]; use this line if persistent command is not used.
+    Hold=H; %save previous solution
+            % Hold=[]; use this line if persistent command is not used.
 end
 % set the state
 dr=oo_.dr;
@@ -159,7 +161,7 @@ dr.ys=ys; % <--- dr.ys =zeros(NewEndo_nbr,1);
 
 function ys=NondistortionarySteadyState(M_)
 if exist([M_.fname,'_steadystate.m'],'file')
-	eval(['ys=',M_.fname,'_steadystate.m;'])
+    eval(['ys=',M_.fname,'_steadystate.m;'])
 else
-	ys=zeros(M_.endo_nbr,1);
+    ys=zeros(M_.endo_nbr,1);
 end
diff --git a/matlab/discretionary_policy_engine.m b/matlab/discretionary_policy_engine.m
index 154b66426..05c781ae4 100644
--- a/matlab/discretionary_policy_engine.m
+++ b/matlab/discretionary_policy_engine.m
@@ -1,23 +1,23 @@
 function [H,G,retcode]=discretionary_policy_engine(AAlag,AA0,AAlead,BB,bigw,instr_id,beta,solve_maxit,discretion_tol,qz_criterium,H00,verbose)
 
 % Solves the discretionary problem for a model of the form:
-% 
+%
 %   Loss=E_0 sum_{t=0}^{\infty} beta^t [y_t'*W*y+x_t'*Q*x_t]
 %   subject to
 %   AAlag*yy_{t-1}+AA0*yy_t+AAlead*yy_{t+1}+BB*e=0
-% 
+%
 % with W the weight on the variables in vector y_t.
-% 
+%
 % The solution takes the form
 %   y_t=H*y_{t-1}+G*e_t
 % where H=[H1;F1] and G=[H2;F2].
-% 
+%
 % We use the Dennis (2007, Macroeconomic Dynamics) algorithm and so we need
 % to re-write the model in the form
 %  A0*y_t=A1*y_{t-1}+A2*y_{t+1}+A3*x_t+A4*x_{t+1}+A5*e_t, with W the
 % weight on the y_t vector and Q the weight on the x_t vector of
 % instruments.
-% 
+%
 % Inputs:
 %   AAlag               [double]    matrix of coefficients on lagged
 %                                   variables
@@ -28,7 +28,7 @@ function [H,G,retcode]=discretionary_policy_engine(AAlag,AA0,AAlead,BB,bigw,inst
 %   BB                  [double]    matrix of coefficients on
 %                                   shocks
 %   bigw                [double]    matrix of coefficients on variables in
-%                                   loss/objective function; stacks [W and Q]                                   
+%                                   loss/objective function; stacks [W and Q]
 %   instr_id            [double]    location vector of the instruments in the yy_t vector.
 %   beta                [scalar]    planner discount factor
 %   solve_maxit         [scalar]    maximum number of iterations
@@ -41,14 +41,14 @@ function [H,G,retcode]=discretionary_policy_engine(AAlag,AA0,AAlead,BB,bigw,inst
 %   H                   [double]    (endo_nbr*endo_nbr) solution matrix for endogenous
 %                                   variables, stacks [H1 and H1]
 %   G                   [double]    (endo_nbr*exo_nbr) solution matrix for shocks, stacks [H2 and F2]
-%                                   
+%
 %   retcode             [scalar]    return code
 %
 % Algorithm:
 %  Dennis, Richard (2007): Optimal policy in rational expectations models: new solution algorithms,
-%       Macroeconomic Dynamics, 11, 31–55.
+%       Macroeconomic Dynamics, 11, 31–55.
 
-% Copyright (C) 2007-2015 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -121,10 +121,10 @@ while 1
     end
     D=A0-A2*H1-A4*F1; %equation (20)
     Dinv=inv(D);
-    A3DPD=A3'*Dinv'*P*Dinv; 
+    A3DPD=A3'*Dinv'*P*Dinv;
     F1=-(Q+A3DPD*A3)\(A3DPD*A1); %component of (26)
     H1=Dinv*(A1+A3*F1); %component of (27)
-    
+
     [rcode,NQ]=CheckConvergence([H1;F1]-[H10;F10],iter,solve_maxit,discretion_tol);
     if rcode
         break
@@ -174,7 +174,7 @@ else
     H(instr_id,endo_augm_id)=F1;
     G(endo_augm_id,:)=H2;
     G(instr_id,:)=F2;
-    
+
     % Account for auxilliary variables
     H(:,instr_id(aux))=H(:,end-(AuxiliaryVariables_nbr-1:-1:0));
     H=H(1:endo_nbr,1:endo_nbr);
@@ -239,11 +239,11 @@ function v= SylvesterDoubling (d,g,h,tol,maxit)
 %   to solve the  Sylvester equation v  = d + g v h
 
 v = d;
-for i =1:maxit,
+for i =1:maxit
     vadd = g*v*h;
     v = v+vadd;
     if norm (vadd,1) <= (tol*norm(v,1))
-        break;
+        break
     end
     g = g*g;
     h = h*h;
@@ -253,7 +253,7 @@ end
 
 function v = SylvesterHessenbergSchur(d,g,h)
 %
-% DSYLHS  Solves a discrete time sylvester equation	using the
+% DSYLHS  Solves a discrete time sylvester equation     using the
 % Hessenberg-Schur algorithm
 %
 % v = DSYLHS(g,d,h) computes the matrix v that satisfies the
@@ -295,13 +295,13 @@ temp = [];
 
 %First handle the i = 1 case outside the loop
 
-if i< n,
-    if abs(h(i+1,i)) < tol,
+if i< n
+    if abs(h(i+1,i)) < tol
         v(:,i)= (w - g*h(i,i))\d(:,i);
         i = i+1;
     else
         A = [w-g*h(i,i)     (-g*h(i+1,i));...
-            -g*h(i,i+1)    w-g*h(i+1,i+1)];
+             -g*h(i,i+1)    w-g*h(i+1,i+1)];
         C = [d(:,i); d(:,i+1)];
         X = A\C;
         v(:,i) = X(1:m,:);
@@ -312,17 +312,17 @@ end
 
 %Handle the rest of the matrix with the possible exception of i=n
 
-while i<n,
+while i<n
     b= i-1;
     temp = [temp g*v(:,size(temp,2)+1:b)]; %#ok<AGROW>
-    if abs(h(i+1,i)) < tol,
+    if abs(h(i+1,i)) < tol
         v(:,i) = (w - g*h(i,i))\(d(:,i) + temp*h(1:b,i));
         i = i+1;
     else
         A = [w - g*h(i,i)    (-g*h(i+1,i));   ...
-            -g*h(i,i+1)    w - g*h(i+1,i+1)];
+             -g*h(i,i+1)    w - g*h(i+1,i+1)];
         C = [d(:,i) + temp*h(1:b,i);         ...
-            d(:,i+1) + temp*h(1:b,i+1)];
+             d(:,i+1) + temp*h(1:b,i+1)];
         X = A\C;
         v(:,i) = X(1:m,:);
         v(:,i+1) = X(m+1:2*m, :);
@@ -332,7 +332,7 @@ end
 
 %Handle the i = n case if i=n was not in a 2-2 block
 
-if i==n,
+if i==n
     b = i-1;
     temp = [temp g*v(:,size(temp,2)+1:b)];
     v(:,i) = (w-g*h(i,i))\(d(:,i) + temp*h(1:b,i));
diff --git a/matlab/disp_dr.m b/matlab/disp_dr.m
index a23c8f4be..d5fcb84fb 100644
--- a/matlab/disp_dr.m
+++ b/matlab/disp_dr.m
@@ -7,8 +7,8 @@ function disp_dr(dr,order,var_list)
 %    order [int]:            order of approximation
 %    var_list [char array]:  list of endogenous variables for which the
 %                            decision rules should be printed
-% 
-% Copyright (C) 2001-2015 Dynare Team
+%
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,6 +27,11 @@ function disp_dr(dr,order,var_list)
 
 global M_ options_
 
+if M_.hessian_eq_zero && order~=1
+    order = 1;
+    warning('disp_dr: using order = 1 because Hessian is equal to zero');
+end
+    
 nx =size(dr.ghx,2);
 nu =size(dr.ghu,2);
 if options_.block
@@ -36,7 +41,7 @@ else
     k = find(dr.kstate(:,2) <= M_.maximum_lag+1);
     klag = dr.kstate(k,[1 2]);
     k1 = dr.order_var;
-end;
+end
 
 if size(var_list,1) == 0
     var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
@@ -80,7 +85,7 @@ var_name_width=max([max(size(deblank(M_.endo_names(k1(ivar),:)),2)),max(size(deb
 
 %deal with covariances
 if order > 1
-    var_name_width=max(2*(var_name_width+aux_var_additional_characters)+2,20); %account for covariances, separated by comma    
+    var_name_width=max(2*(var_name_width+aux_var_additional_characters)+2,20); %account for covariances, separated by comma
 else
     var_name_width=max(var_name_width+aux_var_additional_characters,20);
 end
@@ -90,7 +95,7 @@ label_format  = sprintf('%%-%ds',var_name_width);
 %% start displayimg
 disp('POLICY AND TRANSITION FUNCTIONS')
 % variable names
-str = char(32*ones(1,var_name_width)); 
+str = char(32*ones(1,var_name_width));
 for i=1:nvar
     str = [str sprintf(header_label_format,deblank(M_.endo_names(k1(ivar(i)),:)))];
 end
@@ -232,7 +237,7 @@ for i = 1:length(M_.aux_vars)
     if M_.aux_vars(i).endo_index == aux_index
         switch M_.aux_vars(i).type
           case 0
-            str = sprintf('%s(%d)',deblank(M_.endo_names(aux_index,:)),aux_lead_lag);                
+            str = sprintf('%s(%d)',deblank(M_.endo_names(aux_index,:)),aux_lead_lag);
             return
           case 1
             orig_name = deblank(M_.endo_names(M_.aux_vars(i).orig_index, :));
@@ -256,10 +261,10 @@ error(sprintf('Could not find aux var: %s', M_.endo_names(aux_index, :)))
 end
 
 function [str,flag]=get_print_string(str,x,value_format_zero,value_format_float,flag,options_)
-    if abs(x) >= options_.dr_display_tol
-        flag = 1;
-        str = [str sprintf(value_format_float,x)];
-    else
-        str = [str sprintf(value_format_zero,0)];
-    end
+if abs(x) >= options_.dr_display_tol
+    flag = 1;
+    str = [str sprintf(value_format_float,x)];
+else
+    str = [str sprintf(value_format_zero,0)];
+end
 end
\ No newline at end of file
diff --git a/matlab/disp_identification.m b/matlab/disp_identification.m
index 5bdb3e8e5..b8a3421d5 100644
--- a/matlab/disp_identification.m
+++ b/matlab/disp_identification.m
@@ -1,6 +1,6 @@
 function disp_identification(pdraws, idemodel, idemoments, name, advanced)
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -19,7 +19,7 @@ function disp_identification(pdraws, idemodel, idemoments, name, advanced)
 
 global options_
 
-if nargin < 5 || isempty(advanced),
+if nargin < 5 || isempty(advanced)
     advanced=0;
 end
 
@@ -84,16 +84,16 @@ end
 
 disp(['  ']),
 
-if any(idemodel.ino),
+if any(idemodel.ino)
     disp('WARNING !!!')
-    if SampleSize>1,
+    if SampleSize>1
         disp(['The rank of H (model) is deficient for ', num2str(length(find(idemodel.ino))),' out of ',int2str(SampleSize),' MC runs!'  ]),
     else
         disp(['The rank of H (model) is deficient!'  ]),
     end
     skipline()
-    for j=1:npar,
-        if any(idemodel.ind0(:,j)==0),
+    for j=1:npar
+        if any(idemodel.ind0(:,j)==0)
             pno = 100*length(find(idemodel.ind0(:,j)==0))/SampleSize;
             if SampleSize>1
                 disp(['    ',name{j},' is not identified in the model for ',num2str(pno),'% of MC runs!' ])
@@ -107,9 +107,9 @@ if any(idemodel.ino),
     jmap_pair=dyn_unvech(1:npairs);
     jstore=[];
     skipline()
-    for j=1:npairs,
+    for j=1:npairs
         iweak = length(find(idemodel.jweak_pair(:,j)));
-        if iweak,
+        if iweak
             [jx,jy]=find(jmap_pair==j);
             jstore=[jstore jx(1) jy(1)];
             if SampleSize > 1
@@ -118,12 +118,12 @@ if any(idemodel.ino),
                 disp(['    [',name{jx(1)},',',name{jy(1)},'] are PAIRWISE collinear (with tol = 1.e-10) !' ])
             end
         end
-        
+
     end
     skipline()
-    for j=1:npar,
+    for j=1:npar
         iweak = length(find(idemodel.jweak(:,j)));
-        if iweak && ~ismember(j,jstore),
+        if iweak && ~ismember(j,jstore)
             %         disp('WARNING !!!')
             %         disp(['Model derivatives of parameter ',name{j},' are multi-collinear (with tol = 1.e-10) for ',num2str(iweak/SampleSize*100),'% of MC runs!' ])
             if SampleSize>1
@@ -133,23 +133,23 @@ if any(idemodel.ino),
             end
         end
     end
-%         if npar>(j+1),
-%             [ipair, jpair] = find(squeeze(idemodel.Pco(j,j+1:end,:))'>(1-1.e-10));
-%         else
-%             [ipair, jpair] = find(squeeze(idemodel.Pco(j,j+1:end,:))>(1-1.e-10));
-%         end
-%         if ~isempty(jpair),
-%             for jx=j+1:npar,
-%                 ixp = find(jx==(jpair+j));
-%                 if ~isempty(ixp)
-%                     if SampleSize > 1,
-%                         disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10) for ',num2str(length(ixp)/SampleSize*100),'% of MC runs!' ])
-%                     else
-%                         disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10)!' ])
-%                     end
-%                 end
-%             end
-%         end
+    %         if npar>(j+1),
+    %             [ipair, jpair] = find(squeeze(idemodel.Pco(j,j+1:end,:))'>(1-1.e-10));
+    %         else
+    %             [ipair, jpair] = find(squeeze(idemodel.Pco(j,j+1:end,:))>(1-1.e-10));
+    %         end
+    %         if ~isempty(jpair),
+    %             for jx=j+1:npar,
+    %                 ixp = find(jx==(jpair+j));
+    %                 if ~isempty(ixp)
+    %                     if SampleSize > 1,
+    %                         disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10) for ',num2str(length(ixp)/SampleSize*100),'% of MC runs!' ])
+    %                     else
+    %                         disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10)!' ])
+    %                     end
+    %                 end
+    %             end
+    %         end
 end
 
 if ~any(idemodel.ino) && ~any(any(idemodel.ind0==0))
@@ -157,24 +157,24 @@ if ~any(idemodel.ino) && ~any(any(idemodel.ind0==0))
     skipline()
 end
 
-if any(idemoments.ino),
+if any(idemoments.ino)
     skipline()
     disp('WARNING !!!')
-    if SampleSize > 1,
+    if SampleSize > 1
         disp(['The rank of J (moments) is deficient for ', num2str(length(find(idemoments.ino))),' out of ',int2str(SampleSize),' MC runs!'  ]),
     else
         disp(['The rank of J (moments) is deficient!'  ]),
     end
     %     disp('WARNING !!!')
     %     disp(['The rank of J (moments) is deficient for ', num2str(length(find(idemoments.ino))/SampleSize*100),'% of MC runs!'  ]),
-%     indno=[];
-%     for j=1:SampleSize, indno=[indno;idemoments.indno{j}]; end
-%     freqno = mean(indno)*100;
-%     ifreq=find(freqno);
+    %     indno=[];
+    %     for j=1:SampleSize, indno=[indno;idemoments.indno{j}]; end
+    %     freqno = mean(indno)*100;
+    %     ifreq=find(freqno);
     %     disp('MOMENT RANK FAILURE DUE TO COLLINEARITY OF PARAMETERS:');
     skipline()
-    for j=1:npar,
-        if any(idemoments.ind0(:,j)==0),
+    for j=1:npar
+        if any(idemoments.ind0(:,j)==0)
             pno = 100*length(find(idemoments.ind0(:,j)==0))/SampleSize;
             if SampleSize > 1
                 disp(['    ',name{j},' is not identified by J moments for ',num2str(pno),'% of MC runs!' ])
@@ -188,9 +188,9 @@ if any(idemoments.ino),
     npairs=size(idemoments.jweak_pair,2);
     jmap_pair=dyn_unvech(1:npairs);
     jstore=[];
-    for j=1:npairs,
+    for j=1:npairs
         iweak = length(find(idemoments.jweak_pair(:,j)));
-        if iweak,
+        if iweak
             [jx,jy]=find(jmap_pair==j);
             jstore=[jstore'  jx(1) jy(1)]';
             if SampleSize > 1
@@ -199,40 +199,40 @@ if any(idemoments.ino),
                 disp(['    [',name{jx(1)},',',name{jy(1)},'] are PAIRWISE collinear (with tol = 1.e-10) !' ])
             end
         end
-        
+
     end
     skipline()
-    for j=1:npar,
+    for j=1:npar
         iweak = length(find(idemoments.jweak(:,j)));
-        if iweak && ~ismember(j,jstore),
+        if iweak && ~ismember(j,jstore)
             %             disp('WARNING !!!')
             %             disp(['Moment derivatives of parameter ',name{j},' are multi-collinear (with tol = 1.e-10) for ',num2str(iweak/SampleSize*100),'% of MC runs!' ])
-            if SampleSize > 1,
+            if SampleSize > 1
                 disp([name{j},' is collinear w.r.t. all other params ',num2str(iweak/SampleSize*100),'% of MC runs!' ])
             else
                 disp([name{j},' is collinear w.r.t. all other params!' ])
             end
         end
     end
-%             if npar>(j+1),
-%                 [ipair, jpair] = find(squeeze(idemoments.Pco(j,j+1:end,:))'>(1-1.e-10));
-%             else
-%                 [ipair, jpair] = find(squeeze(idemoments.Pco(j,j+1:end,:))>(1-1.e-10));
-%             end
-%             if ~isempty(jpair),
-%                 for jx=j+1:npar,
-%                     ixp = find(jx==(jpair+j));
-%                     if ~isempty(ixp)
-%                         if SampleSize > 1
-%                             disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10) for ',num2str(length(ixp)/SampleSize*100),'% of MC runs!' ])
-%                         else
-%                             disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10) !' ])
-%                         end
-%                     end
-%                 end
-%             end
-%         end
-%     end
+    %             if npar>(j+1),
+    %                 [ipair, jpair] = find(squeeze(idemoments.Pco(j,j+1:end,:))'>(1-1.e-10));
+    %             else
+    %                 [ipair, jpair] = find(squeeze(idemoments.Pco(j,j+1:end,:))>(1-1.e-10));
+    %             end
+    %             if ~isempty(jpair),
+    %                 for jx=j+1:npar,
+    %                     ixp = find(jx==(jpair+j));
+    %                     if ~isempty(ixp)
+    %                         if SampleSize > 1
+    %                             disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10) for ',num2str(length(ixp)/SampleSize*100),'% of MC runs!' ])
+    %                         else
+    %                             disp(['    [',name{j},',',name{jx},'] are PAIRWISE collinear (with tol = 1.e-10) !' ])
+    %                         end
+    %                     end
+    %                 end
+    %             end
+    %         end
+    %     end
 end
 if ~any(idemoments.ino) && ~any(any(idemoments.ind0==0))
     skipline()
@@ -255,30 +255,30 @@ end
 % if advanced && (~options_.noprint),
 %     for j=1:length(kokP),
 %         dyntable([name{kokP(j)},' pairwise correlations in the model'],char(' ','min','mean','max'), ...
-%                  char(name{jpM{j}}),[pminM{j}' pmeanM{j}' pmaxM{j}'],10,10,3);  
+%                  char(name{jpM{j}}),[pminM{j}' pmeanM{j}' pmaxM{j}'],10,10,3);
 %     end
-% 
+%
 %     for j=1:length(kokPJ),
 %         dyntable([name{kokPJ(j)},' pairwise correlations in J moments'],char(' ','min','mean','max'), ...
-%                  char(name{jpJ{j}}),[pminJ{j}' pmeanJ{j}' pmaxJ{j}'],10,10,3);  
+%                  char(name{jpJ{j}}),[pminJ{j}' pmeanJ{j}' pmaxJ{j}'],10,10,3);
 %     end
 % end
 % disp(' ')
 
 % identificaton patterns
-if SampleSize==1 && advanced,
+if SampleSize==1 && advanced
     skipline()
     disp('Press ENTER to print advanced diagnostics'), pause(5),
-    for  j=1:size(idemoments.cosnJ,2),
+    for  j=1:size(idemoments.cosnJ,2)
         pax=NaN(npar,npar);
         fprintf('\n')
         disp(['Collinearity patterns with ', int2str(j) ,' parameter(s)'])
         fprintf('%-15s [%-*s] %10s\n','Parameter',(15+1)*j,' Expl. params ','cosn')
-        for i=1:npar,
+        for i=1:npar
             namx='';
-            for in=1:j,
+            for in=1:j
                 dumpindx = idemoments.pars{i,j}(in);
-                if isnan(dumpindx),
+                if isnan(dumpindx)
                     namx=[namx ' ' sprintf('%-15s','--')];
                 else
                     namx=[namx ' ' sprintf('%-15s',name{dumpindx})];
diff --git a/matlab/disp_model_summary.m b/matlab/disp_model_summary.m
index 394bc00d9..b04d025b4 100644
--- a/matlab/disp_model_summary.m
+++ b/matlab/disp_model_summary.m
@@ -4,11 +4,11 @@ function disp_model_summary(M,dr,options)
 %     displays the model summary
 %
 % INPUTS
-%   M         [matlab structure] Definition of the model.           
+%   M         [matlab structure] Definition of the model.
 %   dr        [matlab structure] Decision rules
 %   options   [matlab structure] Options
 %
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,4 +40,3 @@ labels = deblank(M.exo_names);
 headers = char('Variables',labels);
 lh = size(labels,2)+2;
 dyntable(options,my_title,headers,labels,M.Sigma_e,lh,10,6);
-
diff --git a/matlab/disp_moments.m b/matlab/disp_moments.m
index cec582c4e..6e55bb571 100644
--- a/matlab/disp_moments.m
+++ b/matlab/disp_moments.m
@@ -7,11 +7,11 @@ function oo_=disp_moments(y,var_list,M_,options_,oo_)
 %   M_                  [structure]    Dynare's model structure
 %   oo_                 [structure]    Dynare's results structure
 %   options_            [structure]    Dynare's options structure
-%    
+%
 % OUTPUTS
 %   oo_                 [structure]    Dynare's results structure,
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -57,18 +57,18 @@ s2 = mean(y.*y);
 s = sqrt(s2);
 oo_.mean = transpose(m);
 oo_.var = y'*y/size(y,1);
-oo_.skewness = (mean(y.^3)./s2.^1.5)'; 
+oo_.skewness = (mean(y.^3)./s2.^1.5)';
 oo_.kurtosis = (mean(y.^4)./(s2.*s2)-3)';
 
 labels = deblank(M_.endo_names(ivar,:));
 labels_TeX = deblank(M_.endo_names_tex(ivar,:));
 
 if options_.nomoments == 0
-    z = [ m' s' s2' (mean(y.^3)./s2.^1.5)' (mean(y.^4)./(s2.*s2)-3)' ];    
+    z = [ m' s' s2' (mean(y.^3)./s2.^1.5)' (mean(y.^4)./(s2.*s2)-3)' ];
     title='MOMENTS OF SIMULATED VARIABLES';
-    
+
     title=add_filter_subtitle(title,options_);
-    
+
     headers=char('VARIABLE','MEAN','STD. DEV.','VARIANCE','SKEWNESS', ...
                  'KURTOSIS');
     dyntable(options_,title,headers,labels,z,size(labels,2)+2,16,6);
@@ -79,7 +79,7 @@ end
 
 if options_.nocorr == 0
     corr = (y'*y/size(y,1))./(s'*s);
-    if options_.contemporaneous_correlation 
+    if options_.contemporaneous_correlation
         oo_.contemporaneous_correlation = corr;
     end
     if options_.noprint == 0
@@ -98,7 +98,7 @@ if options_.nocorr == 0
 end
 
 if options_.noprint == 0 && length(options_.conditional_variance_decomposition)
-   fprintf('\nSTOCH_SIMUL: conditional_variance_decomposition requires theoretical moments, i.e. periods=0.\n') 
+    fprintf('\nSTOCH_SIMUL: conditional_variance_decomposition requires theoretical moments, i.e. periods=0.\n')
 end
 
 ar = options_.ar;
@@ -119,7 +119,7 @@ if ar > 0
             dyn_latex_table(M_,options_,title,'sim_autocorr_matrix',headers,labels_TeX,autocorr,size(labels_TeX,2)+2,8,4);
         end
     end
-    
+
 end
 
 
@@ -132,14 +132,18 @@ if ~options_.nodecomposition
         if isempty(M_.endo_histval)
             y0 = oo_.dr.ys;
         else
-            y0 = M_.endo_histval;
+            if options_.loglinear
+                y0 = log_variable(1:M_.endo_nbr,M_.endo_histval,M_);
+            else
+                y0 = M_.endo_histval;
+            end
         end
         %back out shock matrix used for generating y
         i_exo_var = setdiff([1:M_.exo_nbr],find(diag(M_.Sigma_e) == 0)); % find shocks with 0 variance
         chol_S = chol(M_.Sigma_e(i_exo_var,i_exo_var)); %decompose rest
         shock_mat=zeros(options_.periods,M_.exo_nbr); %initialize
         shock_mat(:,i_exo_var)=oo_.exo_simul(:,i_exo_var)/chol_S; %invert construction of oo_.exo_simul from simult.m
-        
+
         for shock_iter=1:length(i_exo_var)
             temp_shock_mat=zeros(size(shock_mat));
             temp_shock_mat(:,i_exo_var(shock_iter))=shock_mat(:,i_exo_var(shock_iter));
@@ -152,9 +156,9 @@ if ~options_.nodecomposition
         if ~options_.noprint %options_.nomoments == 0
             skipline()
             title='VARIANCE DECOMPOSITION SIMULATING ONE SHOCK AT A TIME (in percent)';
-        
+
             title=add_filter_subtitle(title,options_);
-            
+
             headers = M_.exo_names;
             headers(M_.exo_names_orig_ord,:) = headers;
             headers = char(' ',headers);
@@ -177,12 +181,12 @@ if ~options_.nodecomposition
 
     end
 end
-        
+
 warning(warning_old_state);
 end
 
 function y=get_filtered_time_series(y,m,options_)
-        
+
 if options_.hp_filter && ~options_.one_sided_hp_filter  && ~options_.bandpass.indicator
     [hptrend,y] = sample_hp_filter(y,options_.hp_filter);
 elseif ~options_.hp_filter && options_.one_sided_hp_filter && ~options_.bandpass.indicator
@@ -193,8 +197,8 @@ elseif ~options_.hp_filter && ~options_.one_sided_hp_filter && options_.bandpass
     y=data_temp.data;
 elseif ~options_.hp_filter && ~options_.one_sided_hp_filter  && ~options_.bandpass.indicator
     y = bsxfun(@minus, y, m);
-else 
+else
     error('disp_moments:: You cannot use more than one filter at the same time')
 end
-        
+
 end
\ No newline at end of file
diff --git a/matlab/disp_steady_state.m b/matlab/disp_steady_state.m
index 354b0f6a4..0543affc7 100644
--- a/matlab/disp_steady_state.m
+++ b/matlab/disp_steady_state.m
@@ -1,18 +1,18 @@
 function disp_steady_state(M,oo)
 % function disp_steady_state(M,oo)
 % computes and prints the steady state calculations
-%  
+%
 % INPUTS
 %   M      structure of parameters
 %   oo     structure of results
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2011 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/disp_th_moments.m b/matlab/disp_th_moments.m
index 45d217611..f3227f4f4 100644
--- a/matlab/disp_th_moments.m
+++ b/matlab/disp_th_moments.m
@@ -1,7 +1,7 @@
 function oo_=disp_th_moments(dr,var_list,M_,options_,oo_)
 % Display theoretical moments of variables
 
-% Copyright (C) 2001-2015 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,7 +44,7 @@ m(non_stationary_vars) = NaN;
 i1 = find(abs(diag(oo_.gamma_y{1})) > 1e-12);
 s2 = diag(oo_.gamma_y{1});
 sd = sqrt(s2);
-if options_.order == 2
+if options_.order == 2 && ~M_.hessian_eq_zero
     m = m+oo_.gamma_y{options_.ar+3};
 end
 
@@ -76,7 +76,7 @@ if size(stationary_vars, 1) > 0
         if M_.exo_nbr > 1 && ~nodecomposition
             skipline()
             if options_.order == 2
-                title='APPROXIMATED VARIANCE DECOMPOSITION (in percent)';            
+                title='APPROXIMATED VARIANCE DECOMPOSITION (in percent)';
             else
                 title='VARIANCE DECOMPOSITION (in percent)';
             end
@@ -86,7 +86,7 @@ if size(stationary_vars, 1) > 0
             headers = char(' ',headers);
             lh = size(deblank(M_.endo_names(ivar(stationary_vars),:)),2)+2;
             dyntable(options_,title,headers,deblank(M_.endo_names(ivar(stationary_vars), ...
-                                                         :)),100* ...
+                                                              :)),100* ...
                      oo_.gamma_y{options_.ar+2}(stationary_vars,:),lh,8,2);
             if options_.TeX
                 headers=M_.exo_names_tex;
@@ -97,7 +97,7 @@ if size(stationary_vars, 1) > 0
             end
         end
     end
-    
+
     conditional_variance_steps = options_.conditional_variance_decomposition;
     if length(conditional_variance_steps)
         StateSpaceModel.number_of_state_equations = M_.endo_nbr;
@@ -107,10 +107,10 @@ if size(stationary_vars, 1) > 0
         StateSpaceModel.state_innovations_covariance_matrix = M_.Sigma_e;
         StateSpaceModel.order_var = dr.order_var;
         oo_.conditional_variance_decomposition = conditional_variance_decomposition(StateSpaceModel,conditional_variance_steps,ivar);
-        
+
         if options_.noprint == 0
             display_conditional_variance_decomposition(oo_.conditional_variance_decomposition,conditional_variance_steps,...
-                                                         ivar,M_,options_);
+                                                       ivar,M_,options_);
         end
     end
 end
@@ -123,14 +123,15 @@ if length(i1) == 0
 end
 
 if options_.nocorr == 0 && size(stationary_vars, 1) > 0
-    corr = oo_.gamma_y{1}(i1,i1)./(sd(i1)*sd(i1)');
+    corr=NaN(size(oo_.gamma_y{1}));
+    corr(i1,i1) = oo_.gamma_y{1}(i1,i1)./(sd(i1)*sd(i1)');
     if options_.contemporaneous_correlation 
         oo_.contemporaneous_correlation = corr;
     end
-    if ~options_.noprint,
+    if ~options_.noprint
         skipline()
         if options_.order == 2
-            title='APPROXIMATED MATRIX OF CORRELATIONS';            
+            title='APPROXIMATED MATRIX OF CORRELATIONS';
         else
             title='MATRIX OF CORRELATIONS';
         end
@@ -138,12 +139,12 @@ if options_.nocorr == 0 && size(stationary_vars, 1) > 0
         labels = deblank(M_.endo_names(ivar(i1),:));
         headers = char('Variables',labels);
         lh = size(labels,2)+2;
-        dyntable(options_,title,headers,labels,corr,lh,8,4);
+        dyntable(options_,title,headers,labels,corr(i1,i1),lh,8,4);
         if options_.TeX
             labels = deblank(M_.endo_names_tex(ivar(i1),:));
             headers=char('Variables',labels);
             lh = size(labels,2)+2;
-            dyn_latex_table(M_,options_,title,'th_corr_matrix',headers,labels,corr,lh,8,4);
+            dyn_latex_table(M_,options_,title,'th_corr_matrix',headers,labels,corr(i1,i1),lh,8,4);
         end
     end
 end
@@ -153,23 +154,23 @@ if options_.ar > 0 && size(stationary_vars, 1) > 0
         oo_.autocorr{i} = oo_.gamma_y{i+1};
         z(:,i) = diag(oo_.gamma_y{i+1}(i1,i1));
     end
-    if ~options_.noprint,      
-        skipline()    
+    if ~options_.noprint
+        skipline()
         if options_.order == 2
-            title='APPROXIMATED COEFFICIENTS OF AUTOCORRELATION';            
+            title='APPROXIMATED COEFFICIENTS OF AUTOCORRELATION';
         else
             title='COEFFICIENTS OF AUTOCORRELATION';
         end
         title=add_filter_subtitle(title,options_);
-        labels = deblank(M_.endo_names(ivar(i1),:));      
+        labels = deblank(M_.endo_names(ivar(i1),:));
         headers = char('Order ',int2str([1:options_.ar]'));
         lh = size(labels,2)+2;
         dyntable(options_,title,headers,labels,z,lh,8,4);
         if options_.TeX
-            labels = deblank(M_.endo_names_tex(ivar(i1),:)); 
+            labels = deblank(M_.endo_names_tex(ivar(i1),:));
             headers=char('Order ',int2str([1:options_.ar]'));
             lh = size(labels,2)+2;
             dyn_latex_table(M_,options_,title,'th_autocorr_matrix',headers,labels,z,lh,8,4);
         end
-    end  
+    end
 end
diff --git a/matlab/display_conditional_variance_decomposition.m b/matlab/display_conditional_variance_decomposition.m
index 597aa0b1b..f0c115ad4 100644
--- a/matlab/display_conditional_variance_decomposition.m
+++ b/matlab/display_conditional_variance_decomposition.m
@@ -1,8 +1,8 @@
 function display_conditional_variance_decomposition(conditional_decomposition_array,Steps,SubsetOfVariables,M_,options_)
 % This function displays the conditional variance decomposition of a given state space model
 % for a subset of endogenous variables.
-% 
-% INPUTS 
+%
+% INPUTS
 %   conditional_decomposition_array     [matrix]   Output matrix from compute_conditional_variance_decomposition
 %   Steps               [integer]     1*h vector of dates.
 %   SubsetOfVariables   [integer]     1*q vector of indices.
@@ -10,10 +10,10 @@ function display_conditional_variance_decomposition(conditional_decomposition_ar
 %                                     Model description
 %   options_            [structure]   Dynare structure containing the
 %                                     options
-% OUTPUTS 
+% OUTPUTS
 %   none
 %
-% Copyright (C) 2010-2014 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -56,10 +56,10 @@ for i=1:length(Steps)
     dyntable(options_,'',headers,...
              deblank(M_.endo_names(SubsetOfVariables,:)),...
              vardec_i,lh,8,2);
-     if options_.TeX
-         labels_TeX = deblank(M_.endo_names_tex(SubsetOfVariables,:));
-         headers_TeX=char('',deblank(M_.exo_names_tex));
-         lh = size(labels_TeX,2)+2;
-         dyn_latex_table(M_,options_,[title,'; Period ' int2str(Steps(i))],['th_var_decomp_cond_h',int2str(Steps(i))],headers_TeX,labels_TeX,vardec_i,lh,8,2);
-     end    
+    if options_.TeX
+        labels_TeX = deblank(M_.endo_names_tex(SubsetOfVariables,:));
+        headers_TeX=char('',deblank(M_.exo_names_tex));
+        lh = size(labels_TeX,2)+2;
+        dyn_latex_table(M_,options_,[title,'; Period ' int2str(Steps(i))],['th_var_decomp_cond_h',int2str(Steps(i))],headers_TeX,labels_TeX,vardec_i,lh,8,2);
+    end
 end
\ No newline at end of file
diff --git a/matlab/display_estimation_results_table.m b/matlab/display_estimation_results_table.m
index 152ea006b..6faf6a834 100644
--- a/matlab/display_estimation_results_table.m
+++ b/matlab/display_estimation_results_table.m
@@ -1,26 +1,26 @@
 function oo_=display_estimation_results_table(xparam1,stdh,M_,options_,estim_params_,bayestopt_,oo_,pnames,table_title,field_name)
 %function oo_=display_results_table(xparam1,stdh,M_,estim_params_,bayestopt_,oo_,pnames,table_title,field_name)
 % Display estimation results on screen and write them to TeX-file
-% 
-% INPUTS 
+%
+% INPUTS
 %   o xparam1       [double]   (p*1) vector of estimate parameters.
 %   o stdh          [double]   (p*1) vector of estimate parameters.
-%   o M_                        Matlab's structure describing the Model (initialized by dynare, see @ref{M_}).          
+%   o M_                        Matlab's structure describing the Model (initialized by dynare, see @ref{M_}).
 %   o estim_params_             Matlab's structure describing the estimated_parameters (initialized by dynare, see @ref{estim_params_}).
 %   o options_                  Matlab's structure describing the options (initialized by dynare, see @ref{options_}).
 %   o bayestopt_                Matlab's structure describing the priors (initialized by dynare, see @ref{bayesopt_}).
 %   o oo_                       Matlab's structure gathering the results (initialized by dynare, see @ref{oo_}).
-%   o pnames        [string]    Character Array storing the names for prior distributions     
-%   o table_title   [string]    Title of the Table     
+%   o pnames        [string]    Character Array storing the names for prior distributions
+%   o table_title   [string]    Title of the Table
 %   o field_name    [string]    String storing the name of the fields for oo_ where the parameters are stored
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   o oo_                       Matlab's structure gathering the results
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2014-2016 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -64,13 +64,13 @@ if np
         name = bayestopt_.name{ip};
         if strcmp(field_name,'posterior')
             fprintf('%-*s %7.3f %8.4f %7.4f %4s %6.4f \n', ...
-                     header_width,name, ...
-                     bayestopt_.p1(ip),xparam1(ip),stdh(ip), ...
-                     pnames(bayestopt_.pshape(ip)+1,:), ...
-                     bayestopt_.p2(ip));
+                    header_width,name, ...
+                    bayestopt_.p1(ip),xparam1(ip),stdh(ip), ...
+                    pnames(bayestopt_.pshape(ip)+1,:), ...
+                    bayestopt_.p2(ip));
         else
             fprintf('%-*s %8.4f %7.4f %7.4f \n', ...
-                 header_width,name,xparam1(ip),stdh(ip),tstath(ip));
+                    header_width,name,xparam1(ip),stdh(ip),tstath(ip));
         end
         eval(['oo_.' field_name '_mode.parameters.' name ' = xparam1(ip);']);
         eval(['oo_.' field_name '_std_at_mode.parameters.' name ' = stdh(ip);']);
@@ -87,9 +87,9 @@ if nvx
         name = deblank(M_.exo_names(k,:));
         if strcmp(field_name,'posterior')
             fprintf('%-*s %7.3f %8.4f %7.4f %4s %6.4f \n', ...
-                     header_width,name,bayestopt_.p1(ip),xparam1(ip), ...
-                     stdh(ip),pnames(bayestopt_.pshape(ip)+1,:), ...
-                     bayestopt_.p2(ip));
+                    header_width,name,bayestopt_.p1(ip),xparam1(ip), ...
+                    stdh(ip),pnames(bayestopt_.pshape(ip)+1,:), ...
+                    bayestopt_.p2(ip));
         else
             fprintf('%-*s %8.4f %7.4f %7.4f \n',header_width,name,xparam1(ip),stdh(ip),tstath(ip));
         end
@@ -99,28 +99,28 @@ if nvx
         ip = ip+1;
     end
     skipline()
- end
- if nvn
+end
+if nvn
     disp('standard deviation of measurement errors')
     disp(tit1)
     ip = nvx+1;
     for i=1:nvn
         name = options_.varobs{estim_params_.nvn_observable_correspondence(i,1)};
-        if strcmp(field_name,'posterior')           
+        if strcmp(field_name,'posterior')
             fprintf('%-*s %7.3f %8.4f %7.4f %4s %6.4f \n', ...
-                     header_width,name,bayestopt_.p1(ip), ...
-                     xparam1(ip),stdh(ip), ...
-                     pnames(bayestopt_.pshape(ip)+1,:), ...
-                     bayestopt_.p2(ip));
+                    header_width,name,bayestopt_.p1(ip), ...
+                    xparam1(ip),stdh(ip), ...
+                    pnames(bayestopt_.pshape(ip)+1,:), ...
+                    bayestopt_.p2(ip));
         else
-            fprintf('%-*s %8.4f %7.4f %7.4f \n',header_width,name,xparam1(ip),stdh(ip),tstath(ip))            
+            fprintf('%-*s %8.4f %7.4f %7.4f \n',header_width,name,xparam1(ip),stdh(ip),tstath(ip))
         end
         eval(['oo_.' field_name '_mode.measurement_errors_std.' name ' = xparam1(ip);']);
         eval(['oo_.' field_name '_std_at_mode.measurement_errors_std.' name ' = stdh(ip);']);
         ip = ip+1;
     end
     skipline()
- end
+end
 
 if ncx
     disp('correlation of shocks')
@@ -131,12 +131,12 @@ if ncx
         k2 = estim_params_.corrx(i,2);
         name = [deblank(M_.exo_names(k1,:)) ',' deblank(M_.exo_names(k2,:))];
         NAME = [deblank(M_.exo_names(k1,:)) '_' deblank(M_.exo_names(k2,:))];
-        if strcmp(field_name,'posterior')           
+        if strcmp(field_name,'posterior')
             fprintf('%-*s %7.3f %8.4f %7.4f %4s %6.4f \n', ...
-                     header_width,name,bayestopt_.p1(ip),xparam1(ip),stdh(ip),  ...
-                     pnames(bayestopt_.pshape(ip)+1,:), bayestopt_.p2(ip));
+                    header_width,name,bayestopt_.p1(ip),xparam1(ip),stdh(ip),  ...
+                    pnames(bayestopt_.pshape(ip)+1,:), bayestopt_.p2(ip));
         else
-            fprintf('%-*s %8.4f %7.4f %7.4f \n', header_width,name,xparam1(ip),stdh(ip),tstath(ip));            
+            fprintf('%-*s %8.4f %7.4f %7.4f \n', header_width,name,xparam1(ip),stdh(ip),tstath(ip));
         end
         M_.Sigma_e(k1,k2) = xparam1(ip)*sqrt(M_.Sigma_e(k1,k1)*M_.Sigma_e(k2,k2));
         M_.Sigma_e(k2,k1) = M_.Sigma_e(k1,k2);
@@ -156,12 +156,12 @@ if ncn
         k2 = estim_params_.corrn(i,2);
         name = [deblank(M_.endo_names(k1,:)) ',' deblank(M_.endo_names(k2,:))];
         NAME = [deblank(M_.endo_names(k1,:)) '_' deblank(M_.endo_names(k2,:))];
-        if strcmp(field_name,'posterior')                 
+        if strcmp(field_name,'posterior')
             fprintf('%-*s %7.3f %8.4f %7.4f %4s %6.4f \n', ...
-                     header_width,name,bayestopt_.p1(ip),xparam1(ip),stdh(ip), ...
-                     pnames(bayestopt_.pshape(ip)+1,:), bayestopt_.p2(ip));
+                    header_width,name,bayestopt_.p1(ip),xparam1(ip),stdh(ip), ...
+                    pnames(bayestopt_.pshape(ip)+1,:), bayestopt_.p2(ip));
         else
-            fprintf('%-*s %8.4f %7.4f %7.4f \n',header_width,name,xparam1(ip),stdh(ip),tstath(ip));            
+            fprintf('%-*s %8.4f %7.4f %7.4f \n',header_width,name,xparam1(ip),stdh(ip),tstath(ip));
         end
         eval(['oo_.' field_name '_mode.measurement_errors_corr.' NAME ' = xparam1(ip);']);
         eval(['oo_.' field_name '_std_at_mode.measurement_errors_corr.' NAME ' = stdh(ip);']);
@@ -268,17 +268,17 @@ if any(bayestopt_.pshape > 0) && options_.TeX %% Bayesian estimation (posterior
         TeXEnd(fidTeX)
     end
 elseif all(bayestopt_.pshape == 0) && options_.TeX %% MLE and GMM Latex output
-    if np        
+    if np
         filename = [OutputDirectoryName '/' M_.fname '_' LaTeXtitle '_Mode_1.tex'];
         fidTeX = fopen(filename,'w');
-        TeXBegin_ML(fidTeX,1,'parameters',table_title,LaTeXtitle)   
+        TeXBegin_ML(fidTeX,1,'parameters',table_title,LaTeXtitle)
         ip = nvx+nvn+ncx+ncn+1;
         for i=1:np
             fprintf(fidTeX,'$%s$ & %8.4f & %7.4f & %7.4f\\\\ \n',...
                     M_.param_names_tex(estim_params_.param_vals(i,1),:),...
                     xparam1(ip),...
                     stdh(ip),...
-                    tstath(ip));                    
+                    tstath(ip));
             ip = ip + 1;
         end
         TeXEnd(fidTeX)
@@ -286,7 +286,7 @@ elseif all(bayestopt_.pshape == 0) && options_.TeX %% MLE and GMM Latex output
     if nvx
         filename = [OutputDirectoryName '/' M_.fname '_' LaTeXtitle '_Mode_2.tex'];
         fidTeX = fopen(filename,'w');
-        TeXBegin_ML(fidTeX,2,'standard deviation of structural shocks',table_title,LaTeXtitle)   
+        TeXBegin_ML(fidTeX,2,'standard deviation of structural shocks',table_title,LaTeXtitle)
         ip = 1;
         for i=1:nvx
             k = estim_params_.var_exo(i,1);
@@ -302,11 +302,11 @@ elseif all(bayestopt_.pshape == 0) && options_.TeX %% MLE and GMM Latex output
     if nvn
         filename = [OutputDirectoryName '/' M_.fname '_' LaTeXtitle '_Mode_3.tex'];
         fidTeX = fopen(filename,'w');
-        TeXBegin_ML(fidTeX,3,'standard deviation of measurement errors',table_title,LaTeXtitle)   
+        TeXBegin_ML(fidTeX,3,'standard deviation of measurement errors',table_title,LaTeXtitle)
         ip = nvx+1;
         for i=1:nvn
-           idx = strmatch(options_.varobs{estim_params_.nvn_observable_correspondence(i,1)},M_.endo_names);
-           fprintf(fidTeX,'$%s$ & %8.4f & %7.4f & %7.4f \\\\ \n',...
+            idx = strmatch(options_.varobs{estim_params_.nvn_observable_correspondence(i,1)},M_.endo_names);
+            fprintf(fidTeX,'$%s$ & %8.4f & %7.4f & %7.4f \\\\ \n',...
                     deblank(M_.endo_names_tex(idx,:)), ...
                     xparam1(ip),...
                     stdh(ip),...
@@ -318,7 +318,7 @@ elseif all(bayestopt_.pshape == 0) && options_.TeX %% MLE and GMM Latex output
     if ncx
         filename = [OutputDirectoryName '/' M_.fname '_' LaTeXtitle '_Mode_4.tex'];
         fidTeX = fopen(filename,'w');
-        TeXBegin_ML(fidTeX,4,'correlation of structural shocks',table_title,LaTeXtitle)   
+        TeXBegin_ML(fidTeX,4,'correlation of structural shocks',table_title,LaTeXtitle)
         ip = nvx+nvn+1;
         for i=1:ncx
             k1 = estim_params_.corrx(i,1);
@@ -335,7 +335,7 @@ elseif all(bayestopt_.pshape == 0) && options_.TeX %% MLE and GMM Latex output
     if ncn
         filename = [OutputDirectoryName '/' M_.fname '_' LaTeXtitle '_Mode_5.tex'];
         fidTeX = fopen(filename,'w');
-        TeXBegin_ML(fidTeX,5,'correlation of measurement errors',table_title,LaTeXtitle)   
+        TeXBegin_ML(fidTeX,5,'correlation of measurement errors',table_title,LaTeXtitle)
         ip = nvx+nvn+ncx+1;
         for i=1:ncn
             k1 = estim_params_.corrn(i,1);
@@ -347,7 +347,7 @@ elseif all(bayestopt_.pshape == 0) && options_.TeX %% MLE and GMM Latex output
                     tstath(ip));
             ip = ip+1;
         end
-    TeXEnd(fidTeX)
+        TeXEnd(fidTeX)
     end
 end
 
@@ -356,51 +356,51 @@ end
 %% subfunctions:
 %
 function TeXBegin_Bayesian(fid,fnum,title)
-    fprintf(fid,'%% TeX-table generated by dynare_estimation (Dynare).\n');
-    fprintf(fid,['%% RESULTS FROM POSTERIOR MAXIMIZATION (' title ')\n']);
-    fprintf(fid,['%% ' datestr(now,0)]);
-    fprintf(fid,' \n');
-    fprintf(fid,' \n');
-    fprintf(fid,'\\begin{center}\n');
-    fprintf(fid,'\\begin{longtable}{llcccc} \n');
-    fprintf(fid,['\\caption{Results from posterior maximization (' title ')}\\\\\n ']);
-    fprintf(fid,['\\label{Table:Posterior:' int2str(fnum)  '}\\\\\n']);
-    fprintf(fid,'\\toprule \n');
-    fprintf(fid,'  & \\multicolumn{3}{c}{Prior}  &  \\multicolumn{2}{c}{Posterior} \\\\\n');
-    fprintf(fid,'  \\cmidrule(r{.75em}){2-4} \\cmidrule(r{.75em}){5-6}\n');
-    fprintf(fid,'  & Dist. & Mean  & Stdev & Mode & Stdev \\\\ \n');
-    fprintf(fid,'\\midrule \\endfirsthead \n');
-    fprintf(fid,'\\caption{(continued)}\\\\\n ');
-    fprintf(fid,'\\bottomrule \n');
-    fprintf(fid,'  & \\multicolumn{3}{c}{Prior}  &  \\multicolumn{2}{c}{Posterior} \\\\\n');
-    fprintf(fid,'  \\cmidrule(r{.75em}){2-4} \\cmidrule(r{.75em}){5-6}\n');
-    fprintf(fid,'  & Dist. & Mean  & Stdev & Mode & Stdev \\\\ \n');
-    fprintf(fid,'\\midrule \\endhead \n');
-    fprintf(fid,'\\bottomrule \\multicolumn{6}{r}{(Continued on next page)}\\endfoot \n');
-    fprintf(fid,'\\bottomrule\\endlastfoot \n');
+fprintf(fid,'%% TeX-table generated by dynare_estimation (Dynare).\n');
+fprintf(fid,['%% RESULTS FROM POSTERIOR MAXIMIZATION (' title ')\n']);
+fprintf(fid,['%% ' datestr(now,0)]);
+fprintf(fid,' \n');
+fprintf(fid,' \n');
+fprintf(fid,'\\begin{center}\n');
+fprintf(fid,'\\begin{longtable}{llcccc} \n');
+fprintf(fid,['\\caption{Results from posterior maximization (' title ')}\\\\\n ']);
+fprintf(fid,['\\label{Table:Posterior:' int2str(fnum)  '}\\\\\n']);
+fprintf(fid,'\\toprule \n');
+fprintf(fid,'  & \\multicolumn{3}{c}{Prior}  &  \\multicolumn{2}{c}{Posterior} \\\\\n');
+fprintf(fid,'  \\cmidrule(r{.75em}){2-4} \\cmidrule(r{.75em}){5-6}\n');
+fprintf(fid,'  & Dist. & Mean  & Stdev & Mode & Stdev \\\\ \n');
+fprintf(fid,'\\midrule \\endfirsthead \n');
+fprintf(fid,'\\caption{(continued)}\\\\\n ');
+fprintf(fid,'\\bottomrule \n');
+fprintf(fid,'  & \\multicolumn{3}{c}{Prior}  &  \\multicolumn{2}{c}{Posterior} \\\\\n');
+fprintf(fid,'  \\cmidrule(r{.75em}){2-4} \\cmidrule(r{.75em}){5-6}\n');
+fprintf(fid,'  & Dist. & Mean  & Stdev & Mode & Stdev \\\\ \n');
+fprintf(fid,'\\midrule \\endhead \n');
+fprintf(fid,'\\bottomrule \\multicolumn{6}{r}{(Continued on next page)}\\endfoot \n');
+fprintf(fid,'\\bottomrule\\endlastfoot \n');
+
+function TeXBegin_ML(fid,fnum,title,table_title,LaTeXtitle)
+fprintf(fid,'%% TeX-table generated by dynare_estimation (Dynare).\n');
+fprintf(fid,['%% RESULTS FROM ' table_title ' MAXIMIZATION (' title ')\n']);
+fprintf(fid,['%% ' datestr(now,0)]);
+fprintf(fid,' \n');
+fprintf(fid,' \n');
+fprintf(fid,'\\begin{center}\n');
+fprintf(fid,'\\begin{longtable}{llcc} \n');
+fprintf(fid,['\\caption{Results from ' table_title ' maximization (' title ')}\\\\\n ']);
+fprintf(fid,['\\label{Table:' LaTeXtitle ':' int2str(fnum) '}\\\\\n']);
+fprintf(fid,'\\toprule \n');
+fprintf(fid,'  & Mode & s.d. & t-stat\\\\ \n');
+fprintf(fid,'\\midrule \\endfirsthead \n');
+fprintf(fid,'\\caption{(continued)}\\\\\n ');
+fprintf(fid,'\\toprule \n');
+fprintf(fid,'  & Mode & s.d. & t-stat\\\\ \n');
+fprintf(fid,'\\midrule \\endhead \n');
+fprintf(fid,'\\bottomrule  \\multicolumn{4}{r}{(Continued on next page)} \\endfoot \n');
+fprintf(fid,'\\bottomrule \\endlastfoot \n');
 
- function TeXBegin_ML(fid,fnum,title,table_title,LaTeXtitle)   
-        fprintf(fid,'%% TeX-table generated by dynare_estimation (Dynare).\n');
-        fprintf(fid,['%% RESULTS FROM ' table_title ' MAXIMIZATION (' title ')\n']);
-        fprintf(fid,['%% ' datestr(now,0)]);
-        fprintf(fid,' \n');
-        fprintf(fid,' \n');
-        fprintf(fid,'\\begin{center}\n');
-        fprintf(fid,'\\begin{longtable}{llcc} \n');
-        fprintf(fid,['\\caption{Results from ' table_title ' maximization (' title ')}\\\\\n ']);
-        fprintf(fid,['\\label{Table:' LaTeXtitle ':' int2str(fnum) '}\\\\\n']);
-        fprintf(fid,'\\toprule \n');
-        fprintf(fid,'  & Mode & s.d. & t-stat\\\\ \n');
-        fprintf(fid,'\\midrule \\endfirsthead \n');
-        fprintf(fid,'\\caption{(continued)}\\\\\n ');
-        fprintf(fid,'\\toprule \n');
-        fprintf(fid,'  & Mode & s.d. & t-stat\\\\ \n');
-        fprintf(fid,'\\midrule \\endhead \n');
-        fprintf(fid,'\\bottomrule  \\multicolumn{4}{r}{(Continued on next page)} \\endfoot \n');
-        fprintf(fid,'\\bottomrule \\endlastfoot \n');
-   
 function TeXEnd(fid)
-fprintf(fid,'\\end{longtable}\n ');    
+fprintf(fid,'\\end{longtable}\n ');
 fprintf(fid,'\\end{center}\n');
 fprintf(fid,'%% End of TeX file.\n');
 fclose(fid);
\ No newline at end of file
diff --git a/matlab/display_problematic_vars_Jacobian.m b/matlab/display_problematic_vars_Jacobian.m
index a4278208b..310b37fa5 100644
--- a/matlab/display_problematic_vars_Jacobian.m
+++ b/matlab/display_problematic_vars_Jacobian.m
@@ -1,22 +1,22 @@
 function []=display_problematic_vars_Jacobian(problemrow,problemcol,M_,x,type,caller_string)
 % []=display_problematic_vars_Jacobian(problemrow,problemcol,M_,ys,caller_string)
-% print the equation numbers and variables associated with problematic entries 
-% of the Jacobian 
+% print the equation numbers and variables associated with problematic entries
+% of the Jacobian
 %
 % INPUTS
 %   problemrow      [vector] rows associated with problematic entries
 %   problemcol      [vector] columns associated with problematic entries
-%   M_              [matlab structure] Definition of the model.           
+%   M_              [matlab structure] Definition of the model.
 %   x               [vector] point at which the Jacobian was evaluated
 %   type            [string] 'static' or 'dynamic' depending on the type of
 %                               Jacobian
-%   caller_string   [string] contains name of calling function for printing 
-%    
+%   caller_string   [string] contains name of calling function for printing
+%
 % OUTPUTS
 %   none.
-%  
+%
 
-% Copyright (C) 2014-16 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,7 +50,7 @@ if strcmp(type,'dynamic')
             type_string='';
         elseif var_row==1
             type_string='lag of';
-        elseif var_row==3;
+        elseif var_row==3
             type_string='lead of';
         end
         if problemcol(ii)<=max(max(M_.lead_lag_incidence)) && var_index<=M_.orig_endo_nbr
@@ -62,25 +62,25 @@ if strcmp(type,'dynamic')
                 fprintf('Derivative of Equation %d with respect to %s Variable %s  (initial value of %s: %g) \n',eq_nbr,type_string,deblank(M_.endo_names(var_index,:)),deblank(M_.endo_names(var_index,:)),x(var_index))
             end
         elseif problemcol(ii)<=max(max(M_.lead_lag_incidence)) && var_index>M_.orig_endo_nbr %auxiliary vars
-            if M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).type ==6 %Ramsey Lagrange Multiplier 
-                if problemrow(ii)<=aux_eq_nbr
-                    eq_nbr=problemrow(ii);
-                    fprintf('Derivative of Auxiliary Equation %d with respect to %s of Langrange multiplier of equation %s (initial value: %g) \n',eq_nbr,type_string,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))            
-                else
-                    eq_nbr=problemrow(ii)-aux_eq_nbr;
-                    fprintf('Derivative of Equation %d with respect to %s of Langrange multiplier of equation %s (initial value: %g) \n',eq_nbr,type_string,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))            
-                end
+        if M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).type ==6 %Ramsey Lagrange Multiplier
+            if problemrow(ii)<=aux_eq_nbr
+                eq_nbr=problemrow(ii);
+                fprintf('Derivative of Auxiliary Equation %d with respect to %s of Langrange multiplier of equation %s (initial value: %g) \n',eq_nbr,type_string,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))
             else
-                if problemrow(ii)<=aux_eq_nbr
-                    eq_nbr=problemrow(ii);
-                    orig_var_index=M_.aux_vars(1,var_index-M_.orig_endo_nbr).orig_index;
-                    fprintf('Derivative of Auxiliary Equation %d with respect to %s Variable %s  (initial value of %s: %g) \n',eq_nbr,type_string,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(orig_var_index))            
-                else
-                    eq_nbr=problemrow(ii)-aux_eq_nbr;
-                    orig_var_index=M_.aux_vars(1,var_index-M_.orig_endo_nbr).orig_index;
-                    fprintf('Derivative of Equation %d with respect to %s Variable %s  (initial value of %s: %g) \n',eq_nbr,type_string,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(orig_var_index))            
-                end
+                eq_nbr=problemrow(ii)-aux_eq_nbr;
+                fprintf('Derivative of Equation %d with respect to %s of Langrange multiplier of equation %s (initial value: %g) \n',eq_nbr,type_string,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))
             end
+        else
+            if problemrow(ii)<=aux_eq_nbr
+                eq_nbr=problemrow(ii);
+                orig_var_index=M_.aux_vars(1,var_index-M_.orig_endo_nbr).orig_index;
+                fprintf('Derivative of Auxiliary Equation %d with respect to %s Variable %s  (initial value of %s: %g) \n',eq_nbr,type_string,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(orig_var_index))
+            else
+                eq_nbr=problemrow(ii)-aux_eq_nbr;
+                orig_var_index=M_.aux_vars(1,var_index-M_.orig_endo_nbr).orig_index;
+                fprintf('Derivative of Equation %d with respect to %s Variable %s  (initial value of %s: %g) \n',eq_nbr,type_string,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(orig_var_index))
+            end
+        end
         elseif problemcol(ii)>max(max(M_.lead_lag_incidence)) && var_index<=M_.exo_nbr
             if problemrow(ii)<=aux_eq_nbr
                 eq_nbr=problemrow(ii);
@@ -88,7 +88,7 @@ if strcmp(type,'dynamic')
             else
                 eq_nbr=problemrow(ii)-aux_eq_nbr;
                 fprintf('Derivative of Equation %d with respect to %s shock %s \n',eq_nbr,type_string,deblank(M_.exo_names(var_index,:)));
-            end            
+            end
         else
             error('display_problematic_vars_Jacobian:: The error should not happen. Please contact the developers')
         end
@@ -108,24 +108,24 @@ elseif strcmp(type,'static')
                 fprintf('Derivative of Equation %d with respect to Variable %s  (initial value of %s: %g) \n',eq_nbr,deblank(M_.endo_names(problemcol(ii),:)),deblank(M_.endo_names(problemcol(ii),:)),x(problemcol(ii)))
             end
         else %auxiliary vars
-            if M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).type ==6 %Ramsey Lagrange Multiplier 
+            if M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).type ==6 %Ramsey Lagrange Multiplier
                 if problemrow(ii)<=aux_eq_nbr
                     eq_nbr=problemrow(ii);
-                    fprintf('Derivative of Auxiliary Equation %d with respect to Lagrange multiplier of equation %d (initial value: %g) \n',eq_nbr,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))            
+                    fprintf('Derivative of Auxiliary Equation %d with respect to Lagrange multiplier of equation %d (initial value: %g) \n',eq_nbr,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))
                 else
                     eq_nbr=problemrow(ii)-aux_eq_nbr;
-                    fprintf('Derivative of Equation %d with respect to Lagrange multiplier of equation %d (initial value: %g) \n',eq_nbr,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))            
+                    fprintf('Derivative of Equation %d with respect to Lagrange multiplier of equation %d (initial value: %g) \n',eq_nbr,M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).eq_nbr,x(problemcol(ii)))
                 end
             else
-            if problemrow(ii)<=aux_eq_nbr
-                eq_nbr=problemrow(ii);
-                orig_var_index=M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).orig_index;
-                fprintf('Derivative of Auxiliary Equation %d with respect to Variable %s  (initial value of %s: %g) \n',eq_nbr,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(problemcol(ii)))            
-            else
-                eq_nbr=problemrow(ii)-aux_eq_nbr;
-                orig_var_index=M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).orig_index;
-                fprintf('Derivative of Equation %d with respect to Variable %s  (initial value of %s: %g) \n',eq_nbr,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(problemcol(ii)))            
-            end
+                if problemrow(ii)<=aux_eq_nbr
+                    eq_nbr=problemrow(ii);
+                    orig_var_index=M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).orig_index;
+                    fprintf('Derivative of Auxiliary Equation %d with respect to Variable %s  (initial value of %s: %g) \n',eq_nbr,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(problemcol(ii)))
+                else
+                    eq_nbr=problemrow(ii)-aux_eq_nbr;
+                    orig_var_index=M_.aux_vars(1,problemcol(ii)-M_.orig_endo_nbr).orig_index;
+                    fprintf('Derivative of Equation %d with respect to Variable %s  (initial value of %s: %g) \n',eq_nbr,deblank(M_.endo_names(orig_var_index,:)),deblank(M_.endo_names(orig_var_index,:)),x(problemcol(ii)))
+                end
             end
         end
     end
@@ -134,5 +134,5 @@ elseif strcmp(type,'static')
     fprintf('%s  and evaluating it at the steady state then results in a division by 0.\n',caller_string)
     fprintf('%s  If you are using model-local variables (# operator), check their values as well.\n',caller_string)
 else
-    error('Unknown Type')    
+    error('Unknown Type')
 end
\ No newline at end of file
diff --git a/matlab/distributions/beta_specification.m b/matlab/distributions/beta_specification.m
index 33a38085d..df804812c 100644
--- a/matlab/distributions/beta_specification.m
+++ b/matlab/distributions/beta_specification.m
@@ -2,17 +2,17 @@ function [a, b] = beta_specification(mu, sigma2, lb, ub, name)   % --*-- Unitary
 
 % Returns the hyperparameters of the beta distribution given the expectation and variance.
 %
-% INPUTS 
+% INPUTS
 % - mu     [double]   Expectation of the Gamma random variable.
 % - sigma2 [double]   Variance of the Gamma random variable.
 % - lb     [double]   Lower bound of the domain (default is zero).
 % - ub     [double]   Upper bound of the domain (default is one).
 %
-% OUTPUTS 
+% OUTPUTS
 % - a      [double]   First hyperparameter of the Beta density.
 % - b      [double]   Second hyperparameter of the Beta density.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -63,7 +63,7 @@ if sigma2>(1-mu)*mu
     error('Beta prior%s. Given the declared prior expectation, prior lower and upper bounds, the prior std. has to be smaller than %f.',name2,sqrt((1-mu)*mu))
 end
 
-a = (1-mu)*mu*mu/sigma2-mu; 
+a = (1-mu)*mu*mu/sigma2-mu;
 b = a*(1/mu-1);
 
 %@test:1
diff --git a/matlab/distributions/compute_prior_mode.m b/matlab/distributions/compute_prior_mode.m
index 3286c08ea..86c20dae8 100644
--- a/matlab/distributions/compute_prior_mode.m
+++ b/matlab/distributions/compute_prior_mode.m
@@ -1,8 +1,8 @@
 function m = compute_prior_mode(hyperparameters,shape) % --*-- Unitary tests --*--
 % This function computes the mode of the prior distribution given the (two, three or four) hyperparameters
 % of the prior distribution.
-%    
-% INPUTS 
+%
+% INPUTS
 %   hyperparameters     [double]    1*n vector of hyper parameters.
 %   shape               [integer]   scalar specifying the prior shape:
 %                                     shape=1 => Beta distribution,
@@ -12,18 +12,18 @@ function m = compute_prior_mode(hyperparameters,shape) % --*-- Unitary tests --*
 %                                     shape=5 => Uniform distribution,
 %                                     shape=6 => Inverse Gamma (type 2) distribution,
 %                                     shape=8 => Weibull distribution.
-%                                     
-% OUTPUTS 
+%
+% OUTPUTS
 %   m       [double]    scalar or 2*1 vector, the prior mode.
 %
-% REMARKS 
-% [1] The size of the vector of hyperparameters is 3 when the Gamma or Inverse Gamma is shifted and 4 when 
-%     the support of the Beta distribution is not [0,1].      
-% [2] The hyperparameters of the uniform distribution are the lower and upper bounds.    
+% REMARKS
+% [1] The size of the vector of hyperparameters is 3 when the Gamma or Inverse Gamma is shifted and 4 when
+%     the support of the Beta distribution is not [0,1].
+% [2] The hyperparameters of the uniform distribution are the lower and upper bounds.
 % [3] The uniform distribution has an infinity of modes. In this case the function returns the prior mean.
 % [4] For the beta distribution we can have 1, 2 or an infinity of modes.
 
-% Copyright (C) 2009-2016 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/distributions/gamma_specification.m b/matlab/distributions/gamma_specification.m
index 0f7301193..c78713407 100644
--- a/matlab/distributions/gamma_specification.m
+++ b/matlab/distributions/gamma_specification.m
@@ -2,17 +2,17 @@ function [a, b] = gamma_specification(mu, sigma2, lb, name)   % --*-- Unitary te
 
 % Returns the hyperparameters of the gamma distribution given the expectation and variance.
 %
-% INPUTS 
+% INPUTS
 % - mu     [double]   Expectation of the Gamma random variable.
 % - sigma2 [double]   Variance of the Gamma random variable.
 % - lb     [double]   Lower bound of the domain (default is zero).
 % - name   [string]   Name of the parameter (or random variable).
 %
-% OUTPUTS 
+% OUTPUTS
 % - a      [double]   First hyperparameter of the Gamma density (shape).
 % - b      [double]   Second hyperparameter of the Gamma density (scale).
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/distributions/inverse_gamma_specification.m b/matlab/distributions/inverse_gamma_specification.m
index c7f02a194..410d4e52b 100644
--- a/matlab/distributions/inverse_gamma_specification.m
+++ b/matlab/distributions/inverse_gamma_specification.m
@@ -2,7 +2,7 @@ function [s,nu] = inverse_gamma_specification(mu, sigma2, lb, type, use_fzero_fl
 
 % Computes the inverse Gamma hyperparameters from the prior mean and standard deviation.
 %
-% INPUTS 
+% INPUTS
 % - mu               [double]   scalar, prior mean.
 % - sigma2           [double]   positive scalar, prior variance.
 % - type             [integer]  scalar equal to 1 or 2, type of the inverse gamma distribution
@@ -10,16 +10,16 @@ function [s,nu] = inverse_gamma_specification(mu, sigma2, lb, type, use_fzero_fl
 %                               dynare's implementation of the secant method otherwise.
 % - name             [string]   name of the parameter or random variable.
 %
-% OUTPUS 
+% OUTPUS
 % - s                [double]    scalar, first hyperparameter.
 % - nu               [double]    scalar, second hyperparameter.
 %
-% REMARK 
+% REMARK
 % The call to the matlab's implementation of the secant method is here for testing purpose and should not be used. This routine fails
 % more often in finding an interval for nu containing a signe change because it expands the interval on both sides and eventually
 % violates  the condition nu>2.
 
-% Copyright (C) 2003-2015 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -85,10 +85,10 @@ nu = [];
 sigma = sqrt(sigma2);
 mu2 = mu*mu;
 
-if type == 2;       % Inverse Gamma 2
+if type == 2       % Inverse Gamma 2
     nu   = 2*(2+mu2/sigma2);
     s    = 2*mu*(1+mu2/sigma2);
-elseif type == 1;   % Inverse Gamma 1
+elseif type == 1   % Inverse Gamma 1
     if sigma2 < Inf
         nu = sqrt(2*(2+mu2/sigma2));
         if use_fzero_flag
diff --git a/matlab/distributions/lpdfgweibull.m b/matlab/distributions/lpdfgweibull.m
index 3f2df819d..708a5b4d4 100644
--- a/matlab/distributions/lpdfgweibull.m
+++ b/matlab/distributions/lpdfgweibull.m
@@ -1,14 +1,14 @@
 function [ldens,Dldens,D2ldens] = lpdfgweibull(x,a,b,c)  % --*-- Unitary tests --*--
 
-% Evaluates the logged Weibull PDF at x. 
+% Evaluates the logged Weibull PDF at x.
 %
-% INPUTS 
+% INPUTS
 % - x       [double]  m*n matrix of points where the (logged) density will be evaluated,
 % - a       [double]  m*n matrix of First Weibull distribution parameters (shape parameter, k),
 % - b       [double]  m*n matrix of Second Weibull distribution parameters (scale parameter, λ),
 % - c       [double]  m*n matrix of Third Weibull distribution parameters (location parameter, default is 0).
 %
-% OUTPUTS 
+% OUTPUTS
 % - ldens   [double]  m*n matrix of logged (generalized) Weibull densities.
 % - Dldens  [double]  m*n matrix (first order derivatives w.r.t. x)
 % - D2ldens [double]  m*n matrix (second order derivatives w.r.t. x)
@@ -16,7 +16,7 @@ function [ldens,Dldens,D2ldens] = lpdfgweibull(x,a,b,c)  % --*-- Unitary tests -
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,11 +54,11 @@ end
 if ~isscalar(x)
     if isscalar(a)
         a = repmat(a, size(x));
-    end 
+    end
     if isscalar(b)
         b = repmat(b, size(x));
     end
-    if isscalar(c) 
+    if isscalar(c)
         c = repmat(c, size(x));
     end
 end
@@ -77,7 +77,7 @@ if isempty(idx), return, end
 
 jdx = find( abs(a-1)<1e-12 & x>=c & (x-c)<1e-12) ;
 ldens(jdx) = 1.0;
-    
+
 if ~isempty(idx)
     x0 = x(idx)-c(idx);
     x1 = x0./b(idx);
@@ -136,7 +136,7 @@ end
 %$ catch
 %$    t(1) = false;
 %$ end
-%$ 
+%$
 %$ if t(1)
 %$    t(2) = isinf(a);
 %$ end
@@ -179,7 +179,7 @@ end
 %$ scale = 1;
 %$ shape = 2;
 %$ mode  = scale*((shape-1)/shape)^(1/shape);
-%$ 
+%$
 %$ try
 %$    [a, b, c] = lpdfgweibull(mode, shape, scale);
 %$    p = rand(1000,1)*4;
@@ -203,7 +203,7 @@ end
 %$ scale = 1;
 %$ shape = 2;
 %$ density  = @(x) exp(lpdfgweibull(x,shape,scale));
-%$ 
+%$
 %$ try
 %$    if isoctave
 %$        s = quadv(density, .0000000001, 100000,1e-10);
@@ -226,7 +226,7 @@ end
 %$ scale = 1;
 %$ shape = 1;
 %$ density  = @(x) exp(lpdfgweibull(x,shape,scale));
-%$ 
+%$
 %$ try
 %$    if isoctave
 %$        s = quadv(density, .0000000001, 100000,1e-10);
@@ -249,7 +249,7 @@ end
 %$ scale = 1;
 %$ shape = .5;
 %$ density  = @(x) exp(lpdfgweibull(x,shape,scale));
-%$ 
+%$
 %$ try
 %$    if isoctave
 %$        s = quadv(density, .0000000001, 100000,1e-10)
@@ -276,7 +276,7 @@ end
 %$ scale = 1;
 %$ shape = 2;
 %$ xdens = @(x) x.*exp(lpdfgweibull(x,shape,scale));
-%$ 
+%$
 %$ try
 %$    if isoctave
 %$        s = quadv(xdens, .0000000001, 20,1e-10)
@@ -299,7 +299,7 @@ end
 %$ scale = 1;
 %$ shape = 1;
 %$ xdens = @(x) x.*exp(lpdfgweibull(x,shape,scale));
-%$ 
+%$
 %$ try
 %$    if isoctave
 %$        s = quadv(xdens, .0000000001, 100000,1e-10)
@@ -322,7 +322,7 @@ end
 %$ scale = 1;
 %$ shape = .5;
 %$ xdens = @(x) x.*exp(lpdfgweibull(x,shape,scale));
-%$ 
+%$
 %$ try
 %$    if isoctave
 %$        s = quadv(xdens, .0000000001, 100000,1e-10)
diff --git a/matlab/distributions/mode_and_variance_to_mean.m b/matlab/distributions/mode_and_variance_to_mean.m
index a69f0cdbe..8611955b0 100644
--- a/matlab/distributions/mode_and_variance_to_mean.m
+++ b/matlab/distributions/mode_and_variance_to_mean.m
@@ -1,23 +1,23 @@
 function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bound,upper_bound)
 % This function computes the mean of a distribution given the mode and variance of this distribution.
 %
-%  INPUTS 
+%  INPUTS
 %    m                [double]    scalar, mode of the distribution.
 %    s2               [double]    scalar, variance of the distribution.
-%    distribution     [integer]   scalar for the distribution shape 
+%    distribution     [integer]   scalar for the distribution shape
 %                                    1 gamma
 %                                    2 inv-gamma-2
 %                                    3 inv-gamma-1
-%                                    4 beta    
+%                                    4 beta
 %    lower_bound      [double]    scalar, lower bound of the random variable support (optional).
 %    upper_bound      [double]    scalar, upper bound of the random variable support (optional).
-%    
-%  OUTPUT 
+%
+%  OUTPUT
 %    mu               [double]    scalar, mean of the distribution.
 %    parameters       [double]    2*1 vector, parameters of the distribution.
-%    
+%
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,7 +34,7 @@ function [mu, parameters] = mode_and_variance_to_mean(m,s2,distribution,lower_bo
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-% Check input aruments. 
+% Check input aruments.
 if ~(nargin==3 || nargin==5 || nargin==4 )
     error('mode_and_variance_to mean:: 3 or 5 input arguments are needed!')
 end
@@ -80,7 +80,7 @@ if (distribution==1)% Gamma distribution
     end
     if (m-lower_bound)<1e-12
         error('The gamma distribution should be specified with the mean and variance.')
-    end        
+    end
     m = m - lower_bound ;
     beta  = -.5*m*(1-sqrt(1+4*s2/(m*m))) ;
     alpha = (m+beta)/beta ;
diff --git a/matlab/distributions/multivariate_normal_pdf.m b/matlab/distributions/multivariate_normal_pdf.m
index 29feabaf6..55bae7283 100644
--- a/matlab/distributions/multivariate_normal_pdf.m
+++ b/matlab/distributions/multivariate_normal_pdf.m
@@ -1,21 +1,21 @@
-function density = multivariate_normal_pdf(X,Mean,Sigma_upper_chol,n);
+function density = multivariate_normal_pdf(X,Mean,Sigma_upper_chol,n)
 % Evaluates the density of a multivariate gaussian, with expectation Mean
 % and variance Sigma_upper_chol'*Sigma_upper_chol, at X.
-% 
 %
-% INPUTS 
 %
-%    X                  [double]    1*n vector        
+% INPUTS
+%
+%    X                  [double]    1*n vector
 %    Mean               [double]    1*n vector, expectation of the multivariate random variable.
 %    Sigma_upper_chol   [double]    n*n matrix, upper triangular Cholesky decomposition of Sigma (the covariance matrix).
 %    n                  [integer]   dimension.
-%    
-% OUTPUTS 
-%    density            [double]    density 
-%        
+%
+% OUTPUTS
+%    density            [double]    density
+%
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,6 +31,6 @@ function density = multivariate_normal_pdf(X,Mean,Sigma_upper_chol,n);
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-density = (2*pi)^(-.5*n) * ... 
+density = (2*pi)^(-.5*n) * ...
           prod(diag(Sigma_upper_chol))^(-1) * ...
           exp(-.5*(X-Mean)*(Sigma_upper_chol\(transpose(Sigma_upper_chol)\transpose(X-Mean))));
\ No newline at end of file
diff --git a/matlab/distributions/multivariate_student_pdf.m b/matlab/distributions/multivariate_student_pdf.m
index 3f498c673..1465d4402 100644
--- a/matlab/distributions/multivariate_student_pdf.m
+++ b/matlab/distributions/multivariate_student_pdf.m
@@ -1,20 +1,20 @@
-function density = multivariate_student_pdf(X,Mean,Sigma_upper_chol,df);
+function density = multivariate_student_pdf(X,Mean,Sigma_upper_chol,df)
 % Evaluates the density of a multivariate student, with expectation Mean,
 % variance Sigma_upper_chol'*Sigma_upper_chol and degrees of freedom df, at X.
 %
-% INPUTS 
+% INPUTS
 %
-%    X                  [double]    1*n vector        
+%    X                  [double]    1*n vector
 %    Mean               [double]    1*n vector, expectation of the multivariate random variable.
 %    Sigma_upper_chol   [double]    n*n matrix, upper triangular Cholesky decomposition of Sigma (the "covariance matrix").
 %    df                 [integer]   degrees of freedom.
-%    
-% OUTPUTS 
-%    density            [double]    density. 
-%        
+%
+% OUTPUTS
+%    density            [double]    density.
+%
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/distributions/rand_inverse_wishart.m b/matlab/distributions/rand_inverse_wishart.m
index c561fb7f4..4f3675e3c 100644
--- a/matlab/distributions/rand_inverse_wishart.m
+++ b/matlab/distributions/rand_inverse_wishart.m
@@ -17,14 +17,14 @@ function G = rand_inverse_wishart(m, v, H_inv_upper_chol)
 % OUTPUTS:
 %     G:          G ~ IW(m, v, H) where H = inv(H_inv_upper_chol'*H_inv_upper_chol)
 %                 or, equivalently, using the correspondence between Wishart and
-%                 inverse-Wishart: inv(G) ~ W(m, v, S) where 
+%                 inverse-Wishart: inv(G) ~ W(m, v, S) where
 %                 S = H_inv_upper_chol'*H_inv_upper_chol = inv(H)
-%  
+%
 % SPECIAL REQUIREMENT
 %     none
-%    
+%
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,7 +41,7 @@ function G = rand_inverse_wishart(m, v, H_inv_upper_chol)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-X = randn(v, m) * H_inv_upper_chol; 
+X = randn(v, m) * H_inv_upper_chol;
 
 
 % At this point, X'*X is Wishart distributed
diff --git a/matlab/distributions/rand_matrix_normal.m b/matlab/distributions/rand_matrix_normal.m
index ff595cca8..0de2faf08 100644
--- a/matlab/distributions/rand_matrix_normal.m
+++ b/matlab/distributions/rand_matrix_normal.m
@@ -2,7 +2,7 @@ function B = rand_matrix_normal(n, p, M, Omega_lower_chol, Sigma_lower_chol)
 
 % function B = rand_matrix_normal(n, p, M, Omega_lower_chol, Sigma_lower_chol)
 % Pseudo random matrices drawn from a matrix-normal distribution
-% B ~ MN_n*p(M, Omega, Sigma) 
+% B ~ MN_n*p(M, Omega, Sigma)
 % Equivalent to vec(B) ~ N(vec(Mu), kron(Omega, Sigma))
 %
 % INPUTS
@@ -13,14 +13,14 @@ function B = rand_matrix_normal(n, p, M, Omega_lower_chol, Sigma_lower_chol)
 %                       (Omega_lower_chol = chol(Omega, 'lower'))
 %    Sigma_lower_chol:  (n*n), lower Cholesky decomposition of Sigma,
 %                       (Sigma_lower_chol = chol(Sigma, 'lower'))
-%    
+%
 % OUTPUTS
 %    B:                 (n*p) matrix drawn from a Matrix-normal distribution
-%        
+%
 % SPECIAL REQUIREMENTS
 %    Same notations than: http://en.wikipedia.org/wiki/Matrix_normal_distribution
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/distributions/rand_multivariate_normal.m b/matlab/distributions/rand_multivariate_normal.m
index 174c3706c..d74d74b7b 100644
--- a/matlab/distributions/rand_multivariate_normal.m
+++ b/matlab/distributions/rand_multivariate_normal.m
@@ -2,19 +2,19 @@ function draw = rand_multivariate_normal(Mean,Sigma_upper_chol,n)
 % Pseudo random draws from a multivariate normal distribution,
 % \mathcal N_n(Mean,Sigma), with expectation Mean and variance Sigma.
 %
-% INPUTS 
+% INPUTS
 %
 %    Mean               [double]    1*n vector, expectation of the multivariate random variable.
 %    Sigma_upper_chol   [double]    n*n matrix, upper triangular Cholesky decomposition of Sigma (the covariance matrix).
 %    n                  [integer]   dimension.
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %    draw               [double]    1*n vector drawn from a multivariate normal distribution with expectation Mean and
-%                                   covariance Sigma 
-%        
+%                                   covariance Sigma
+%
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/distributions/rand_multivariate_student.m b/matlab/distributions/rand_multivariate_student.m
index eca1d0585..69b26e85e 100644
--- a/matlab/distributions/rand_multivariate_student.m
+++ b/matlab/distributions/rand_multivariate_student.m
@@ -3,27 +3,27 @@ function draw = rand_multivariate_student(Mean,Sigma_upper_chol,df)
 % Pseudo random draws from a multivariate student distribution,
 % with expectation Mean, variance Sigma*df/(df-2) and degrees of freedom df>0.
 %
-% INPUTS 
+% INPUTS
 %
 %    Mean               [double]    1*n vector, expectation of the multivariate random variable.
-%    Sigma_upper_chol   [double]    n*n matrix, upper triangular Cholesky decomposition of Sigma 
+%    Sigma_upper_chol   [double]    n*n matrix, upper triangular Cholesky decomposition of Sigma
 %                                   (the covariance matrix up to a factor df/(df-2)).
 %    df                 [integer]   degrees of freedom.
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %    draw               [double]    1*n vector drawn from a multivariate normal distribution with expectation Mean and
 %                                   covariance Sigma.
-%        
 %
-% NOTE See Zellner (appendix B.2, 1971) for a definition.     
-%    Computes the t-distributed random numbers from 
+%
+% NOTE See Zellner (appendix B.2, 1971) for a definition.
+%    Computes the t-distributed random numbers from
 %       X = \mu + Y\sqrt{\frac{\nu}{U}}
-%   where 
+%   where
 %       Y~N(0,Sigma) with Sigma=Sigma_upper_chol'*Sigma_upper_chol
 %       U~\Chi^2_{\nu}
 %   The latter is constructed as the sum of \nu standard normals.
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/distributions/weibull_specification.m b/matlab/distributions/weibull_specification.m
index 8036dcb8d..b9d498a53 100644
--- a/matlab/distributions/weibull_specification.m
+++ b/matlab/distributions/weibull_specification.m
@@ -2,14 +2,14 @@ function [shape, scale] = weibull_specification(mu, sigma2, lb, name)   % --*--
 
 % Returns the hyperparameters of the Weibull distribution given the expectation and variance.
 %
-% INPUTS 
+% INPUTS
 %
 %
-% OUTPUTS 
+% OUTPUTS
+%
 %
-% 
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,8 +49,8 @@ end
 scale = NaN;
 shape = NaN;
 
-mu = mu-lb; 
-mu2 = mu*mu;   
+mu = mu-lb;
+mu2 = mu*mu;
 
 eqn = @(k) gammaln(1+2./k) - 2*gammaln(1+1./k) - log(1+sigma2/mu2);
 eqn2 = @(k) eqn(k).*eqn(k);
@@ -140,4 +140,3 @@ scale = mu/gamma(1+1/shape);
 %$ end
 %$ T = all(t);
 %@eof:1
-
diff --git a/matlab/do_parameter_initialization.m b/matlab/do_parameter_initialization.m
index 1f18c3f56..145984cec 100644
--- a/matlab/do_parameter_initialization.m
+++ b/matlab/do_parameter_initialization.m
@@ -6,24 +6,24 @@ function [xparam1,estim_params_,xparam1_explicitly_initialized,xparam1_properly_
 %    o estim_params_    [structure] characterizing parameters to be estimated.
 %    o xparam1_calib    [double]    vector of parameters to be estimated, with parameters
 %                                   initialized from calibration using get_all_parameters
-%     
+%
 %    o xparam1_NaN_set_to_prior_mean [double]    vector of parameters to be estimated, with parameters
 %                                                initialized using dynare_estimation_init; not explicitly initialized
 %                                                parameters are at prior mean
 % OUTPUTS
 %    o xparam1                           [double]    vector of initialized parameters; uses the hierarchy: 1) explicitly initialized parameters,
 %                                                    2) calibrated parameters, 3) prior mean
-%    o estim_params_    [structure] characterizing parameters to be estimated; it is 
+%    o estim_params_    [structure] characterizing parameters to be estimated; it is
 %                                   updated here to reflect calibrated parameters
 %    o xparam1_explicitly_initialized    [double]    vector of parameters to be estimated that
-%                                                    were explicitly initialized 
+%                                                    were explicitly initialized
 %    o xparam1_properly_calibrated       [double]    vector of parameters to be estimated that
-%                                                    were properly calibrated 
-%    
+%                                                    were properly calibrated
+%
 % SPECIAL REQUIREMENTS
 %    None
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -59,7 +59,7 @@ offset=0;
 if nvx
     initialized_par_index=find(~isnan(estim_params_.var_exo(:,2)));
     calibrated_par_index=find(isnan(estim_params_.var_exo(:,2)) & ~isnan(xparam1_calib(offset+1:offset+nvx,1)));
-    uninitialized_par_index=find(isnan(estim_params_.var_exo(:,2)) & isnan(xparam1_calib(offset+1:offset+nvx,1)));    
+    uninitialized_par_index=find(isnan(estim_params_.var_exo(:,2)) & isnan(xparam1_calib(offset+1:offset+nvx,1)));
     xparam1_explicitly_initialized(offset+initialized_par_index,1) = estim_params_.var_exo(initialized_par_index,2);
     %update estim_params_ with calibrated starting values
     estim_params_.var_exo(calibrated_par_index,2)=xparam1_calib(offset+calibrated_par_index,1);
@@ -67,13 +67,13 @@ if nvx
     xparam1_properly_calibrated(offset+calibrated_par_index,1) = xparam1_calib(offset+calibrated_par_index,1);
     inv_gamma_violation=find(estim_params_.var_exo(calibrated_par_index,2)==0 & estim_params_.var_exo(calibrated_par_index,5)==4);
     if inv_gamma_violation
-        estim_params_.var_exo(calibrated_par_index(inv_gamma_violation),2)=NaN;        
-        xparam1_properly_calibrated(offset+calibrated_par_index(inv_gamma_violation),1)=NaN;        
-        fprintf('PARAMETER INITIALIZATION: Some standard deviations of shocks of the calibrated model are 0 and\n') 
-        fprintf('PARAMETER INITIALIZATION: violate the inverse gamma prior. They will instead be initialized with the prior mean.\n')    
+        estim_params_.var_exo(calibrated_par_index(inv_gamma_violation),2)=NaN;
+        xparam1_properly_calibrated(offset+calibrated_par_index(inv_gamma_violation),1)=NaN;
+        fprintf('PARAMETER INITIALIZATION: Some standard deviations of shocks of the calibrated model are 0 and\n')
+        fprintf('PARAMETER INITIALIZATION: violate the inverse gamma prior. They will instead be initialized with the prior mean.\n')
     end
     if uninitialized_par_index
-        fprintf('PARAMETER INITIALIZATION: Warning, some estimated standard deviations of shocks are not\n') 
+        fprintf('PARAMETER INITIALIZATION: Warning, some estimated standard deviations of shocks are not\n')
         fprintf('PARAMETER INITIALIZATION: initialized. They will be initialized with the prior mean.\n')
     end
 end
@@ -88,10 +88,10 @@ if nvn
     xparam1_properly_calibrated(offset+calibrated_par_index,1) = xparam1_calib(offset+calibrated_par_index,1);
     inv_gamma_violation=find(estim_params_.var_endo(calibrated_par_index,2)==0 & estim_params_.var_endo(calibrated_par_index,5)==4);
     if inv_gamma_violation
-        estim_params_.var_endo(calibrated_par_index(inv_gamma_violation),2)=NaN;        
-        xparam1_properly_calibrated(offset+calibrated_par_index(inv_gamma_violation),1)=NaN;        
+        estim_params_.var_endo(calibrated_par_index(inv_gamma_violation),2)=NaN;
+        xparam1_properly_calibrated(offset+calibrated_par_index(inv_gamma_violation),1)=NaN;
         fprintf('PARAMETER INITIALIZATION: Some measurement errors of the calibrated model are 0 and violate the\n')
-        fprintf('PARAMETER INITIALIZATION: inverse gamma prior. They will instead be initialized with the prior mean.\n')    
+        fprintf('PARAMETER INITIALIZATION: inverse gamma prior. They will instead be initialized with the prior mean.\n')
     end
     if uninitialized_par_index
         fprintf('PARAMETER INITIALIZATION: Warning, some measurement errors are not initialized. They will be initialized\n')
@@ -140,4 +140,3 @@ end
 xparam1=xparam1_explicitly_initialized;
 xparam1(isnan(xparam1))=xparam1_properly_calibrated(isnan(xparam1)); %set not explicitly initialized parameters that do not obviously violate prior distribution to calibrated parameter values
 xparam1(isnan(xparam1))=xparam1_NaN_set_to_prior_mean(isnan(xparam1)); %set not yet initialized parameters to prior mean coming from dynare_estimation_init
-
diff --git a/matlab/dr_block.m b/matlab/dr_block.m
index 47c20add2..61826d390 100644
--- a/matlab/dr_block.m
+++ b/matlab/dr_block.m
@@ -1,40 +1,40 @@
 function [dr,info,M_,options_,oo_] = dr_block(dr,task,M_,options_,oo_,varargin)
 % function [dr,info,M_,options_,oo_] = dr_block(dr,task,M_,options_,oo_,varargin)
 % computes the reduced form solution of a rational expectations model
-% (first order approximation of the stochastic model around the deterministic steady state). 
+% (first order approximation of the stochastic model around the deterministic steady state).
 %
 % INPUTS
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   task       [integer]          if task = 0 then dr_block computes decision rules.
 %                                 if task = 1 then dr_block computes eigenvalues.
-%   M_         [matlab structure] Definition of the model.           
+%   M_         [matlab structure] Definition of the model.
 %   options_   [matlab structure] Global options.
-%   oo_        [matlab structure] Results 
+%   oo_        [matlab structure] Results
 %   oo_        [matlab cell]      Other input arguments
-%    
+%
 % OUTPUTS
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   info       [integer]          info=1: the model doesn't define current variables uniquely
-%                                 info=2: problem in mjdgges.dll info(2) contains error code. 
+%                                 info=2: problem in mjdgges.dll info(2) contains error code.
 %                                 info=3: BK order condition not satisfied info(2) contains "distance"
 %                                         absence of stable trajectory.
 %                                 info=4: BK order condition not satisfied info(2) contains "distance"
 %                                         indeterminacy.
 %                                 info=5: BK rank condition not satisfied.
-%                                 info=6: The jacobian matrix evaluated at the steady state is complex.        
-%   M_         [matlab structure]            
+%                                 info=6: The jacobian matrix evaluated at the steady state is complex.
+%   M_         [matlab structure]
 %   options_   [matlab structure]
 %   oo_        [matlab structure]
-%  
+%
 % ALGORITHM
 %   first order block relaxation method applied to the model
 %    E[A Yt-1 + B Yt + C Yt+1 + ut] = 0
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,7 +54,7 @@ function [dr,info,M_,options_,oo_] = dr_block(dr,task,M_,options_,oo_,varargin)
 info = 0;
 verbose = 0;
 if nargin > 5
-  verbose = varargin{1};
+    verbose = varargin{1};
 end
 %verbose = options_.verbosity;
 if options_.order > 1
@@ -69,13 +69,13 @@ if (isfield(M_,'block_structure'))
 else
     data = M_;
     Size = 1;
-end;
+end
 if (options_.bytecode)
     [chck, 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;
+end
 mexErrCheck('bytecode', chck);
 dr.full_rank = 1;
 dr.eigval = [];
@@ -90,7 +90,7 @@ n_sv = size(dr.state_var, 2);
 dr.ghx = zeros(M_.endo_nbr, length(dr.state_var));
 dr.exo_var = 1:M_.exo_nbr;
 dr.ghu = zeros(M_.endo_nbr, M_.exo_nbr);
-for i = 1:Size;
+for i = 1:Size
     ghx = [];
     indexi_0 = 0;
     if (verbose)
@@ -98,7 +98,7 @@ for i = 1:Size;
         disp(['Block ' int2str(i)]);
         disp('-----------');
         data(i)
-    end;
+    end
     n_pred = data(i).n_backward;
     n_fwrd = data(i).n_forward;
     n_both = data(i).n_mixed;
@@ -118,23 +118,23 @@ for i = 1:Size;
         disp(jacob);
         disp('lead_lag_incidence');
         disp(lead_lag_incidence);
-    end;
+    end
     maximum_lag = data(i).maximum_endo_lag;
     maximum_lead = data(i).maximum_endo_lead;
     n = n_dynamic + n_static;
-    
+
     block_type = M_.block_structure.block(i).Simulation_Type;
     if task ~= 1
-        if block_type == 2 || block_type == 4 || block_type == 7 
+        if block_type == 2 || block_type == 4 || block_type == 7
             block_type = 8;
-        end;
-    end;
-    if maximum_lag > 0 && (n_pred > 0  || n_both > 0) && block_type ~= 1 
+        end
+    end
+    if maximum_lag > 0 && (n_pred > 0  || n_both > 0) && block_type ~= 1
         indexi_0 = min(lead_lag_incidence(2,:));
-    end;
+    end
     switch block_type
       case 1
-      %% ------------------------------------------------------------------
+        %% ------------------------------------------------------------------
         %Evaluate Forward
         if maximum_lag > 0 && n_pred > 0
             indx_r = find(M_.block_structure.block(i).lead_lag_incidence(1,:));
@@ -153,7 +153,7 @@ for i = 1:Size;
             if (maximum_lag > 0 && n_pred > 0)
                 [indx_r, tmp1, indx_r_v]  = find(M_.block_structure.block(i).lead_lag_incidence(1,:));
                 ghx = - B \ jacob(:,indx_r_v);
-            end;
+            end
             if other_endo_nbr
                 fx = data(i).g1_o;
                 % retrieves the derivatives with respect to endogenous
@@ -175,11 +175,11 @@ for i = 1:Size;
                 l_x_sv = dr.ghx(dr.state_var, 1:n_sv);
 
                 selector_tm1 = M_.block_structure.block(i).tm1;
-               
+
                 ghx_other = - B \ (fx_t * l_x + (fx_tp1 * l_x * l_x_sv) + fx_tm1 * selector_tm1);
                 dr.ghx(endo, :) = dr.ghx(endo, :) + ghx_other;
-            end;
-            
+            end
+
             if exo_nbr
                 fu = data(i).g1_x;
                 exo = dr.exo_var;
@@ -194,21 +194,21 @@ for i = 1:Size;
                     fu_complet = zeros(n, M_.exo_nbr);
                     fu_complet(:,data(i).exogenous) = fu;
                     ghu = - B \ fu_complet;
-                end;
+                end
             else
                 exo = dr.exo_var;
                 if other_endo_nbr > 0
-                     l_u_sv = dr.ghu(dr.state_var,:);
-                     l_x = dr.ghx(data(i).other_endogenous,:);
-                     l_u = dr.ghu(data(i).other_endogenous,:);
-                     ghu = -B \ (fx_tp1 * l_x * l_u_sv + (fx_t) * l_u );
+                    l_u_sv = dr.ghu(dr.state_var,:);
+                    l_x = dr.ghx(data(i).other_endogenous,:);
+                    l_u = dr.ghu(data(i).other_endogenous,:);
+                    ghu = -B \ (fx_tp1 * l_x * l_u_sv + (fx_t) * l_u );
                 else
                     ghu = [];
                 end
             end
         end
       case 2
-      %% ------------------------------------------------------------------
+        %% ------------------------------------------------------------------
         %Evaluate Backward
         if maximum_lead > 0 && n_fwrd > 0
             indx_r = find(M_.block_structure.block(i).lead_lag_incidence(3,:));
@@ -229,11 +229,11 @@ for i = 1:Size;
                 indx_r = find(M_.block_structure.block(i).lead_lag_incidence(3,:));
                 indx_c = M_.block_structure.block(i).lead_lag_incidence(3,indx_r);
                 ghx = - inv(jacob(indx_r, indx_c));
-            end;
+            end
             ghu =  - inv(jacob(indx_r, indx_c)) * data(i).g1_x;
         end
       case 3
-      %% ------------------------------------------------------------------
+        %% ------------------------------------------------------------------
         %Solve Forward single equation
         if maximum_lag > 0 && n_pred > 0
             data(i).eigval = - jacob(1 , 1 : n_pred) / jacob(1 , n_pred + n_static + 1 : n_pred + n_static + n_pred + n_both);
@@ -241,15 +241,15 @@ for i = 1:Size;
         else
             data(i).eigval = [];
             data(i).rank = 0;
-        end;
+        end
         dr.eigval = [dr.eigval ; data(i).eigval];
         %First order approximation
         if task ~= 1
             if (maximum_lag > 0)
-                 ghx = - jacob(1 , 1 : n_pred) / jacob(1 , n_pred + n_static + 1 : n_pred + n_static + n_pred + n_both);
+                ghx = - jacob(1 , 1 : n_pred) / jacob(1 , n_pred + n_static + 1 : n_pred + n_static + n_pred + n_both);
             else
-                 ghx = 0;
-            end;
+                ghx = 0;
+            end
             if other_endo_nbr
                 fx = data(i).g1_o;
                 % retrieves the derivatives with respect to endogenous
@@ -269,12 +269,12 @@ for i = 1:Size;
 
                 l_x = dr.ghx(data(i).other_endogenous,:);
                 l_x_sv = dr.ghx(dr.state_var, 1:n_sv);
-                
+
                 selector_tm1 = M_.block_structure.block(i).tm1;
                 ghx_other = - (fx_t * l_x + (fx_tp1 * l_x * l_x_sv) + fx_tm1 * selector_tm1) / jacob(1 , n_pred + 1 : n_pred + n_static + n_pred + n_both);
                 dr.ghx(endo, :) = dr.ghx(endo, :) + ghx_other;
 
-            end;
+            end
             if exo_nbr
                 fu = data(i).g1_x;
                 if other_endo_nbr > 0
@@ -287,21 +287,21 @@ for i = 1:Size;
                     exo = dr.exo_var;
                 else
                     ghu = - fu  / jacob(1 , n_pred + 1 : n_pred + n_static + n_pred + n_both);
-                end;
+                end
             else
-                 if other_endo_nbr > 0
-                     l_u_sv = dr.ghu(dr.state_var,:);
-                     l_x = dr.ghx(data(i).other_endogenous,:);
-                     l_u = dr.ghu(data(i).other_endogenous,:);
-                     ghu = -(fx_tp1 * l_x * l_u_sv + (fx_t) * l_u ) / jacob(1 , n_pred + 1 : n_pred + n_static + n_pred + n_both);
-                     exo = dr.exo_var;
-                 else
-                     ghu = [];
-                 end
+                if other_endo_nbr > 0
+                    l_u_sv = dr.ghu(dr.state_var,:);
+                    l_x = dr.ghx(data(i).other_endogenous,:);
+                    l_u = dr.ghu(data(i).other_endogenous,:);
+                    ghu = -(fx_tp1 * l_x * l_u_sv + (fx_t) * l_u ) / jacob(1 , n_pred + 1 : n_pred + n_static + n_pred + n_both);
+                    exo = dr.exo_var;
+                else
+                    ghu = [];
+                end
             end
         end
       case 4
-      %% ------------------------------------------------------------------
+        %% ------------------------------------------------------------------
         %Solve Backward single equation
         if maximum_lead > 0 && n_fwrd > 0
             data(i).eigval = - jacob(1 , n_pred + n - n_fwrd + 1 : n_pred + n) / jacob(1 , n_pred + n + 1 : n_pred + n + n_fwrd) ;
@@ -311,18 +311,18 @@ for i = 1:Size;
             data(i).eigval = [];
             data(i).rank = 0;
             full_rank = 1;
-        end;
+        end
         dr.full_rank = dr.full_rank && full_rank;
         dr.eigval = [dr.eigval ; data(i).eigval];
       case 6
-      %% ------------------------------------------------------------------
-      %Solve Forward complete
+        %% ------------------------------------------------------------------
+        %Solve Forward complete
         if (maximum_lag > 0)
             ghx = - jacob(: , n_pred + 1 : n_pred + n_static ...
-                        + n_pred + n_both) \ jacob(: , 1 : n_pred);
+                          + n_pred + n_both) \ jacob(: , 1 : n_pred);
         else
             ghx = 0;
-        end;
+        end
         if maximum_lag > 0 && n_pred > 0
             data(i).eigval = -eig(ghx(n_static+1:end,:));
             data(i).rank = 0;
@@ -331,7 +331,7 @@ for i = 1:Size;
             data(i).eigval = [];
             data(i).rank = 0;
             full_rank = 1;
-        end;
+        end
         dr.eigval = [dr.eigval ; data(i).eigval];
         dr.full_rank = dr.full_rank && full_rank;
         if task ~= 1
@@ -354,11 +354,11 @@ for i = 1:Size;
 
                 l_x = dr.ghx(data(i).other_endogenous,:);
                 l_x_sv = dr.ghx(dr.state_var, 1:n_sv);
-                
+
                 selector_tm1 = M_.block_structure.block(i).tm1;
                 ghx_other = - (fx_t * l_x + (fx_tp1 * l_x * l_x_sv) + fx_tm1 * selector_tm1) / jacob(: , n_pred + 1 : n_pred + n_static + n_pred + n_both);
                 dr.ghx(endo, :) = dr.ghx(endo, :) + ghx_other;
-            end;
+            end
             if exo_nbr
                 fu = data(i).g1_x;
                 if other_endo_nbr > 0
@@ -371,21 +371,21 @@ for i = 1:Size;
                     exo = dr.exo_var;
                 else
                     ghu = - fu  / jacob(: , n_pred + 1 : n_pred + n_static + n_pred + n_both);
-                end;
+                end
             else
-                 if other_endo_nbr > 0
-                     l_u_sv = dr.ghu(dr.state_var,:);
-                     l_x = dr.ghx(data(i).other_endogenous,:);
-                     l_u = dr.ghu(data(i).other_endogenous,:);
-                     ghu = -(fx_tp1 * l_x * l_u_sv + (fx_t) * l_u ) / jacob(1 , n_pred + 1 : n_pred + n_static + n_pred + n_both);
-                     exo = dr.exo_var;
-                 else
-                     ghu = [];
-                 end
+                if other_endo_nbr > 0
+                    l_u_sv = dr.ghu(dr.state_var,:);
+                    l_x = dr.ghx(data(i).other_endogenous,:);
+                    l_u = dr.ghu(data(i).other_endogenous,:);
+                    ghu = -(fx_tp1 * l_x * l_u_sv + (fx_t) * l_u ) / jacob(1 , n_pred + 1 : n_pred + n_static + n_pred + n_both);
+                    exo = dr.exo_var;
+                else
+                    ghu = [];
+                end
             end
         end
       case 7
-      %% ------------------------------------------------------------------
+        %% ------------------------------------------------------------------
         %Solve Backward complete
         if maximum_lead > 0 && n_fwrd > 0
             data(i).eigval = eig(- jacob(: , n_pred + n - n_fwrd + 1: n_pred + n))/ ...
@@ -397,14 +397,14 @@ for i = 1:Size;
             data(i).eigval = [];
             data(i).rank = 0;
             full_rank = 1;
-        end;
+        end
         dr.full_rank = dr.full_rank && full_rank;
         dr.eigval = [dr.eigval ; data(i).eigval];
       case {5,8}
-      %% ------------------------------------------------------------------
+        %% ------------------------------------------------------------------
         %The lead_lag_incidence contains columns in the following order:
         %  static variables, backward variable, mixed variables and forward variables
-        %  
+        %
         %Proceeds to a QR decomposition on the jacobian matrix in order to reduce the problem size
         index_c = lead_lag_incidence(2,:);             % Index of all endogenous variables present at time=t
         index_s = lead_lag_incidence(2,1:n_static);    % Index of all static endogenous variables present at time=t
@@ -413,7 +413,7 @@ for i = 1:Size;
             aa = Q'*jacob;
         else
             aa = jacob;
-        end;
+        end
         index_0m = (n_static+1:n_static+n_pred) + indexi_0 - 1;
         index_0p = (n_static+n_pred+1:n) + indexi_0 - 1;
         index_m = 1:(n_pred+n_both);
@@ -435,7 +435,7 @@ for i = 1:Size;
             hx = ghx(1:n_pred+n_both,:);
             gx = ghx(1+n_pred:end,:);
         end
-        
+
         if (task ~= 1 && ((options_.dr_cycle_reduction == 1 && info ==1) || options_.dr_cycle_reduction == 0)) || task == 1
             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) ] ];
@@ -445,7 +445,7 @@ for i = 1:Size;
             if (verbose)
                 disp('eigval');
                 disp(data(i).eigval);
-            end;
+            end
             if info1
                 if info1 == -30
                     % one eigenvalue is close to 0/0
@@ -468,7 +468,7 @@ for i = 1:Size;
                 disp(['sum eigval > 1 = ' int2str(sum(abs(data(i).eigval) > 1.)) ' nyf=' int2str(nyf) ' and dr.rank=' int2str(data(i).rank)]);
                 disp(['data(' int2str(i) ').eigval']);
                 disp(data(i).eigval);
-            end;
+            end
 
             %First order approximation
             if task ~= 1
@@ -483,11 +483,11 @@ for i = 1:Size;
                             nba = nyf;
                         end
                     else
-					    sorted_roots = sort(abs(data(i).eigval));
+                        sorted_roots = sort(abs(data(i).eigval));
                         if nba > nyf
                             temp = sorted_roots(nd-nba+1:nd-nyf)-1-options_.qz_criterium;
                             info(1) = 3;
-                        elseif nba < nyf;
+                        elseif nba < nyf
                             temp = sorted_roots(nd-nyf+1:nd-nba)-1-options_.qz_criterium;
                             info(1) = 4;
                         end
@@ -497,8 +497,8 @@ for i = 1:Size;
                 end
                 indx_stable_root = 1: (nd - nyf);     %=> index of stable roots
                 indx_explosive_root = n_pred + n_both + 1:nd;  %=> index of explosive roots
-                % derivatives with respect to dynamic state variables
-                % forward variables
+                                                               % derivatives with respect to dynamic state variables
+                                                               % forward variables
                 Z = w';
                 Z11t = Z(indx_stable_root,    indx_stable_root)';
                 Z21  = Z(indx_explosive_root, indx_stable_root);
@@ -507,7 +507,7 @@ for i = 1:Size;
                     % condest() fails on a scalar under Octave
                     info(1) = 5;
                     info(2) = condest(Z21);
-                    return;
+                    return
                 else
                     %gx = -inv(Z22) * Z21;
                     gx = - Z22 \ Z21;
@@ -520,20 +520,20 @@ for i = 1:Size;
                 k2 = 1:(n_fwrd+n_both);
 
                 ghx = [hx(k1,:); gx(k2(n_both+1:end),:)];
-            end;
-        end;
-        
-        if  task~= 1 
+            end
+        end
+
+        if  task~= 1
             %lead variables actually present in the model
             j4 = n_static+n_pred+1:n_static+n_pred+n_both+n_fwrd;   % Index on the forward and both variables
             j3 = nonzeros(lead_lag_incidence(2,j4)) - n_static - 2 * n_pred - n_both;  % Index on the non-zeros forward and both variables
-            j4 = find(lead_lag_incidence(2,j4)); 
-            
+            j4 = find(lead_lag_incidence(2,j4));
+
             if n_static > 0
                 B_static = B(:,1:n_static);  % submatrix containing the derivatives w.r. to static variables
             else
                 B_static = [];
-            end;
+            end
             %static variables, backward variable, mixed variables and forward variables
             B_pred = B(:,n_static+1:n_static+n_pred+n_both);
             B_fyd = B(:,n_static+n_pred+n_both+1:end);
@@ -549,16 +549,16 @@ for i = 1:Size;
                 temp = b10\(temp-b11*ghx);
                 ghx = [temp; ghx];
                 temp = [];
-            end;
-            
+            end
+
             A_ = real([B_static C(:,j3)*gx+B_pred B_fyd]); % The state_variable of the block are located at [B_pred B_both]
-            
+
             if other_endo_nbr
                 if n_static > 0
-                     fx = Q' * data(i).g1_o;
+                    fx = Q' * data(i).g1_o;
                 else
                     fx = data(i).g1_o;
-                end;
+                end
                 % retrieves the derivatives with respect to endogenous
                 % variable belonging to previous blocks
                 fx_tm1 = zeros(n,other_endo_nbr);
@@ -575,10 +575,10 @@ for i = 1:Size;
                 fx_tp1(:,c) = fx(:,lead);
 
                 l_x = dr.ghx(data(i).other_endogenous,:);
-                
+
                 l_x_sv = dr.ghx(dr.state_var, :);
-                
-                selector_tm1 = M_.block_structure.block(i).tm1; 
+
+                selector_tm1 = M_.block_structure.block(i).tm1;
 
                 B_ = [zeros(size(B_static)) zeros(n,n_pred) C(:,j3) ];
                 C_ = l_x_sv;
@@ -590,23 +590,23 @@ for i = 1:Size;
                     ghx_other = reshape(vghx_other, size(D_,1), size(D_,2));
                 elseif options_.sylvester_fp == 1
                     ghx_other = gensylv_fp(A_, B_, C_, D_, i, options_.sylvester_fixed_point_tol);
-                else 
+                else
                     [err, ghx_other] = gensylv(1, A_, B_, C_, -D_);
-                end;
-                if options_.aim_solver ~= 1 && options_.use_qzdiv
-                   % Necessary when using Sims' routines for QZ
-                   ghx_other = real(ghx_other);
                 end
-                
+                if options_.aim_solver ~= 1 && options_.use_qzdiv
+                    % Necessary when using Sims' routines for QZ
+                    ghx_other = real(ghx_other);
+                end
+
                 dr.ghx(endo, :) = dr.ghx(endo, :) + ghx_other;
-            end;
+            end
 
             if exo_nbr
                 if n_static > 0
                     fu = Q' * data(i).g1_x;
                 else
                     fu = data(i).g1_x;
-                end;
+                end
 
                 if other_endo_nbr > 0
                     l_u_sv = dr.ghu(dr.state_var,:);
@@ -616,12 +616,12 @@ for i = 1:Size;
                     fu_complet(:,data(i).exogenous) = fu;
                     % Solve the equation in ghu:
                     % A_ * ghu + (fu_complet + fx_tp1 * l_x * l_u_sv + (fx_t + B_ * ghx_other) * l_u ) = 0
-                    
+
                     ghu = -A_\ (fu_complet + fx_tp1 * l_x * l_u_sv + fx_t * l_u + B_ * ghx_other  * l_u_sv  );
                     exo = dr.exo_var;
                 else
                     ghu = - A_ \ fu;
-                end;
+                end
             else
                 if other_endo_nbr > 0
                     l_u_sv = dr.ghu(dr.state_var,:);
@@ -633,20 +633,20 @@ for i = 1:Size;
                     exo = dr.exo_var;
                 else
                     ghu = [];
-                end;
+                end
             end
 
 
-            
+
             if options_.loglinear
                 error('The loglinear option is not yet supported in first order approximation for a block decomposed model');
-%                 k = find(dr.kstate(:,2) <= M_.maximum_endo_lag+1);
-%                 klag = dr.kstate(k,[1 2]);
-%                 k1 = dr.order_var;
-%                 
-%                 ghx = repmat(1./dr.ys(k1),1,size(ghx,2)).*ghx.* ...
-%                       repmat(dr.ys(k1(klag(:,1)))',size(ghx,1),1);
-%                 ghu = repmat(1./dr.ys(k1),1,size(ghu,2)).*ghu;
+                %                 k = find(dr.kstate(:,2) <= M_.maximum_endo_lag+1);
+                %                 klag = dr.kstate(k,[1 2]);
+                %                 k1 = dr.order_var;
+                %
+                %                 ghx = repmat(1./dr.ys(k1),1,size(ghx,2)).*ghx.* ...
+                %                       repmat(dr.ys(k1(klag(:,1)))',size(ghx,1),1);
+                %                 ghu = repmat(1./dr.ys(k1),1,size(ghu,2)).*ghu;
             end
 
 
@@ -659,19 +659,19 @@ for i = 1:Size;
             %exogenous deterministic variables
             if exo_det_nbr > 0
                 error('Deterministic exogenous variables are not yet implemented in first order approximation for a block decomposed model');
-%                 f1 = sparse(jacobia_(:,nonzeros(M_.lead_lag_incidence(M_.maximum_endo_lag+2:end,order_var))));
-%                 f0 = sparse(jacobia_(:,nonzeros(M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var))));
-%                 fudet = data(i).g1_xd;
-%                 M1 = inv(f0+[zeros(n,n_static) f1*gx zeros(n,nyf-n_both)]);
-%                 M2 = M1*f1;
-%                 dr.ghud = cell(M_.exo_det_length,1);
-%                 dr.ghud{1} = -M1*fudet;
-%                 for i = 2:M_.exo_det_length
-%                     dr.ghud{i} = -M2*dr.ghud{i-1}(end-nyf+1:end,:);
-%                 end
+                %                 f1 = sparse(jacobia_(:,nonzeros(M_.lead_lag_incidence(M_.maximum_endo_lag+2:end,order_var))));
+                %                 f0 = sparse(jacobia_(:,nonzeros(M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var))));
+                %                 fudet = data(i).g1_xd;
+                %                 M1 = inv(f0+[zeros(n,n_static) f1*gx zeros(n,nyf-n_both)]);
+                %                 M2 = M1*f1;
+                %                 dr.ghud = cell(M_.exo_det_length,1);
+                %                 dr.ghud{1} = -M1*fudet;
+                %                 for i = 2:M_.exo_det_length
+                %                     dr.ghud{i} = -M2*dr.ghud{i-1}(end-nyf+1:end,:);
+                %                 end
             end
         end
-    end;
+    end
     if task ~=1
         if (maximum_lag > 0 && (n_pred > 0 || n_both > 0))
             sorted_col_dr_ghx = M_.block_structure.block(i).sorted_col_dr_ghx;
@@ -680,27 +680,27 @@ for i = 1:Size;
             data(i).pol.i_ghx = sorted_col_dr_ghx;
         else
             data(i).pol.i_ghx = [];
-        end;
+        end
         data(i).ghu = ghu;
         dr.ghu(endo, exo) = ghu;
         data(i).pol.i_ghu = exo;
-    end;
-    
-   if (verbose)
+    end
+
+    if (verbose)
         disp('dr.ghx');
         dr.ghx
         disp('dr.ghu');
         dr.ghu
-   end; 
-   
-end;
+    end
+
+end
 M_.block_structure.block = data ;
 if (verbose)
-        disp('dr.ghx');
-        disp(real(dr.ghx));
-        disp('dr.ghu');
-        disp(real(dr.ghu));
-end; 
+    disp('dr.ghx');
+    disp(real(dr.ghx));
+    disp('dr.ghu');
+    disp(real(dr.ghu));
+end
 if (task == 1)
-    return;
-end;
+    return
+end
diff --git a/matlab/draw_prior_density.m b/matlab/draw_prior_density.m
index 23479b404..94f32ac88 100644
--- a/matlab/draw_prior_density.m
+++ b/matlab/draw_prior_density.m
@@ -1,20 +1,20 @@
-function [x,f,abscissa,dens,binf,bsup] = draw_prior_density(indx,bayestopt_);
+function [x,f,abscissa,dens,binf,bsup] = draw_prior_density(indx,bayestopt_)
 % Computes values of prior densities at many points (before plotting)
 %
 % INPUTS
 %    indx          [integer]    Parameter number.
 %    bayestopt_    [structure]  Describes the prior beliefs.
-%    
+%
 % OUTPUTS
 %    x             [double]     Row vector, subset of 'abscissa' such as the density is less than 10
 %    f             [double]     Row vector, subset of 'dens' such as the density is less than 10
-%    abscissa      [double]     Row vector, abscissa 
+%    abscissa      [double]     Row vector, abscissa
 %    dens          [double]     Row vector, density
 %    binf:         [double]     Scalar, first element of x
 %    bsup:         [double]     Scalar, last element of x
 
 
-% Copyright (C) 2004-2011 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -63,10 +63,10 @@ switch pshape(indx)
     abscissa = linspace(infbound,supbound,steps);
     dens = density(abscissa,p6(indx),p7(indx),p3(indx));
   case 3% Gaussian prior
-    infbound = norminv(truncprior,p6(indx),p7(indx)); 
+    infbound = norminv(truncprior,p6(indx),p7(indx));
     supbound = norminv(1-truncprior,p6(indx),p7(indx));
     abscissa = linspace(infbound,supbound,steps);
-    dens = normpdf(abscissa,p6(indx),p7(indx));  
+    dens = normpdf(abscissa,p6(indx),p7(indx));
   case 4% Inverse-gamma of type 1 prior
     try
         infbound = 1/sqrt(gaminv(1-10*truncprior, p7(indx)/2, 2/p6(indx)))+p3(indx);
@@ -80,7 +80,7 @@ switch pshape(indx)
         end
     end
     abscissa = linspace(infbound,supbound,steps);
-    dens = exp(lpdfig1(abscissa-p3(indx),p6(indx),p7(indx)));  
+    dens = exp(lpdfig1(abscissa-p3(indx),p6(indx),p7(indx)));
   case 5% Uniform prior
     infbound = p6(indx);
     supbound = p7(indx);
@@ -108,9 +108,9 @@ switch pshape(indx)
     dens = density(abscissa,p6(indx),p7(indx),p3(indx));
   otherwise
     error(sprintf('draw_prior_density: unknown distribution shape (index %d, type %d)', indx, pshape(indx)));
-end 
+end
 
-if pshape(indx) ~= 5 
+if pshape(indx) ~= 5
     [junk,k1] = max(dens);
     if k1 == 1 || k1 == length(dens)
         k = find(dens > 10);
diff --git a/matlab/dsample.m b/matlab/dsample.m
index 2e7251ac1..945c0fd86 100644
--- a/matlab/dsample.m
+++ b/matlab/dsample.m
@@ -1,21 +1,21 @@
 function dsample(s1,s2)
 % function dsample(s1,s2)
 % This optional command permits to reduce the number of periods considered in following output commands.
-% If only one argument is provided, output is from period 1 to the period specified in the DSAMPLE command. 
+% If only one argument is provided, output is from period 1 to the period specified in the DSAMPLE command.
 % If two arguments are present output is done for the interval between the two periods.
 % DSAMPLE without arguments reset the sample to the one specified by PERIODS
 %
 % INPUTS
 %    s1:      first period
 %    s2:      last period
-%    
+%
 % OUTPUTS
 %    none
-%    
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/dsge_likelihood.m b/matlab/dsge_likelihood.m
index d911adc6e..0b62e5167 100644
--- a/matlab/dsge_likelihood.m
+++ b/matlab/dsge_likelihood.m
@@ -115,7 +115,7 @@ function [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff,Model,DynareOpti
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -149,7 +149,7 @@ xparam1 = xparam1(:);
 if DynareOptions.estimation_dll
     [fval,exit_flag,SteadyState,trend_coeff,info,params,H,Q] ...
         = logposterior(xparam1,DynareDataset, DynareOptions,Model, ...
-                          EstimatedParameters,BayesInfo,DynareResults);
+                       EstimatedParameters,BayesInfo,DynareResults);
     mexErrCheck('logposterior', exit_flag);
     Model.params = params;
     if ~isequal(Model.H,0)
@@ -167,11 +167,11 @@ if analytic_derivation && DynareOptions.loglinear
     error('The analytic_derivation and loglinear options are not compatible')
 end
 
-if nargout==1,
+if nargout==1
     analytic_derivation=0;
 end
 
-if analytic_derivation,
+if analytic_derivation
     kron_flag=DynareOptions.analytic_derivation_mode;
 end
 
@@ -180,26 +180,26 @@ end
 %------------------------------------------------------------------------------
 
 % Return, with endogenous penalty, if some parameters are smaller than the lower bound of the prior domain.
-if ~isequal(DynareOptions.mode_compute,1) && any(xparam1<BoundsInfo.lb)
+if isestimation(DynareOptions) && ~isequal(DynareOptions.mode_compute,1) && any(xparam1<BoundsInfo.lb)
     k = find(xparam1<BoundsInfo.lb);
     fval = Inf;
     exit_flag = 0;
     info(1) = 41;
     info(4)= sum((BoundsInfo.lb(k)-xparam1(k)).^2);
-    if analytic_derivation,
+    if analytic_derivation
         DLIK=ones(length(xparam1),1);
     end
     return
 end
 
 % Return, with endogenous penalty, if some parameters are greater than the upper bound of the prior domain.
-if ~isequal(DynareOptions.mode_compute,1) && any(xparam1>BoundsInfo.ub)
+if isestimation(DynareOptions) && ~isequal(DynareOptions.mode_compute,1) && any(xparam1>BoundsInfo.ub)
     k = find(xparam1>BoundsInfo.ub);
     fval = Inf;
     exit_flag = 0;
     info(1) = 42;
     info(4)= sum((xparam1(k)-BoundsInfo.ub(k)).^2);
-    if analytic_derivation,
+    if analytic_derivation
         DLIK=ones(length(xparam1),1);
     end
     return
@@ -268,41 +268,38 @@ end
 % Return, with endogenous penalty when possible, if dynare_resolve issues an error code (defined in resol).
 if info(1)
     if info(1) == 3 || info(1) == 4 || info(1) == 5 || info(1)==6 ||info(1) == 19 ||...
-            info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
-            info(1) == 81 || info(1) == 84 ||  info(1) == 85 ||  info(1) == 86
+                info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
+                info(1) == 81 || info(1) == 84 ||  info(1) == 85 ||  info(1) == 86
         %meaningful second entry of output that can be used
         fval = Inf;
         info(4) = info(2);
         exit_flag = 0;
-        if analytic_derivation,
+        if analytic_derivation
             DLIK=ones(length(xparam1),1);
         end
-        
         return
     else
         fval = Inf;
         info(4) = 0.1;
         exit_flag = 0;
-        if analytic_derivation,
+        if analytic_derivation
             DLIK=ones(length(xparam1),1);
         end
-        
         return
     end
 end
 
 % check endogenous prior restrictions
 info=endogenous_prior_restrictions(T,R,Model,DynareOptions,DynareResults);
-if info(1),
+if info(1)
     fval = Inf;
     info(4)=info(2);
     exit_flag = 0;
-    if analytic_derivation,
+    if analytic_derivation
         DLIK=ones(length(xparam1),1);
     end
     return
 end
-%
 
 % Define a vector of indices for the observed variables. Is this really usefull?...
 BayesInfo.mf = BayesInfo.mf1;
@@ -323,8 +320,8 @@ if BayesInfo.with_trend
     [trend_addition, trend_coeff]=compute_trend_coefficients(Model,DynareOptions,DynareDataset.vobs,DynareDataset.nobs);
     trend = repmat(constant,1,DynareDataset.nobs)+trend_addition;
 else
-   trend_coeff = zeros(DynareDataset.vobs,1);
-   trend = repmat(constant,1,DynareDataset.nobs);
+    trend_coeff = zeros(DynareDataset.vobs,1);
+    trend = repmat(constant,1,DynareDataset.nobs);
 end
 
 % Get needed informations for kalman filter routines.
@@ -372,8 +369,8 @@ switch DynareOptions.lik_init
     if kalman_algo == 0
         kalman_algo = 3;
     elseif ~((kalman_algo == 3) || (kalman_algo == 4))
-            error(['The model requires Diffuse filter, but you specified a different Kalman filter. You must set options_.kalman_algo ' ...
-                   'to 0 (default), 3 or 4'])
+        error(['The model requires Diffuse filter, but you specified a different Kalman filter. You must set options_.kalman_algo ' ...
+               'to 0 (default), 3 or 4'])
     end
     [Pstar,Pinf] = compute_Pinf_Pstar(Z,T,R,Q,DynareOptions.qz_criterium,[1:length(T)]);
     Z =zeros(length(BayesInfo.mf),size(T,1));
@@ -387,9 +384,9 @@ switch DynareOptions.lik_init
         Pstar0 = Pstar; % store Pstar
         if no_missing_data_flag
             [dLIK,dlik,a,Pstar] = kalman_filter_d(Y, 1, size(Y,2), ...
-                                                       zeros(mm,1), Pinf, Pstar, ...
-                                                       kalman_tol, diffuse_kalman_tol, riccati_tol, DynareOptions.presample, ...
-                                                       T,R,Q,H,Z,mm,pp,rr);
+                                                  zeros(mm,1), Pinf, Pstar, ...
+                                                  kalman_tol, diffuse_kalman_tol, riccati_tol, DynareOptions.presample, ...
+                                                  T,R,Q,H,Z,mm,pp,rr);
         else
             [dLIK,dlik,a,Pstar] = missing_observations_kalman_filter_d(DatasetInfo.missing.aindex,DatasetInfo.missing.number_of_observations,DatasetInfo.missing.no_more_missing_observations, ...
                                                               Y, 1, size(Y,2), ...
@@ -433,27 +430,27 @@ switch DynareOptions.lik_init
                 Pinf  = blkdiag(Pinf,zeros(pp));
                 H1 = zeros(pp,1);
                 mmm   = mm+pp;
-                
+
             end
         end
 
         [dLIK,dlik,a,Pstar] = univariate_kalman_filter_d(DatasetInfo.missing.aindex,...
-                                                        DatasetInfo.missing.number_of_observations,...
-                                                        DatasetInfo.missing.no_more_missing_observations, ...
-                                                        Y, 1, size(Y,2), ...
-                                                        zeros(mmm,1), Pinf, Pstar, ...
-                                                        kalman_tol, diffuse_kalman_tol, riccati_tol, DynareOptions.presample, ...
-                                                        T,R,Q,H1,Z,mmm,pp,rr);
+                                                         DatasetInfo.missing.number_of_observations,...
+                                                         DatasetInfo.missing.no_more_missing_observations, ...
+                                                         Y, 1, size(Y,2), ...
+                                                         zeros(mmm,1), Pinf, Pstar, ...
+                                                         kalman_tol, diffuse_kalman_tol, riccati_tol, DynareOptions.presample, ...
+                                                         T,R,Q,H1,Z,mmm,pp,rr);
         diffuse_periods = size(dlik,1);
     end
-    if isnan(dLIK),
+    if isnan(dLIK)
         fval = Inf;
         info(1) = 45;
         info(4) = 0.1;
         exit_flag = 0;
         return
     end
-    
+
   case 4% Start from the solution of the Riccati equation.
     if kalman_algo ~= 2
         kalman_algo = 1;
@@ -495,20 +492,19 @@ switch DynareOptions.lik_init
     error('dsge_likelihood:: Unknown initialization approach for the Kalman filter!')
 end
 
-if analytic_derivation,
+if analytic_derivation
     offset = EstimatedParameters.nvx;
     offset = offset+EstimatedParameters.nvn;
     offset = offset+EstimatedParameters.ncx;
     offset = offset+EstimatedParameters.ncn;
-
     no_DLIK = 0;
     full_Hess = analytic_derivation==2;
     asy_Hess = analytic_derivation==-2;
     outer_product_gradient = analytic_derivation==-1;
-    if asy_Hess,
+    if asy_Hess
         analytic_derivation=1;
     end
-    if outer_product_gradient,
+    if outer_product_gradient
         analytic_derivation=1;
     end
     DLIK = [];
@@ -526,8 +522,7 @@ if analytic_derivation,
         else
             indparam=[];
         end
-
-        if full_Hess,
+        if full_Hess
             [dum, DT, DOm, DYss, dum2, D2T, D2Om, D2Yss] = getH(A, B, EstimatedParameters, Model,DynareResults,DynareOptions,kron_flag,indparam,indexo,iv);
             clear dum dum2;
         else
@@ -537,15 +532,15 @@ if analytic_derivation,
         DT = derivatives_info.DT(iv,iv,:);
         DOm = derivatives_info.DOm(iv,iv,:);
         DYss = derivatives_info.DYss(iv,:);
-        if isfield(derivatives_info,'full_Hess'),
+        if isfield(derivatives_info,'full_Hess')
             full_Hess = derivatives_info.full_Hess;
         end
-        if full_Hess,
-        D2T = derivatives_info.D2T;
-        D2Om = derivatives_info.D2Om;
-        D2Yss = derivatives_info.D2Yss;
+        if full_Hess
+            D2T = derivatives_info.D2T;
+            D2Om = derivatives_info.D2Om;
+            D2Yss = derivatives_info.D2Yss;
         end
-        if isfield(derivatives_info,'no_DLIK'),
+        if isfield(derivatives_info,'no_DLIK')
             no_DLIK = derivatives_info.no_DLIK;
         end
         clear('derivatives_info');
@@ -554,73 +549,73 @@ if analytic_derivation,
     DH=zeros([length(H),length(H),length(xparam1)]);
     DQ=zeros([size(Q),length(xparam1)]);
     DP=zeros([size(T),length(xparam1)]);
-    if full_Hess,
-        for j=1:size(D2Yss,1),
-        tmp(j,:,:) = blkdiag(zeros(offset,offset), squeeze(D2Yss(j,:,:)));
+    if full_Hess
+        for j=1:size(D2Yss,1)
+            tmp(j,:,:) = blkdiag(zeros(offset,offset), squeeze(D2Yss(j,:,:)));
         end
         D2Yss = tmp;
         D2H=sparse(size(D2Om,1),size(D2Om,2)); %zeros([size(H),length(xparam1),length(xparam1)]);
         D2P=sparse(size(D2Om,1),size(D2Om,2)); %zeros([size(T),length(xparam1),length(xparam1)]);
         jcount=0;
     end
-    if DynareOptions.lik_init==1,
-    for i=1:EstimatedParameters.nvx
-        k =EstimatedParameters.var_exo(i,1);
-        DQ(k,k,i) = 2*sqrt(Q(k,k));
-        dum =  lyapunov_symm(T,DOm(:,:,i),DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
-%         kk = find(abs(dum) < 1e-12);
-%         dum(kk) = 0;
-        DP(:,:,i)=dum;
-        if full_Hess
-        for j=1:i,
-            jcount=jcount+1;
-            dum =  lyapunov_symm(T,dyn_unvech(D2Om(:,jcount)),DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
-%             kk = (abs(dum) < 1e-12);
-%             dum(kk) = 0;
-            D2P(:,jcount)=dyn_vech(dum);
-%             D2P(:,:,j,i)=dum;
+    if DynareOptions.lik_init==1
+        for i=1:EstimatedParameters.nvx
+            k =EstimatedParameters.var_exo(i,1);
+            DQ(k,k,i) = 2*sqrt(Q(k,k));
+            dum =  lyapunov_symm(T,DOm(:,:,i),DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
+            %         kk = find(abs(dum) < 1e-12);
+            %         dum(kk) = 0;
+            DP(:,:,i)=dum;
+            if full_Hess
+                for j=1:i
+                    jcount=jcount+1;
+                    dum =  lyapunov_symm(T,dyn_unvech(D2Om(:,jcount)),DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
+                    %             kk = (abs(dum) < 1e-12);
+                    %             dum(kk) = 0;
+                    D2P(:,jcount)=dyn_vech(dum);
+                    %             D2P(:,:,j,i)=dum;
+                end
+            end
         end
-        end
-    end
     end
     offset = EstimatedParameters.nvx;
     for i=1:EstimatedParameters.nvn
         k = EstimatedParameters.var_endo(i,1);
         DH(k,k,i+offset) = 2*sqrt(H(k,k));
         if full_Hess
-        D2H(k,k,i+offset,i+offset) = 2;
+            D2H(k,k,i+offset,i+offset) = 2;
         end
     end
     offset = offset + EstimatedParameters.nvn;
-    if DynareOptions.lik_init==1,
-    for j=1:EstimatedParameters.np
-        dum =  lyapunov_symm(T,DT(:,:,j+offset)*Pstar*T'+T*Pstar*DT(:,:,j+offset)'+DOm(:,:,j+offset),DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
-%         kk = find(abs(dum) < 1e-12);
-%         dum(kk) = 0;
-        DP(:,:,j+offset)=dum;
-        if full_Hess
-        DTj = DT(:,:,j+offset);
-        DPj = dum;
-        for i=1:j+offset,
-            jcount=jcount+1;
-            DTi = DT(:,:,i);
-            DPi = DP(:,:,i);
-            D2Tij = reshape(D2T(:,jcount),size(T));
-            D2Omij = dyn_unvech(D2Om(:,jcount));
-            tmp = D2Tij*Pstar*T' + T*Pstar*D2Tij' + DTi*DPj*T' + DTj*DPi*T' + T*DPj*DTi' + T*DPi*DTj' + DTi*Pstar*DTj' + DTj*Pstar*DTi' + D2Omij;
-            dum = lyapunov_symm(T,tmp,DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
-%             dum(abs(dum)<1.e-12) = 0;
-            D2P(:,jcount) = dyn_vech(dum);
-%             D2P(:,:,j+offset,i) = dum;
-        end
+    if DynareOptions.lik_init==1
+        for j=1:EstimatedParameters.np
+            dum =  lyapunov_symm(T,DT(:,:,j+offset)*Pstar*T'+T*Pstar*DT(:,:,j+offset)'+DOm(:,:,j+offset),DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
+            %         kk = find(abs(dum) < 1e-12);
+            %         dum(kk) = 0;
+            DP(:,:,j+offset)=dum;
+            if full_Hess
+                DTj = DT(:,:,j+offset);
+                DPj = dum;
+                for i=1:j+offset
+                    jcount=jcount+1;
+                    DTi = DT(:,:,i);
+                    DPi = DP(:,:,i);
+                    D2Tij = reshape(D2T(:,jcount),size(T));
+                    D2Omij = dyn_unvech(D2Om(:,jcount));
+                    tmp = D2Tij*Pstar*T' + T*Pstar*D2Tij' + DTi*DPj*T' + DTj*DPi*T' + T*DPj*DTi' + T*DPi*DTj' + DTi*Pstar*DTj' + DTj*Pstar*DTi' + D2Omij;
+                    dum = lyapunov_symm(T,tmp,DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold,[],DynareOptions.debug);
+                    %             dum(abs(dum)<1.e-12) = 0;
+                    D2P(:,jcount) = dyn_vech(dum);
+                    %             D2P(:,:,j+offset,i) = dum;
+                end
+            end
         end
     end
-    end
-    if analytic_derivation==1,
+    if analytic_derivation==1
         analytic_deriv_info={analytic_derivation,DT,DYss,DOm,DH,DP,asy_Hess};
     else
         analytic_deriv_info={analytic_derivation,DT,DYss,DOm,DH,DP,D2T,D2Yss,D2Om,D2H,D2P};
-        clear DT DYss DOm DP D2T D2Yss D2Om D2H D2P,
+        clear DT DYss DOm DP D2T D2Yss D2Om D2H D2P
     end
 else
     analytic_deriv_info={0};
@@ -645,10 +640,9 @@ if ((kalman_algo==1) || (kalman_algo==3))% Multivariate Kalman Filter
                 fval = Inf;
                 info(1) = 55;
                 info(4) = 0.1;
-                exit_flag = 0; 
+                exit_flag = 0;
                 return
             end
-
             [LIK,lik] = kalman_filter_fast(Y,diffuse_periods+1,size(Y,2), ...
                                            a,Pstar, ...
                                            kalman_tol, riccati_tol, ...
@@ -659,6 +653,7 @@ if ((kalman_algo==1) || (kalman_algo==3))% Multivariate Kalman Filter
             [LIK,lik] = kalman_filter(Y,diffuse_periods+1,size(Y,2), ...
                                       a,Pstar, ...
                                       kalman_tol, riccati_tol, ...
+                                      DynareOptions.rescale_prediction_error_covariance, ...
                                       DynareOptions.presample, ...
                                       T,Q,R,H,Z,mm,pp,rr,Zflag,diffuse_periods, ...
                                       analytic_deriv_info{:});
@@ -671,11 +666,12 @@ if ((kalman_algo==1) || (kalman_algo==3))% Multivariate Kalman Filter
             [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, ...
                                                            kalman_tol, DynareOptions.riccati_tol, ...
+                                                           DynareOptions.rescale_prediction_error_covariance, ...
                                                            DynareOptions.presample, ...
                                                            T,Q,R,H,Z,mm,pp,rr,Zflag,diffuse_periods);
         end
     end
-    if analytic_derivation,
+    if analytic_derivation
         LIK1=LIK;
         LIK=LIK1{1};
         lik1=lik;
@@ -699,8 +695,8 @@ if ((kalman_algo==1) || (kalman_algo==3))% Multivariate Kalman Filter
     else
         if DynareOptions.lik_init==3
             LIK = LIK + dLIK;
-            if analytic_derivation==0 && nargout>3,
-                if ~singular_diffuse_filter,
+            if analytic_derivation==0 && nargout>3
+                if ~singular_diffuse_filter
                     lik = [dlik; lik];
                 else
                     lik = [sum(dlik,2); lik];
@@ -716,7 +712,7 @@ if (kalman_algo==2) || (kalman_algo==4)
     if isequal(H,0)
         H1 = zeros(pp,1);
         mmm = mm;
-        if analytic_derivation,
+        if analytic_derivation
             DH = zeros(pp,length(xparam1));
         end
     else
@@ -724,8 +720,8 @@ if (kalman_algo==2) || (kalman_algo==4)
             H1 = diag(H);
             mmm = mm;
             clear('tmp')
-            if analytic_derivation,
-                for j=1:pp,
+            if analytic_derivation
+                for j=1:pp
                     tmp(j,:)=DH(j,j,:);
                 end
                 DH=tmp;
@@ -750,21 +746,20 @@ if (kalman_algo==2) || (kalman_algo==4)
             if singularity_has_been_detected
                 a = zeros(mmm,1);
             elseif ~expanded_state_vector_for_univariate_filter
-                a = [a; zeros(pp,1)];                
+                a = [a; zeros(pp,1)];
             end
         end
     end
-    if analytic_derivation,
+    if analytic_derivation
         analytic_deriv_info{5}=DH;
     end
-
     [LIK, lik] = univariate_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, ...
                                           DynareOptions.kalman_tol, ...
                                           DynareOptions.riccati_tol, ...
                                           DynareOptions.presample, ...
                                           T,Q,R,H1,Z,mmm,pp,rr,Zflag,diffuse_periods,analytic_deriv_info{:});
-    if analytic_derivation,
+    if analytic_derivation
         LIK1=LIK;
         LIK=LIK1{1};
         lik1=lik;
@@ -772,7 +767,7 @@ if (kalman_algo==2) || (kalman_algo==4)
     end
     if DynareOptions.lik_init==3
         LIK = LIK+dLIK;
-        if analytic_derivation==0 && nargout>3,
+        if analytic_derivation==0 && nargout>3
             lik = [dlik; lik];
         end
     end
@@ -783,12 +778,12 @@ if analytic_derivation
         DLIK = LIK1{2};
         %                 [DLIK] = score(T,R,Q,H,Pstar,Y,DT,DYss,DOm,DH,DP,start,Z,kalman_tol,riccati_tol);
     end
-    if full_Hess ,
+    if full_Hess
         Hess = -LIK1{3};
         %                     [Hess, DLL] = get_Hessian(T,R,Q,H,Pstar,Y,DT,DYss,DOm,DH,DP,D2T,D2Yss,D2Om,D2H,D2P,start,Z,kalman_tol,riccati_tol);
         %                     Hess0 = getHessian(Y,T,DT,D2T, R*Q*transpose(R),DOm,D2Om,Z,DYss,D2Yss);
     end
-    if asy_Hess,
+    if asy_Hess
         %         if ~((kalman_algo==2) || (kalman_algo==4)),
         %             [Hess] = AHessian(T,R,Q,H,Pstar,Y,DT,DYss,DOm,DH,DP,start,Z,kalman_tol,riccati_tol);
         %         else
@@ -827,7 +822,7 @@ likelihood = LIK;
 % 5. Adds prior if necessary
 % ------------------------------------------------------------------------------
 if analytic_derivation
-    if full_Hess,
+    if full_Hess
         [lnprior, dlnprior, d2lnprior] = priordens(xparam1,BayesInfo.pshape,BayesInfo.p6,BayesInfo.p7,BayesInfo.p3,BayesInfo.p4);
         Hess = Hess - d2lnprior;
     else
@@ -836,7 +831,7 @@ if analytic_derivation
     if no_DLIK==0
         DLIK = DLIK - dlnprior';
     end
-    if outer_product_gradient,
+    if outer_product_gradient
         dlik = lik1{2};
         dlik=[- dlnprior; dlik(start:end,:)];
         Hess = dlik'*dlik;
@@ -846,14 +841,14 @@ else
 end
 
 if DynareOptions.endogenous_prior==1
-  if DynareOptions.lik_init==2 || DynareOptions.lik_init==3
-    error('Endogenous prior not supported with non-stationary models')
-  else
-    [lnpriormom]  = endogenous_prior(Y,Pstar,BayesInfo,H);
-    fval    = (likelihood-lnprior-lnpriormom);
-  end
+    if DynareOptions.lik_init==2 || DynareOptions.lik_init==3
+        error('Endogenous prior not supported with non-stationary models')
+    else
+        [lnpriormom]  = endogenous_prior(Y,Pstar,BayesInfo,H);
+        fval    = (likelihood-lnprior-lnpriormom);
+    end
 else
-  fval    = (likelihood-lnprior);
+    fval    = (likelihood-lnprior);
 end
 
 if DynareOptions.prior_restrictions.status
@@ -882,7 +877,7 @@ if ~DynareOptions.kalman.keep_kalman_algo_if_singularity_is_detected
     DynareOptions.kalman_algo = kalman_algo;
 end
 
-if analytic_derivation==0 && nargout>3,
+if analytic_derivation==0 && nargout>3
     lik=lik(start:end,:);
     DLIK=[-lnprior; lik(:)];
-end
\ No newline at end of file
+end
diff --git a/matlab/dsge_simulated_theoretical_correlation.m b/matlab/dsge_simulated_theoretical_correlation.m
index 265336dbb..ae141905b 100644
--- a/matlab/dsge_simulated_theoretical_correlation.m
+++ b/matlab/dsge_simulated_theoretical_correlation.m
@@ -16,8 +16,8 @@ function [nvar,vartan,CorrFileNumber] = dsge_simulated_theoretical_correlation(S
 %   nvar           [integer]        nvar is the number of stationary variables.
 %   vartan         [char]           array of characters (with nvar rows).
 %   CorrFileNumber [integer]        scalar, number of prior or posterior data files (for correlation).
- 
-% Copyright (C) 2007-2015 Dynare Team
+
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -126,7 +126,7 @@ for file = 1:NumberOfDrawsFiles
                 Correlation_array = zeros(NumberOfLinesInTheLastCorrFile,nvar,nvar,nar);
                 NumberOfCorrLines = NumberOfLinesInTheLastCorrFile;
                 CorrFileNumber = CorrFileNumber - 1;
-            elseif test<0;
+            elseif test<0
                 Correlation_array = zeros(MaXNumberOfCorrLines,nvar,nvar,nar);
             else
                 clear('Correlation_array');
diff --git a/matlab/dsge_simulated_theoretical_covariance.m b/matlab/dsge_simulated_theoretical_covariance.m
index 38ef7c3b6..304028ba5 100644
--- a/matlab/dsge_simulated_theoretical_covariance.m
+++ b/matlab/dsge_simulated_theoretical_covariance.m
@@ -16,7 +16,7 @@ function [nvar,vartan,CovarFileNumber] = dsge_simulated_theoretical_covariance(S
 %   vartan            [char]     array of characters (with nvar rows).
 %   CovarFileNumber   [integer]  scalar, number of prior or posterior data files (for covariance).
 
-% Copyright (C) 2007-2015 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -126,7 +126,6 @@ for file = 1:NumberOfDrawsFiles
             if ~test% Prepare the last round...
                 Covariance_matrix = zeros(NumberOfLinesInTheLastCovarFile,nvar*(nvar+1)/2);
                 NumberOfCovarLines = NumberOfLinesInTheLastCovarFile;
-                CovarFileNumber = CovarFileNumber - 1;
             elseif test<0
                 Covariance_matrix = zeros(MaXNumberOfCovarLines,nvar*(nvar+1)/2);
             else
diff --git a/matlab/dsge_simulated_theoretical_variance_decomposition.m b/matlab/dsge_simulated_theoretical_variance_decomposition.m
index a8ddadec6..9eb985174 100644
--- a/matlab/dsge_simulated_theoretical_variance_decomposition.m
+++ b/matlab/dsge_simulated_theoretical_variance_decomposition.m
@@ -18,7 +18,7 @@ function [nvar,vartan,NumberOfDecompFiles] = ...
 %   vartan            [char]     array of characters (with nvar rows).
 %   CovarFileNumber   [integer]  scalar, number of prior or posterior data files (for covariance).
 
-% Copyright (C) 2007-2015 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -119,17 +119,17 @@ for file = 1:NumberOfDrawsFiles
         if file==1 && linee==1
             [tmp, stationary_vars] = th_autocovariances(dr,ivar,M_,options_,nodecomposition);
             if isempty(stationary_vars)
-              fprintf('\ndsge_simulated_theoretical_variance_decomposition:: All requested endogenous variables have a unit root and thus infinite variance.\n')
-              fprintf('dsge_simulated_theoretical_variance_decomposition:: No decomposition is performed.\n')
-              only_non_stationary_vars=1; 
+                fprintf('\ndsge_simulated_theoretical_variance_decomposition:: All requested endogenous variables have a unit root and thus infinite variance.\n')
+                fprintf('dsge_simulated_theoretical_variance_decomposition:: No decomposition is performed.\n')
+                only_non_stationary_vars=1;
             end
         end
         if only_non_stationary_vars
-           for i=1:nvar
+            for i=1:nvar
                 for j=1:nexo
                     Decomposition_array(linea,(i-1)*nexo+j) = NaN;
                 end
-           end            
+            end
         else
             tmp = th_autocovariances(dr,ivar,M_,options_,nodecomposition);
             for i=1:nvar
@@ -150,7 +150,7 @@ for file = 1:NumberOfDrawsFiles
             if ~test% Prepare the last round...
                 Decomposition_array = zeros(NumberOfLinesInTheLastDecompFile,nvar*nexo);
                 NumberOfDecompLines = NumberOfLinesInTheLastDecompFile;
-            elseif test<0;
+            elseif test<0
                 Decomposition_array = zeros(MaXNumberOfDecompLines,nvar*nexo);
             else
                 clear('Decomposition_array');
diff --git a/matlab/dsge_var_likelihood.m b/matlab/dsge_var_likelihood.m
index b97beef26..9878d19c9 100644
--- a/matlab/dsge_var_likelihood.m
+++ b/matlab/dsge_var_likelihood.m
@@ -9,15 +9,15 @@ function [fval,info,exit_flag,grad,hess,SteadyState,trend_coeff,PHI_tilde,SIGMA_
 %   o fval          [double]     Value of the posterior kernel at xparam1.
 %   o info          [integer]    Vector of informations about the penalty.
 %   o exit_flag     [integer]    Zero if the function returns a penalty, one otherwise.
-%   o grad          [double]     place holder for gradient of the likelihood 
+%   o grad          [double]     place holder for gradient of the likelihood
 %                                currently not supported by dsge_var
-%   o hess          [double]     place holder for hessian matrix of the likelihood 
+%   o hess          [double]     place holder for hessian matrix of the likelihood
 %                                currently not supported by dsge_var
 %   o SteadyState   [double]     Steady state vector possibly recomputed
 %                                by call to dynare_resolve()
 %   o trend_coeff   [double]     place holder for trend coefficients,
 %                                currently not supported by dsge_var
-%   o PHI_tilde     [double]     Stacked BVAR-DSGE autoregressive matrices (at the mode associated to xparam1); 
+%   o PHI_tilde     [double]     Stacked BVAR-DSGE autoregressive matrices (at the mode associated to xparam1);
 %                                formula (28), DS (2004)
 %   o SIGMA_u_tilde [double]     Covariance matrix of the BVAR-DSGE (at the mode associated to xparam1),
 %                                formula (29), DS (2004)
@@ -32,8 +32,8 @@ function [fval,info,exit_flag,grad,hess,SteadyState,trend_coeff,PHI_tilde,SIGMA_
 % ALGORITHMS
 %   Follows the computations outlined in Del Negro/Schorfheide (2004):
 %   Priors from general equilibrium models for VARs, International Economic
-%   Review, 45(2), pp. 643-673 
-% 
+%   Review, 45(2), pp. 643-673
+%
 % SPECIAL REQUIREMENTS
 %   None.
 
@@ -102,23 +102,23 @@ mXY = evalin('base', 'mXY');
 mXX = evalin('base', 'mXX');
 
 % Return, with endogenous penalty, if some dsge-parameters are smaller than the lower bound of the prior domain.
-if DynareOptions.mode_compute ~= 1 && any(xparam1 < BoundsInfo.lb)
+if isestimation(DynareOptions) && DynareOptions.mode_compute ~= 1 && any(xparam1 < BoundsInfo.lb)
     k = find(xparam1 < BoundsInfo.lb);
     fval = Inf;
     exit_flag = 0;
     info(1) = 41;
     info(4)= sum((BoundsInfo.lb(k)-xparam1(k)).^2);
-    return;
+    return
 end
 
 % Return, with endogenous penalty, if some dsge-parameters are greater than the upper bound of the prior domain.
-if DynareOptions.mode_compute ~= 1 && any(xparam1 > BoundsInfo.ub)
+if isestimation(DynareOptions) && DynareOptions.mode_compute ~= 1 && any(xparam1 > BoundsInfo.ub)
     k = find(xparam1 > BoundsInfo.ub);
     fval = Inf;
     exit_flag = 0;
     info(1) = 42;
     info(4) = sum((xparam1(k)-BoundsInfo.ub(k)).^2);
-    return;
+    return
 end
 
 % Get the variance of each structural innovation.
@@ -137,7 +137,7 @@ Model.Sigma_e = Q;
 dsge_prior_weight = Model.params(dsge_prior_weight_idx);
 
 % Is the dsge prior proper?
-if dsge_prior_weight<(NumberOfParameters+NumberOfObservedVariables)/NumberOfObservations;
+if dsge_prior_weight<(NumberOfParameters+NumberOfObservedVariables)/NumberOfObservations
     fval = Inf;
     exit_flag = 0;
     info(1) = 51;
@@ -158,8 +158,8 @@ end
 % Return, with endogenous penalty when possible, if dynare_resolve issues an error code (defined in resol).
 if info(1)
     if info(1) == 3 || info(1) == 4 || info(1) == 5 || info(1)==6 ||info(1) == 19 ||...
-            info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
-            info(1) == 81 || info(1) == 84 ||  info(1) == 85
+                info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
+                info(1) == 81 || info(1) == 84 ||  info(1) == 85
         %meaningful second entry of output that can be used
         fval = Inf;
         info(4) = info(2);
@@ -233,11 +233,20 @@ assignin('base','GYX',GYX);
 iGXX = inv(GXX);
 PHI_star = iGXX*transpose(GYX); %formula (22), DS (2004)
 SIGMA_u_star=GYY - GYX*PHI_star; %formula (23), DS (2004)
+[SIGMA_u_star_is_positive_definite, penalty] = ispd(SIGMA_u_star);
+if ~SIGMA_u_star_is_positive_definite
+    fval = Inf;
+    info(1) = 53;
+    info(4) = penalty;
+    exit_flag = 0;
+    return
+end
+
 if ~isinf(dsge_prior_weight)% Evaluation of the likelihood of the dsge-var model when the dsge prior weight is finite.
     tmp0 = dsge_prior_weight*NumberOfObservations*TheoreticalAutoCovarianceOfTheObservedVariables(:,:,1) + mYY ;  %first term of square bracket in formula (29), DS (2004)
     tmp1 = dsge_prior_weight*NumberOfObservations*GYX + mYX;        %first element of second term of square bracket in formula (29), DS (2004)
     tmp2 = inv(dsge_prior_weight*NumberOfObservations*GXX+mXX);     %middle element of second term of square bracket in formula (29), DS (2004)
-    SIGMA_u_tilde = tmp0 - tmp1*tmp2*tmp1';                               %square bracket term in formula (29), DS (2004) 
+    SIGMA_u_tilde = tmp0 - tmp1*tmp2*tmp1';                               %square bracket term in formula (29), DS (2004)
     clear('tmp0');
     [SIGMAu_is_positive_definite, penalty] = ispd(SIGMA_u_tilde);
     if ~SIGMAu_is_positive_definite
@@ -245,7 +254,7 @@ if ~isinf(dsge_prior_weight)% Evaluation of the likelihood of the dsge-var model
         info(1) = 52;
         info(4) = penalty;
         exit_flag = 0;
-        return;
+        return
     end
     SIGMA_u_tilde = SIGMA_u_tilde / (NumberOfObservations*(1+dsge_prior_weight));   %prefactor of formula (29), DS (2004)
     PHI_tilde = tmp2*tmp1';                                                   %formula (28), DS (2004)
@@ -256,7 +265,7 @@ if ~isinf(dsge_prior_weight)% Evaluation of the likelihood of the dsge-var model
     prodlng2 = sum(gammaln(.5*(dsge_prior_weight*NumberOfObservations- ...
                                NumberOfParameters ...
                                +1-(1:NumberOfObservedVariables)')));    %last term in denominator of third line of (A.2), DS (2004)
-    %Compute minus log likelihood according to (A.2), DS (2004)
+                                                                        %Compute minus log likelihood according to (A.2), DS (2004)
     lik = .5*NumberOfObservedVariables*log(det(dsge_prior_weight*NumberOfObservations*GXX+mXX)) ... %first term in numerator of second line of (A.2), DS (2004)
           + .5*((dsge_prior_weight+1)*NumberOfObservations-NumberOfParameters)*log(det((dsge_prior_weight+1)*NumberOfObservations*SIGMA_u_tilde)) ... %second term in numerator of second line of (A.2), DS (2004)
           - .5*NumberOfObservedVariables*log(det(dsge_prior_weight*NumberOfObservations*GXX)) ... %first term in denominator of second line of (A.2), DS (2004)
@@ -269,7 +278,7 @@ else% Evaluation of the likelihood of the dsge-var model when the dsge prior wei
     PHI_star = iGXX*transpose(GYX);
     %Compute minus log likelihood according to (33), DS (2004) (where the last term in the trace operator has been multiplied out)
     lik = NumberOfObservations * ( log(det(SIGMA_u_star)) + NumberOfObservedVariables*log(2*pi) +  ...
-                   trace(inv(SIGMA_u_star)*(mYY - transpose(mYX*PHI_star) - mYX*PHI_star + transpose(PHI_star)*mXX*PHI_star)/NumberOfObservations));
+                                   trace(inv(SIGMA_u_star)*(mYY - transpose(mYX*PHI_star) - mYX*PHI_star + transpose(PHI_star)*mXX*PHI_star)/NumberOfObservations));
     lik = .5*lik;% Minus likelihood
     SIGMA_u_tilde=SIGMA_u_star;
     PHI_tilde=PHI_star;
@@ -328,8 +337,8 @@ if (nargout >= 10)
 end
 
 if (nargout==11)
-    prior.SIGMA_u_star = SIGMA_u_star; 
-    prior.PHI_star = PHI_star; 
+    prior.SIGMA_u_star = SIGMA_u_star;
+    prior.PHI_star = PHI_star;
     prior.ArtificialSampleSize = fix(dsge_prior_weight*NumberOfObservations);
     prior.DF = prior.ArtificialSampleSize - NumberOfParameters - NumberOfObservedVariables;
     prior.iGXX_star = iGXX;
diff --git a/matlab/dy_date.m b/matlab/dy_date.m
index 7ce72e836..9d9bb31f4 100644
--- a/matlab/dy_date.m
+++ b/matlab/dy_date.m
@@ -1,6 +1,6 @@
 function y=dy_date(year,period)
 
-% Copyright (C) 2005-2009 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -20,4 +20,3 @@ function y=dy_date(year,period)
 global M_
 
 y = M_.freq*(year-M_.start_date(1))+period-M_.start_date(2)+1;
-
diff --git a/matlab/dyn2vec.m b/matlab/dyn2vec.m
index a944dc188..50e62b4f1 100644
--- a/matlab/dyn2vec.m
+++ b/matlab/dyn2vec.m
@@ -12,9 +12,9 @@ function [z,zss]=dyn2vec(s1,s2)
 %
 % SPECIAL REQUIREMENTS
 %   none
-%  
+%
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,7 +50,7 @@ if nargin == 0
     end
     return
 else
-    j = strmatch(s1,M_.endo_names,'exact'); 
+    j = strmatch(s1,M_.endo_names,'exact');
     if ~ isempty(j)
         z = oo_.endo_simul(j,k)';
     else
@@ -83,6 +83,3 @@ end
 % 08/24/01 MJ replaced globlize by internal assignin
 % 08/24/01 MJ added 'exact' to strmatch (thanks to David Vavra)
 % 01/31/03 MJ added provision for alternative name of variable
-
-
-
diff --git a/matlab/dyn_autocorr.m b/matlab/dyn_autocorr.m
index 43534d7be..e4565cf45 100644
--- a/matlab/dyn_autocorr.m
+++ b/matlab/dyn_autocorr.m
@@ -35,6 +35,6 @@ acf = NaN(ar+1,1);
 acf(1)=1;
 m = mean(y);
 sd = std(y,1);
-for i=1:ar,
+for i=1:ar
     acf(i+1) = (y(i+1:end)-m)'*(y(1:end-i)-m)./((size(y,1))*sd^2);
 end
diff --git a/matlab/dyn_diag_vech.m b/matlab/dyn_diag_vech.m
index 5d5d94664..e8b9cf338 100644
--- a/matlab/dyn_diag_vech.m
+++ b/matlab/dyn_diag_vech.m
@@ -1,14 +1,14 @@
 function d = dyn_diag_vech(Vector)
 % This function returns the diagonal elements of a symmetric matrix
 % stored in vech form
-% 
-% INPUTS 
+%
+% INPUTS
 %   Vector             [double]   a m*1 vector.
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   d                  [double]   a n*1 vector, where n solves n*(n+1)/2=m.
 
-% Copyright (C) 2010 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/dyn_figure.m b/matlab/dyn_figure.m
index f26a39345..62182a291 100644
--- a/matlab/dyn_figure.m
+++ b/matlab/dyn_figure.m
@@ -1,9 +1,9 @@
-function h=dyn_figure(DynareOptions,varargin)
-%function h=dyn_figure(DynareOptions,varargin)
+function h = dyn_figure(nodisplay, varargin)
+%function h = dyn_figure(nodisplay, varargin)
 % initializes figures for DYNARE
 %
 % INPUTS
-%    DynareOptions: dynare options
+%    nodisplay: the value of the command-specific nodisplay argument or options_.nodisplay
 %    varargin: the same list of possible inputs of the MATLAB function figure
 %
 % OUTPUTS
@@ -12,7 +12,7 @@ function h=dyn_figure(DynareOptions,varargin)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,7 +29,7 @@ function h=dyn_figure(DynareOptions,varargin)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if DynareOptions.nodisplay,
+if nodisplay
     h = figure(varargin{:},'visible','off');
 else
     h = figure(varargin{:});
diff --git a/matlab/dyn_first_order_solver.m b/matlab/dyn_first_order_solver.m
index cb5e407a8..a09aa1645 100644
--- a/matlab/dyn_first_order_solver.m
+++ b/matlab/dyn_first_order_solver.m
@@ -47,7 +47,7 @@ function [dr,info] = dyn_first_order_solver(jacobia,DynareModel,dr,DynareOptions
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2001-2012 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -66,8 +66,8 @@ function [dr,info] = dyn_first_order_solver(jacobia,DynareModel,dr,DynareOptions
 
 persistent reorder_jacobian_columns innovations_idx index_s index_m index_c
 persistent index_p row_indx index_0m index_0p k1 k2 state_var
-persistent ndynamic nstatic nfwrd npred nboth nd nsfwrd n_current index_d 
-persistent index_e index_d1 index_d2 index_e1 index_e2 row_indx_de_1 
+persistent ndynamic nstatic nfwrd npred nboth nd nsfwrd n_current index_d
+persistent index_e index_d1 index_d2 index_e1 index_e2 row_indx_de_1
 persistent row_indx_de_2 cols_b
 
 
@@ -82,7 +82,7 @@ end
 exo_nbr = DynareModel.exo_nbr;
 
 if isempty(reorder_jacobian_columns)
-    
+
     maximum_lag = DynareModel.maximum_endo_lag;
     kstate   = dr.kstate;
     nfwrd    = DynareModel.nfwrd;
@@ -149,7 +149,7 @@ if isempty(reorder_jacobian_columns)
     index_e1 = [1:npred+nboth, npred+nboth+find(llx(maximum_lag+1,nstatic+npred+(1: ...
                                                       nsfwrd)))];
     index_e2 = npred+nboth+(1:nboth);
-    
+
     [junk,cols_b] = find(lead_lag_incidence(maximum_lag+1, order_var));
 
     reorder_jacobian_columns = [nonzeros(lead_lag_incidence(:,order_var)'); ...
@@ -179,12 +179,12 @@ if task ~= 1 && (DynareOptions.dr_cycle_reduction || DynareOptions.dr_logarithmi
     if n_current < DynareModel.endo_nbr
         if DynareOptions.dr_cycle_reduction
             error(['The cycle reduction algorithme can''t be used when the ' ...
-               'coefficient matrix for current variables isn''t invertible'])
+                   'coefficient matrix for current variables isn''t invertible'])
         elseif DynareOptions.dr_logarithmic_reduction
             error(['The logarithmic reduction algorithme can''t be used when the ' ...
                    'coefficient matrix for current variables isn''t invertible'])
         end
-    end  
+    end
     if DynareOptions.gpu
         gpuArray(A1);
         gpuArray(B1);
@@ -212,7 +212,7 @@ else
     D(row_indx_de_2,index_d2) = eye(nboth);
     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);
 
@@ -235,7 +235,7 @@ else
             dr.full_rank = 0;
         else
             dr.full_rank = 1;
-        end            
+        end
         return
     end
 
@@ -244,14 +244,13 @@ else
         if nba > nsfwrd
             temp = temp(nd-nba+1:nd-nsfwrd)-1-DynareOptions.qz_criterium;
             info(1) = 3;
-        elseif nba < nsfwrd;
+        elseif nba < nsfwrd
             temp = temp(nd-nsfwrd+1:nd-nba)-1-DynareOptions.qz_criterium;
             info(1) = 4;
         end
         info(2) = temp'*temp;
         return
     end
-
     %First order approximation
     indx_stable_root = 1: (nd - nsfwrd);     %=> index of stable roots
     indx_explosive_root = npred + nboth + 1:nd;  %=> index of explosive roots
@@ -267,7 +266,7 @@ else
         % Z22 is near singular
         info(1) = 5;
         info(2) = -log(rc);
-        return;
+        return
     end
     gx  = -minus_gx;
     % predetermined variables
@@ -285,7 +284,7 @@ if nstatic > 0
     B_static = B(:,1:nstatic);  % submatrix containing the derivatives w.r. to static variables
 else
     B_static = [];
-end;
+end
 %static variables, backward variable, mixed variables and forward variables
 B_pred = B(:,nstatic+1:nstatic+npred+nboth);
 B_fyd = B(:,nstatic+npred+nboth+1:end);
@@ -309,12 +308,12 @@ if exo_nbr
         fu = Q' * jacobia(:,innovations_idx);
     else
         fu = jacobia(:,innovations_idx);
-    end;
+    end
 
     ghu = - A_ \ fu;
 else
     ghu = [];
-end;
+end
 
 dr.ghx = ghx;
 dr.ghu = ghu;
diff --git a/matlab/dyn_forecast.m b/matlab/dyn_forecast.m
index 770d73e41..a58b126a1 100644
--- a/matlab/dyn_forecast.m
+++ b/matlab/dyn_forecast.m
@@ -1,7 +1,7 @@
 function [forecast,info] = dyn_forecast(var_list,M,options,oo,task,dataset_info)
 % function dyn_forecast(var_list,M,options,oo,task,dataset_info)
 %   computes mean forecast for a given value of the parameters
-%   compues also confidence band for the forecast    
+%   compues also confidence band for the forecast
 %
 % INPUTS
 %   var_list:    list of variables (character matrix)
@@ -21,7 +21,7 @@ function [forecast,info] = dyn_forecast(var_list,M,options,oo,task,dataset_info)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,7 +43,7 @@ if nargin<6 && options.prefilter
 elseif nargin==6
     mean_varobs=dataset_info.descriptive.mean';
 end
-    
+
 info = 0;
 
 oo=make_ex_(M,options,oo);
@@ -73,9 +73,17 @@ switch task
         horizon = 5;
     end
     if isempty(M.endo_histval)
-        y0 = repmat(oo.dr.ys,1,maximum_lag);
+        if options.loglinear && ~options.logged_steady_state
+            y0 = repmat(log(oo.dr.ys),1,maximum_lag);
+        else
+            y0 = repmat(oo.dr.ys,1,maximum_lag);
+        end
     else
-        y0 = M.endo_histval;
+        if options.loglinear
+            y0 = log_variable(1:M.endo_nbr,M.endo_histval,M);
+        else
+            y0 = M.endo_histval;
+        end
     end
   case 'smoother'
     horizon = options.forecast;
@@ -84,7 +92,7 @@ switch task
     for i = 1:M.endo_nbr
         v_name = deblank(M.endo_names(i,:));
         y0(i,:) = y_smoothed.(v_name)(end-maximum_lag+1:end); %includes steady state or mean, but simult_ will subtract only steady state
-        % 2. Subtract mean/steady state and add steady state; takes care of prefiltering        
+                                                              % 2. Subtract mean/steady state and add steady state; takes care of prefiltering
         if isfield(oo.Smoother,'Constant') && isfield(oo.Smoother.Constant,v_name)
             y0(i,:)=y0(i,:)-oo.Smoother.Constant.(v_name)(end-maximum_lag+1:end); %subtract mean or steady state
             if options.loglinear
@@ -92,7 +100,7 @@ switch task
             else
                 y0(i,:)=y0(i,:)+oo.dr.ys(strmatch(v_name,deblank(M.endo_names),'exact'));
             end
-        end                
+        end
         % 2. Subtract trend
         if isfield(oo.Smoother,'Trend') && isfield(oo.Smoother.Trend,v_name)
             y0(i,:)=y0(i,:)-oo.Smoother.Trend.(v_name)(end-maximum_lag+1:end); %subtract trend, which is not subtracted by simult_
@@ -113,8 +121,8 @@ switch task
                 trend_coeffs = [trend_coeffs; oo.Smoother.TrendCoeffs(trend_var_index)];
             end
         end
-        if ~isempty(trend_coeffs) 
-            trend = trend_coeffs*(options.first_obs+gend-1+(1-M.maximum_lag:horizon)); 
+        if ~isempty(trend_coeffs)
+            trend = trend_coeffs*(options.first_obs+gend-1+(1-M.maximum_lag:horizon));
             if options.prefilter
                 trend = trend - repmat(mean(trend_coeffs*[options.first_obs:options.first_obs+gend-1],2),1,horizon+1); %subtract mean trend
             end
@@ -124,13 +132,13 @@ switch task
     end
   otherwise
     error('Wrong flag value')
-end 
+end
 
 if M.exo_det_nbr == 0
     if isequal(M.H,0)
         [yf,int_width] = forcst(oo.dr,y0,horizon,var_list,M,oo,options);
     else
-        [yf,int_width,int_width_ME] = forcst(oo.dr,y0,horizon,var_list,M,oo,options);        
+        [yf,int_width,int_width_ME] = forcst(oo.dr,y0,horizon,var_list,M,oo,options);
     end
 else
     exo_det_length = size(oo.exo_det_simul,1)-M.maximum_lag;
@@ -138,17 +146,17 @@ else
         ex = zeros(horizon,M.exo_nbr);
         oo.exo_det_simul = [ oo.exo_det_simul;...
                             repmat(oo.exo_det_steady_state',...
-                                   horizon- ... 
+                                   horizon- ...
                                    exo_det_length,1)];
-    elseif horizon <= exo_det_length 
-        ex = zeros(exo_det_length,M.exo_nbr); 
+    elseif horizon <= exo_det_length
+        ex = zeros(exo_det_length,M.exo_nbr);
     end
     if isequal(M.H,0)
         [yf,int_width] = simultxdet(y0,ex,oo.exo_det_simul,...
-                                options.order,var_list,M,oo,options);
+                                    options.order,var_list,M,oo,options);
     else
         [yf,int_width,int_width_ME] = simultxdet(y0,ex,oo.exo_det_simul,...
-                                options.order,var_list,M,oo,options);
+                                                 options.order,var_list,M,oo,options);
     end
 end
 
@@ -163,7 +171,7 @@ if options.loglinear == 1
 else
     if options.prefilter == 1 %subtract steady state and add mean for observables
         yf(i_var_obs,:)=yf(i_var_obs,:)-repmat(oo.dr.ys(i_var_obs),1,horizon+M.maximum_lag)+ repmat(mean_varobs,1,horizon+M.maximum_lag);
-    end    
+    end
 end
 
 for i=1:n_var
diff --git a/matlab/dyn_latex_table.m b/matlab/dyn_latex_table.m
index 63fb6095f..8cfdc6e53 100644
--- a/matlab/dyn_latex_table.m
+++ b/matlab/dyn_latex_table.m
@@ -1,7 +1,7 @@
 function dyn_latex_table(M_,options_,title,LaTeXtitle,headers,labels,values,label_width,val_width,val_precis,optional_header)
 %function dyn_latex_table(M_,options_,title,LaTeXtitle,headers,labels,values,label_width,val_width,val_precis,optional_header)
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,7 +27,7 @@ OutputDirectoryName = CheckPath('Output',M_.dname);
 %% get width of label column
 if ~isempty(label_width)
     label_width = max(size(deblank(char(headers(1,:),labels)),2)+2, ...
-        label_width);
+                      label_width);
 else %use default length
     label_width = max(size(deblank(char(headers(1,:),labels)),2))+2;
 end
diff --git a/matlab/dyn_ramsey_static.m b/matlab/dyn_ramsey_static.m
index 511f5ed15..25b5301e6 100644
--- a/matlab/dyn_ramsey_static.m
+++ b/matlab/dyn_ramsey_static.m
@@ -8,7 +8,7 @@ function [steady_state,params,check] = dyn_ramsey_static(ys_init,M,options_,oo)
 %    M:             Dynare model structure
 %    options:       Dynare options structure
 %    oo:            Dynare results structure
-% 
+%
 % OUTPUTS
 %    steady_state:  steady state value
 %    params:        parameters at steady state, potentially updated by
@@ -18,7 +18,7 @@ function [steady_state,params,check] = dyn_ramsey_static(ys_init,M,options_,oo)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,7 +39,7 @@ function [steady_state,params,check] = dyn_ramsey_static(ys_init,M,options_,oo)
 params = M.params;
 check = 0;
 options_.steadystate.nocheck = 1; %locally disable checking because Lagrange multipliers are not accounted for in evaluate_steady_state_file
-% dyn_ramsey_static_1 is a subfunction
+                                  % dyn_ramsey_static_1 is a subfunction
 nl_func = @(x) dyn_ramsey_static_1(x,M,options_,oo);
 
 % check_static_model is a subfunction
@@ -61,7 +61,7 @@ elseif options_.steadystate_flag
         end
         if info1==4
             check=87;
-        end        
+        end
     else
         %solve for instrument, using multivariate solver, starting at
         %initial value for instrument
@@ -82,7 +82,10 @@ else
     xx = oo.steady_state(1:n_var);
     opt = options_;
     opt.jacobian_flag = 0;
-    [xx,check] = dynare_solve(nl_func,xx,opt);
+    [xx,info1] = dynare_solve(nl_func,xx,opt);
+    if info1~=0
+        check=81;
+    end
     [junk,junk,steady_state] = nl_func(xx);
 end
 
@@ -99,7 +102,7 @@ endo_nbr = M.endo_nbr;
 endo_names = M.endo_names;
 orig_endo_nbr = M.orig_endo_nbr;
 aux_vars_type = [M.aux_vars.type];
-orig_endo_aux_nbr = orig_endo_nbr + min(find(aux_vars_type == 6)) - 1; 
+orig_endo_aux_nbr = orig_endo_nbr + min(find(aux_vars_type == 6)) - 1;
 orig_eq_nbr = M.orig_eq_nbr;
 inst_nbr = orig_endo_aux_nbr - orig_eq_nbr;
 % indices of Lagrange multipliers
@@ -117,12 +120,12 @@ if options_.steadystate_flag
     ys_init(k_inst) = x; %set instrument, the only value required for steady state computation, to current value
     [x,params,check] = evaluate_steady_state_file(ys_init,... %returned x now has size endo_nbr as opposed to input size of n_instruments
                                                   [oo.exo_steady_state; ...
-                                                  oo.exo_det_steady_state], ...
+                        oo.exo_det_steady_state], ...
                                                   M,options_,~options_.steadystate.nocheck);
     if any(imag(x(1:M.orig_endo_nbr))) %return with penalty
         resids=1+sum(abs(imag(x(1:M.orig_endo_nbr)))); %return with penalty
         steady_state=NaN(endo_nbr,1);
-        return;
+        return
     end
 
 end
@@ -134,7 +137,7 @@ xx(1:M.orig_endo_nbr) = x(1:M.orig_endo_nbr); %set values of original endogenous
 if any([M.aux_vars.type] ~= 6) %auxiliary variables other than multipliers
     needs_set_auxiliary_variables = 1;
     fh = str2func([M.fname '_set_auxiliary_variables']);
-    s_a_v_func = @(z) fh(z,... 
+    s_a_v_func = @(z) fh(z,...
                          [oo.exo_steady_state,...
                         oo.exo_det_steady_state],...
                          params);
@@ -151,12 +154,12 @@ 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');
-   fJ = junk.g1;
+    [chck, 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], ...
-               params);
+    [res,fJ] = feval([fname '_static'],xx,[oo.exo_steady_state oo.exo_det_steady_state], ...
+                     params);
 end
 % index of multipliers and corresponding equations
 % the auxiliary variables before the Lagrange multipliers are treated
@@ -190,7 +193,7 @@ function result = check_static_model(ys,M,options_,oo)
 result = false;
 if (options_.bytecode)
     [chck, res, junk] = bytecode('static',ys,[oo.exo_steady_state oo.exo_det_steady_state], ...
-                                 M.params, 'evaluate'); 
+                                 M.params, 'evaluate');
 else
     res = feval([M.fname '_static'],ys,[oo.exo_steady_state oo.exo_det_steady_state], ...
                 M.params);
@@ -198,4 +201,3 @@ end
 if norm(res) < options_.solve_tolf
     result = true;
 end
-
diff --git a/matlab/dyn_risky_steadystate_solver.m b/matlab/dyn_risky_steadystate_solver.m
index a7e09b1bd..b677c7840 100644
--- a/matlab/dyn_risky_steadystate_solver.m
+++ b/matlab/dyn_risky_steadystate_solver.m
@@ -1,550 +1,550 @@
 function [dr,info] = dyn_risky_steadystate_solver(ys0,M, ...
                                                   dr,options,oo)
 
-    %@info:
-    %! @deftypefn {Function File} {[@var{dr},@var{info}] =} dyn_risky_steadystate_solver (@var{ys0},@var{M},@var{dr},@var{options},@var{oo})
-    %! @anchor{dyn_risky_steadystate_solver}
-    %! @sp 1
-    %! Computes the second order risky steady state and first and second order reduced form of the DSGE model.
-    %! @sp 2
-    %! @strong{Inputs}
-    %! @sp 1
-    %! @table @ @var
-    %! @item ys0
-    %! Vector containing a guess value for the risky steady state
-    %! @item M
-    %! Matlab's structure describing the model (initialized by @code{dynare}).
-    %! @item dr
-    %! Matlab's structure describing the reduced form solution of the model.
-    %! @item options
-    %! Matlab's structure describing the options (initialized by @code{dynare}).
-    %! @item oo
-    %! Matlab's structure gathering the results (initialized by @code{dynare}).
-    %! @end table
-    %! @sp 2
-    %! @strong{Outputs}
-    %! @sp 1
-    %! @table @ @var
-    %! @item dr
-    %! Matlab's structure describing the reduced form solution of the model.
-    %! @item info
-    %! Integer scalar, error code.
-    %! @sp 1
-    %! @table @ @code
-    %! @item info==0
-    %! No error.
-    %! @item info==1
-    %! The model doesn't determine the current variables uniquely.
-    %! @item info==2
-    %! MJDGGES returned an error code.
-    %! @item info==3
-    %! Blanchard & Kahn conditions are not satisfied: no stable equilibrium.
-    %! @item info==4
-    %! Blanchard & Kahn conditions are not satisfied: indeterminacy.
-    %! @item info==5
-    %! Blanchard & Kahn conditions are not satisfied: indeterminacy due to rank failure.
-    %! @item info==6
-    %! The jacobian evaluated at the deterministic steady state is complex.
-    %! @item info==19
-    %! The steadystate routine thrown an exception (inconsistent deep parameters).
-    %! @item info==20
-    %! Cannot find the steady state, info(2) contains the sum of square residuals (of the static equations).
-    %! @item info==21
-    %! The steady state is complex, info(2) contains the sum of square of imaginary parts of the steady state.
-    %! @item info==22
-    %! The steady has NaNs.
-    %! @item info==23
-    %! M_.params has been updated in the steadystate routine and has complex valued scalars.
-    %! @item info==24
-    %! M_.params has been updated in the steadystate routine and has some NaNs.
-    %! @end table
-    %! @end table
-    %! @end deftypefn
-    %@eod:
+%@info:
+%! @deftypefn {Function File} {[@var{dr},@var{info}] =} dyn_risky_steadystate_solver (@var{ys0},@var{M},@var{dr},@var{options},@var{oo})
+%! @anchor{dyn_risky_steadystate_solver}
+%! @sp 1
+%! Computes the second order risky steady state and first and second order reduced form of the DSGE model.
+%! @sp 2
+%! @strong{Inputs}
+%! @sp 1
+%! @table @ @var
+%! @item ys0
+%! Vector containing a guess value for the risky steady state
+%! @item M
+%! Matlab's structure describing the model (initialized by @code{dynare}).
+%! @item dr
+%! Matlab's structure describing the reduced form solution of the model.
+%! @item options
+%! Matlab's structure describing the options (initialized by @code{dynare}).
+%! @item oo
+%! Matlab's structure gathering the results (initialized by @code{dynare}).
+%! @end table
+%! @sp 2
+%! @strong{Outputs}
+%! @sp 1
+%! @table @ @var
+%! @item dr
+%! Matlab's structure describing the reduced form solution of the model.
+%! @item info
+%! Integer scalar, error code.
+%! @sp 1
+%! @table @ @code
+%! @item info==0
+%! No error.
+%! @item info==1
+%! The model doesn't determine the current variables uniquely.
+%! @item info==2
+%! MJDGGES returned an error code.
+%! @item info==3
+%! Blanchard & Kahn conditions are not satisfied: no stable equilibrium.
+%! @item info==4
+%! Blanchard & Kahn conditions are not satisfied: indeterminacy.
+%! @item info==5
+%! Blanchard & Kahn conditions are not satisfied: indeterminacy due to rank failure.
+%! @item info==6
+%! The jacobian evaluated at the deterministic steady state is complex.
+%! @item info==19
+%! The steadystate routine thrown an exception (inconsistent deep parameters).
+%! @item info==20
+%! Cannot find the steady state, info(2) contains the sum of square residuals (of the static equations).
+%! @item info==21
+%! The steady state is complex, info(2) contains the sum of square of imaginary parts of the steady state.
+%! @item info==22
+%! The steady has NaNs.
+%! @item info==23
+%! M_.params has been updated in the steadystate routine and has complex valued scalars.
+%! @item info==24
+%! M_.params has been updated in the steadystate routine and has some NaNs.
+%! @end table
+%! @end table
+%! @end deftypefn
+%@eod:
 
-    % Copyright (C) 2001-2012 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/>.
+% Copyright (C) 2001-2017 Dynare Team
+%
+% This file is part of Dynare.
+%
+% Dynare is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version.
+%
+% Dynare is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    
-    info = 0;
-    lead_lag_incidence = M.lead_lag_incidence;
-    order_var = dr.order_var;
-    endo_nbr = M.endo_nbr;
-    exo_nbr = M.exo_nbr;
-    
-    M.var_order_endo_names = M.endo_names(dr.order_var,:);
-    
-    [junk,dr.i_fwrd_g,i_fwrd_f] = find(lead_lag_incidence(3,order_var));
-    dr.i_fwrd_f = i_fwrd_f;
-    nd = nnz(lead_lag_incidence) + M.exo_nbr;
-    dr.nd = nd;
-    kk = reshape(1:nd^2,nd,nd);
-    kkk = reshape(1:nd^3,nd^2,nd);
-    dr.i_fwrd2_f = kk(i_fwrd_f,i_fwrd_f);
-    dr.i_fwrd2a_f = kk(i_fwrd_f,:);
-    dr.i_fwrd3_f = kkk(dr.i_fwrd2_f,:);
-    dr.i_uu = kk(end-exo_nbr+1:end,end-exo_nbr+1:end);
-    if options.k_order_solver
-        func = @risky_residuals_k_order;
-    else
-        func = @risky_residuals;
-    end
-    
-    if isfield(options,'portfolio') && options.portfolio == 1
-        pm = portfolio_model_structure(M,options);
-        
-        x0 = ys0(pm.v_p);
-        n = length(x0);
-        [x, info] = solve1(@risky_residuals_ds,x0,1:n,1:n,0,options.gstep, ...
-                           options.solve_tolf,options.solve_tolx, ...
-                           options.steady.maxit,options.debug,pm,M,dr, ...
-                           options,oo);
-        if info
-            error('DS approach can''t be computed')
-        end
-        %[x, info] = csolve(@risky_residuals_ds,x0,[],1e-10,100,M,dr,options,oo);
-        %        ys0(l_var) = x;
-        [resids,dr1] = risky_residuals_ds(x,pm,M,dr,options,oo); 
-        ys1 = dr1.ys;
-    else
-        pm = model_structure(M,options);
-    end
-    
-    [ys, info] = solve1(func,ys0,1:endo_nbr,1:endo_nbr,0,options.gstep, ...
-                        options.solve_tolf,options.solve_tolx, ...
-                        options.steady.maxit,options.debug,pm,M,dr,options,oo);
-    %    [ys, info] = csolve(func,ys0,[],1e-10,100,M,dr,options,oo);
+
+info = 0;
+lead_lag_incidence = M.lead_lag_incidence;
+order_var = dr.order_var;
+endo_nbr = M.endo_nbr;
+exo_nbr = M.exo_nbr;
+
+M.var_order_endo_names = M.endo_names(dr.order_var,:);
+
+[junk,dr.i_fwrd_g,i_fwrd_f] = find(lead_lag_incidence(3,order_var));
+dr.i_fwrd_f = i_fwrd_f;
+nd = nnz(lead_lag_incidence) + M.exo_nbr;
+dr.nd = nd;
+kk = reshape(1:nd^2,nd,nd);
+kkk = reshape(1:nd^3,nd^2,nd);
+dr.i_fwrd2_f = kk(i_fwrd_f,i_fwrd_f);
+dr.i_fwrd2a_f = kk(i_fwrd_f,:);
+dr.i_fwrd3_f = kkk(dr.i_fwrd2_f,:);
+dr.i_uu = kk(end-exo_nbr+1:end,end-exo_nbr+1:end);
+if options.k_order_solver
+    func = @risky_residuals_k_order;
+else
+    func = @risky_residuals;
+end
+
+if isfield(options,'portfolio') && options.portfolio == 1
+    pm = portfolio_model_structure(M,options);
+
+    x0 = ys0(pm.v_p);
+    n = length(x0);
+    [x, info] = solve1(@risky_residuals_ds,x0,1:n,1:n,0,options.gstep, ...
+                       options.solve_tolf,options.solve_tolx, ...
+                       options.steady.maxit,options.debug,pm,M,dr, ...
+                       options,oo);
     if info
-        error('RSS approach can''t be computed')
+        error('DS approach can''t be computed')
     end
-    dr.ys = ys;
+    %[x, info] = csolve(@risky_residuals_ds,x0,[],1e-10,100,M,dr,options,oo);
+    %        ys0(l_var) = x;
+    [resids,dr1] = risky_residuals_ds(x,pm,M,dr,options,oo);
+    ys1 = dr1.ys;
+else
+    pm = model_structure(M,options);
+end
 
-    [resid,dr] = func(ys,pm,M,dr,options,oo);
-    dr.ghs2 = zeros(M.endo_nbr,1);
-    
-    for i=1:M.endo_nbr
-        if isfield(options,'portfolio') && options.portfolio == 1
-            disp(sprintf('%16s %12.6f %12.6f',M.endo_names(i,:),ys1(i), ...
-                         ys(i)))
-        else
-            disp(sprintf('%16s %12.6f %12.6f',M.endo_names(i,:),ys(i)))
-        end
+[ys, info] = solve1(func,ys0,1:endo_nbr,1:endo_nbr,0,options.gstep, ...
+                    options.solve_tolf,options.solve_tolx, ...
+                    options.steady.maxit,options.debug,pm,M,dr,options,oo);
+%    [ys, info] = csolve(func,ys0,[],1e-10,100,M,dr,options,oo);
+if info
+    error('RSS approach can''t be computed')
+end
+dr.ys = ys;
+
+[resid,dr] = func(ys,pm,M,dr,options,oo);
+dr.ghs2 = zeros(M.endo_nbr,1);
+
+for i=1:M.endo_nbr
+    if isfield(options,'portfolio') && options.portfolio == 1
+        disp(sprintf('%16s %12.6f %12.6f',M.endo_names(i,:),ys1(i), ...
+                     ys(i)))
+    else
+        disp(sprintf('%16s %12.6f %12.6f',M.endo_names(i,:),ys(i)))
     end
+end
 
 end
 
 function [resid,dr] = risky_residuals(ys,pm,M,dr,options,oo)
-    
-    lead_lag_incidence = M.lead_lag_incidence;
-    iyv = lead_lag_incidence';
-    iyv = iyv(:);
-    iyr0 = find(iyv) ;
-    
-    if M.exo_nbr == 0
-        oo.exo_steady_state = [] ;
-    end
-    
-    z = repmat(ys,1,3);
-    z = z(iyr0) ;
-    [resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
-                           [oo.exo_simul ...
-                        oo.exo_det_simul], M.params, dr.ys, 2);
-    if ~isreal(d1) || ~isreal(d2)
-        pause
-    end
-    
-    if options.use_dll
-        % In USE_DLL mode, the hessian is in the 3-column sparse representation
-        d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
-                    size(d1, 1), size(d1, 2)*size(d1, 2));
-    end
 
-    if isfield(options,'portfolio') && options.portfolio == 1
-        pm = portfolio_model_structure(M,options);
-        x = ys(pm.v_p);
-        dr = first_step_ds(x,pm,M,dr,options,oo);
-        dr.ys = ys;
-    else
-        pm = model_structure(M,options);
-        [dr,info] = dyn_first_order_solver(d1,M,dr,options,0);
-        if info
-            print_info(info,options.noprint,options);
-        end
-        dr = dyn_second_order_solver(d1,d2,dr,M,...
-                                     options.threads.kronecker.A_times_B_kronecker_C,...
-                                     options.threads.kronecker.sparse_hessian_times_B_kronecker_C);
-    end
-    
-    gu1 = dr.ghu(pm.i_fwrd_g,:);
+lead_lag_incidence = M.lead_lag_incidence;
+iyv = lead_lag_incidence';
+iyv = iyv(:);
+iyr0 = find(iyv) ;
 
-    resid = resid1+0.5*(d1(:,pm.i_fwrd_f1)*dr.ghuu(pm.i_fwrd_g,:)+ ...
-                        d2(:,pm.i_fwrd_f2)*kron(gu1,gu1))*vec(M.Sigma_e);
+if M.exo_nbr == 0
+    oo.exo_steady_state = [] ;
+end
+
+z = repmat(ys,1,3);
+z = z(iyr0) ;
+[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
+                       [oo.exo_simul ...
+                    oo.exo_det_simul], M.params, dr.ys, 2);
+if ~isreal(d1) || ~isreal(d2)
+    pause
+end
+
+if options.use_dll
+    % In USE_DLL mode, the hessian is in the 3-column sparse representation
+    d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
+                size(d1, 1), size(d1, 2)*size(d1, 2));
+end
+
+if isfield(options,'portfolio') && options.portfolio == 1
+    pm = portfolio_model_structure(M,options);
+    x = ys(pm.v_p);
+    dr = first_step_ds(x,pm,M,dr,options,oo);
+    dr.ys = ys;
+else
+    pm = model_structure(M,options);
+    [dr,info] = dyn_first_order_solver(d1,M,dr,options,0);
+    if info
+        print_info(info,options.noprint,options);
+    end
+    dr = dyn_second_order_solver(d1,d2,dr,M,...
+                                 options.threads.kronecker.A_times_B_kronecker_C,...
+                                 options.threads.kronecker.sparse_hessian_times_B_kronecker_C);
+end
+
+gu1 = dr.ghu(pm.i_fwrd_g,:);
+
+resid = resid1+0.5*(d1(:,pm.i_fwrd_f1)*dr.ghuu(pm.i_fwrd_g,:)+ ...
+                    d2(:,pm.i_fwrd_f2)*kron(gu1,gu1))*vec(M.Sigma_e);
 end
 
 function [resid,dr] = risky_residuals_ds(x,pm,M,dr,options,oo)
-    
-    v_p = pm.v_p;
-    v_np = pm.v_np;
-    
-    % computing steady state of non-portfolio variables  consistent with
-    % assumed portfolio 
-    dr.ys(v_p) = x;
-    ys0 = dr.ys(v_np);
-    f_h =str2func([M.fname '_static']);
-    [dr.ys(v_np),info] = csolve(@ds_static_model,ys0,[],1e-10,100,f_h,x,pm.eq_np,v_np,v_p, ...
-                                M.endo_nbr,M.exo_nbr,M.params);
-    if info
-        error('can''t compute non-portfolio steady state')
-    end
-    
-    dr_np = first_step_ds(x,pm,M,dr,options,oo);
 
-    lead_lag_incidence = M.lead_lag_incidence;
-    iyv = lead_lag_incidence';
-    iyv = iyv(:);
-    iyr0 = find(iyv) ;
-    
-    z = repmat(dr.ys,1,3);
-    z = z(iyr0) ;
-    [resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
-                           [oo.exo_simul ...
-                        oo.exo_det_simul], M.params, dr.ys, 2);
-    if ~isreal(d1) || ~isreal(d2)
-        pause
-    end
-    
-    if options.use_dll
-        % In USE_DLL mode, the hessian is in the 3-column sparse representation
-        d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
-                    size(d1, 1), size(d1, 2)*size(d1, 2));
-    end
+v_p = pm.v_p;
+v_np = pm.v_np;
 
-    
-    gu1 = dr_np.ghu(pm.i_fwrd_g,:);
+% computing steady state of non-portfolio variables  consistent with
+% assumed portfolio
+dr.ys(v_p) = x;
+ys0 = dr.ys(v_np);
+f_h =str2func([M.fname '_static']);
+[dr.ys(v_np),info] = csolve(@ds_static_model,ys0,[],1e-10,100,f_h,x,pm.eq_np,v_np,v_p, ...
+                            M.endo_nbr,M.exo_nbr,M.params);
+if info
+    error('can''t compute non-portfolio steady state')
+end
 
-    resid = resid1+0.5*(d2(:,pm.i_fwrd_f2)*kron(gu1,gu1))*vec(M.Sigma_e);
+dr_np = first_step_ds(x,pm,M,dr,options,oo);
 
-    resid = resid(pm.eq_p)
+lead_lag_incidence = M.lead_lag_incidence;
+iyv = lead_lag_incidence';
+iyv = iyv(:);
+iyr0 = find(iyv) ;
+
+z = repmat(dr.ys,1,3);
+z = z(iyr0) ;
+[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
+                       [oo.exo_simul ...
+                    oo.exo_det_simul], M.params, dr.ys, 2);
+if ~isreal(d1) || ~isreal(d2)
+    pause
+end
+
+if options.use_dll
+    % In USE_DLL mode, the hessian is in the 3-column sparse representation
+    d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
+                size(d1, 1), size(d1, 2)*size(d1, 2));
+end
+
+
+gu1 = dr_np.ghu(pm.i_fwrd_g,:);
+
+resid = resid1+0.5*(d2(:,pm.i_fwrd_f2)*kron(gu1,gu1))*vec(M.Sigma_e);
+
+resid = resid(pm.eq_p)
 end
 
 function dr_np = first_step_ds(x,pm,M,dr,options,oo)
 
-    lead_lag_incidence = M.lead_lag_incidence;
-    iyv = lead_lag_incidence';
-    iyv = iyv(:);
-    iyr0 = find(iyv) ;
+lead_lag_incidence = M.lead_lag_incidence;
+iyv = lead_lag_incidence';
+iyv = iyv(:);
+iyr0 = find(iyv) ;
 
-    ys = dr.ys;
-    ys(pm.v_p) = x;
-    
-    z = repmat(ys,1,3);
-    z = z(iyr0) ;
-    [resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
-                           [oo.exo_simul ...
-                        oo.exo_det_simul], M.params, dr.ys, 2);
-    if ~isreal(d1) || ~isreal(d2)
-        pause
-    end
-    
-    if options.use_dll
-        % In USE_DLL mode, the hessian is in the 3-column sparse representation
-        d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
-                    size(d1, 1), size(d1, 2)*size(d1, 2));
-    end
+ys = dr.ys;
+ys(pm.v_p) = x;
+
+z = repmat(ys,1,3);
+z = z(iyr0) ;
+[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
+                       [oo.exo_simul ...
+                    oo.exo_det_simul], M.params, dr.ys, 2);
+if ~isreal(d1) || ~isreal(d2)
+    pause
+end
+
+if options.use_dll
+    % In USE_DLL mode, the hessian is in the 3-column sparse representation
+    d2 = sparse(d2(:,1), d2(:,2), d2(:,3), ...
+                size(d1, 1), size(d1, 2)*size(d1, 2));
+end
+
+d1_np = d1(pm.eq_np,pm.i_d1_np);
+d2_np = d2(pm.eq_np,pm.i_d2_np);
+
+[dr_np,info] = dyn_first_order_solver(d1_np,pm.M_np,pm.dr_np,options,0);
+if info
+    print_info(info, 0, options);
+    return
+end
+
+dr_np = dyn_second_order_solver(d1_np,d2_np,dr_np,pm.M_np,...
+                                options.threads.kronecker.A_times_B_kronecker_C,...
+                                options.threads.kronecker.sparse_hessian_times_B_kronecker_C);
+end
+
+function [resid,dr] = risky_residuals_k_order(ys,pm,M,dr,options,oo)
+exo_nbr = M.exo_nbr;
+endo_nbr = M.endo_nbr;
+
+iyv = M.lead_lag_incidence';
+iyv = iyv(:);
+iyr0 = find(iyv) ;
+
+if exo_nbr == 0
+    oo.exo_steady_state = [] ;
+end
+
+z = repmat(ys,1,3);
+z = z(iyr0) ;
+[resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
+                       [oo.exo_simul ...
+                    oo.exo_det_simul], M.params, dr.ys, 2);
+
+if isfield(options,'portfolio') && options.portfolio == 1
+    eq_np = pm.eq_np;
+
+    d1_np = d1(eq_np,pm.i_d1_np);
+    d2_np = d2(eq_np,pm.i_d2_np);
+
+    M_np = pm.M_np;
+    dr_np = pm.dr_np;
 
-    d1_np = d1(pm.eq_np,pm.i_d1_np);
-    d2_np = d2(pm.eq_np,pm.i_d2_np);
-    
     [dr_np,info] = dyn_first_order_solver(d1_np,pm.M_np,pm.dr_np,options,0);
     if info
         print_info(info, 0, options);
         return
     end
-    
+
     dr_np = dyn_second_order_solver(d1_np,d2_np,dr_np,pm.M_np,...
                                     options.threads.kronecker.A_times_B_kronecker_C,...
                                     options.threads.kronecker.sparse_hessian_times_B_kronecker_C);
 end
 
-function [resid,dr] = risky_residuals_k_order(ys,pm,M,dr,options,oo)
-    exo_nbr = M.exo_nbr;
-    endo_nbr = M.endo_nbr;
-    
-    iyv = M.lead_lag_incidence';
-    iyv = iyv(:);
-    iyr0 = find(iyv) ;
-    
-    if exo_nbr == 0
-        oo.exo_steady_state = [] ;
-    end
-    
-    z = repmat(ys,1,3);
-    z = z(iyr0) ;
-    [resid1,d1,d2] = feval([M.fname '_dynamic'],z,...
+i_fwrd_f1 = pm.i_fwrd_f1;
+i_fwrd_f2 = pm.i_fwrd_f2;
+i_fwrd_f3 = pm.i_fwrd_f3;
+i_fwrd_g = pm.i_fwrd_g;
+gu1 = dr_np.ghu(i_fwrd_g,:);
+ghuu = dr_np.ghuu;
+
+resid = resid1+0.5*(d1(:,i_fwrd_f1)*ghuu(i_fwrd_g,:)+d2(:,i_fwrd_f2)* ...
+                    kron(gu1,gu1))*vec(M.Sigma_e);
+
+if nargout > 1
+    [resid1,d1,d2,d3] = feval([M.fname '_dynamic'],z,...
                               [oo.exo_simul ...
                         oo.exo_det_simul], M.params, dr.ys, 2);
-    
-    if isfield(options,'portfolio') && options.portfolio == 1
-        eq_np = pm.eq_np;
-        
-        d1_np = d1(eq_np,pm.i_d1_np);
-        d2_np = d2(eq_np,pm.i_d2_np);
 
-        M_np = pm.M_np;
-        dr_np = pm.dr_np;
-        
-        [dr_np,info] = dyn_first_order_solver(d1_np,pm.M_np,pm.dr_np,options,0);
-        if info
-            print_info(info, 0, options);
-            return
-        end
-        
-        dr_np = dyn_second_order_solver(d1_np,d2_np,dr_np,pm.M_np,...
-                                        options.threads.kronecker.A_times_B_kronecker_C,...
-                                        options.threads.kronecker.sparse_hessian_times_B_kronecker_C);
+
+    [a,b,c] = find(d2(eq_np,pm.i_d2_np));
+    d2_np = [a b c];
+
+    [a,b,c] = find(d3(eq_np,pm.i_d3_np));
+    d3_np = [a b c];
+
+    options.order = 3;
+    % space holder, unused by k_order_pertrubation
+    dr_np.ys = dr.ys(pm.v_np);
+    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,g_0, g_1, g_2, g_3] = k_order_perturbation(dr_np,M_np,options,d1_np,d2_np,d3_np);
+    mexErrCheck('k_order_perturbation', err);
+
+    gu1 = g_1(i_fwrd_g,end-exo_nbr+1:end);
+    ghuu = unfold2(g_2(:,end-nu2+1:end),exo_nbr);
+    ghsuu = get_ghsuu(g_3,size(g_1,2),exo_nbr);
+
+    i_fwrd1_f2 = pm.i_fwrd1_f2;
+    i_fwrd1_f3 = pm.i_fwrd1_f3;
+    n = size(d1,2);
+    d1b = d1 + 0.5*( ...
+        d1(:,i_fwrd_f1)*...
+        d2(:,i_fwrd1_f2)*kron(eye(n),dr_np.ghuu(i_fwrd_g,:)*vec(M.Sigma_e))...
+        + 0.5*d3(:,i_fwrd1_f3)*kron(eye(n),kron(gu1,gu1)*vec(M.Sigma_e)));
+    format short
+    kk1 = [nonzeros(M.lead_lag_incidence(:,1:6)'); ...
+           nnz(M.lead_lag_incidence)+[1; 2]]
+    kk2 = [nonzeros(M.lead_lag_incidence(:,1:6)'); ...
+           nnz(M.lead_lag_incidence)+[3; 4]]
+    format short
+    gu1
+    kron(gu1,gu1)*vec(M.Sigma_e)
+    disp(d1(:,:))
+    disp(d1b(:,:))
+    aa2=d2(:,i_fwrd1_f2)*kron(eye(n),dr_np.ghuu(i_fwrd_g,:)*vec(M.Sigma_e));
+    aa3=d3(:,i_fwrd1_f3)*kron(eye(n),kron(gu1,gu1)*vec(M.Sigma_e));
+    disp(d3(4,7+6*n+6*n*n))
+    disp(d3(4,8+16*n+17*n*n))   %8,17,18
+    disp(d3(4,8+17*n+16*n*n))   %8,17,18
+    disp(d3(4,7*n+17+17*n*n))   %8,17,18
+    disp(d3(4,7*n+18+16*n*n))   %8,17,18
+    disp(d3(4,7*n*n+16*n+18))   %8,17,18
+    disp(d3(4,7*n*n+17+17*n))   %8,17,18
+    pause
+    disp(aa2(:,kk1))
+    disp(aa2(:,kk2))
+    disp(aa3(:,kk1))
+    disp(aa3(:,kk2))
+    [dr,info] = dyn_first_order_solver(d1b,M,dr,options,0);
+    if info
+        print_info(info, 0, options);
+        return
     end
-    
-    i_fwrd_f1 = pm.i_fwrd_f1;
-    i_fwrd_f2 = pm.i_fwrd_f2;
-    i_fwrd_f3 = pm.i_fwrd_f3;
-    i_fwrd_g = pm.i_fwrd_g;
-    gu1 = dr_np.ghu(i_fwrd_g,:);
-    ghuu = dr_np.ghuu;
-    
-    resid = resid1+0.5*(d1(:,i_fwrd_f1)*ghuu(i_fwrd_g,:)+d2(:,i_fwrd_f2)* ...
-                        kron(gu1,gu1))*vec(M.Sigma_e);
 
-    if nargout > 1
-        [resid1,d1,d2,d3] = feval([M.fname '_dynamic'],z,...
-                                  [oo.exo_simul ...
-                            oo.exo_det_simul], M.params, dr.ys, 2);
+    disp_dr(dr,dr.order_var,[]);
 
-        
-        [a,b,c] = find(d2(eq_np,pm.i_d2_np));
-        d2_np = [a b c];
-        
-        [a,b,c] = find(d3(eq_np,pm.i_d3_np));
-        d3_np = [a b c];
-         
-        options.order = 3;
-        % space holder, unused by k_order_pertrubation
-        dr_np.ys = dr.ys(pm.v_np);
-        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,g_0, g_1, g_2, g_3] = k_order_perturbation(dr_np,M_np,options,d1_np,d2_np,d3_np);
-        mexErrCheck('k_order_perturbation', err);
-
-        gu1 = g_1(i_fwrd_g,end-exo_nbr+1:end);
-        ghuu = unfold2(g_2(:,end-nu2+1:end),exo_nbr);
-        ghsuu = get_ghsuu(g_3,size(g_1,2),exo_nbr);
-
-        i_fwrd1_f2 = pm.i_fwrd1_f2;
-        i_fwrd1_f3 = pm.i_fwrd1_f3;
-        n = size(d1,2);
-        d1b = d1 + 0.5*( ...
-            d1(:,i_fwrd_f1)*...
-            d2(:,i_fwrd1_f2)*kron(eye(n),dr_np.ghuu(i_fwrd_g,:)*vec(M.Sigma_e))...
-            + 0.5*d3(:,i_fwrd1_f3)*kron(eye(n),kron(gu1,gu1)*vec(M.Sigma_e)));
-        format short
-        kk1 = [nonzeros(M.lead_lag_incidence(:,1:6)'); ...
-               nnz(M.lead_lag_incidence)+[1; 2]]
-        kk2 = [nonzeros(M.lead_lag_incidence(:,1:6)'); ...
-               nnz(M.lead_lag_incidence)+[3; 4]]
-        format short
-        gu1
-        kron(gu1,gu1)*vec(M.Sigma_e)
-        disp(d1(:,:))
-        disp(d1b(:,:))
-        aa2=d2(:,i_fwrd1_f2)*kron(eye(n),dr_np.ghuu(i_fwrd_g,:)*vec(M.Sigma_e));
-        aa3=d3(:,i_fwrd1_f3)*kron(eye(n),kron(gu1,gu1)*vec(M.Sigma_e));
-        disp(d3(4,7+6*n+6*n*n))
-        disp(d3(4,8+16*n+17*n*n))   %8,17,18
-        disp(d3(4,8+17*n+16*n*n))   %8,17,18
-        disp(d3(4,7*n+17+17*n*n))   %8,17,18
-        disp(d3(4,7*n+18+16*n*n))   %8,17,18
-        disp(d3(4,7*n*n+16*n+18))   %8,17,18
-        disp(d3(4,7*n*n+17+17*n))   %8,17,18
-        pause
-        disp(aa2(:,kk1))
-        disp(aa2(:,kk2))
-        disp(aa3(:,kk1))
-        disp(aa3(:,kk2))
-        [dr,info] = dyn_first_order_solver(d1b,M,dr,options,0);
-        if info
-            print_info(info, 0, options);
-            return
-        end
-        
-        disp_dr(dr,dr.order_var,[]);
-        
-    end
+end
 end
 
 function y=unfold2(x,n)
-    y = zeros(size(x,1),n*n);
-    k = 1;
-    for i=1:n
-        for j=i:n
-            y(:,(i-1)*n+j) = x(:,k);
-            if i ~= j
-                y(:,(j-1)*n+i) = x(:,k);
-            end
+y = zeros(size(x,1),n*n);
+k = 1;
+for i=1:n
+    for j=i:n
+        y(:,(i-1)*n+j) = x(:,k);
+        if i ~= j
+            y(:,(j-1)*n+i) = x(:,k);
+        end
+        k = k+1;
+    end
+end
+end
+
+function y=unfold3(x,n)
+y = zeros(size(x,1),n*n*n);
+k = 1;
+for i=1:n
+    for j=i:n
+        for m=j:n
+            y(:,(i-1)*n*n+(j-1)*n+m) = x(:,k);
+            y(:,(i-1)*n*n+(m-1)*n+j) = x(:,k);
+            y(:,(j-1)*n*n+(i-1)*n+m) = x(:,k);
+            y(:,(j-1)*n*n+(m-1)*n+i) = x(:,k);
+            y(:,(m-1)*n*n+(i-1)*n+j) = x(:,k);
+            y(:,(m-1)*n*n+(j-1)*n+i) = x(:,k);
+
             k = k+1;
         end
     end
 end
-
-function y=unfold3(x,n)
-    y = zeros(size(x,1),n*n*n);
-    k = 1;
-    for i=1:n
-        for j=i:n
-            for m=j:n
-                y(:,(i-1)*n*n+(j-1)*n+m) = x(:,k);
-                y(:,(i-1)*n*n+(m-1)*n+j) = x(:,k);
-                y(:,(j-1)*n*n+(i-1)*n+m) = x(:,k);
-                y(:,(j-1)*n*n+(m-1)*n+i) = x(:,k);
-                y(:,(m-1)*n*n+(i-1)*n+j) = x(:,k);
-                y(:,(m-1)*n*n+(j-1)*n+i) = x(:,k);
-                
-                k = k+1;
-            end
-        end
-    end
 end
 
 function pm  = model_structure(M,options)
 
 
-    lead_index = M.maximum_endo_lag+2;
-    lead_lag_incidence = M.lead_lag_incidence;
-    dr = struct();
-    dr = set_state_space(dr,M,options);
-    pm.i_fwrd_g = find(lead_lag_incidence(lead_index,dr.order_var)');    
+lead_index = M.maximum_endo_lag+2;
+lead_lag_incidence = M.lead_lag_incidence;
+dr = struct();
+dr = set_state_space(dr,M,options);
+pm.i_fwrd_g = find(lead_lag_incidence(lead_index,dr.order_var)');
 
-    i_fwrd_f1 = nonzeros(lead_lag_incidence(lead_index,dr.order_var));
-    pm.i_fwrd_f1 = i_fwrd_f1;
-    n = nnz(lead_lag_incidence)+M.exo_nbr;
-    ih = reshape(1:n*n,n,n);
-    i_fwrd_f2 = ih(i_fwrd_f1,i_fwrd_f1);
-    pm.i_fwrd_f2 = i_fwrd_f2(:);
-    i_fwrd1_f2 = ih(i_fwrd_f1,:);
-    pm.i_fwrd1_f2 = i_fwrd1_f2(:);
+i_fwrd_f1 = nonzeros(lead_lag_incidence(lead_index,dr.order_var));
+pm.i_fwrd_f1 = i_fwrd_f1;
+n = nnz(lead_lag_incidence)+M.exo_nbr;
+ih = reshape(1:n*n,n,n);
+i_fwrd_f2 = ih(i_fwrd_f1,i_fwrd_f1);
+pm.i_fwrd_f2 = i_fwrd_f2(:);
+i_fwrd1_f2 = ih(i_fwrd_f1,:);
+pm.i_fwrd1_f2 = i_fwrd1_f2(:);
 
-    ih = reshape(1:n*n*n,n,n,n);
-    i_fwrd_f3 = ih(i_fwrd_f1,i_fwrd_f1,i_fwrd_f1);
-    pm.i_fwrd_f3 = i_fwrd_f3(:);
-    i_fwrd1_f3 = ih(i_fwrd_f1,i_fwrd_f1,:);
-    pm.i_fwrd1_f3 = i_fwrd1_f3(:);
+ih = reshape(1:n*n*n,n,n,n);
+i_fwrd_f3 = ih(i_fwrd_f1,i_fwrd_f1,i_fwrd_f1);
+pm.i_fwrd_f3 = i_fwrd_f3(:);
+i_fwrd1_f3 = ih(i_fwrd_f1,i_fwrd_f1,:);
+pm.i_fwrd1_f3 = i_fwrd1_f3(:);
 end
 
 function pm  = portfolio_model_structure(M,options)
 
-    i_d3_np = [];
-    i_d3_p = [];
+i_d3_np = [];
+i_d3_p = [];
 
-    lead_index = M.maximum_endo_lag+2;
-    lead_lag_incidence = M.lead_lag_incidence;
-    eq_tags = M.equations_tags;
-    n_tags = size(eq_tags,1);
-    eq_p = cell2mat(eq_tags(strcmp(eq_tags(:,2), ...
-                                   'portfolio'),1));
-    pm.eq_p = eq_p;
-    pm.eq_np = setdiff(1:M.endo_nbr,eq_p);
-    v_p = zeros(n_tags,1);
-    for i=1:n_tags
-        v_p(i) = find(strncmp(eq_tags(i,3),M.endo_names, ...
-                              length(cell2mat(eq_tags(i,3)))));
-    end
-    if any(lead_lag_incidence(lead_index,v_p))
-        error(['portfolio variables appear in the model as forward ' ...
-               'variable'])
-    end
-    pm.v_p = v_p;
-    v_np = setdiff(1:M.endo_nbr,v_p);
-    pm.v_np = v_np;
-    lli_np = lead_lag_incidence(:,v_np)';
-    k = find(lli_np);
-    lead_lag_incidence_np = lli_np;
-    lead_lag_incidence_np(k) = 1:nnz(lli_np);
-    lead_lag_incidence_np = lead_lag_incidence_np';
-    pm.lead_lag_incidence_np = lead_lag_incidence_np;
-    i_d1_np = [nonzeros(lli_np); nnz(lead_lag_incidence)+(1:M.exo_nbr)'];
-    pm.i_d1_np = i_d1_np;
-    
-    n = nnz(lead_lag_incidence)+M.exo_nbr;
-    ih = reshape(1:n*n,n,n);
-    i_d2_np = ih(i_d1_np,i_d1_np);
-    pm.i_d2_np = i_d2_np(:);
+lead_index = M.maximum_endo_lag+2;
+lead_lag_incidence = M.lead_lag_incidence;
+eq_tags = M.equations_tags;
+n_tags = size(eq_tags,1);
+eq_p = cell2mat(eq_tags(strcmp(eq_tags(:,2), ...
+                               'portfolio'),1));
+pm.eq_p = eq_p;
+pm.eq_np = setdiff(1:M.endo_nbr,eq_p);
+v_p = zeros(n_tags,1);
+for i=1:n_tags
+    v_p(i) = find(strncmp(eq_tags(i,3),M.endo_names, ...
+                          length(cell2mat(eq_tags(i,3)))));
+end
+if any(lead_lag_incidence(lead_index,v_p))
+    error(['portfolio variables appear in the model as forward ' ...
+           'variable'])
+end
+pm.v_p = v_p;
+v_np = setdiff(1:M.endo_nbr,v_p);
+pm.v_np = v_np;
+lli_np = lead_lag_incidence(:,v_np)';
+k = find(lli_np);
+lead_lag_incidence_np = lli_np;
+lead_lag_incidence_np(k) = 1:nnz(lli_np);
+lead_lag_incidence_np = lead_lag_incidence_np';
+pm.lead_lag_incidence_np = lead_lag_incidence_np;
+i_d1_np = [nonzeros(lli_np); nnz(lead_lag_incidence)+(1:M.exo_nbr)'];
+pm.i_d1_np = i_d1_np;
 
-    ih = reshape(1:n*n*n,n,n,n);
-    i_d3_np = ih(i_d1_np,i_d1_np,i_d1_np);
-    pm.i_d3_np = i_d3_np(:);
+n = nnz(lead_lag_incidence)+M.exo_nbr;
+ih = reshape(1:n*n,n,n);
+i_d2_np = ih(i_d1_np,i_d1_np);
+pm.i_d2_np = i_d2_np(:);
 
-    M_np = M;
-    M_np.lead_lag_incidence = lead_lag_incidence_np;
-    M_np.lead_lag_incidence = lead_lag_incidence_np;
-    M_np.endo_nbr = length(v_np);
-    M_np.endo_names = M.endo_names(v_np,:);
-    dr_np = struct();
-    dr_np = set_state_space(dr_np,M_np,options);
-    pm.dr_np = dr_np;
-    M_np.var_order_endo_names = M_np.endo_names(dr_np.order_var,:);
-    pm.M_np = M_np;
-    pm.i_fwrd_g = find(lead_lag_incidence_np(lead_index,dr_np.order_var)');    
+ih = reshape(1:n*n*n,n,n,n);
+i_d3_np = ih(i_d1_np,i_d1_np,i_d1_np);
+pm.i_d3_np = i_d3_np(:);
 
-    i_fwrd_f1 = nonzeros(lead_lag_incidence(lead_index,:));
-    pm.i_fwrd_f1 = i_fwrd_f1;
-    n = nnz(lead_lag_incidence)+M.exo_nbr;
-    ih = reshape(1:n*n,n,n);
-    i_fwrd_f2 = ih(i_fwrd_f1,i_fwrd_f1);
-    pm.i_fwrd_f2 = i_fwrd_f2(:);
-    i_fwrd1_f2 = ih(i_fwrd_f1,:);
-    pm.i_fwrd1_f2 = i_fwrd1_f2(:);
+M_np = M;
+M_np.lead_lag_incidence = lead_lag_incidence_np;
+M_np.lead_lag_incidence = lead_lag_incidence_np;
+M_np.endo_nbr = length(v_np);
+M_np.endo_names = M.endo_names(v_np,:);
+dr_np = struct();
+dr_np = set_state_space(dr_np,M_np,options);
+pm.dr_np = dr_np;
+M_np.var_order_endo_names = M_np.endo_names(dr_np.order_var,:);
+pm.M_np = M_np;
+pm.i_fwrd_g = find(lead_lag_incidence_np(lead_index,dr_np.order_var)');
 
-    ih = reshape(1:n*n*n,n,n,n);
-    i_fwrd_f3 = ih(i_fwrd_f1,i_fwrd_f1,i_fwrd_f1);
-    pm.i_fwrd_f3 = i_fwrd_f3(:);
-    i_fwrd1_f3 = ih(i_fwrd_f1,i_fwrd_f1,:);
-    pm.i_fwrd1_f3 = i_fwrd1_f3(:);
+i_fwrd_f1 = nonzeros(lead_lag_incidence(lead_index,:));
+pm.i_fwrd_f1 = i_fwrd_f1;
+n = nnz(lead_lag_incidence)+M.exo_nbr;
+ih = reshape(1:n*n,n,n);
+i_fwrd_f2 = ih(i_fwrd_f1,i_fwrd_f1);
+pm.i_fwrd_f2 = i_fwrd_f2(:);
+i_fwrd1_f2 = ih(i_fwrd_f1,:);
+pm.i_fwrd1_f2 = i_fwrd1_f2(:);
+
+ih = reshape(1:n*n*n,n,n,n);
+i_fwrd_f3 = ih(i_fwrd_f1,i_fwrd_f1,i_fwrd_f1);
+pm.i_fwrd_f3 = i_fwrd_f3(:);
+i_fwrd1_f3 = ih(i_fwrd_f1,i_fwrd_f1,:);
+pm.i_fwrd1_f3 = i_fwrd1_f3(:);
 end
 
 function r=ds_static_model(y0,f_h,p0,eq_np,v_np,v_p,endo_nbr,exo_nbr,params)
-    ys = zeros(endo_nbr,1);
-    ys(v_p) = p0;
-    ys(v_np) = y0;
-    r = f_h(ys,zeros(exo_nbr,1),params);
-    r = r(eq_np);
+ys = zeros(endo_nbr,1);
+ys(v_p) = p0;
+ys(v_np) = y0;
+r = f_h(ys,zeros(exo_nbr,1),params);
+r = r(eq_np);
 end
 
 function ghsuu = get_ghsuu(g,ns,nx)
-    nxx = nx*(nx+1)/2;
-    m1 = 0;
-    m2 = ns*(ns+1)/2;
-    kk = 1:(nx*nx);
-    ghsuu = zeros(size(g,1),(ns*nx*nx));
-    
-    for i=1:n
-        j = m1+(1:m2);
-        k = j(end-nxx+1:end);
-        ghsuu(:,kk) = unfold2(g(:,k),nx);
-        m1 = m1+m2;
-        m2 = m2 - (n-i+1);
-        kk = kk + nx*nx;
-    end
+nxx = nx*(nx+1)/2;
+m1 = 0;
+m2 = ns*(ns+1)/2;
+kk = 1:(nx*nx);
+ghsuu = zeros(size(g,1),(ns*nx*nx));
+
+for i=1:n
+    j = m1+(1:m2);
+    k = j(end-nxx+1:end);
+    ghsuu(:,kk) = unfold2(g(:,k),nx);
+    m1 = m1+m2;
+    m2 = m2 - (n-i+1);
+    kk = kk + nx*nx;
+end
 end
\ No newline at end of file
diff --git a/matlab/dyn_saveas.m b/matlab/dyn_saveas.m
index 4c897a620..009a49d5e 100644
--- a/matlab/dyn_saveas.m
+++ b/matlab/dyn_saveas.m
@@ -1,11 +1,12 @@
-function dyn_saveas(h,fname,DynareOptions)
-%function dyn_saveas(h,fname,DynareOptions)
+function dyn_saveas(h, fname, nodisplay, graph_format)
+%function dyn_saveas(h, fname, nodisplay, graph_format)
 % save figures for DYNARE
 %
 % INPUTS
 %    h     : figure handle
 %    fname : name of the saved figure
-%    DynareOptions: dynare options
+%    nodisplay: the value of the command-specific nodisplay argument or options_.nodisplay
+%    graph_format: the value of the command-specific graph_format argument or options_.graph_format
 %
 % OUTPUTS
 %    none
@@ -13,7 +14,7 @@ function dyn_saveas(h,fname,DynareOptions)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2012-2013 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,42 +31,42 @@ function dyn_saveas(h,fname,DynareOptions)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if any(strcmp('eps',cellstr(DynareOptions.graph_format)))
+if any(strcmp('eps',cellstr(graph_format)))
     if isoctave
         fname = strrep(fname,'/',filesep);
         fname = strrep(fname,'\',filesep);
-        if DynareOptions.nodisplay && ispc,
+        if nodisplay && ispc
             set(h, 'Visible','on');
         end
     end
-    print(h,'-depsc2',[fname,'.eps']) 
+    print(h,'-depsc2',[fname,'.eps'])
 end
-if any(strcmp('pdf',cellstr(DynareOptions.graph_format)))
+if any(strcmp('pdf',cellstr(graph_format)))
     if isoctave
         error('Octave cannot create pdf files!')
     else
-        print(h,'-dpdf',[fname,'.pdf']) 
+        print(h,'-dpdf',[fname,'.pdf'])
     end
 end
-if any(strcmp('fig',cellstr(DynareOptions.graph_format)))
+if any(strcmp('fig',cellstr(graph_format)))
     if isoctave
         error('Octave cannot create fig files!')
     else
-        if DynareOptions.nodisplay
-%  THE FOLLOWING LINES COULD BE USED IF BUGS/PROBLEMS ARE REPORTED USING LINE 60		
-%             set(h,'Units','Normalized')
-%             mypos=get(h,'Position');
-%             set(h,'Position',[-1 -1 mypos(3:4)])
-%             set(h, 'Visible','on');
+        if nodisplay
+            %  THE FOLLOWING LINES COULD BE USED IF BUGS/PROBLEMS ARE REPORTED USING LINE 60
+            %             set(h,'Units','Normalized')
+            %             mypos=get(h,'Position');
+            %             set(h,'Position',[-1 -1 mypos(3:4)])
+            %             set(h, 'Visible','on');
             set(h,'CreateFcn','set(gcf, ''Visible'',''on'')') ;
         end
         saveas(h,[fname '.fig']);
     end
 end
-if any(strcmp('none',cellstr(DynareOptions.graph_format)))
-% don't save
-% check here as a reminder that none is an option to graph_format
+if any(strcmp('none',cellstr(graph_format)))
+    % don't save
+    % check here as a reminder that none is an option to graph_format
 end
-if DynareOptions.nodisplay
+if nodisplay
     close(h);
 end
diff --git a/matlab/dyn_second_order_solver.m b/matlab/dyn_second_order_solver.m
index dd2d2bfb8..df6ba7693 100644
--- a/matlab/dyn_second_order_solver.m
+++ b/matlab/dyn_second_order_solver.m
@@ -32,7 +32,7 @@ function dr = dyn_second_order_solver(jacobia,hessian_mat,dr,M_,threads_ABC,thre
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2001-2012 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -48,135 +48,135 @@ function dr = dyn_second_order_solver(jacobia,hessian_mat,dr,M_,threads_ABC,thre
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
-    dr.ghxx = [];
-    dr.ghuu = [];
-    dr.ghxu = [];
-    dr.ghs2 = [];
-    Gy = dr.Gy;
-    
-    kstate = dr.kstate;
-    nstatic = M_.nstatic;
-    nfwrd = M_.nfwrd;
-    nspred = M_.nspred;
-    nboth = M_.nboth;
-    nsfwrd = M_.nsfwrd;
-    order_var = dr.order_var;
-    nd = size(kstate,1);
-    lead_lag_incidence = M_.lead_lag_incidence;
 
-    np = nd - nsfwrd;
+dr.ghxx = [];
+dr.ghuu = [];
+dr.ghxu = [];
+dr.ghs2 = [];
+Gy = dr.Gy;
 
-    k1 = nonzeros(lead_lag_incidence(:,order_var)');
-    kk = [k1; length(k1)+(1:M_.exo_nbr+M_.exo_det_nbr)'];
-    nk = size(kk,1);
-    kk1 = reshape([1:nk^2],nk,nk);
-    kk1 = kk1(kk,kk);
-    % reordering second order derivatives
-    hessian_mat = hessian_mat(:,kk1(:));
+kstate = dr.kstate;
+nstatic = M_.nstatic;
+nfwrd = M_.nfwrd;
+nspred = M_.nspred;
+nboth = M_.nboth;
+nsfwrd = M_.nsfwrd;
+order_var = dr.order_var;
+nd = size(kstate,1);
+lead_lag_incidence = M_.lead_lag_incidence;
 
-    zx = zeros(np,np);
-    zu=zeros(np,M_.exo_nbr);
-    zx(1:np,:)=eye(np);
-    k0 = [1:M_.endo_nbr];
-    gx1 = dr.ghx;
-    hu = dr.ghu(nstatic+[1:nspred],:);
-    k0 = find(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)');
-    zx = [zx; gx1(k0,:)];
-    zu = [zu; dr.ghu(k0,:)];
-    k1 = find(lead_lag_incidence(M_.maximum_endo_lag+2,order_var)');
-    zu = [zu; gx1(k1,:)*hu];
-    zx = [zx; gx1(k1,:)*Gy];
-    zx=[zx; zeros(M_.exo_nbr,np);zeros(M_.exo_det_nbr,np)];
-    zu=[zu; eye(M_.exo_nbr);zeros(M_.exo_det_nbr,M_.exo_nbr)];
-    [nrzx,nczx] = size(zx);
+np = nd - nsfwrd;
 
-    [rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat,zx,threads_BC);
-    mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
-    rhs = -rhs;
+k1 = nonzeros(lead_lag_incidence(:,order_var)');
+kk = [k1; length(k1)+(1:M_.exo_nbr+M_.exo_det_nbr)'];
+nk = size(kk,1);
+kk1 = reshape([1:nk^2],nk,nk);
+kk1 = kk1(kk,kk);
+% reordering second order derivatives
+hessian_mat = hessian_mat(:,kk1(:));
 
-    %lhs
-    n = M_.endo_nbr+sum(kstate(:,2) > M_.maximum_endo_lag+1 & kstate(:,2) < M_.maximum_endo_lag+M_.maximum_endo_lead+1);
-    A = zeros(M_.endo_nbr,M_.endo_nbr);
-    B = zeros(M_.endo_nbr,M_.endo_nbr);
-    A(:,k0) = jacobia(:,nonzeros(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)));
-    % variables with the highest lead
-    k1 = find(kstate(:,2) == M_.maximum_endo_lag+2);
-    % Jacobian with respect to the variables with the highest lead
-    fyp = jacobia(:,kstate(k1,3)+nnz(M_.lead_lag_incidence(M_.maximum_endo_lag+1,:)));
-    B(:,nstatic+M_.npred+1:end) = fyp;
-    [junk,k1,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+M_.maximum_endo_lead+1,order_var));
-    A(1:M_.endo_nbr,nstatic+1:nstatic+nspred)=...
-        A(1:M_.endo_nbr,nstatic+[1:nspred])+fyp*gx1(k1,1:nspred);
-    C = Gy;
-    D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
+zx = zeros(np,np);
+zu=zeros(np,M_.exo_nbr);
+zx(1:np,:)=eye(np);
+k0 = [1:M_.endo_nbr];
+gx1 = dr.ghx;
+hu = dr.ghu(nstatic+[1:nspred],:);
+k0 = find(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)');
+zx = [zx; gx1(k0,:)];
+zu = [zu; dr.ghu(k0,:)];
+k1 = find(lead_lag_incidence(M_.maximum_endo_lag+2,order_var)');
+zu = [zu; gx1(k1,:)*hu];
+zx = [zx; gx1(k1,:)*Gy];
+zx=[zx; zeros(M_.exo_nbr,np);zeros(M_.exo_det_nbr,np)];
+zu=[zu; eye(M_.exo_nbr);zeros(M_.exo_det_nbr,M_.exo_nbr)];
+[nrzx,nczx] = size(zx);
+
+[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat,zx,threads_BC);
+mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
+rhs = -rhs;
+
+%lhs
+n = M_.endo_nbr+sum(kstate(:,2) > M_.maximum_endo_lag+1 & kstate(:,2) < M_.maximum_endo_lag+M_.maximum_endo_lead+1);
+A = zeros(M_.endo_nbr,M_.endo_nbr);
+B = zeros(M_.endo_nbr,M_.endo_nbr);
+A(:,k0) = jacobia(:,nonzeros(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)));
+% variables with the highest lead
+k1 = find(kstate(:,2) == M_.maximum_endo_lag+2);
+% Jacobian with respect to the variables with the highest lead
+fyp = jacobia(:,kstate(k1,3)+nnz(M_.lead_lag_incidence(M_.maximum_endo_lag+1,:)));
+B(:,nstatic+M_.npred+1:end) = fyp;
+[junk,k1,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+M_.maximum_endo_lead+1,order_var));
+A(1:M_.endo_nbr,nstatic+1:nstatic+nspred)=...
+    A(1:M_.endo_nbr,nstatic+[1:nspred])+fyp*gx1(k1,1:nspred);
+C = Gy;
+D = [rhs; zeros(n-M_.endo_nbr,size(rhs,2))];
 
 
-    [err, dr.ghxx] = gensylv(2,A,B,C,D);
-    mexErrCheck('gensylv', err);
+[err, dr.ghxx] = gensylv(2,A,B,C,D);
+mexErrCheck('gensylv', err);
 
-    %ghxu
-    %rhs
-    hu = dr.ghu(nstatic+1:nstatic+nspred,:);
-    [rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat,zx,zu,threads_BC);
-    mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
+%ghxu
+%rhs
+hu = dr.ghu(nstatic+1:nstatic+nspred,:);
+[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat,zx,zu,threads_BC);
+mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
 
-    hu1 = [hu;zeros(np-nspred,M_.exo_nbr)];
-    [nrhx,nchx] = size(Gy);
-    [nrhu1,nchu1] = size(hu1);
+hu1 = [hu;zeros(np-nspred,M_.exo_nbr)];
+[nrhx,nchx] = size(Gy);
+[nrhu1,nchu1] = size(hu1);
 
-    [abcOut,err] = A_times_B_kronecker_C(dr.ghxx,Gy,hu1,threads_ABC);
-    mexErrCheck('A_times_B_kronecker_C', err);
-    B1 = B*abcOut;
-    rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
+[abcOut,err] = A_times_B_kronecker_C(dr.ghxx,Gy,hu1,threads_ABC);
+mexErrCheck('A_times_B_kronecker_C', err);
+B1 = B*abcOut;
+rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
 
 
-    %lhs
-    dr.ghxu = A\rhs;
+%lhs
+dr.ghxu = A\rhs;
 
-    %ghuu
-    %rhs
-    [rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat,zu,threads_BC);
-    mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
+%ghuu
+%rhs
+[rhs, err] = sparse_hessian_times_B_kronecker_C(hessian_mat,zu,threads_BC);
+mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
 
-    [B1, err] = A_times_B_kronecker_C(B*dr.ghxx,hu1,threads_ABC);
-    mexErrCheck('A_times_B_kronecker_C', err);
-    rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
+[B1, err] = A_times_B_kronecker_C(B*dr.ghxx,hu1,threads_ABC);
+mexErrCheck('A_times_B_kronecker_C', err);
+rhs = -[rhs; zeros(n-M_.endo_nbr,size(rhs,2))]-B1;
 
-    %lhs
-    dr.ghuu = A\rhs;
+%lhs
+dr.ghuu = A\rhs;
 
-    % dr.ghs2
-    % derivatives of F with respect to forward variables
-    % reordering predetermined variables in diminishing lag order
-    O1 = zeros(M_.endo_nbr,nstatic);
-    O2 = zeros(M_.endo_nbr,M_.endo_nbr-nstatic-nspred);
-    LHS = zeros(M_.endo_nbr,M_.endo_nbr);
-    LHS(:,k0) = jacobia(:,nonzeros(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)));
-    RHS = zeros(M_.endo_nbr,M_.exo_nbr^2);
-    gu = dr.ghu; 
-    guu = dr.ghuu; 
-    E = eye(M_.endo_nbr);
-    kh = reshape([1:nk^2],nk,nk);
-    kp = sum(kstate(:,2) <= M_.maximum_endo_lag+1);
-    E1 = [eye(nspred); zeros(kp-nspred,nspred)];
-    H = E1;
-    hxx = dr.ghxx(nstatic+[1:nspred],:);
-    [junk,k2a,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+2,order_var));
-    k3 = nnz(M_.lead_lag_incidence(1:M_.maximum_endo_lag+1,:))+(1:M_.nsfwrd)';
-    [B1, err] = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kh(k3,k3)),gu(k2a,:),threads_BC);
-    mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
-    RHS = RHS + jacobia(:,k2)*guu(k2a,:)+B1;
+% dr.ghs2
+% derivatives of F with respect to forward variables
+% reordering predetermined variables in diminishing lag order
+O1 = zeros(M_.endo_nbr,nstatic);
+O2 = zeros(M_.endo_nbr,M_.endo_nbr-nstatic-nspred);
+LHS = zeros(M_.endo_nbr,M_.endo_nbr);
+LHS(:,k0) = jacobia(:,nonzeros(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)));
+RHS = zeros(M_.endo_nbr,M_.exo_nbr^2);
+gu = dr.ghu;
+guu = dr.ghuu;
+E = eye(M_.endo_nbr);
+kh = reshape([1:nk^2],nk,nk);
+kp = sum(kstate(:,2) <= M_.maximum_endo_lag+1);
+E1 = [eye(nspred); zeros(kp-nspred,nspred)];
+H = E1;
+hxx = dr.ghxx(nstatic+[1:nspred],:);
+[junk,k2a,k2] = find(M_.lead_lag_incidence(M_.maximum_endo_lag+2,order_var));
+k3 = nnz(M_.lead_lag_incidence(1:M_.maximum_endo_lag+1,:))+(1:M_.nsfwrd)';
+[B1, err] = sparse_hessian_times_B_kronecker_C(hessian_mat(:,kh(k3,k3)),gu(k2a,:),threads_BC);
+mexErrCheck('sparse_hessian_times_B_kronecker_C', err);
+RHS = RHS + jacobia(:,k2)*guu(k2a,:)+B1;
 
-    % LHS
-    LHS = LHS + jacobia(:,k2)*(E(k2a,:)+[O1(k2a,:) dr.ghx(k2a,:)*H O2(k2a,:)]);
-    
-    RHS = RHS*M_.Sigma_e(:);
-    dr.fuu = RHS;
-    %RHS = -RHS-dr.fbias;
-    RHS = -RHS;
-    dr.ghs2 = LHS\RHS;
+% LHS
+LHS = LHS + jacobia(:,k2)*(E(k2a,:)+[O1(k2a,:) dr.ghx(k2a,:)*H O2(k2a,:)]);
 
-    % deterministic exogenous variables
-    if M_.exo_det_nbr > 0
-    end
+RHS = RHS*M_.Sigma_e(:);
+dr.fuu = RHS;
+%RHS = -RHS-dr.fbias;
+RHS = -RHS;
+dr.ghs2 = LHS\RHS;
+
+% deterministic exogenous variables
+if M_.exo_det_nbr > 0
+end
diff --git a/matlab/dyn_unvech.m b/matlab/dyn_unvech.m
index f70670a98..0c6c853cc 100644
--- a/matlab/dyn_unvech.m
+++ b/matlab/dyn_unvech.m
@@ -1,13 +1,13 @@
 function Matrix = dyn_unvech(Vector)
 % This function implements the unvech operator.
-% 
-% INPUTS 
+%
+% INPUTS
 %   Vector             [double]   a m*1 vector.
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   Matrix             [double]   a n*n symetric matrix, where n solves n*(n+1)/2=m.
 
-% Copyright (C) 2010 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/dyn_vech.m b/matlab/dyn_vech.m
index 6e54c4050..dc18f974b 100644
--- a/matlab/dyn_vech.m
+++ b/matlab/dyn_vech.m
@@ -1,13 +1,13 @@
 function Vector = dyn_vech(Matrix)
 % This function implements the vech operator.
-% 
-% INPUTS 
+%
+% INPUTS
 %   Matrix             [double]   a squared n*n symetric matrix.
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   Vector             [double]   a n*(n+1)/2 vector.
 
-% Copyright (C) 2010 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/dyn_waitbar.m b/matlab/dyn_waitbar.m
index f9665c950..43567dcd3 100644
--- a/matlab/dyn_waitbar.m
+++ b/matlab/dyn_waitbar.m
@@ -4,7 +4,7 @@ function h = dyn_waitbar(prctdone, varargin)
 % octave and when console_mode=1
 
 %
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ if iscell(prctdone)
     prctdone=prctdone{1};
 end
 
-if prctdone==0,
+if prctdone==0
     init=1;
     if isempty(whoiam)
         whoiam=0;
@@ -38,23 +38,20 @@ if prctdone==0,
 else
     init=0;
 end
-if nargout,
+if nargout
     h=[];
 end
 
 if ~whoiam
-    
     if isoctave || options_.console_mode
-                
-        if init,
+        if init
             diary off;
             running_text = varargin{1};
             newString='';
-            return;
-        elseif nargin>2,
+            return
+        elseif nargin>2
             running_text =  varargin{2};
         end
-        
         if isoctave
             printf([running_text,' %3.f%% done\r'], prctdone*100);
         else
@@ -62,26 +59,23 @@ if ~whoiam
             newString=sprintf([running_text,' %3.f%% done'], prctdone*100);
             fprintf([s0,'%s'],newString);
         end
-        
     else
-        if nargout,
+        if nargout
             h = waitbar(prctdone,varargin{:});
         else
             waitbar(prctdone,varargin{:});
         end
     end
-    
 else
-    if init,
+    if init
         running_text = varargin{1};
     elseif nargin>2
         running_text = varargin{2};
     end
-    if Parallel.Local,
+    if Parallel.Local
         waitbarTitle=['Local '];
     else
         waitbarTitle=[Parallel.ComputerName];
     end
     fMessageStatus(prctdone,whoiam,running_text, waitbarTitle, Parallel);
 end
-
diff --git a/matlab/dyn_waitbar_close.m b/matlab/dyn_waitbar_close.m
index 894e4c6fa..c2864a9b6 100644
--- a/matlab/dyn_waitbar_close.m
+++ b/matlab/dyn_waitbar_close.m
@@ -1,10 +1,10 @@
 function dyn_waitbar_close(h)
 % h = dyn_waitbar_close(h)
-% adaptive close waitbar, compatible with 
+% adaptive close waitbar, compatible with
 % octave and when console_mode=1
 
 %
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -22,14 +22,12 @@ function dyn_waitbar_close(h)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 global options_
 
-if isoctave || options_.console_mode,
+if isoctave || options_.console_mode
     clear dyn_waitbar;
-    diary on,
+    diary on
     fprintf('\n');
 else
-    close(h),
+    close(h)
 end
 
 clear dyn_waitbar;
-
-
diff --git a/matlab/dynare.m b/matlab/dynare.m
index 34ee71148..91ae8beb4 100644
--- a/matlab/dynare.m
+++ b/matlab/dynare.m
@@ -1,7 +1,7 @@
 function dynare(fname, varargin)
 %       This command runs dynare with specified model file in argument
 %       Filename.
-%       The name of model file begins with an alphabetic character, 
+%       The name of model file begins with an alphabetic character,
 %       and has a filename extension of .mod or .dyn.
 %       When extension is omitted, a model file with .mod extension
 %       is processed.
@@ -9,10 +9,10 @@ function dynare(fname, varargin)
 % INPUTS
 %   fname:      file name
 %   varargin:   list of arguments following fname
-%             
+%
 % OUTPUTS
 %   none
-%        
+%
 % SPECIAL REQUIREMENTS
 %   none
 
@@ -64,7 +64,7 @@ dynareroot = dynare_config;
 
 warning_config()
 
-if isoctave 
+if isoctave
     if octave_ver_less_than('3.6.0')
         warning('This version of Dynare has only been tested on Octave 3.6.0 and above. Since your Octave version is older than that, Dynare may fail to run, or give unexpected results. Consider upgrading your Octave installation.');
     end
@@ -111,12 +111,12 @@ if isempty(strfind(fname,'.'))
     % Checking file extension
 else
     if dot_location~=length(fname)-3 ... %if the file name has fewer than 4 characters and there is a period
-        || ~strcmp(upper(fname(size(fname,2)-3:size(fname,2))),'.MOD') ...
+            || ~strcmp(upper(fname(size(fname,2)-3:size(fname,2))),'.MOD') ...
             && ~strcmp(upper(fname(size(fname,2)-3:size(fname,2))),'.DYN')
         error('DYNARE: argument must be a filename with .mod or .dyn extension and must not include any other periods')
-    end;
+    end
     fnamelength = length(fname) - 4;
-end;
+end
 
 if fnamelength + length('_set_auxiliary_variables') > namelengthmax()
     error('The name of your MOD file is too long, please shorten it')
@@ -176,11 +176,11 @@ else
 end
 
 if isempty(strfind(arch, '64'))
-  arch_ext = '32';
-  disp('Using 32-bit preprocessor');
+    arch_ext = '32';
+    disp('Using 32-bit preprocessor');
 else
-  arch_ext = '64';
-  disp('Using 64-bit preprocessor');
+    arch_ext = '64';
+    disp('Using 64-bit preprocessor');
 end
 
 command = ['"' dynareroot 'preprocessor' arch_ext filesep 'dynare_m" ' fname] ;
@@ -192,7 +192,7 @@ end
 disp(result)
 if ismember('onlymacro', varargin)
     disp('Preprocesser stopped after macroprocessing step because of ''onlymacro'' option.');
-    return;
+    return
 end
 
 if ismember('onlyjson', varargin)
diff --git a/matlab/dynare_config.m b/matlab/dynare_config.m
index c70e0a89f..ae65aab15 100644
--- a/matlab/dynare_config.m
+++ b/matlab/dynare_config.m
@@ -15,7 +15,7 @@ function dynareroot = dynare_config(path_to_dynare,verbose)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,6 +58,7 @@ p = {'/distributions/' ; ...
      '/particles/src' ; ...
      '/gsa/' ; ...
      '/ep/' ; ...
+     '/backward/' ; ...
      '/convergence_diagnostics/' ; ... 
      '/cli/' ; ...
      '/lmmcp/' ; ...
@@ -68,6 +69,7 @@ p = {'/distributions/' ; ...
      '/utilities/tests/src/' ; ...
      '/utilities/dataset/' ; ...
      '/utilities/general/' ; ...
+     '/utilities/graphics/' ; ...
      '/modules/reporting/src/' ; ...
      '/modules/reporting/macros/'};
 
@@ -113,10 +115,15 @@ end
 % nanmean is in Octave Forge Statistics package and in MATLAB Statistics
 % toolbox
 if (isoctave && ~user_has_octave_forge_package('statistics')) ...
-    || (~isoctave && ~user_has_matlab_license('statistics_toolbox'))
+        || (~isoctave && ~user_has_matlab_license('statistics_toolbox'))
     p{end+1} = '/missing/nanmean';
 end
 
+% Check if struct2array is available.
+if ~exist('struct2array')
+    p{end+1} = '/missing/struct2array';
+end
+
 P = cellfun(@(c)[dynareroot(1:end-1) c], p, 'uni',false);
 
 % Get mex files folder(s)
diff --git a/matlab/dynare_estimation.m b/matlab/dynare_estimation.m
index dff898fb4..98ad16c32 100644
--- a/matlab/dynare_estimation.m
+++ b/matlab/dynare_estimation.m
@@ -12,7 +12,7 @@ function oo_recursive_=dynare_estimation(var_list,dname)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2003-2015 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,8 +32,8 @@ function oo_recursive_=dynare_estimation(var_list,dname)
 global options_ oo_ M_ dataset_ dataset_info
 
 oo_recursive_={};
-
-% Test if the order of approximation is nonzero (the preprocessor tests if order is non negative).
+mode_file0 = options_.mode_file; % store mode_file set by the user
+                                 % Test if the order of approximation is nonzero (the preprocessor tests if order is non negative).
 if isequal(options_.order,0)
     error('Estimation:: The order of the Taylor approximation cannot be 0!')
 end
@@ -46,8 +46,8 @@ end
 var_list = check_list_of_variables(options_, M_, var_list);
 options_.varlist = var_list;
 
-nobs = sort(options_.nobs); 
-first_obs = sort(options_.first_obs); 
+nobs = sort(options_.nobs);
+first_obs = sort(options_.first_obs);
 
 nnobs = length(nobs);
 nfirstobs = length(first_obs);
@@ -55,7 +55,7 @@ nfirstobs = length(first_obs);
 if nnobs~=1 && nfirstobs~=1
     error('You cannot simultaneously do rolling window and recursive estimation')
 end
-    
+
 horizon = options_.forecast;
 
 if nargin<2 || ~exist('dname','var') || isempty(dname)
@@ -82,8 +82,8 @@ if nnobs>1 || nfirstobs > 1
         if nnobs>1
             options_.nobs = nobs(i);
             M_.dname = [dname '_' int2str(nobs(i))];
-        elseif nfirstobs>1;
-            options_.first_obs=first_obs(i);            
+        elseif nfirstobs>1
+            options_.first_obs=first_obs(i);
             M_.dname = [dname '_' int2str(first_obs(i))];
         end
         dynare_estimation_1(var_list,M_.dname);
@@ -97,7 +97,7 @@ if nnobs>1 || nfirstobs > 1
         end
         if nnobs>1
             oo_recursive_{nobs(i)} = oo_;
-        elseif nfirstobs>1;
+        elseif nfirstobs>1
             oo_recursive_{first_obs(i)} = oo_;
         end
     end
@@ -105,7 +105,7 @@ else
     dynare_estimation_1(var_list,dname);
 end
 
-if isnumeric(options_.mode_compute) && options_.mode_compute && options_.analytic_derivation,
+if isnumeric(options_.mode_compute) && options_.mode_compute && options_.analytic_derivation
     options_.analytic_derivation=analytic_derivation0;
 end
 
@@ -138,11 +138,11 @@ if nnobs > 1 && horizon > 0
             IdObs(j,1) = iobs;
         end
     end
-    
+
     gend = dataset_.nobs;
     time_offset=min(3,gend-1); %for observables, plot 3 previous periods unless data is shorter
     k = time_offset+min(nobs(end)-nobs(1)+horizon, ...
-              size(dataset_.data,1)-nobs(1));
+                        size(dataset_.data,1)-nobs(1));
     data2 = dataset_info.rawdata(end-k+1:end,:);
     [nbplt,nr,nc,lr,lc,nstar] = pltorg(nvar);
     m = 1;
@@ -151,7 +151,7 @@ if nnobs > 1 && horizon > 0
     for i = 1:size(var_list,1)
         if mod(i,nstar) == 1
             plot_index=plot_index+1;
-            hfig = dyn_figure(options_,'Name',['Out of sample forecasts (',num2str(plot_index),')']);
+            hfig = dyn_figure(options_.nodisplay,'Name',['Out of sample forecasts (',num2str(plot_index),')']);
             m = 1;
         end
         subplot(nr,nc,m)
@@ -167,23 +167,23 @@ if nnobs > 1 && horizon > 0
         for j=1:nnobs
             if mh_replic > 0
                 oo_.RecursiveForecast.Mean.(vname)(j,:) = ...
-                      oo_recursive_{nobs(j)}.MeanForecast.Mean.(vname);
+                    oo_recursive_{nobs(j)}.MeanForecast.Mean.(vname);
                 oo_.RecursiveForecast.HPDinf.(vname)(j,:) = ...
-                      oo_recursive_{nobs(j)}.MeanForecast.HPDinf.(vname);
+                    oo_recursive_{nobs(j)}.MeanForecast.HPDinf.(vname);
                 oo_.RecursiveForecast.HPDsup.(vname)(j,:) = ...
-                      oo_recursive_{nobs(j)}.MeanForecast.HPDsup.(vname);
+                    oo_recursive_{nobs(j)}.MeanForecast.HPDsup.(vname);
                 oo_.RecursiveForecast.HPDTotalinf.(vname)(j,:) = ...
-                      oo_recursive_{nobs(j)}.PointForecast.HPDinf.(vname);
+                    oo_recursive_{nobs(j)}.PointForecast.HPDinf.(vname);
                 oo_.RecursiveForecast.HPDTotalsup.(vname)(j,:) = ...
-                      oo_recursive_{nobs(j)}.PointForecast.HPDsup.(vname);
+                    oo_recursive_{nobs(j)}.PointForecast.HPDsup.(vname);
             else
                 oo_.RecursiveForecast.Mean.(vname)(j,:) =...
-                      oo_recursive_{nobs(j)}.forecast.Mean.(vname);
+                    oo_recursive_{nobs(j)}.forecast.Mean.(vname);
                 oo_.RecursiveForecast.HPDinf.(vname)(j,:) =...
-                      oo_recursive_{nobs(j)}.forecast.HPDinf.(vname);
+                    oo_recursive_{nobs(j)}.forecast.HPDinf.(vname);
                 oo_.RecursiveForecast.HPDsup.(vname)(j,:) =...
-                      oo_recursive_{nobs(j)}.forecast.HPDsup.(vname);
-              end
+                    oo_recursive_{nobs(j)}.forecast.HPDsup.(vname);
+            end
             x = nobs(1)+nobs(j)-nobs(1)+(1:horizon);
 
             y = oo_.RecursiveForecast.Mean.(vname)(j,:);
@@ -208,8 +208,9 @@ if nnobs > 1 && horizon > 0
         xlim([nobs(1)-offsetx nobs(end)+horizon])
         m = m + 1;
         if mod(i+1,nstar) == 1 || i ==size(var_list,1)
-            dyn_saveas(hfig,[M_.fname,filesep,'graphs',filesep M_.fname '_RecursiveForecasts_' int2str(plot_index)],options_);
+            dyn_saveas(hfig,[M_.fname,filesep,'graphs',filesep M_.fname '_RecursiveForecasts_' int2str(plot_index)],options_.nodisplay,options_.graph_format);
         end
     end
 end
-options_.mode_file = ''; %delete stored mode-file so that it is not reaccessed in later calls (and in case it was only set by the recursive estimation)
+options_.mode_file = mode_file0;
+%reset stored mode-file to user defined one (and in case it was only set by the recursive estimation)
diff --git a/matlab/dynare_estimation_1.m b/matlab/dynare_estimation_1.m
index 6077501ca..a4b416614 100644
--- a/matlab/dynare_estimation_1.m
+++ b/matlab/dynare_estimation_1.m
@@ -12,7 +12,7 @@ function dynare_estimation_1(var_list_,dname)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,17 +31,33 @@ function dynare_estimation_1(var_list_,dname)
 
 global M_ options_ oo_ estim_params_ bayestopt_ dataset_ dataset_info
 
+if isempty(estim_params_)
+    mode_compute_o = options_.mode_compute;
+    mh_replic_o = options_.mh_replic;
+    options_.mode_compute = 0;
+    options_.mh_replic = 0;
+    reset_options_related_to_estimation = true;
+else
+    reset_options_related_to_estimation = false;
+end
+
+
 %store qz_criterium
 qz_criterium_old=options_.qz_criterium;
+if isnan(options_.first_obs)
+    first_obs_nan_indicator=true;
+else
+    first_obs_nan_indicator=false;
+end
 
 % Set particle filter flag.
 if options_.order > 1
-    if options_.particle.status && options_.order==2  
+    if options_.particle.status && options_.order==2
         skipline()
         disp('Estimation using a non linear filter!')
         skipline()
         if ~options_.nointeractive && ismember(options_.mode_compute,[1,3,4]) && ~strcmpi(options_.particle.filter_algorithm,'gf')% Known gradient-based optimizers
-            disp('You are using a gradient-based mode-finder. Particle filtering introduces discontinuities in the') 
+            disp('You are using a gradient-based mode-finder. Particle filtering introduces discontinuities in the')
             disp('objective function w.r.t the parameters. Thus, should use a non-gradient based optimizer.')
             fprintf('\nPlease choose a mode-finder:\n')
             fprintf('\t 0 - Continue using gradient-based method (it is most likely that you will no get any sensible result).\n')
@@ -154,7 +170,7 @@ catch % if check fails, provide info on using calibration if present
         fprintf('ESTIMATION_CHECKS: There was an error in computing the likelihood for initial parameter values.\n')
         fprintf('ESTIMATION_CHECKS: If this is not a problem with the setting of options (check the error message below),\n')
         fprintf('ESTIMATION_CHECKS: you should try using the calibrated version of the model as starting values. To do\n')
-        fprintf('ESTIMATION_CHECKS: this, add an empty estimated_params_init-block with use_calibration option immediately before the estimation\n')    
+        fprintf('ESTIMATION_CHECKS: this, add an empty estimated_params_init-block with use_calibration option immediately before the estimation\n')
         fprintf('ESTIMATION_CHECKS: command (and after the estimated_params-block so that it does not get overwritten):\n');
         skipline(2);
     end
@@ -186,7 +202,7 @@ if ~isequal(options_.mode_compute,0) && ~options_.mh_posterior_mode_estimation
                 end
             end
         end
-        if options_.analytic_derivation,
+        if options_.analytic_derivation
             options_analytic_derivation_old = options_.analytic_derivation;
             options_.analytic_derivation = -1;
             if ~isempty(newratflag) && newratflag~=0 %numerical hessian explicitly specified
@@ -194,32 +210,32 @@ if ~isequal(options_.mode_compute,0) && ~options_.mh_posterior_mode_estimation
             else %use default
                 newratflag=0; %exclude DYNARE numerical hessian
             end
-        elseif ~options_.analytic_derivation 
-            if isempty(newratflag) 
-                newratflag=options_.newrat.hess; %use default numerical dynare hessian                
+        elseif ~options_.analytic_derivation
+            if isempty(newratflag)
+                newratflag=options_.newrat.hess; %use default numerical dynare hessian
             end
         end
     end
-    
+
     [xparam1, fval, exitflag, hh, options_, Scale, new_rat_hess_info] = dynare_minimize_objective(objective_function,xparam1,options_.mode_compute,options_,[bounds.lb bounds.ub],bayestopt_.name,bayestopt_,hh,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_);
     fprintf('\nFinal value of minus the log posterior (or likelihood):%f \n', fval);
 
     if isnumeric(options_.mode_compute) && options_.mode_compute==5 && options_.analytic_derivation==-1 %reset options changed by newrat
-            options_.analytic_derivation = options_analytic_derivation_old; %reset      
+        options_.analytic_derivation = options_analytic_derivation_old; %reset
     elseif isnumeric(options_.mode_compute) && options_.mode_compute==6 %save scaling factor
         save([M_.fname '_optimal_mh_scale_parameter.mat'],'Scale');
         options_.mh_jscale = Scale;
         bayestopt_.jscale = ones(length(xparam1),1)*Scale;
-    end       
+    end
     if ~isnumeric(options_.mode_compute) || ~isequal(options_.mode_compute,6) %always already computes covariance matrix
         if options_.cova_compute == 1 %user did not request covariance not to be computed
-            if options_.analytic_derivation && strcmp(func2str(objective_function),'dsge_likelihood'),
+            if options_.analytic_derivation && strcmp(func2str(objective_function),'dsge_likelihood')
                 ana_deriv_old = options_.analytic_derivation;
                 options_.analytic_derivation = 2;
                 [junk1, junk2,junk3, junk4, hh] = feval(objective_function,xparam1, ...
-                    dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_);
+                                                        dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_);
                 options_.analytic_derivation = ana_deriv_old;
-            elseif ~isnumeric(options_.mode_compute) || ~(isequal(options_.mode_compute,5) && newratflag~=1), 
+            elseif ~isnumeric(options_.mode_compute) || ~(isequal(options_.mode_compute,5) && newratflag~=1)
                 % with flag==0, we force to use the hessian from outer product gradient of optimizer 5
                 if options_.hessian.use_penalized_objective
                     penalized_objective_function = str2func('penalty_objective_function');
@@ -242,15 +258,15 @@ if ~isequal(options_.mode_compute,0) && ~options_.mh_posterior_mode_estimation
                 % densitities for outer product gradient
                 kalman_algo0 = options_.kalman_algo;
                 compute_hessian = 1;
-                if ~((options_.kalman_algo == 2) || (options_.kalman_algo == 4)),
+                if ~((options_.kalman_algo == 2) || (options_.kalman_algo == 4))
                     options_.kalman_algo=2;
-                    if options_.lik_init == 3,
+                    if options_.lik_init == 3
                         options_.kalman_algo=4;
                     end
-                elseif newratflag==0, % hh already contains outer product gradient with univariate filter
-                    compute_hessian = 0;                                            
+                elseif newratflag==0 % hh already contains outer product gradient with univariate filter
+                    compute_hessian = 0;
                 end
-                if compute_hessian,
+                if compute_hessian
                     crit = options_.newrat.tolerance.f;
                     newratflag = newratflag>0;
                     hh = reshape(mr_hessian(xparam1,objective_function,fval,newratflag,crit,new_rat_hess_info,dataset_, dataset_info, options_,M_,estim_params_,bayestopt_,bounds,oo_), nx, nx);
@@ -280,7 +296,7 @@ if ~options_.mh_posterior_mode_estimation && options_.cova_compute
         params_at_bound=find(abs(xparam1-bounds.ub)<1.e-10 | abs(xparam1-bounds.lb)<1.e-10);
         if ~isempty(params_at_bound)
             for ii=1:length(params_at_bound)
-            params_at_bound_name{ii,1}=get_the_name(params_at_bound(ii),0,M_,estim_params_,options_);
+                params_at_bound_name{ii,1}=get_the_name(params_at_bound(ii),0,M_,estim_params_,options_);
             end
             disp_string=[params_at_bound_name{1,:}];
             for ii=2:size(params_at_bound_name,1)
@@ -369,41 +385,40 @@ if np > 0
 end
 
 switch options_.MCMC_jumping_covariance
-    case 'hessian' %Baseline
-        %do nothing and use hessian from mode_compute
-    case 'prior_variance' %Use prior variance
-        if any(isinf(bayestopt_.p2))
-            error('Infinite prior variances detected. You cannot use the prior variances as the proposal density, if some variances are Inf.')
-        else
-            hh = diag(1./(bayestopt_.p2.^2));
-        end
+  case 'hessian' %Baseline
+                 %do nothing and use hessian from mode_compute
+  case 'prior_variance' %Use prior variance
+    if any(isinf(bayestopt_.p2))
+        error('Infinite prior variances detected. You cannot use the prior variances as the proposal density, if some variances are Inf.')
+    else
+        hh = diag(1./(bayestopt_.p2.^2));
+    end
+    hsd = sqrt(diag(hh));
+    invhess = inv(hh./(hsd*hsd'))./(hsd*hsd');
+  case 'identity_matrix' %Use identity
+    invhess = eye(nx);
+  otherwise %user specified matrix in file
+    try
+        load(options_.MCMC_jumping_covariance,'jumping_covariance')
+        hh=jumping_covariance;
+    catch
+        error(['No matrix named ''jumping_covariance'' could be found in ',options_.MCMC_jumping_covariance,'.mat'])
+    end
+    [nrow, ncol]=size(hh);
+    if ~isequal(nrow,ncol) && ~isequal(nrow,nx) %check if square and right size
+        error(['jumping_covariance matrix must be square and have ',num2str(nx),' rows and columns'])
+    end
+    try %check for positive definiteness
+        chol(hh);
         hsd = sqrt(diag(hh));
         invhess = inv(hh./(hsd*hsd'))./(hsd*hsd');
-    case 'identity_matrix' %Use identity
-        invhess = eye(nx);
-    otherwise %user specified matrix in file
-        try
-            load(options_.MCMC_jumping_covariance,'jumping_covariance')
-            hh=jumping_covariance;
-        catch
-            error(['No matrix named ''jumping_covariance'' could be found in ',options_.MCMC_jumping_covariance,'.mat'])
-        end
-        [nrow, ncol]=size(hh);
-        if ~isequal(nrow,ncol) && ~isequal(nrow,nx) %check if square and right size
-            error(['jumping_covariance matrix must be square and have ',num2str(nx),' rows and columns'])
-        end
-        try %check for positive definiteness
-            chol(hh);
-            hsd = sqrt(diag(hh));
-            invhess = inv(hh./(hsd*hsd'))./(hsd*hsd');
-        catch
-            error(['Specified jumping_covariance is not positive definite'])
-        end
+    catch
+        error(['Specified jumping_covariance is not positive definite'])
+    end
 end
 
 if (any(bayestopt_.pshape  >0 ) && options_.mh_replic) || ...
         (any(bayestopt_.pshape >0 ) && options_.load_mh_file)  %% not ML estimation
-    bounds = prior_bounds(bayestopt_, options_.prior_trunc);
     outside_bound_pars=find(xparam1 < bounds.lb | xparam1 > bounds.ub);
     if ~isempty(outside_bound_pars)
         for ii=1:length(outside_bound_pars)
@@ -420,16 +435,18 @@ if (any(bayestopt_.pshape  >0 ) && options_.mh_replic) || ...
         end
     end
     % runs MCMC
-    if options_.mh_replic
-        ana_deriv_old = options_.analytic_derivation;
-        options_.analytic_derivation = 0;
+    if options_.mh_replic || options_.load_mh_file
         posterior_sampler_options = options_.posterior_sampler_options.current_options;
         posterior_sampler_options.invhess = invhess;
         [posterior_sampler_options, options_] = check_posterior_sampler_options(posterior_sampler_options, options_);
         % store current options in global
         options_.posterior_sampler_options.current_options = posterior_sampler_options;
-        posterior_sampler(objective_function,posterior_sampler_options.proposal_distribution,xparam1,posterior_sampler_options,bounds,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,oo_);
-        options_.analytic_derivation = ana_deriv_old;
+        if options_.mh_replic
+            ana_deriv_old = options_.analytic_derivation;
+            options_.analytic_derivation = 0;
+            posterior_sampler(objective_function,posterior_sampler_options.proposal_distribution,xparam1,posterior_sampler_options,bounds,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,oo_);
+            options_.analytic_derivation = ana_deriv_old;
+        end
     end
     %% Here I discard first mh_drop percent of the draws:
     CutSample(M_, options_, estim_params_);
@@ -440,9 +457,9 @@ if (any(bayestopt_.pshape  >0 ) && options_.mh_replic) || ...
     else
         %get stored results if required
         if options_.load_mh_file && options_.load_results_after_load_mh
-            oo_load_mh=load([M_.fname '_results'],'oo_');    
+            oo_load_mh=load([M_.fname '_results'],'oo_');
         end
-        if ~options_.nodiagnostic 
+        if ~options_.nodiagnostic
             if (options_.mh_replic>0 || (options_.load_mh_file && ~options_.load_results_after_load_mh))
                 oo_= McMCDiagnostics(options_, estim_params_, M_,oo_);
             elseif options_.load_mh_file && options_.load_results_after_load_mh
@@ -464,20 +481,20 @@ if (any(bayestopt_.pshape  >0 ) && options_.mh_replic) || ...
             [oo_.posterior.metropolis.mean,oo_.posterior.metropolis.Variance] ...
                 = GetPosteriorMeanVariance(M_,options_.mh_drop);
         elseif options_.load_mh_file && options_.load_results_after_load_mh
-            %% load fields from previous MCMC run stored in results-file            
+            %% load fields from previous MCMC run stored in results-file
             field_names={'posterior_mode','posterior_std_at_mode',...% fields set by marginal_density
-                'posterior_mean','posterior_hpdinf','posterior_hpdsup','posterior_median','posterior_variance','posterior_std','posterior_deciles','posterior_density',...% fields set by GetPosteriorParametersStatistics
-                'prior_density',...%fields set by PlotPosteriorDistributions
-                };
+                         'posterior_mean','posterior_hpdinf','posterior_hpdsup','posterior_median','posterior_variance','posterior_std','posterior_deciles','posterior_density',...% fields set by GetPosteriorParametersStatistics
+                         'prior_density',...%fields set by PlotPosteriorDistributions
+                        };
             for field_iter=1:size(field_names,2)
                 if isfield(oo_load_mh.oo_,field_names{1,field_iter})
                     oo_.(field_names{1,field_iter})=oo_load_mh.oo_.(field_names{1,field_iter});
                 end
-            end            
+            end
             % field set by marginal_density
             if isfield(oo_load_mh.oo_,'MarginalDensity') && isfield(oo_load_mh.oo_.MarginalDensity,'ModifiedHarmonicMean')
                 oo_.MarginalDensity.ModifiedHarmonicMean=oo_load_mh.oo_.MarginalDensity.ModifiedHarmonicMean;
-            end            
+            end
             % field set by GetPosteriorMeanVariance
             if isfield(oo_load_mh.oo_,'posterior') && isfield(oo_load_mh.oo_.posterior,'metropolis')
                 oo_.posterior.metropolis=oo_load_mh.oo_.posterior.metropolis;
@@ -513,14 +530,13 @@ if options_.particle.status
     return
 end
 
-if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.pshape ...
-                                                      > 0) && options_.load_mh_file)) ...
+if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.pshape> 0) && options_.load_mh_file)) ...
     || ~options_.smoother ) && options_.partial_information == 0  % to be fixed
     %% ML estimation, or posterior mode without Metropolis-Hastings or Metropolis without Bayesian smoothes variables
     [atT,innov,measurement_error,updated_variables,ys,trend_coeff,aK,T,R,P,PK,decomp,Trend,state_uncertainty,M_,oo_,options_,bayestopt_] = DsgeSmoother(xparam1,dataset_.nobs,transpose(dataset_.data),dataset_info.missing.aindex,dataset_info.missing.state,M_,oo_,options_,bayestopt_,estim_params_);
     [oo_,yf]=store_smoother_results(M_,oo_,options_,bayestopt_,dataset_,dataset_info,atT,innov,measurement_error,updated_variables,ys,trend_coeff,aK,P,PK,decomp,Trend,state_uncertainty);
 
-    if ~options_.nograph,
+    if ~options_.nograph
         [nbplt,nr,nc,lr,lc,nstar] = pltorg(M_.exo_nbr);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fidTeX = fopen([M_.fname '_SmoothedShocks.tex'],'w');
@@ -528,8 +544,8 @@ if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.psha
             fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
             fprintf(fidTeX,' \n');
         end
-        for plt = 1:nbplt,
-            fh = dyn_figure(options_,'Name','Smoothed shocks');
+        for plt = 1:nbplt
+            fh = dyn_figure(options_.nodisplay,'Name','Smoothed shocks');
             NAMES = [];
             if options_.TeX, TeXNAMES = []; end
             nstar0=min(nstar,M_.exo_nbr-(plt-1)*nstar);
@@ -540,7 +556,7 @@ if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.psha
                 marker_string{1,1}='-r';
                 marker_string{2,1}='-k';
             end
-            for i=1:nstar0,
+            for i=1:nstar0
                 k = (plt-1)*nstar+i;
                 subplot(nr,nc,i);
                 plot([1 gend],[0 0],marker_string{1,1},'linewidth',.5)
@@ -570,7 +586,7 @@ if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.psha
                 end
                 title(name,'Interpreter','none')
             end
-            dyn_saveas(fh,[M_.fname '_SmoothedShocks' int2str(plt)],options_);
+            dyn_saveas(fh,[M_.fname '_SmoothedShocks' int2str(plt)],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fprintf(fidTeX,'\\begin{figure}[H]\n');
                 for jj = 1:nstar0
@@ -608,7 +624,7 @@ if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.psha
                 fprintf(fidTeX,' \n');
             end
             for plt = 1:nbplt
-                fh = dyn_figure(options_,'Name','Smoothed observation errors');
+                fh = dyn_figure(options_.nodisplay,'Name','Smoothed observation errors');
                 NAMES = [];
                 if options_.TeX, TeXNAMES = []; end
                 nstar0=min(nstar,number_of_plots_to_draw-(nbplt-1)*nstar);
@@ -650,7 +666,7 @@ if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.psha
                     end
                     title(name,'Interpreter','none')
                 end
-                dyn_saveas(fh,[M_.fname '_SmoothedObservationErrors' int2str(plt)],options_);
+                dyn_saveas(fh,[M_.fname '_SmoothedObservationErrors' int2str(plt)],options_.nodisplay,options_.graph_format);
                 if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                     fprintf(fidTeX,'\\begin{figure}[H]\n');
                     for jj = 1:nstar0
@@ -675,75 +691,75 @@ if (~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.psha
     %%  Historical and smoothed variabes
     %%
     if ~options_.nograph
-    [nbplt,nr,nc,lr,lc,nstar] = pltorg(n_varobs);
-    if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
-        fidTeX = fopen([M_.fname '_HistoricalAndSmoothedVariables.tex'],'w');
-        fprintf(fidTeX,'%% TeX eps-loader file generated by dynare_estimation_1.m (Dynare).\n');
-        fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
-        fprintf(fidTeX,' \n');
-    end
-    for plt = 1:nbplt,
-        fh = dyn_figure(options_,'Name','Historical and smoothed variables');
-        NAMES = [];
-        if options_.TeX, TeXNAMES = []; end
-        nstar0=min(nstar,n_varobs-(plt-1)*nstar);
-        if gend==1
-           marker_string{1,1}='-ro';
-           marker_string{2,1}='--ko';
-        else
-           marker_string{1,1}='-r';
-           marker_string{2,1}='--k';
-        end
-        for i=1:nstar0,
-            k = (plt-1)*nstar+i;
-            subplot(nr,nc,i);
-            plot(1:gend,yf(k,:),marker_string{1,1},'linewidth',1)
-            hold on
-            plot(1:gend,rawdata(:,k),marker_string{2,1},'linewidth',1)
-            hold off
-            name = options_.varobs{k};
-            if isempty(NAMES)
-                NAMES = name;
-            else
-                NAMES = char(NAMES,name);
-            end
-            if ~isempty(options_.XTick)
-                set(gca,'XTick',options_.XTick)
-                set(gca,'XTickLabel',options_.XTickLabel)
-            end
-            if gend>1
-                xlim([1 gend])
-            end
-            if options_.TeX
-                idx = strmatch(options_.varobs{k},M_.endo_names,'exact');
-                texname = M_.endo_names_tex(idx,:);
-                if isempty(TeXNAMES)
-                    TeXNAMES = ['$ ' deblank(texname) ' $'];
-                else
-                    TeXNAMES = char(TeXNAMES,['$ ' deblank(texname) ' $']);
-                end
-            end
-            title(name,'Interpreter','none')
-        end
-        dyn_saveas(fh,[M_.fname '_HistoricalAndSmoothedVariables' int2str(plt)],options_);
+        [nbplt,nr,nc,lr,lc,nstar] = pltorg(n_varobs);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
-            fprintf(fidTeX,'\\begin{figure}[H]\n');
-            for jj = 1:nstar0,
-                fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(jj,:)),deblank(TeXNAMES(jj,:)));
-            end
-            fprintf(fidTeX,'\\centering \n');
-            fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s_HistoricalAndSmoothedVariables%s}\n',options_.figures.textwidth*min(i/nc,1),M_.fname,int2str(plt));
-            fprintf(fidTeX,'\\caption{Historical and smoothed variables.}');
-            fprintf(fidTeX,'\\label{Fig:HistoricalAndSmoothedVariables:%s}\n',int2str(plt));
-            fprintf(fidTeX,'\\end{figure}\n');
-            fprintf(fidTeX,'\n');
+            fidTeX = fopen([M_.fname '_HistoricalAndSmoothedVariables.tex'],'w');
+            fprintf(fidTeX,'%% TeX eps-loader file generated by dynare_estimation_1.m (Dynare).\n');
+            fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
+            fprintf(fidTeX,' \n');
+        end
+        for plt = 1:nbplt
+            fh = dyn_figure(options_.nodisplay,'Name','Historical and smoothed variables');
+            NAMES = [];
+            if options_.TeX, TeXNAMES = []; end
+            nstar0=min(nstar,n_varobs-(plt-1)*nstar);
+            if gend==1
+                marker_string{1,1}='-ro';
+                marker_string{2,1}='--ko';
+            else
+                marker_string{1,1}='-r';
+                marker_string{2,1}='--k';
+            end
+            for i=1:nstar0
+                k = (plt-1)*nstar+i;
+                subplot(nr,nc,i);
+                plot(1:gend,yf(k,:),marker_string{1,1},'linewidth',1)
+                hold on
+                plot(1:gend,rawdata(:,k),marker_string{2,1},'linewidth',1)
+                hold off
+                name = options_.varobs{k};
+                if isempty(NAMES)
+                    NAMES = name;
+                else
+                    NAMES = char(NAMES,name);
+                end
+                if ~isempty(options_.XTick)
+                    set(gca,'XTick',options_.XTick)
+                    set(gca,'XTickLabel',options_.XTickLabel)
+                end
+                if gend>1
+                    xlim([1 gend])
+                end
+                if options_.TeX
+                    idx = strmatch(options_.varobs{k},M_.endo_names,'exact');
+                    texname = M_.endo_names_tex(idx,:);
+                    if isempty(TeXNAMES)
+                        TeXNAMES = ['$ ' deblank(texname) ' $'];
+                    else
+                        TeXNAMES = char(TeXNAMES,['$ ' deblank(texname) ' $']);
+                    end
+                end
+                title(name,'Interpreter','none')
+            end
+            dyn_saveas(fh,[M_.fname '_HistoricalAndSmoothedVariables' int2str(plt)],options_.nodisplay,options_.graph_format);
+            if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
+                fprintf(fidTeX,'\\begin{figure}[H]\n');
+                for jj = 1:nstar0
+                    fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(jj,:)),deblank(TeXNAMES(jj,:)));
+                end
+                fprintf(fidTeX,'\\centering \n');
+                fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s_HistoricalAndSmoothedVariables%s}\n',options_.figures.textwidth*min(i/nc,1),M_.fname,int2str(plt));
+                fprintf(fidTeX,'\\caption{Historical and smoothed variables.}');
+                fprintf(fidTeX,'\\label{Fig:HistoricalAndSmoothedVariables:%s}\n',int2str(plt));
+                fprintf(fidTeX,'\\end{figure}\n');
+                fprintf(fidTeX,'\n');
+            end
+        end
+        if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
+            fprintf(fidTeX,'\n');
+            fprintf(fidTeX,'%% End of TeX file.\n');
+            fclose(fidTeX);
         end
-    end
-    if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
-        fprintf(fidTeX,'\n');
-        fprintf(fidTeX,'%% End of TeX file.\n');
-        fclose(fidTeX);
-    end
     end
 end
 
@@ -758,3 +774,11 @@ end
 
 %reset qz_criterium
 options_.qz_criterium=qz_criterium_old;
+
+if reset_options_related_to_estimation
+    options_.mode_compute = mode_compute_o;
+    options_.mh_replic = mh_replic_o;
+end
+if first_obs_nan_indicator
+    options_.first_obs=NaN;
+end
\ No newline at end of file
diff --git a/matlab/dynare_estimation_init.m b/matlab/dynare_estimation_init.m
index 05c6c8983..3cbbf6d60 100644
--- a/matlab/dynare_estimation_init.m
+++ b/matlab/dynare_estimation_init.m
@@ -14,7 +14,7 @@ function [dataset_, dataset_info, xparam1, hh, M_, options_, oo_, estim_params_,
 %   estim_params_:  structure storing information about estimated
 %                   parameters
 %   bayestopt_:     structure storing information about priors
-    
+
 % OUTPUTS
 %   dataset_:       the dataset after required transformation
 %   dataset_info:   Various informations about the dataset (descriptive statistics and missing observations).
@@ -28,11 +28,11 @@ function [dataset_, dataset_info, xparam1, hh, M_, options_, oo_, estim_params_,
 %                   parameters
 %   bayestopt_:     structure storing information about priors
 %   bounds:         structure containing prior bounds
-% 
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,6 +50,7 @@ function [dataset_, dataset_info, xparam1, hh, M_, options_, oo_, estim_params_,
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 hh = [];
+xparam1 = [];
 
 if isempty(gsa_flag)
     gsa_flag = 0;
@@ -104,13 +105,13 @@ if options_.analytic_derivation && options_.fast_kalman_filter
 end
 
 % fast kalman filter is only available with kalman_algo == 0,1,3
-if options_.fast_kalman_filter 
+if options_.fast_kalman_filter
     if ~ismember(options_.kalman_algo, [0,1,3])
         error(['estimation option conflict: fast_kalman_filter is only available ' ...
-            'with kalman_algo = 0, 1 or 3'])
+               'with kalman_algo = 0, 1 or 3'])
     elseif options_.block
         error(['estimation option conflict: fast_kalman_filter is not available ' ...
-            'with block'])
+               'with block'])
     end
 end
 
@@ -126,6 +127,9 @@ end
 options_=select_qz_criterium_value(options_);
 
 % Set options related to filtered variables.
+if  isequal(options_.filtered_vars,0) && ~isempty(options_.filter_step_ahead)
+    options_.filtered_vars = 1;
+end
 if ~isequal(options_.filtered_vars,0) && isempty(options_.filter_step_ahead)
     options_.filter_step_ahead = 1;
 end
@@ -186,7 +190,7 @@ if ~isempty(estim_params_) && ~(isfield(estim_params_,'nvx') && sum(estim_params
             % The posterior mode is not estimated.
             error('Please change the mode_file option, the list of estimated parameters or set mode_compute>0.')
         else
-            % The posterior mode is estimated, the Hessian evaluated at the mode is not needed so we set values for the parameters missing in the mode file using the prior mean. 
+            % The posterior mode is estimated, the Hessian evaluated at the mode is not needed so we set values for the parameters missing in the mode file using the prior mean.
             if ~isempty(xd)
                 xparam1(xd) = mode_file.xparam1(md);
             else
@@ -226,7 +230,7 @@ if ~isempty(estim_params_) && ~(isfield(estim_params_,'nvx') && sum(estim_params
                 error('Please change the mode_file option, the list of estimated parameters or set mode_compute>0.')
             end
         else
-            % The posterior mode is estimated, the Hessian evaluated at the mode is not needed so we set values for the parameters missing in the mode file using the prior mean. 
+            % The posterior mode is estimated, the Hessian evaluated at the mode is not needed so we set values for the parameters missing in the mode file using the prior mean.
             if ~isempty(xd)
                 xparam1(xd) = mode_file.xparam1(md);
             else
@@ -235,7 +239,7 @@ if ~isempty(estim_params_) && ~(isfield(estim_params_,'nvx') && sum(estim_params
             end
         end
     else
-        % The number of declared estimated parameters match the number of parameters in the mode file. 
+        % The number of declared estimated parameters match the number of parameters in the mode file.
         % Check that the parameters in the mode file and according to the current mod file are identical.
         if ~isfield(mode_file,'parameter_names')
             disp(['The posterior mode file ' options_.mode_file ' has been generated using an older version of Dynare. It cannot be verified if it matches the present model. Proceed at your own risk.'])
@@ -272,7 +276,7 @@ if ~isempty(estim_params_) && ~(isfield(estim_params_,'nvx') && sum(estim_params
                     error('Please change the mode_file option, the list of estimated parameters or set mode_compute>0.')
                 end
             else
-                % The posterior mode is estimated, the Hessian evaluated at the mode is not needed so we set values for the parameters missing in the mode file using the prior mean. 
+                % The posterior mode is estimated, the Hessian evaluated at the mode is not needed so we set values for the parameters missing in the mode file using the prior mean.
                 if ~isempty(xd)
                     xparam1(xd) = mode_file.xparam1(md);
                     if isfield(mode_file,'hh')
@@ -308,6 +312,10 @@ if options_.use_calibration_initialization %set calibration as starting values
     end
 end
 
+if ~isempty(bayestopt_) && all(bayestopt_.pshape==0) && any(isnan(xparam1))
+    error('ML estimation requires all estimated parameters to be initialized, either in an estimated_params or estimated_params_init-block ')
+end
+
 if ~isempty(estim_params_) && ~(all(strcmp(fieldnames(estim_params_),'full_calibration_detected'))  || (isfield(estim_params_,'nvx') && sum(estim_params_.nvx+estim_params_.nvn+estim_params_.ncx+estim_params_.ncn+estim_params_.np)==0))
     if ~isempty(bayestopt_) && any(bayestopt_.pshape > 0)
         % Plot prior densities.
@@ -319,8 +327,8 @@ if ~isempty(estim_params_) && ~(all(strcmp(fieldnames(estim_params_),'full_calib
         bounds.lb = max(bounds.lb,lb);
         bounds.ub = min(bounds.ub,ub);
     else  % estimated parameters but no declared priors
-        % No priors are declared so Dynare will estimate the model by
-        % maximum likelihood with inequality constraints for the parameters.
+          % No priors are declared so Dynare will estimate the model by
+          % maximum likelihood with inequality constraints for the parameters.
         options_.mh_replic = 0;% No metropolis.
         bounds.lb = lb;
         bounds.ub = ub;
@@ -336,7 +344,7 @@ if ~isempty(estim_params_) && ~(all(strcmp(fieldnames(estim_params_),'full_calib
         end
     else
         check_prior_bounds(xparam1,bounds,M_,estim_params_,options_,bayestopt_)
-    end        
+    end
 end
 
 if isempty(estim_params_) || all(strcmp(fieldnames(estim_params_),'full_calibration_detected')) || (isfield(estim_params_,'nvx') && sum(estim_params_.nvx+estim_params_.nvn+estim_params_.ncx+estim_params_.ncn+estim_params_.np)==0) % If estim_params_ is empty (e.g. when running the smoother on a calibrated model)
@@ -397,12 +405,12 @@ nstatic = M_.nstatic;          % Number of static variables.
 npred = M_.nspred;             % Number of predetermined variables.
 nspred = M_.nspred;            % Number of predetermined variables in the state equation.
 
-%% Setting resticted state space (observed + predetermined variables)
+%% Setting restricted state space (observed + predetermined variables)
 % oo_.dr.restrict_var_list: location of union of observed and state variables in decision rules (decision rule order)
 % bayestopt_.mfys: position of observables in oo_.dr.ys (declaration order)
 % bayestopt_.mf0: position of state variables in restricted state vector (oo_.dr.restrict_var_list)
-% bayestopt_.mf1: positions of observed variables in decision rules (oo_.dr.restrict_var_list)
-% bayestopt_.mf2: positions of observed variables in decision rules (decision rule order)
+% bayestopt_.mf1: positions of observed variables in restricted state vector (oo_.dr.restrict_var_list order)
+% bayestopt_.mf2: positions of observed variables in decision rules/expanded state vector (decision rule order)
 % bayestopt_.smoother_var_list: positions of observed variables and requested smoothed variables in decision rules (decision rule order)
 % bayestopt_.smoother_saved_var_list: positions of requested smoothed variables in bayestopt_.smoother_var_list
 % bayestopt_.smoother_restrict_columns: positions of states in observed variables and requested smoothed variables in decision rules (decision rule order)
@@ -420,7 +428,7 @@ if options_.selected_variables_only
     if options_.forecast > 0 && options_.mh_replic == 0 && ~options_.load_mh_file
         fprintf('\nEstimation: The selected_variables_only option is incompatible with classical forecasts. It will be ignored.\n')
         k3 = (1:M_.endo_nbr)';
-        k3p = (1:M_.endo_nbr)';    
+        k3p = (1:M_.endo_nbr)';
     else
         for i=1:size(var_list_,1)
             k3 = [k3; strmatch(var_list_(i,:),M_.endo_names(dr.order_var,:), 'exact')];
@@ -471,18 +479,18 @@ else
     [junk,ic] = intersect(bayestopt_.smoother_var_list,nstatic+(1:npred)');
     bayestopt_.smoother_restrict_columns = ic;
     [junk,bayestopt_.smoother_mf] = ismember(var_obs_index_dr, bayestopt_.smoother_var_list);
-end;
+end
 
-if options_.analytic_derivation,
-    if options_.lik_init == 3,
+if options_.analytic_derivation
+    if options_.lik_init == 3
         error('analytic derivation is incompatible with diffuse filter')
     end
     options_.analytic_derivation = 1;
-    if ~(exist('sylvester3','file')==2),
+    if ~(exist('sylvester3','file')==2)
         dynareroot = strrep(which('dynare'),'dynare.m','');
         addpath([dynareroot 'gensylv'])
     end
-    if estim_params_.np,
+    if estim_params_.np
         % check if steady state changes param values
         M=M_;
         M.params(estim_params_.param_vals(:,1)) = xparam1(estim_params_.nvx+estim_params_.ncx+estim_params_.nvn+estim_params_.ncn+1:end); %set parameters
@@ -494,8 +502,8 @@ if options_.analytic_derivation,
         end
         [tmp1, params] = evaluate_steady_state(oo_.steady_state,M,options_,oo_,steadystate_check_flag);
         change_flag=any(find(params-M.params));
-        if change_flag,
-            skipline();
+        if change_flag
+            skipline()
             if any(isnan(params))
                 disp('After computing the steadystate, the following parameters are still NaN: '),
                 disp(M.param_names(isnan(params),:))
@@ -524,13 +532,16 @@ if ~isempty(options_.datafile)
     end
 end
 
+if isnan(options_.first_obs)
+    options_.first_obs=1;
+end
 [dataset_, dataset_info, newdatainterfaceflag] = makedataset(options_, options_.dsge_var*options_.dsge_varlag, gsa_flag);
 
 %set options for old interface from the ones for new interface
 if ~isempty(dataset_)
     options_.nobs = dataset_.nobs;
-    options_.first_obs=double(dataset_.init);
 end
+
 % setting steadystate_check_flag option
 if options_.diffuse_filter || options_.steadystate.nocheck
     steadystate_check_flag = 0;
@@ -545,12 +556,12 @@ ncx = estim_params_.ncx;
 nvn = estim_params_.nvn;
 ncn = estim_params_.ncn;
 if estim_params_.np
-  M.params(estim_params_.param_vals(:,1)) = xparam1(nvx+ncx+nvn+ncn+1:end);
+    M.params(estim_params_.param_vals(:,1)) = xparam1(nvx+ncx+nvn+ncn+1:end);
 end
 [oo_.steady_state, params,info] = evaluate_steady_state(oo_.steady_state,M,options_,oo_,steadystate_check_flag);
 
 if info(1)
-    fprintf('\ndynare_estimation_init:: The steady state at the initial parameters cannot be computed.')
+    fprintf('\ndynare_estimation_init:: The steady state at the initial parameters cannot be computed.\n')
     print_info(info, 0, options_);
 end
 
@@ -603,7 +614,7 @@ if options_.load_results_after_load_mh
     end
 end
 
-if options_.mh_replic
+if options_.mh_replic || options_.load_mh_file
     [current_options, options_] = check_posterior_sampler_options([], options_, bounds);
     options_.posterior_sampler_options.current_options = current_options;
 end
diff --git a/matlab/dynare_gradient.m b/matlab/dynare_gradient.m
index 91b4140c1..2f4dfc9d4 100644
--- a/matlab/dynare_gradient.m
+++ b/matlab/dynare_gradient.m
@@ -4,15 +4,15 @@ function [F,G] = dynare_gradient(fcn,x,epsilon,varargin)
 % INPUTS:
 %  fcn      [string]  name of the matlab's function.
 %  x        [double]  m*1 vector (where the gradient is evaluated).
-%  epsilon  [double]  scalar or m*1 vector of steps. 
+%  epsilon  [double]  scalar or m*1 vector of steps.
 %
-% OUTPUTS: 
+% OUTPUTS:
 %  F        [double]  n*1 vector, evaluation of the function at x.
 %  G        [double]  n*m matrix, evaluation of the gradient at x.
 %
 % OUTPUTS
-% 
-% Copyright (C) 2010-2012 Dynare Team
+%
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -51,7 +51,7 @@ for i=1:m
         h = H(i,:);
     else
         h = H(:,i);
-    end   
+    end
     [Fh,junk1,junk2,flag] = feval(fcn, x+transpose(h), varargin{:});
     if flag
         G(:,i) = (Fh-F)/epsilon;
diff --git a/matlab/dynare_graph.m b/matlab/dynare_graph.m
index 9af832f7f..3717efa45 100644
--- a/matlab/dynare_graph.m
+++ b/matlab/dynare_graph.m
@@ -1,5 +1,5 @@
 function dyn_graph=dynare_graph(dyn_graph,y,tit,x)
-% function dynare_graph(y,tit,x) 
+% function dynare_graph(y,tit,x)
 % graphs
 %
 % INPUT
@@ -12,7 +12,7 @@ function dyn_graph=dynare_graph(dyn_graph,y,tit,x)
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2006-2013 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,7 +32,7 @@ function dyn_graph=dynare_graph(dyn_graph,y,tit,x)
 if nargin < 4
     x = (1:size(y,1))';
 end
-nplot = dyn_graph.plot_nbr + 1; 
+nplot = dyn_graph.plot_nbr + 1;
 if nplot > dyn_graph.max_nplot
     figure('Name',dyn_graph.figure_name);
     nplot = 1;
@@ -42,11 +42,11 @@ subplot(dyn_graph.nr,dyn_graph.nc,nplot);
 
 line_types = dyn_graph.line_types;
 line_type = line_types{1};
-for i=1:size(y,2);
+for i=1:size(y,2)
     if length(line_types) > 1
         line_type = line_types{i};
     end
-    
+
     plot(x,y(:,i),line_type);
     hold on
 end
diff --git a/matlab/dynare_graph_close.m b/matlab/dynare_graph_close.m
index ed4371034..72622314d 100644
--- a/matlab/dynare_graph_close.m
+++ b/matlab/dynare_graph_close.m
@@ -1,5 +1,5 @@
 function dynare_graph_close()
-% function dynare_graph_close() 
+% function dynare_graph_close()
 % close a figure
 %
 % INPUT
@@ -11,7 +11,7 @@ function dynare_graph_close()
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2006-2009 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,4 +27,3 @@ function dynare_graph_close()
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-
diff --git a/matlab/dynare_graph_init.m b/matlab/dynare_graph_init.m
index 4e0af5b8c..b97c2b5f8 100644
--- a/matlab/dynare_graph_init.m
+++ b/matlab/dynare_graph_init.m
@@ -1,5 +1,5 @@
 function dyn_graph=dynare_graph_init(figure_name,nplot,line_types,line_width)
-% function dynare_graph_init(figure_name,colors) 
+% function dynare_graph_init(figure_name,colors)
 % initializes set of graphs
 %
 % INPUTS:
@@ -12,7 +12,7 @@ function dyn_graph=dynare_graph_init(figure_name,nplot,line_types,line_width)
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2006-2013 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,7 +31,7 @@ function dyn_graph=dynare_graph_init(figure_name,nplot,line_types,line_width)
 
 global options_
 
-dyn_graph.fh = dyn_figure(options_,'Name',figure_name);
+dyn_graph.fh = dyn_figure(options_.nodisplay,'Name',figure_name);
 dyn_graph.figure_name = figure_name;
 if nargin > 2
     dyn_graph.line_types = line_types;
diff --git a/matlab/dynare_identification.m b/matlab/dynare_identification.m
index c84faf2c6..7b5c1e556 100644
--- a/matlab/dynare_identification.m
+++ b/matlab/dynare_identification.m
@@ -3,8 +3,8 @@ function [pdraws, TAU, GAM, LRE, gp, H, JJ] = dynare_identification(options_iden
 %
 % INPUTS
 %    o options_ident    [structure] identification options
-%    o pdraws0          [matrix] optional: matrix of MC sample of model params. 
-%    
+%    o pdraws0          [matrix] optional: matrix of MC sample of model params.
+%
 % OUTPUTS
 %    o pdraws           [matrix] matrix of MC sample of model params used
 %    o TAU,             [matrix] MC sample of entries in the model solution (stacked vertically)
@@ -13,13 +13,13 @@ function [pdraws, TAU, GAM, LRE, gp, H, JJ] = dynare_identification(options_iden
 %    o gp,              [matrix] derivatives of the Jacobian (LRE model)
 %    o H,               [matrix] derivatives of the model solution
 %    o JJ               [matrix] derivatives of the  moments
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 
-% main 
+% main
 %
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ else
     if options_.diffuse_filter==1 %warning if estimation with diffuse filter was done, but not passed
         warning('IDENTIFICATION:: Previously the diffuse_filter option was used, but it was not passed to the identification command. This may result in problems if your model contains unit roots.')
     end
-    if isfield(options_ident,'lik_init') 
+    if isfield(options_ident,'lik_init')
         options_.lik_init=options_ident.lik_init; %make options_ inherit lik_init
         if options_ident.lik_init==3 %user specified diffuse filter using the lik_init option
             options_ident.analytic_derivation=0; %diffuse filter not compatible with analytic derivation
@@ -78,48 +78,48 @@ end
 options_ident = set_default_option(options_ident,'lik_init',1);
 options_ident = set_default_option(options_ident,'analytic_derivation',1);
 
-if isfield(options_ident,'nograph'),
+if isfield(options_ident,'nograph')
     options_.nograph=options_ident.nograph;
 end
-if isfield(options_ident,'nodisplay'),
+if isfield(options_ident,'nodisplay')
     options_.nodisplay=options_ident.nodisplay;
 end
-if isfield(options_ident,'graph_format'),
+if isfield(options_ident,'graph_format')
     options_.graph_format=options_ident.graph_format;
 end
-if isfield(options_ident,'prior_trunc'),
+if isfield(options_ident,'prior_trunc')
     options_.prior_trunc=options_ident.prior_trunc;
 end
 
-if options_ident.gsa_sample_file,
+if options_ident.gsa_sample_file
     GSAFolder = checkpath('gsa',M_.dname);
-    if options_ident.gsa_sample_file==1,
+    if options_ident.gsa_sample_file==1
         load([GSAFolder,filesep,fname_,'_prior'],'lpmat','lpmat0','istable');
-    elseif options_ident.gsa_sample_file==2,
+    elseif options_ident.gsa_sample_file==2
         load([GSAFolder,filesep,fname_,'_mc'],'lpmat','lpmat0','istable');
     else
         load([GSAFolder,filesep,options_ident.gsa_sample_file],'lpmat','lpmat0','istable');
     end
-    if isempty(istable),
+    if isempty(istable)
         istable=1:size(lpmat,1);
     end
-    if ~isempty(lpmat0),
+    if ~isempty(lpmat0)
         lpmatx=lpmat0(istable,:);
     else
         lpmatx=[];
     end
     pdraws0 = [lpmatx lpmat(istable,:)];
     clear lpmat lpmat0 istable;
-elseif nargin==1,
+elseif nargin==1
     pdraws0=[];
 end
 external_sample=0;
-if nargin==2 || ~isempty(pdraws0),
+if nargin==2 || ~isempty(pdraws0)
     options_ident.prior_mc=size(pdraws0,1);
     options_ident.load_ident_files = 0;
     external_sample=1;
 end
-if isempty(estim_params_),
+if isempty(estim_params_)
     options_ident.prior_mc=1;
     options_ident.prior_range=0;
     prior_exist=0;
@@ -164,28 +164,24 @@ end
 
 SampleSize = options_ident.prior_mc;
 
-if ~(exist('sylvester3','file')==2),
-
+if ~(exist('sylvester3','file')==2)
     dynareroot = strrep(which('dynare'),'dynare.m','');
     addpath([dynareroot 'gensylv'])
 end
 
 IdentifDirectoryName = CheckPath('identification',M_.dname);
-if prior_exist,
-
+if prior_exist
     indx = [];
-    if ~isempty(estim_params_.param_vals),
+    if ~isempty(estim_params_.param_vals)
         indx = estim_params_.param_vals(:,1);
     end
     indexo=[];
     if ~isempty(estim_params_.var_exo)
         indexo = estim_params_.var_exo(:,1);
     end
-
     nparam = length(bayestopt_.name);
     np = estim_params_.np;
-
-    if estim_params_.nvn || estim_params_.ncn,
+    if estim_params_.nvn || estim_params_.ncn
         error('Identification does not support measurement errors. Instead, define them explicitly in measurement equations in model definition.')
     else
         offset = estim_params_.nvx;
@@ -199,7 +195,7 @@ if prior_exist,
     end
     name=cell(nparam,1);
     name_tex=cell(nparam,1);
-    for jj=1:nparam        
+    for jj=1:nparam
         if options_.TeX
             [param_name_temp, param_name_tex_temp]= get_the_name(jj,options_.TeX,M_,estim_params_,options_);
             name_tex{jj,1} = strrep(param_name_tex_temp,'$','');
@@ -229,9 +225,9 @@ else
 end
 
 skipline()
-disp(['==== Identification analysis ====' ]),
+disp(['==== Identification analysis ====' ])
 skipline()
-if nparam<2,
+if nparam<2
     options_ident.advanced=0;
     advanced = options_ident.advanced;
     disp('There is only one parameter to study for identitification.')
@@ -246,22 +242,21 @@ options_ident.max_dim_cova_group = min([options_ident.max_dim_cova_group,nparam-
 MaxNumberOfBytes=options_.MaxNumberOfBytes;
 store_options_ident = options_ident;
 
-if iload <=0,
-    
+if iload <=0
     [I,J]=find(M_.lead_lag_incidence');
-    if prior_exist,
-%         if exist([fname_,'_mean.mat'],'file'),
-% %             disp('Testing posterior mean')
-%             load([fname_,'_mean'],'xparam1')
-%             pmean = xparam1';
-%             clear xparam1
-%         end
-%         if exist([fname_,'_mode.mat'],'file'),
-% %             disp('Testing posterior mode')
-%             load([fname_,'_mode'],'xparam1')
-%             pmode = xparam1';
-%             clear xparam1
-%         end
+    if prior_exist
+        %         if exist([fname_,'_mean.mat'],'file'),
+        % %             disp('Testing posterior mean')
+        %             load([fname_,'_mean'],'xparam1')
+        %             pmean = xparam1';
+        %             clear xparam1
+        %         end
+        %         if exist([fname_,'_mode.mat'],'file'),
+        % %             disp('Testing posterior mode')
+        %             load([fname_,'_mode'],'xparam1')
+        %             pmode = xparam1';
+        %             clear xparam1
+        %         end
         params = set_prior(estim_params_,M_,options_)';
         if all(bayestopt_.pshape == 0)
             parameters = 'ML_Starting_value';
@@ -269,38 +264,38 @@ if iload <=0,
             disp('Testing ML Starting value')
         else
             switch parameters
-                case 'calibration'
-                    parameters_TeX = 'Calibration';
-                    disp('Testing calibration')
-                    params(1,:) = get_all_parameters(estim_params_,M_);;
-                case 'posterior_mode'
-                    parameters_TeX = 'Posterior mode';
-                    disp('Testing posterior mode')
-                    params(1,:) = get_posterior_parameters('mode');
-                case 'posterior_mean'
-                    parameters_TeX = 'Posterior mean';
-                    disp('Testing posterior mean')
-                    params(1,:) = get_posterior_parameters('mean');
-                case 'posterior_median'
-                    parameters_TeX = 'Posterior median';
-                    disp('Testing posterior median')
-                    params(1,:) = get_posterior_parameters('median');
-                case 'prior_mode'
-                    parameters_TeX = 'Prior mode';
-                    disp('Testing prior mode')
-                    params(1,:) = bayestopt_.p5(:);
-                case 'prior_mean'
-                    parameters_TeX = 'Prior mean';                    
-                    disp('Testing prior mean')
-                    params(1,:) = bayestopt_.p1;
-                otherwise
-                    disp('The option parameter_set has to be equal to:')
-                    disp('                   ''posterior_mode'', ')
-                    disp('                   ''posterior_mean'', ')
-                    disp('                   ''posterior_median'', ')
-                    disp('                   ''prior_mode'' or')
-                    disp('                   ''prior_mean''.')
-                    error;
+              case 'calibration'
+                parameters_TeX = 'Calibration';
+                disp('Testing calibration')
+                params(1,:) = get_all_parameters(estim_params_,M_);
+              case 'posterior_mode'
+                parameters_TeX = 'Posterior mode';
+                disp('Testing posterior mode')
+                params(1,:) = get_posterior_parameters('mode');
+              case 'posterior_mean'
+                parameters_TeX = 'Posterior mean';
+                disp('Testing posterior mean')
+                params(1,:) = get_posterior_parameters('mean');
+              case 'posterior_median'
+                parameters_TeX = 'Posterior median';
+                disp('Testing posterior median')
+                params(1,:) = get_posterior_parameters('median');
+              case 'prior_mode'
+                parameters_TeX = 'Prior mode';
+                disp('Testing prior mode')
+                params(1,:) = bayestopt_.p5(:);
+              case 'prior_mean'
+                parameters_TeX = 'Prior mean';
+                disp('Testing prior mean')
+                params(1,:) = bayestopt_.p1;
+              otherwise
+                disp('The option parameter_set has to be equal to:')
+                disp('                   ''posterior_mode'', ')
+                disp('                   ''posterior_mean'', ')
+                disp('                   ''posterior_median'', ')
+                disp('                   ''prior_mode'' or')
+                disp('                   ''prior_mean''.')
+                error;
             end
         end
     else
@@ -311,45 +306,45 @@ if iload <=0,
     end
     [idehess_point, idemoments_point, idemodel_point, idelre_point, derivatives_info_point, info, options_ident] = ...
         identification_analysis(params,indx,indexo,options_ident,dataset_, dataset_info, prior_exist, name_tex,1,parameters,bounds);
-    if info(1)~=0,
+    if info(1)~=0
         skipline()
         disp('----------- ')
         disp('Parameter error:')
         disp(['The model does not solve for ', parameters, ' with error code info = ', int2str(info(1))]),
         skipline()
-        if info(1)==1,
-        disp('info==1 %! The model doesn''t determine the current variables uniquely.')
-        elseif info(1)==2,
-        disp('info==2 %! MJDGGES returned an error code.')
-        elseif info(1)==3,
-        disp('info==3 %! Blanchard & Kahn conditions are not satisfied: no stable equilibrium. ')
-        elseif info(1)==4,
-        disp('info==4 %! Blanchard & Kahn conditions are not satisfied: indeterminacy. ')
-        elseif info(1)==5,
-        disp('info==5 %! Blanchard & Kahn conditions are not satisfied: indeterminacy due to rank failure. ')
-        elseif info(1)==6,
-        disp('info==6 %! The jacobian evaluated at the deterministic steady state is complex.')
-        elseif info(1)==19,
-        disp('info==19 %! The steadystate routine thrown an exception (inconsistent deep parameters). ')
-        elseif info(1)==20,
-        disp('info==20 %! Cannot find the steady state, info(2) contains the sum of square residuals (of the static equations). ')
-        elseif info(1)==21,
-        disp('info==21 %! The steady state is complex, info(2) contains the sum of square of imaginary parts of the steady state.')
-        elseif info(1)==22,
-        disp('info==22 %! The steady has NaNs. ')
-        elseif info(1)==23,
-        disp('info==23 %! M_.params has been updated in the steadystate routine and has complex valued scalars. ')
-        elseif info(1)==24,
-        disp('info==24 %! M_.params has been updated in the steadystate routine and has some NaNs. ')
-        elseif info(1)==30,
-        disp('info==30 %! Ergodic variance can''t be computed. ')
+        if info(1)==1
+            disp('info==1 %! The model doesn''t determine the current variables uniquely.')
+        elseif info(1)==2
+            disp('info==2 %! MJDGGES returned an error code.')
+        elseif info(1)==3
+            disp('info==3 %! Blanchard & Kahn conditions are not satisfied: no stable equilibrium. ')
+        elseif info(1)==4
+            disp('info==4 %! Blanchard & Kahn conditions are not satisfied: indeterminacy. ')
+        elseif info(1)==5
+            disp('info==5 %! Blanchard & Kahn conditions are not satisfied: indeterminacy due to rank failure. ')
+        elseif info(1)==6
+            disp('info==6 %! The jacobian evaluated at the deterministic steady state is complex.')
+        elseif info(1)==19
+            disp('info==19 %! The steadystate routine thrown an exception (inconsistent deep parameters). ')
+        elseif info(1)==20
+            disp('info==20 %! Cannot find the steady state, info(2) contains the sum of square residuals (of the static equations). ')
+        elseif info(1)==21
+            disp('info==21 %! The steady state is complex, info(2) contains the sum of square of imaginary parts of the steady state.')
+        elseif info(1)==22
+            disp('info==22 %! The steady has NaNs. ')
+        elseif info(1)==23
+            disp('info==23 %! M_.params has been updated in the steadystate routine and has complex valued scalars. ')
+        elseif info(1)==24
+            disp('info==24 %! M_.params has been updated in the steadystate routine and has some NaNs. ')
+        elseif info(1)==30
+            disp('info==30 %! Ergodic variance can''t be computed. ')
         end
         disp('----------- ')
         skipline()
         if any(bayestopt_.pshape)
             disp('Try sampling up to 50 parameter sets from the prior.')
             kk=0;
-            while kk<50 && info(1),
+            while kk<50 && info(1)
                 kk=kk+1;
                 params = prior_draw();
                 [idehess_point, idemoments_point, idemodel_point, idelre_point, derivatives_info_point, info, options_ident] = ...
@@ -372,20 +367,20 @@ if iload <=0,
         end
     end
     idehess_point.params=params;
-%     siH = idemodel_point.siH;
-%     siJ = idemoments_point.siJ;
-%     siLRE = idelre_point.siLRE;
-%     normH = max(abs(siH)')';
-%     normJ = max(abs(siJ)')';
-%     normLRE = max(abs(siLRE)')';
+    %     siH = idemodel_point.siH;
+    %     siJ = idemoments_point.siJ;
+    %     siLRE = idelre_point.siLRE;
+    %     normH = max(abs(siH)')';
+    %     normJ = max(abs(siJ)')';
+    %     normLRE = max(abs(siLRE)')';
     save([IdentifDirectoryName '/' M_.fname '_identif.mat'], 'idehess_point', 'idemoments_point','idemodel_point', 'idelre_point','store_options_ident')
     save([IdentifDirectoryName '/' M_.fname '_' parameters '_identif.mat'], 'idehess_point', 'idemoments_point','idemodel_point', 'idelre_point','store_options_ident')
     disp_identification(params, idemodel_point, idemoments_point, name, advanced);
-    if ~options_.nograph,
+    if ~options_.nograph
         plot_identification(params,idemoments_point,idehess_point,idemodel_point,idelre_point,advanced,parameters,name,IdentifDirectoryName,parameters_TeX,name_tex);
     end
 
-    if SampleSize > 1,
+    if SampleSize > 1
         skipline()
         disp('Monte Carlo Testing')
         h = dyn_waitbar(0,'Monte Carlo identification checks ...');
@@ -399,16 +394,16 @@ if iload <=0,
         iteration = 1;
         pdraws = [];
     end
-    while iteration < SampleSize,
+    while iteration < SampleSize
         loop_indx = loop_indx+1;
-        if external_sample,
+        if external_sample
             params = pdraws0(iteration+1,:);
         else
             params = prior_draw();
         end
         [dum1, ideJ, ideH, ideGP, dum2 , info, options_MC] = ...
             identification_analysis(params,indx,indexo,options_MC,dataset_, dataset_info, prior_exist, name_tex,0,[],bounds);
-        if iteration==0 && info(1)==0,
+        if iteration==0 && info(1)==0
             MAX_tau   = min(SampleSize,ceil(MaxNumberOfBytes/(size(ideH.siH,1)*nparam)/8));
             stoH = zeros([size(ideH.siH,1),nparam,MAX_tau]);
             stoJJ = zeros([size(ideJ.siJ,1),nparam,MAX_tau]);
@@ -439,7 +434,7 @@ if iload <=0,
             idemoments.V = zeros(SampleSize,nparam,min(8,nparam));
             delete([IdentifDirectoryName '/' M_.fname '_identif_*.mat'])
         end
-        if info(1)==0,
+        if info(1)==0
             iteration = iteration + 1;
             run_index = run_index + 1;
             TAU(:,iteration)=ideH.TAU;
@@ -469,9 +464,9 @@ if iload <=0,
             stoH(:,:,run_index) = ideH.siH;
             stoJJ(:,:,run_index) = ideJ.siJ;
             pdraws(iteration,:) = params;
-            if run_index==MAX_tau || iteration==SampleSize,
+            if run_index==MAX_tau || iteration==SampleSize
                 file_index = file_index + 1;
-                if run_index<MAX_tau,
+                if run_index<MAX_tau
                     stoH = stoH(:,:,1:run_index);
                     stoJJ = stoJJ(:,:,1:run_index);
                     stoLRE = stoLRE(:,:,1:run_index);
@@ -481,142 +476,142 @@ if iload <=0,
                 stoH = zeros(size(stoH));
                 stoJJ = zeros(size(stoJJ));
                 stoLRE = zeros(size(stoLRE));
-                
+
             end
-            
-            if SampleSize > 1,
-%                 if isoctave || options_.console_mode,
-%                     console_waitbar(0,iteration/SampleSize);
-%                 else
-                    dyn_waitbar(iteration/SampleSize,h,['MC identification checks ',int2str(iteration),'/',int2str(SampleSize)])
-%                 end
+
+            if SampleSize > 1
+                %                 if isoctave || options_.console_mode,
+                %                     console_waitbar(0,iteration/SampleSize);
+                %                 else
+                dyn_waitbar(iteration/SampleSize,h,['MC identification checks ',int2str(iteration),'/',int2str(SampleSize)])
+                %                 end
             end
         end
-        
+
     end
-    
-    
-    if SampleSize > 1,
-        if isoctave || options_.console_mode,
+
+
+    if SampleSize > 1
+        if isoctave || options_.console_mode
             fprintf('\n');
             diary on;
         else
-            close(h),
+            close(h)
         end
         normTAU=std(TAU')';
         normLRE=std(LRE')';
         normGAM=std(GAM')';
         normaliz1=std(pdraws);
         iter=0;
-        for ifile_index = 1:file_index,
+        for ifile_index = 1:file_index
             load([IdentifDirectoryName '/' M_.fname '_identif_' int2str(ifile_index) '.mat'], 'stoH', 'stoJJ', 'stoLRE')
-            for irun=1:size(stoH,3),
+            for irun=1:size(stoH,3)
                 iter=iter+1;
                 siJnorm(iter,:) = vnorm(stoJJ(:,:,irun)./repmat(normGAM,1,nparam)).*normaliz1;
                 siHnorm(iter,:) = vnorm(stoH(:,:,irun)./repmat(normTAU,1,nparam)).*normaliz1;
                 siLREnorm(iter,:) = vnorm(stoLRE(:,:,irun)./repmat(normLRE,1,nparam-offset)).*normaliz1(offset+1:end);
             end
-            
+
         end
         idemoments.siJnorm = siJnorm;
         idemodel.siHnorm = siHnorm;
         idelre.siLREnorm = siLREnorm;
         save([IdentifDirectoryName '/' M_.fname '_identif.mat'], 'pdraws', 'idemodel', 'idemoments', 'idelre', ... %'indJJ', 'indH', 'indLRE', ...
-            'TAU', 'GAM', 'LRE','-append')
+             'TAU', 'GAM', 'LRE','-append')
     else
         siJnorm = idemoments_point.siJnorm;
         siHnorm = idemodel_point.siHnorm;
         siLREnorm = idelre_point.siLREnorm;
     end
-    
+
 else
     load([IdentifDirectoryName '/' M_.fname '_identif'])
-%     identFiles = dir([IdentifDirectoryName '/' M_.fname '_identif_*']);
+    %     identFiles = dir([IdentifDirectoryName '/' M_.fname '_identif_*']);
     parameters = store_options_ident.parameter_set;
     options_ident.parameter_set = parameters;
     options_ident.prior_mc=size(pdraws,1);
     SampleSize = options_ident.prior_mc;
     options_.options_ident = options_ident;
-end  
+end
 
-if nargout>3 && iload,
+if nargout>3 && iload
     filnam = dir([IdentifDirectoryName '/' M_.fname '_identif_*.mat']);
     H=[];
     JJ = [];
     gp = [];
-    for j=1:length(filnam),
+    for j=1:length(filnam)
         load([IdentifDirectoryName '/' M_.fname '_identif_',int2str(j),'.mat']);
         H = cat(3,H, stoH(:,abs(iload),:));
         JJ = cat(3,JJ, stoJJ(:,abs(iload),:));
         gp = cat(3,gp, stoLRE(:,abs(iload),:));
-        
+
     end
 end
 
-if iload,
+if iload
     disp(['Testing ',parameters])
     disp_identification(idehess_point.params, idemodel_point, idemoments_point, name,advanced);
-    if ~options_.nograph,
+    if ~options_.nograph
         plot_identification(idehess_point.params,idemoments_point,idehess_point,idemodel_point,idelre_point,advanced,parameters,name,IdentifDirectoryName,[],name_tex);
     end
 end
-if SampleSize > 1,
+if SampleSize > 1
     fprintf('\n')
     disp('Testing MC sample')
     disp_identification(pdraws, idemodel, idemoments, name);
-    if ~options_.nograph,
+    if ~options_.nograph
         plot_identification(pdraws,idemoments,idehess_point,idemodel,idelre,advanced,'MC sample ',name, IdentifDirectoryName,[],name_tex);
     end
-    if advanced,
+    if advanced
         jcrit=find(idemoments.ino);
-        if length(jcrit)<SampleSize,
-            if isempty(jcrit),
+        if length(jcrit)<SampleSize
+            if isempty(jcrit)
                 [dum,jmax]=max(idemoments.cond);
                 fprintf('\n')
                 tittxt = 'Draw with HIGHEST condition number';
                 fprintf('\n')
                 disp(['Testing ',tittxt, '. Press ENTER']), pause(5),
-                if ~iload,
+                if ~iload
                     [idehess_max, idemoments_max, idemodel_max, idelre_max, derivatives_info_max, info_max, options_ident] = ...
                         identification_analysis(pdraws(jmax,:),indx,indexo,options_ident,dataset_,dataset_info, prior_exist, name_tex,1,tittxt);
                     save([IdentifDirectoryName '/' M_.fname '_identif.mat'], 'idehess_max', 'idemoments_max','idemodel_max', 'idelre_max', 'jmax', '-append');
                 end
                 disp_identification(pdraws(jmax,:), idemodel_max, idemoments_max, name,1);
                 close all,
-                if ~options_.nograph,
+                if ~options_.nograph
                     plot_identification(pdraws(jmax,:),idemoments_max,idehess_max,idemodel_max,idelre_max,1,tittxt,name,IdentifDirectoryName,tittxt,name_tex);
                 end
                 [dum,jmin]=min(idemoments.cond);
                 fprintf('\n')
                 tittxt = 'Draw with SMALLEST condition number';
                 fprintf('\n')
-                disp(['Testing ',tittxt, '. Press ENTER']), pause(5),
-                if ~iload,
+                disp(['Testing ',tittxt, '. Press ENTER']), pause(5)
+                if ~iload
                     [idehess_min, idemoments_min, idemodel_min, idelre_min, derivatives_info_min, info_min, options_ident] = ...
                         identification_analysis(pdraws(jmin,:),indx,indexo,options_ident,dataset_, dataset_info, prior_exist, name_tex,1,tittxt);
                     save([IdentifDirectoryName '/' M_.fname '_identif.mat'], 'idehess_min', 'idemoments_min','idemodel_min', 'idelre_min', 'jmin', '-append');
                 end
                 disp_identification(pdraws(jmin,:), idemodel_min, idemoments_min, name,1);
                 close all,
-                if ~options_.nograph,
+                if ~options_.nograph
                     plot_identification(pdraws(jmin,:),idemoments_min,idehess_min,idemodel_min,idelre_min,1,tittxt,name,IdentifDirectoryName,tittxt,name_tex);
                 end
             else
-                for j=1:length(jcrit),
+                for j=1:length(jcrit)
                     tittxt = ['Rank deficient draw n. ',int2str(j)];
                     fprintf('\n')
                     disp(['Testing ',tittxt, '. Press ENTER']), pause(5),
-                    if ~iload,
+                    if ~iload
                         [idehess_(j), idemoments_(j), idemodel_(j), idelre_(j), derivatives_info_(j), info_resolve, options_ident] = ...
                             identification_analysis(pdraws(jcrit(j),:),indx,indexo,options_ident,dataset_, dataset_info, prior_exist, name_tex,1,tittxt);
                     end
                     disp_identification(pdraws(jcrit(j),:), idemodel_(j), idemoments_(j), name,1);
-                    close all,
-                    if ~options_.nograph,
+                    close all
+                    if ~options_.nograph
                         plot_identification(pdraws(jcrit(j),:),idemoments_(j),idehess_(j),idemodel_(j),idelre_(j),1,tittxt,name,IdentifDirectoryName,tittxt,name_tex);
                     end
                 end
-                if ~iload,
+                if ~iload
                     save([IdentifDirectoryName '/' M_.fname '_identif.mat'], 'idehess_', 'idemoments_','idemodel_', 'idelre_', 'jcrit', '-append');
                 end
             end
@@ -625,13 +620,13 @@ if SampleSize > 1,
 end
 
 if isoctave
-    warning('on'),
+    warning('on')
 else
-    warning on,
+    warning on
 end
 
 skipline()
-disp(['==== Identification analysis completed ====' ]),
+disp(['==== Identification analysis completed ====' ])
 skipline(2)
 
 options_ = options0_;
diff --git a/matlab/dynare_resolve.m b/matlab/dynare_resolve.m
index a2fad992a..32a1a885d 100644
--- a/matlab/dynare_resolve.m
+++ b/matlab/dynare_resolve.m
@@ -49,7 +49,7 @@ function [A,B,ys,info,Model,DynareOptions,DynareResults] = dynare_resolve(Model,
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -90,7 +90,7 @@ switch nargin
         ic = [ nstatic+(1:nspred) endo_nbr+(1:size(DynareResults.dr.ghx,2)-nspred) ]';
     else
         ic = DynareResults.dr.restrict_columns;
-    end;
+    end
   case 4
     iv = DynareResults.dr.restrict_var_list;
     ic = DynareResults.dr.restrict_columns;
diff --git a/matlab/dynare_sensitivity.m b/matlab/dynare_sensitivity.m
index 0aad64e1c..acb0f12b5 100644
--- a/matlab/dynare_sensitivity.m
+++ b/matlab/dynare_sensitivity.m
@@ -4,7 +4,7 @@ function x0=dynare_sensitivity(options_gsa)
 % Reference:
 % M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
 
-% Copyright (C) 2008-2016 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -24,64 +24,95 @@ function x0=dynare_sensitivity(options_gsa)
 global M_ options_ oo_ bayestopt_ estim_params_
 
 if options_.dsge_var
-   error('Identification does not support DSGE-VARs at the current stage') 
+    error('Identification does not support DSGE-VARs at the current stage')
 end
 
 fname_ = M_.fname;
 lgy_ = M_.endo_names;
 x0=[];
 
+% check user defined options
+if isfield(options_gsa,'neighborhood_width') && options_gsa.neighborhood_width
+    if isfield(options_gsa,'pprior') && options_gsa.pprior
+        error('sensitivity:: neighborhood_width is incompatible with prior sampling')
+    end
+    if isfield(options_gsa,'ppost') && options_gsa.ppost
+        error('sensitivity:: neighborhood_width is incompatible with posterior sampling')
+    end
+end
+
+if isfield(options_gsa,'morris') && options_gsa.morris==1
+    if isfield(options_gsa,'identification') && options_gsa.identification==0
+        %         options_gsa.redform=1;
+    end
+    if isfield(options_gsa,'ppost') && options_gsa.ppost
+        error('sensitivity:: Morris is incompatible with posterior sampling')
+    elseif isfield(options_gsa,'pprior') && options_gsa.pprior==0
+        if ~(isfield(options_gsa,'neighborhood_width') && options_gsa.neighborhood_width)
+            error('sensitivity:: Morris is incompatible with MC sampling with correlation matrix')
+        end
+    end
+    if isfield(options_gsa,'rmse') && options_gsa.rmse
+        error('sensitivity:: Morris is incompatible with rmse analysis')
+    end
+    if (isfield(options_gsa,'alpha2_stab') && options_gsa.alpha2_stab<1) || ...
+            (isfield(options_gsa,'pvalue_ks') && options_gsa.pvalue_ks) || ...
+            (isfield(options_gsa,'pvalue_corr') && options_gsa.pvalue_corr)
+        error('sensitivity:: Morris is incompatible with Monte Carlo filtering')
+    end
+end
+
+% end check user defined options
 options_gsa = set_default_option(options_gsa,'datafile',[]);
 options_gsa = set_default_option(options_gsa,'rmse',0);
 options_gsa = set_default_option(options_gsa,'useautocorr',0);
 
 options_gsa = set_default_option(options_gsa,'moment_calibration',options_.endogenous_prior_restrictions.moment);
 options_gsa = set_default_option(options_gsa,'irf_calibration',options_.endogenous_prior_restrictions.irf);
-if isfield(options_gsa,'nograph'),
+if isfield(options_gsa,'nograph')
     options_.nograph=options_gsa.nograph;
 end
-if isfield(options_gsa,'nodisplay'),
+if isfield(options_gsa,'nodisplay')
     options_.nodisplay=options_gsa.nodisplay;
 end
-if isfield(options_gsa,'graph_format'),
+if isfield(options_gsa,'graph_format')
     options_.graph_format=options_gsa.graph_format;
 end
-if isfield(options_gsa,'mode_file'),
+if isfield(options_gsa,'mode_file')
     options_.mode_file=options_gsa.mode_file;
-elseif isfield(options_gsa,'neighborhood_width') && options_gsa.neighborhood_width>0,
-    options_.mode_file='';    
+elseif isfield(options_gsa,'neighborhood_width') && options_gsa.neighborhood_width>0
+    options_.mode_file='';
 end
 
 options_.order = 1;
 
-if ~isempty(options_gsa.datafile) || isempty(bayestopt_) || options_gsa.rmse,
-    if isempty(options_gsa.datafile) && options_gsa.rmse,
+if ~isempty(options_gsa.datafile) || isempty(bayestopt_) || options_gsa.rmse
+    if isempty(options_gsa.datafile) && options_gsa.rmse
         disp('The data file and all relevant estimation options ')
         disp('[first_obs, nobs, presample, prefilter, loglinear, lik_init, kalman_algo, ...]')
         disp('must be specified for RMSE analysis!');
-        error('Sensitivity anaysis error!');
+        error('Sensitivity anaysis error!')
     end
-    
     options_.datafile = options_gsa.datafile;
-    if isfield(options_gsa,'first_obs'),
+    if isfield(options_gsa,'first_obs')
         options_.first_obs=options_gsa.first_obs;
     end
-    if isfield(options_gsa,'nobs'),
+    if isfield(options_gsa,'nobs')
         options_.nobs=options_gsa.nobs;
     end
-    if isfield(options_gsa,'presample'),
+    if isfield(options_gsa,'presample')
         options_.presample=options_gsa.presample;
     end
-    if isfield(options_gsa,'prefilter'),
+    if isfield(options_gsa,'prefilter')
         options_.prefilter=options_gsa.prefilter;
     end
-    if isfield(options_gsa,'loglinear'),
+    if isfield(options_gsa,'loglinear')
         options_.loglinear=options_gsa.loglinear;
     end
-    if isfield(options_gsa,'lik_init'),
+    if isfield(options_gsa,'lik_init')
         options_.lik_init=options_gsa.lik_init;
     end
-    if isfield(options_gsa,'kalman_algo'),
+    if isfield(options_gsa,'kalman_algo')
         options_.kalman_algo=options_gsa.kalman_algo;
     end
     options_.mode_compute = 0;
@@ -92,28 +123,28 @@ if ~isempty(options_gsa.datafile) || isempty(bayestopt_) || options_gsa.rmse,
 else
     if isempty(options_.qz_criterium)
         options_.qz_criterium = 1+1e-6;
-    end    
+    end
 end
 [make,my,day,punk,M_,options_,oo_] = dynare_resolve(M_,options_,oo_);
 
 options_gsa = set_default_option(options_gsa,'identification',0);
-if options_gsa.identification,
+if options_gsa.identification
     options_gsa.redform=0;
     options_gsa = set_default_option(options_gsa,'morris',1);
     options_gsa = set_default_option(options_gsa,'trans_ident',0);
     options_gsa = set_default_option(options_gsa,'load_ident_files',0);
     options_gsa = set_default_option(options_gsa,'ar',1);
     options_.ar = options_gsa.ar;
-    if options_gsa.morris==0,
+    if options_gsa.morris==0
         disp('The option morris = 0 is no longer supported (Type I errors)')
         disp('This option is reset at morris = 2 (local identification analysis).')
         options_gsa.morris=2;
     end
-    if options_gsa.morris==2,
-        if isfield(options_,'options_ident'),
+    if options_gsa.morris==2
+        if isfield(options_,'options_ident')
             options_.options_ident.load_ident_files = options_gsa.load_ident_files;
             options_.options_ident.useautocorr = options_gsa.useautocorr;
-            options_.options_ident.ar = options_gsa.ar;            
+            options_.options_ident.ar = options_gsa.ar;
             options_ident=options_.options_ident;
         else
             options_ident=[];
@@ -127,7 +158,6 @@ end
 
 % map stability
 options_gsa = set_default_option(options_gsa,'stab',1);
-options_gsa = set_default_option(options_gsa,'redform',0);
 options_gsa = set_default_option(options_gsa,'pprior',1);
 options_gsa = set_default_option(options_gsa,'prior_range',1);
 options_gsa = set_default_option(options_gsa,'ppost',0);
@@ -138,15 +168,14 @@ options_gsa = set_default_option(options_gsa,'glue',0);
 options_gsa = set_default_option(options_gsa,'morris_nliv',6);
 options_gsa = set_default_option(options_gsa,'morris_ntra',20);
 options_gsa = set_default_option(options_gsa,'Nsam',2048);
-options_gsa = set_default_option(options_gsa,'load_redform',0);
-options_gsa = set_default_option(options_gsa,'load_rmse',0);
 options_gsa = set_default_option(options_gsa,'load_stab',0);
 options_gsa = set_default_option(options_gsa,'alpha2_stab',0);
-options_gsa = set_default_option(options_gsa,'ksstat',0.1);
 options_gsa = set_default_option(options_gsa,'pvalue_ks',0.001);
 options_gsa = set_default_option(options_gsa,'pvalue_corr',1.e-5);
 %options_gsa = set_default_option(options_gsa,'load_mh',0);
 % REDFORM mapping
+options_gsa = set_default_option(options_gsa,'redform',0);
+options_gsa = set_default_option(options_gsa,'load_redform',0);
 options_gsa = set_default_option(options_gsa,'logtrans_redform',0);
 options_gsa = set_default_option(options_gsa,'threshold_redform',[]);
 options_gsa = set_default_option(options_gsa,'ksstat_redform',0.001);
@@ -155,6 +184,7 @@ options_gsa = set_default_option(options_gsa,'namendo',[]);
 options_gsa = set_default_option(options_gsa,'namlagendo',[]);
 options_gsa = set_default_option(options_gsa,'namexo',[]);
 % RMSE mapping
+options_gsa = set_default_option(options_gsa,'load_rmse',0);
 options_gsa = set_default_option(options_gsa,'lik_only',0);
 options_gsa = set_default_option(options_gsa,'var_rmse',char(options_.varobs));
 %get corresponding TeX-names;
@@ -168,27 +198,27 @@ options_gsa = set_default_option(options_gsa,'istart_rmse',options_.presample+1)
 options_gsa = set_default_option(options_gsa,'alpha_rmse',0.001);
 options_gsa = set_default_option(options_gsa,'alpha2_rmse',1.e-5);
 
-if options_gsa.neighborhood_width,
+if options_gsa.neighborhood_width
     options_gsa.pprior=0;
     options_gsa.ppost=0;
 end
 
-if options_gsa.redform && options_gsa.neighborhood_width==0 && isempty(options_gsa.threshold_redform),
+if options_gsa.redform && options_gsa.neighborhood_width==0 && isempty(options_gsa.threshold_redform)
     options_gsa.pprior=1;
     options_gsa.ppost=0;
 end
 
-if options_gsa.morris>2,
+if options_gsa.morris>2
     disp('The option morris = 3 is no longer supported')
     disp('the option is reset at morris = 1 .')
     options_gsa.morris=1;
 end
-   
-if options_gsa.morris==1,
-    if ~options_gsa.identification,
+
+if options_gsa.morris==1
+    if ~options_gsa.identification
         options_gsa.redform=1;
     end
-    if options_gsa.neighborhood_width,
+    if options_gsa.neighborhood_width
         options_gsa.pprior=0;
     else
         options_gsa.pprior=1;
@@ -199,53 +229,51 @@ if options_gsa.morris==1,
     options_gsa.rmse=0;
     options_gsa.load_rmse=0;
     options_gsa.alpha2_stab=1;
-    options_gsa.ksstat=1;
     options_gsa.pvalue_ks=0;
     options_gsa.pvalue_corr=0;
-%     if options_gsa.morris==3,
-%         options_gsa = set_default_option(options_gsa,'Nsam',256);
-%         OutputDirectoryName = CheckPath('gsa/identif',M_.dname);
-%     else
-        OutputDirectoryName = CheckPath('gsa/screen',M_.dname);
-%     end
+    %     if options_gsa.morris==3,
+    %         options_gsa = set_default_option(options_gsa,'Nsam',256);
+    %         OutputDirectoryName = CheckPath('gsa/identif',M_.dname);
+    %     else
+    OutputDirectoryName = CheckPath('gsa/screen',M_.dname);
+    %     end
 else
     OutputDirectoryName = CheckPath('gsa',M_.dname);
 end
 
 % options_.opt_gsa = options_gsa;
 
-if (options_gsa.load_stab || options_gsa.load_rmse || options_gsa.load_redform) ...
-        && options_gsa.pprior,
+if (options_gsa.load_stab || options_gsa.load_rmse || options_gsa.load_redform) && options_gsa.pprior
     filetoload=[OutputDirectoryName '/' fname_ '_prior.mat'];
-    if ~exist(filetoload),
+    if ~exist(filetoload)
         disp([filetoload,' not found!'])
         disp(['You asked to load a non existent analysis'])
         %options_gsa.load_stab=0;
-        return,
+        return
     else
-        if isempty(strmatch('bkpprior',who('-file', filetoload),'exact')),
-            disp('Warning! Missing prior info for saved sample') % trap for files previous 
-            disp('The saved files are generated with previous version of GSA package') % trap for files previous 
+        if isempty(strmatch('bkpprior',who('-file', filetoload),'exact'))
+            disp('Warning! Missing prior info for saved sample') % trap for files previous
+            disp('The saved files are generated with previous version of GSA package') % trap for files previous
         else
-            load(filetoload,'bkpprior'),
+            load(filetoload,'bkpprior')
             if any(bayestopt_.pshape~=bkpprior.pshape) || ...
                     any(bayestopt_.p1~=bkpprior.p1) || ...
                     any(bayestopt_.p2~=bkpprior.p2) || ...
                     any(bayestopt_.p3(~isnan(bayestopt_.p3))~=bkpprior.p3(~isnan(bkpprior.p3))) || ...
-                    any(bayestopt_.p4(~isnan(bayestopt_.p4))~=bkpprior.p4(~isnan(bkpprior.p4))),
+                    any(bayestopt_.p4(~isnan(bayestopt_.p4))~=bkpprior.p4(~isnan(bkpprior.p4)))
                 disp('WARNING!')
                 disp('The saved sample has different priors w.r.t. to current ones!!')
                 skipline()
                 disp('Press ENTER to continue')
-                pause;
+                pause
             end
         end
     end
 end
 
-if options_gsa.stab && ~options_gsa.ppost,
+if options_gsa.stab && ~options_gsa.ppost
     x0 = stab_map_(OutputDirectoryName,options_gsa);
-    if isempty(x0),
+    if isempty(x0)
         skipline()
         disp('Sensitivity computations stopped: no parameter set provided a unique solution')
         return
@@ -256,20 +284,19 @@ end
 % redform_map(namendo, namlagendo, namexo, icomp, pprior, ilog, threshold)
 
 options_.opt_gsa = options_gsa;
-if ~isempty(options_gsa.moment_calibration) || ~isempty(options_gsa.irf_calibration),
+if ~isempty(options_gsa.moment_calibration) || ~isempty(options_gsa.irf_calibration)
     map_calibration(OutputDirectoryName, M_, options_, oo_, estim_params_,bayestopt_);
 end
 
-if options_gsa.identification,
+if options_gsa.identification
     map_ident_(OutputDirectoryName,options_gsa);
 end
 
-if options_gsa.redform && ~isempty(options_gsa.namendo),% ...
-    %         && ~options_gsa.ppost,
-    if options_gsa.ppost,
+if options_gsa.redform && ~isempty(options_gsa.namendo)
+    if options_gsa.ppost
         filnam = dir([M_.dname filesep 'metropolis' filesep '*param_irf*.mat']);
         lpmat=[];
-        for j=1:length(filnam),
+        for j=1:length(filnam)
             load ([M_.dname filesep 'metropolis' filesep M_.fname '_param_irf' int2str(j) '.mat'])
             lpmat=[lpmat; stock];
         end
@@ -278,7 +305,7 @@ if options_gsa.redform && ~isempty(options_gsa.namendo),% ...
         nshock = nshock + estim_params_.nvn;
         nshock = nshock + estim_params_.ncx;
         nshock = nshock + estim_params_.ncn;
-        
+
         lpmat0=lpmat(:,1:nshock);
         lpmat=lpmat(:,nshock+1:end);
         istable=(1:size(lpmat,1));
@@ -287,25 +314,24 @@ if options_gsa.redform && ~isempty(options_gsa.namendo),% ...
         iindeterm=[];
         save([OutputDirectoryName filesep M_.fname '_mc.mat'],'lpmat','lpmat0','istable','iunstable','iwrong','iindeterm')
         options_gsa.load_stab=1;
-        
+
         x0 = stab_map_(OutputDirectoryName,options_gsa);
     end
-    if strmatch(':',options_gsa.namendo,'exact'),
+    if strmatch(':',options_gsa.namendo,'exact')
         options_gsa.namendo=M_.endo_names(1:M_.orig_endo_nbr,:);
     end
-    if strmatch(':',options_gsa.namexo,'exact'),
+    if strmatch(':',options_gsa.namexo,'exact')
         options_gsa.namexo=M_.exo_names;
     end
-    if strmatch(':',options_gsa.namlagendo,'exact'),
+    if strmatch(':',options_gsa.namlagendo,'exact')
         options_gsa.namlagendo=M_.endo_names(1:M_.orig_endo_nbr,:);
     end
-%     options_.opt_gsa = options_gsa;
-    if options_gsa.morris==1,
+    %     options_.opt_gsa = options_gsa;
+    if options_gsa.morris==1
         redform_screen(OutputDirectoryName,options_gsa);
     else
         % check existence of the SS_ANOVA toolbox
-        if isempty(options_gsa.threshold_redform) && ...
-         ~(exist('gsa_sdp','file')==6 || exist('gsa_sdp','file')==2),
+        if isempty(options_gsa.threshold_redform) && ~(exist('gsa_sdp','file')==6 || exist('gsa_sdp','file')==2)
             fprintf('\nThe "SS-ANOVA-R: MATLAB Toolbox for the estimation of Smoothing Spline ANOVA models with Recursive algorithms" is missing.\n')
             fprintf('To obtain it, go to:\n\n')
             fprintf('http://ipsc.jrc.ec.europa.eu/?id=790 \n\n')
@@ -320,79 +346,79 @@ end
 % RMSE mapping
 % function [rmse_MC, ixx] = filt_mc_(vvarvecm, loadSA, pfilt, alpha, alpha2)
 options_.opt_gsa = options_gsa;
-if options_gsa.rmse,
+if options_gsa.rmse
     if ~options_gsa.ppost
         if options_gsa.pprior
             a=whos('-file',[OutputDirectoryName,'/',fname_,'_prior'],'logpo2');
         else
             a=whos('-file',[OutputDirectoryName,'/',fname_,'_mc'],'logpo2');
         end
-        if isoctave
+        if isoctave()
             aflag=0;
-            for ja=1:length(a),
+            for ja=1:length(a)
                 aflag=aflag+strcmp('logpo2',a(ja).name);
             end
-            if aflag==0,
+            if aflag==0
                 a=[];
             else
                 a=1;
             end
         end
-        if isempty(a),
-           if options_gsa.lik_only,
-               options_.smoother=0;
-               options_.filter_step_ahead=[];
-               options_.forecast=0;
-               options_.filtered_vars=0;               
-           end
-%             dynare_MC([],OutputDirectoryName,data,rawdata,data_info);
-        if options_gsa.pprior
-            TmpDirectoryName = ([M_.dname filesep 'gsa' filesep 'prior']);
-        else
-            TmpDirectoryName = ([M_.dname filesep 'gsa' filesep 'mc']);
-        end
-        if exist(TmpDirectoryName,'dir');
-            mydelete([M_.fname '_filter_step_ahead*.mat'],[TmpDirectoryName filesep]);
-            mydelete([M_.fname '_inno*.mat'],[TmpDirectoryName filesep]);
-            mydelete([M_.fname '_smooth*.mat'],[TmpDirectoryName filesep]);
-            mydelete([M_.fname '_update*.mat'],[TmpDirectoryName filesep]);
-            filparam = dir([TmpDirectoryName filesep M_.fname '_param*.mat']);
-            for j=1:length(filparam),
-                if isempty(strmatch([M_.fname '_param_irf'],filparam(j).name))
-                    delete([TmpDirectoryName filesep filparam(j).name]);
-                end
+        if isempty(a)
+            if options_gsa.lik_only
+                options_.smoother=0;
+                options_.filter_step_ahead=[];
+                options_.forecast=0;
+                options_.filtered_vars=0;
             end
-            
-        end
-        prior_posterior_statistics('gsa',dataset_, dataset_info);
-        if options_.bayesian_irf
-            PosteriorIRF('gsa');
-        end
-        options_gsa.load_rmse=0;
-        %   else
-        %     if options_gsa.load_rmse==0,
-        %       disp('You already saved a MC filter/smoother analysis ')
-        %       disp('Do you want to overwrite ?')
-        %       pause;
-        %       if options_gsa.pprior
-        %         delete([OutputDirectoryName,'/',fname_,'_prior_*.mat'])
-        %       else
-        %         delete([OutputDirectoryName,'/',fname_,'_mc_*.mat'])
-        %       end
-        %       dynare_MC([],OutputDirectoryName);
-        %       options_gsa.load_rmse=0;
-        %     end
-            
+            %             dynare_MC([],OutputDirectoryName,data,rawdata,data_info);
+            if options_gsa.pprior
+                TmpDirectoryName = ([M_.dname filesep 'gsa' filesep 'prior']);
+            else
+                TmpDirectoryName = ([M_.dname filesep 'gsa' filesep 'mc']);
+            end
+            if exist(TmpDirectoryName,'dir')
+                mydelete([M_.fname '_filter_step_ahead*.mat'],[TmpDirectoryName filesep]);
+                mydelete([M_.fname '_inno*.mat'],[TmpDirectoryName filesep]);
+                mydelete([M_.fname '_smooth*.mat'],[TmpDirectoryName filesep]);
+                mydelete([M_.fname '_update*.mat'],[TmpDirectoryName filesep]);
+                filparam = dir([TmpDirectoryName filesep M_.fname '_param*.mat']);
+                for j=1:length(filparam)
+                    if isempty(strmatch([M_.fname '_param_irf'],filparam(j).name))
+                        delete([TmpDirectoryName filesep filparam(j).name]);
+                    end
+                end
+
+            end
+            prior_posterior_statistics('gsa',dataset_, dataset_info);
+            if options_.bayesian_irf
+                PosteriorIRF('gsa');
+            end
+            options_gsa.load_rmse=0;
+            %   else
+            %     if options_gsa.load_rmse==0,
+            %       disp('You already saved a MC filter/smoother analysis ')
+            %       disp('Do you want to overwrite ?')
+            %       pause;
+            %       if options_gsa.pprior
+            %         delete([OutputDirectoryName,'/',fname_,'_prior_*.mat'])
+            %       else
+            %         delete([OutputDirectoryName,'/',fname_,'_mc_*.mat'])
+            %       end
+            %       dynare_MC([],OutputDirectoryName);
+            %       options_gsa.load_rmse=0;
+            %     end
+
         end
     end
     clear a;
-%     filt_mc_(OutputDirectoryName,data_info);
+    %     filt_mc_(OutputDirectoryName,data_info);
     filt_mc_(OutputDirectoryName,options_gsa,dataset_,dataset_info);
 end
 options_.opt_gsa = options_gsa;
 
 
-if options_gsa.glue,
+if options_gsa.glue
     dr_ = oo_.dr;
     if options_gsa.ppost
         load([OutputDirectoryName,'/',fname_,'_post']);
@@ -404,7 +430,7 @@ if options_gsa.glue,
             load([OutputDirectoryName,'/',fname_,'_mc']);
         end
     end
-    if ~exist('x'),
+    if ~exist('x')
         disp(['No RMSE analysis is available for current options'])
         disp(['No GLUE file prepared'])
         return,
@@ -422,14 +448,14 @@ if options_gsa.glue,
     else
         data = transpose(rawdata);
     end
-    
+
     Obs.data = data;
     Obs.time = [1:gend];
     Obs.num  = gend;
     for j=1:length(options_.varobs)
         Obs.name{j} = options_.varobs{j};
         vj = options_.varobs{j};
-        
+
         jxj = strmatch(vj,lgy_(dr_.order_var,:),'exact');
         js = strmatch(vj,lgy_,'exact');
         if ~options_gsa.ppost
@@ -451,7 +477,7 @@ if options_gsa.glue,
         Lik(j).ini  = 'yes';
         Lik(j).isam = 1;
         Lik(j).data = rmse_MC(:,j)';
-        
+
         if ~options_gsa.ppost
             %       y0 = squeeze(stock_smooth(:,jxj,:)) + ...
             %         kron(stock_ys(js,:),ones(size(stock_smooth,1),1));
@@ -464,14 +490,14 @@ if options_gsa.glue,
             Out1=Out;
         end
         ismoo(j)=jxj;
-        
+
     end
     jsmoo = length(options_.varobs);
-    for j=1:M_.endo_nbr,
-        if ~ismember(j,ismoo),
+    for j=1:M_.endo_nbr
+        if ~ismember(j,ismoo)
             jsmoo=jsmoo+1;
             vj=deblank(M_.endo_names(dr_.order_var(j),:));
-            if ~options_gsa.ppost        
+            if ~options_gsa.ppost
                 %         y0 = squeeze(stock_smooth(:,j,:)) + ...
                 %           kron(stock_ys(j,:),ones(size(stock_smooth,1),1));
                 %         Out1(jsmoo).time = [1:size(y0,1)];
@@ -487,8 +513,8 @@ if options_gsa.glue,
         end
     end
     tit(M_.exo_names_orig_ord,:) = M_.exo_names;
-    for j=1:M_.exo_nbr,
-        Exo(j).name = deblank(tit(j,:));    
+    for j=1:M_.exo_nbr
+        Exo(j).name = deblank(tit(j,:));
     end
     if ~options_gsa.ppost
         Lik(length(options_.varobs)+1).name = 'logpo';
@@ -499,10 +525,10 @@ if options_gsa.glue,
     Sam.name = bayestopt_.name;
     Sam.dim  = [size(x) 0];
     Sam.data = [x];
-    
+
     Rem.id = 'Original';
     Rem.ind= [1:size(x,1)];
-    
+
     Info.dynare=M_.fname;
     Info.order_var=dr_.order_var;
     Out=Out1;
@@ -513,7 +539,7 @@ if options_gsa.glue,
         Info.TypeofSample='post';
         save([OutputDirectoryName,'/',fname_,'_glue_post.mat'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem','Info', 'Exo')
         %save([fname_,'_post_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem','Info')
-        
+
     else
         if options_gsa.pprior
             Info.TypeofSample='prior';
@@ -529,5 +555,5 @@ if options_gsa.glue,
             %       save([OutputDirectoryName,'/',fname_,'_mc_glue_smooth'], 'Out', 'Sam', 'Lik', 'Obs', 'Rem')
         end
     end
-    
+
 end
diff --git a/matlab/dynare_solve.m b/matlab/dynare_solve.m
index 149d2f9ed..366bfa3a4 100644
--- a/matlab/dynare_solve.m
+++ b/matlab/dynare_solve.m
@@ -17,7 +17,7 @@ function [x,info,fvec,fjac] = dynare_solve(func,x,options,varargin)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,29 +58,91 @@ else
     maxit = options.steady.maxit;
 end
 
-
 info = 0;
 nn = size(x,1);
 
+% Get status of the initial guess (default values?)
+if any(x)
+    % The current initial guess is not the default for all the variables.
+    idx = find(x);      % Indices of the variables with default initial guess values. 
+    in0 = length(idx);
+else
+    % The current initial guess is the default for all the variables.
+    idx = transpose(1:nn);
+    in0 = nn;
+end
+
 % checking initial values
 if jacobian_flag
-    [fvec,fjac] = feval(func,x,varargin{:});
-    if any(any(isinf(fjac) | isnan(fjac)))
-        info=1;
-        x = NaN(size(fvec));
-        return
+    [fvec, fjac] = feval(func, x, varargin{:});
+    wrong_initial_guess_flag = false;
+    if ~all(isfinite(fvec)) || any(isinf(fjac(:))) || any(isnan((fjac(:))))
+        % Let's try random numbers for the variables initialized with the default value.
+        wrong_initial_guess_flag = true;
+        % First try with positive numbers.
+        tentative_number = 0;
+        while wrong_initial_guess_flag && tentative_number<=in0*10
+            tentative_number = tentative_number+1;
+            x(idx) = rand(in0, 1)*10;
+            [fvec, fjac] = feval(func, x, varargin{:});
+            wrong_initial_guess_flag = ~all(isfinite(fvec)) || any(isinf(fjac(:))) || any(isnan((fjac(:))));
+        end
+        % If all previous attempts failed, try with real numbers.
+        tentative_number = 0;
+        while wrong_initial_guess_flag && tentative_number<=in0*10
+            tentative_number = tentative_number+1;
+            x(idx) = randn(in0, 1)*10;
+            [fvec, fjac] = feval(func, x, varargin{:});
+            wrong_initial_guess_flag = ~all(isfinite(fvec)) || any(isinf(fjac(:))) || any(isnan((fjac(:))));
+        end
+        % Last tentative, ff all previous attempts failed, try with negative numbers.
+        tentative_number = 0;
+        while wrong_initial_guess_flag && tentative_number<=in0*10
+            tentative_number = tentative_number+1;
+            x(idx) = -rand(in0, 1)*10;
+            [fvec, fjac] = feval(func, x, varargin{:});
+            wrong_initial_guess_flag = ~all(isfinite(fvec)) || any(isinf(fjac(:))) || any(isnan((fjac(:))));
+        end
     end
 else
     fvec = feval(func,x,varargin{:});
-    fjac = zeros(nn,nn) ;
+    fjac = zeros(nn,nn);
+    wrong_initial_guess_flag = false;
+    if ~all(isfinite(fvec))
+        % Let's try random numbers for the variables initialized with the default value.
+        wrong_initial_guess_flag = true;
+        % First try with positive numbers.
+        tentative_number = 0;
+        while wrong_initial_guess_flag && tentative_number<=in0*10
+            tentative_number = tentative_number+1;
+            x(idx) = rand(in0, 1)*10;
+            fvec = feval(func, x, varargin{:});
+            wrong_initial_guess_flag = ~all(isfinite(fvec));
+        end
+        % If all previous attempts failed, try with real numbers.
+        tentative_number = 0;
+        while wrong_initial_guess_flag && tentative_number<=in0*10
+            tentative_number = tentative_number+1;
+            x(idx) = randn(in0, 1)*10;
+            fvec = feval(func, x, varargin{:});
+            wrong_initial_guess_flag = ~all(isfinite(fvec));
+        end
+        % Last tentative, ff all previous attempts failed, try with negative numbers.
+        tentative_number = 0;
+        while wrong_initial_guess_flag && tentative_number<=in0*10
+            tentative_number = tentative_number+1;
+            x(idx) = -rand(in0, 1)*10;
+            fvec = feval(func, x, varargin{:});
+            wrong_initial_guess_flag = ~all(isfinite(fvec));
+        end
+    end
 end
 
-i = find(~isfinite(fvec));
-
-if ~isempty(i)
-    info = 1;
+% Exit with error if no initial guess has been found.
+if wrong_initial_guess_flag
+    info=1;
     x = NaN(size(fvec));
-    return;
+    return
 end
 
 % this test doesn't check complementarity conditions and is not used for
@@ -125,7 +187,7 @@ if options.solve_algo == 0
             [x,fval,exitval,output] = fsolve(func,x,options4fsolve);
         else
             exitval = 3;
-        end;
+        end
     end
 
     if exitval == 1
@@ -141,19 +203,19 @@ if options.solve_algo == 0
         if max(abs(fvec)) >= tolf
             info = 1;
         else
-            info = 0;        
+            info = 0;
         end
     else
         info = 1;
     end
 elseif options.solve_algo == 1
-        [x,info]=solve1(func,x,1:nn,1:nn,jacobian_flag,options.gstep, ...
+    [x,info]=solve1(func,x,1:nn,1:nn,jacobian_flag,options.gstep, ...
                     tolf,options.solve_tolx, ...
                     maxit,options.debug,varargin{:});
 elseif options.solve_algo == 9
-        [x,info]=trust_region(func,x,1:nn,1:nn,jacobian_flag,options.gstep, ...
-                    tolf,options.solve_tolx, ...
-                    maxit,options.debug,varargin{:});
+    [x,info]=trust_region(func,x,1:nn,1:nn,jacobian_flag,options.gstep, ...
+                          tolf,options.solve_tolx, ...
+                          maxit,options.debug,varargin{:});
 elseif options.solve_algo == 2 || options.solve_algo == 4
 
     if options.solve_algo == 2
@@ -233,4 +295,3 @@ elseif options.solve_algo == 11
 else
     error('DYNARE_SOLVE: option solve_algo must be one of [0,1,2,3,4,9,10,11]')
 end
-
diff --git a/matlab/dynare_solve_block_or_bytecode.m b/matlab/dynare_solve_block_or_bytecode.m
index 1032d0921..2a1f547b9 100644
--- a/matlab/dynare_solve_block_or_bytecode.m
+++ b/matlab/dynare_solve_block_or_bytecode.m
@@ -1,5 +1,5 @@
 function [x,info] = dynare_solve_block_or_bytecode(y, exo, params, options, M)
-% Copyright (C) 2010-2015 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -22,7 +22,7 @@ if options.block && ~options.bytecode
     for b = 1:length(M.block_structure_stat.block)
         ss = x;
         if M.block_structure_stat.block(b).Simulation_Type ~= 1 && ...
-           M.block_structure_stat.block(b).Simulation_Type ~= 2
+                M.block_structure_stat.block(b).Simulation_Type ~= 2
             if options.solve_algo <= 4
                 [y, check] = dynare_solve('block_mfs_steadystate', ...
                                           ss(M.block_structure_stat.block(b).variable), ...
@@ -60,7 +60,7 @@ elseif options.bytecode
     elseif options.block
         for b = 1:length(M.block_structure_stat.block)
             if M.block_structure_stat.block(b).Simulation_Type ~= 1 && ...
-               M.block_structure_stat.block(b).Simulation_Type ~= 2
+                    M.block_structure_stat.block(b).Simulation_Type ~= 2
                 [y, check] = dynare_solve('block_bytecode_mfs_steadystate', ...
                                           x(M.block_structure_stat ...
                                             .block(b).variable), ...
@@ -80,7 +80,7 @@ elseif options.bytecode
                     info = 1;
                     return
                 end
-            end;
+            end
         end
     else
         [x, check] = dynare_solve('bytecode_steadystate', y, ...
diff --git a/matlab/dynare_squeeze.m b/matlab/dynare_squeeze.m
index b01be342f..85e66f332 100644
--- a/matlab/dynare_squeeze.m
+++ b/matlab/dynare_squeeze.m
@@ -1,7 +1,7 @@
-function B = dynare_squeeze(A);
+function B = dynare_squeeze(A)
 % Same as matlab's squeeze function except that it also affects 2D arrays.
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -18,7 +18,7 @@ function B = dynare_squeeze(A);
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-sizA = size(A); 
+sizA = size(A);
 dimA = length(sizA);
 switch dimA
   case 1
diff --git a/matlab/dynare_version.m.in b/matlab/dynare_version.m.in
index 6a1391613..f2c502ea0 100644
--- a/matlab/dynare_version.m.in
+++ b/matlab/dynare_version.m.in
@@ -1,6 +1,6 @@
-function v = dynare_version
-% function v = dynare_version
-%	This command returns Dynare version number
+function v = dynare_version()
+
+% This command returns Dynare version number.
 %
 % INPUTS
 %   none
@@ -11,7 +11,7 @@ function v = dynare_version
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,4 +28,4 @@ function v = dynare_version
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    v = '@PACKAGE_VERSION@';
+v = '@PACKAGE_VERSION@';
diff --git a/matlab/dynasave.m b/matlab/dynasave.m
index f2cc991ca..ef938dbc2 100644
--- a/matlab/dynasave.m
+++ b/matlab/dynasave.m
@@ -12,7 +12,7 @@ function dynasave(s,var_list)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2010 Dynare Team
+% Copyright (C) 2001-2015 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/dynatype.m b/matlab/dynatype.m
index 35276028f..517bcc0b1 100644
--- a/matlab/dynatype.m
+++ b/matlab/dynatype.m
@@ -1,19 +1,19 @@
 function dynatype (s,var_list)
 % function dynatype (s,var_list)
-% This optional command saves the simulation results in a text file. The name of each 
+% This optional command saves the simulation results in a text file. The name of each
 % variable preceeds the corresponding results. This command must follow SIMUL.
-%  
+%
 % INPUTS
 %   s:         filename
 %   var_list:  vector of selected endogenous variables
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/dyntable.m b/matlab/dyntable.m
index 23d56feff..5b632cde3 100644
--- a/matlab/dyntable.m
+++ b/matlab/dyntable.m
@@ -7,11 +7,11 @@ function dyntable(options_,title,headers,labels,values,label_width,val_width,val
 %   labels      [n by nchar]        character array of labels for label column
 %   values      [matrix]            matrix of values to display
 %   label_width [scalar]            Width of the label
-%   val_width   [scalar]            Width of value column    
+%   val_width   [scalar]            Width of value column
 %   val_precis  [integer]           precision of displayed values
-% 
-% 
-% Copyright (C) 2002-2015 Dynare Team
+%
+%
+% Copyright (C) 2002-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,9 +33,9 @@ if options_.noprint
 end
 
 %% get width of label column
-if ~isempty(label_width) 
+if ~isempty(label_width)
     label_width = max(size(deblank(char(headers(1,:),labels)),2)+2, ...
-                     label_width);
+                      label_width);
 else %use default length
     label_width = max(size(deblank(char(headers(1,:),labels)),2))+2;
 end
@@ -51,7 +51,7 @@ if any(values) < 0 %add one character for minus sign
     values_length = values_length+1;
 end
 
-%% get width of header strings 
+%% get width of header strings
 headers_length = max(size(deblank(headers(2:end,:)),2));
 if ~isempty(val_width)
     val_width = max(max(headers_length,values_length)+2,val_width);
diff --git a/matlab/endogenous_prior.m b/matlab/endogenous_prior.m
index c2930abad..26ea7ce5f 100644
--- a/matlab/endogenous_prior.m
+++ b/matlab/endogenous_prior.m
@@ -2,17 +2,17 @@ function [lnpriormom] = endogenous_prior(data,Pstar,BayesInfo,H)
 % Computes the endogenous log prior addition to the initial prior
 %
 % INPUTS
-%    data           [double]     n*T vector of data observations 
+%    data           [double]     n*T vector of data observations
 %    Pstar          [double]     k*k matrix of
-%    BayesInfo      [structure]   
+%    BayesInfo      [structure]
 %
 % OUTPUTS
 %    lnpriormom     [double]     scalar of log endogenous prior value
 
 % Code to implement notes on endogenous priors by Lawrence Christiano,
 % specified in the appendix of:
-% ’Introducing Financial Frictions and Unemployment into a Small Open Economy Model’
-% by Lawrence J. Christiano, Mathias Trabandt and Karl Walentin (2011), Journal of Economic Dynamics and Control      
+% Â’Introducing Financial Frictions and Unemployment into a Small Open Economy ModelÂ’
+% by Lawrence J. Christiano, Mathias Trabandt and Karl Walentin (2011), Journal of Economic Dynamics and Control
 % this is the 'mother' of the priors on the model parameters.
 % the priors include a metric across some choosen moments of the (supposedly
 % pre-sample) data.
@@ -23,8 +23,8 @@ function [lnpriormom] = endogenous_prior(data,Pstar,BayesInfo,H)
 % appropriate adjustment to the following code.
 
 
-% Copyright (C) 2011 Lawrence J. Christiano, Mathias Trabandt and Karl Walentin 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2011 Lawrence J. Christiano, Mathias Trabandt and Karl Walentin
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -75,7 +75,7 @@ end
 
 % Finally, we have the sampling uncertainty measure Shat:
 Shat=C0 +(1-1/(2+1))*(C1+C1')...
-    +(1-2/(2+1))*(C2+C2');
+     +(1-2/(2+1))*(C2+C2');
 
 % Model variances below:
 mf=BayesInfo.mf1;
@@ -86,4 +86,3 @@ Ftheta=diag(Z*Pstar(:,mf)+H);
 % below commented out line is for Del Negro Schorfheide style priors:
 %     lnpriormom=-.5*n*TT*log(2*pi)-.5*TT*log(det(sigma))-.5*TT*trace(inv(sigma)*(gamyy-2*phi'*gamxy+phi'*gamxx*phi));
 lnpriormom=.5*n*log(Tsamp/(2*pi))-.5*log(det(Shat))-.5*Tsamp*(Fhat-Ftheta)'/Shat*(Fhat-Ftheta);
-
diff --git a/matlab/endogenous_prior_restrictions.m b/matlab/endogenous_prior_restrictions.m
index 617116a89..ef734acd1 100644
--- a/matlab/endogenous_prior_restrictions.m
+++ b/matlab/endogenous_prior_restrictions.m
@@ -1,178 +1,173 @@
-function [info, info_irf, info_moment, data_irf, data_moment] = endogenous_prior_restrictions(T,R,Model,DynareOptions,DynareResults);
-% Check for prior (sign) restrictions on irf's and theoretical moments
-%
-% INPUTS
-%    T          [double]     n*n state space matrix
-%    R          [double]     n*k matrix of shocks
-%    Model      [structure]
-%    DynareOptions [structure]
-%    DynareResults [structure]
-
-% OUTPUTS
-%    info     [double]  check if prior restrictions are matched by the
-%                       model and related info
-%    info_irf [double] array of test checks for all individual irf restrictions
-%    info_moment [double] array of test checks for all individual moment restrictions
-%    
-
-% Copyright (C) 2013 Dynare Team
-%
-% This file is part of Dynare.
-%
-% Dynare is free software: you can redistribute it and/or modify
-% it under the terms of the GNU General Public License as published by
-% the Free Software Foundation, either version 3 of the License, or
-% (at your option) any later version.
-%
-% Dynare is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-
-info=[0 0];
-info_irf=[];
-info_moment=[];
-data_irf=[];
-data_moment=[];
-
-endo_prior_restrictions.irf= DynareOptions.endogenous_prior_restrictions.irf;
-endo_prior_restrictions.moment= DynareOptions.endogenous_prior_restrictions.moment;
-
-if ~isempty(endo_prior_restrictions.irf),
-   data_irf=cell(size(endo_prior_restrictions.irf,1),1);    
-    if DynareOptions.order>1,
-        error('The algorithm for prior (sign) restrictions on irf''s is currently restricted to first-order decision rules')
-        return
-    end
-    varlist=Model.endo_names(DynareResults.dr.order_var,:);
-    if isempty(T),
-        [T,R,SteadyState,infox,Model,DynareOptions,DynareResults] = dynare_resolve(Model,DynareOptions,DynareResults);
-    else % check if T and R are given in the restricted form!!!
-        if size(T,1)<size(varlist,1),
-            varlist=varlist(DynareResults.dr.restrict_var_list,:); 
-        end
-        % check if endo_prior_restrictions.irf{:,1} variables are in varlist
-        varlistok=1;
-        for j=1:size(endo_prior_restrictions.irf,1)
-            if isempty(strmatch(endo_prior_restrictions.irf{j,1},varlist,'exact'))
-                varlistok=0;
-            end
-        end
-        if ~varlistok
-            varlist=Model.endo_names(DynareResults.dr.order_var,:);
-            [T,R,SteadyState,infox,Model,DynareOptions,DynareResults] = dynare_resolve(Model,DynareOptions,DynareResults);
-        end
-    end
-    NT=1;
-    for j=1:size(endo_prior_restrictions.irf,1),
-        NT=max(NT,max(endo_prior_restrictions.irf{j,3}));
-    end
-    info_irf=ones(size(endo_prior_restrictions.irf,1),2);
-    for t=1:NT,
-        if ~DynareOptions.relative_irf,
-            RR = T^(t-1)*R*diag(sqrt(diag(Model.Sigma_e)));
-        else
-            RR = T^(t-1)*R*100;
-        end
-        for j=1:size(endo_prior_restrictions.irf,1),
-            if endo_prior_restrictions.irf{j,3}~=t,
-                continue,
-            end
-            iendo=strmatch(endo_prior_restrictions.irf{j,1},varlist,'exact');
-            iexo=strmatch(endo_prior_restrictions.irf{j,2},Model.exo_names,'exact');
-            data_irf{j}=[data_irf{j}; [t RR(iendo,iexo)]];
-            if (RR(iendo,iexo)>endo_prior_restrictions.irf{j,4}(1)) && (RR(iendo,iexo)<endo_prior_restrictions.irf{j,4}(2)),
-                info_irf(j,:)=info_irf(j,:).*[0, 0];
-            else
-                if RR(iendo,iexo)<endo_prior_restrictions.irf{j,4}(1),
-                    delt = (RR(iendo,iexo)-endo_prior_restrictions.irf{j,4}(1))^2;
-                else
-                    delt = (RR(iendo,iexo)-endo_prior_restrictions.irf{j,4}(2))^2;
-                end
-                info_irf(j,:)=info_irf(j,:).*[49, delt];
-            end
-        end
-    end
-    if any(info_irf),
-        info=[49,sum(info_irf(:,2))];
-    end
-    
-end
-
-if ~isempty(endo_prior_restrictions.moment),
-    
-    if DynareOptions.order>1,
-        error('The algorithm for prior (sign) restrictions on moments is currently restricted to first-order decision rules')
-        return
-    end
-    
-    data_moment=cell(size(endo_prior_restrictions.moment,1),1);
-    var_list_=endo_prior_restrictions.moment{1,1};
-    for  j=1:size(endo_prior_restrictions.moment,1),
-        tmp=endo_prior_restrictions.moment{j,1};
-        if ~ismember(tmp,cellstr(var_list_)),
-            var_list_ = char(var_list_, tmp);
-        end
-        tmp=endo_prior_restrictions.moment{j,2};
-        if ~ismember(tmp,cellstr(var_list_)),
-            var_list_ = char(var_list_, tmp);
-        end
-    end
-    NTmax=0;
-    NTmin=0;
-    for j=1:size(endo_prior_restrictions.moment,1),
-        NTmax=max(NTmax,max(endo_prior_restrictions.moment{j,3}));
-        NTmin=min(NTmin,min(endo_prior_restrictions.moment{j,3}));
-    end
-    info_moment=ones(size(endo_prior_restrictions.moment,1),2);
-    nvar = size(var_list_,1);
-    ivar=zeros(nvar,1);
-    for i=1:nvar
-        i_tmp = strmatch(var_list_(i,:),Model.endo_names,'exact');
-        if isempty(i_tmp)
-            error (['One of the variable specified does not exist']) ;
-        else
-            ivar(i) = i_tmp;
-        end
-    end
-    DynareOptions.ar = max(abs(NTmin),NTmax);
-    [gamma_y,stationary_vars] = th_autocovariances(DynareResults.dr, ivar, Model, DynareOptions,1);
-    for t=NTmin:NTmax,
-        RR = gamma_y{abs(t)+1};     
-        if t==0,
-            RR = RR./(sqrt(diag(RR))*sqrt(diag(RR))')-eye(nvar)+diag(diag(gamma_y{t+1})); % becomes correlation            
-        end
-        for j=1:size(endo_prior_restrictions.moment,1),
-            if endo_prior_restrictions.moment{j,3}~=t,
-                continue,
-            end
-            iendo1 = strmatch(endo_prior_restrictions.moment{j,1},var_list_,'exact');
-            iendo2 = strmatch(endo_prior_restrictions.moment{j,2},var_list_,'exact');
-            if t>0
-                tmp0 = iendo1;
-                iendo1=iendo2;
-                iendo2=tmp0;
-            end
-            data_moment{j}=[data_moment{j}; [t RR(iendo1,iendo2)]];
-            if (RR(iendo1,iendo2)>endo_prior_restrictions.moment{j,4}(1)) && (RR(iendo1,iendo2)<endo_prior_restrictions.moment{j,4}(2)),
-                info_moment(j,:)=info_moment(j,:).*[0, 0];
-            else
-                if RR(iendo1,iendo2)<endo_prior_restrictions.moment{j,4}(1),
-                    delt = (RR(iendo1,iendo2)-endo_prior_restrictions.moment{j,4}(1))^2;
-                else
-                    delt = (RR(iendo1,iendo2)-endo_prior_restrictions.moment{j,4}(2))^2;
-                end
-                info_moment(j,:)=info_moment(j,:).*[49, delt];
-            end
-        end
-    end
-    if any(info_moment),
-        info=[49, info(2) + sum(info_moment(:,2))];
-    end
-end
-return
-
-
+function [info, info_irf, info_moment, data_irf, data_moment] = endogenous_prior_restrictions(T,R,Model,DynareOptions,DynareResults)
+% Check for prior (sign) restrictions on irf's and theoretical moments
+%
+% INPUTS
+%    T          [double]     n*n state space matrix
+%    R          [double]     n*k matrix of shocks
+%    Model      [structure]
+%    DynareOptions [structure]
+%    DynareResults [structure]
+
+% OUTPUTS
+%    info     [double]  check if prior restrictions are matched by the
+%                       model and related info
+%    info_irf [double] array of test checks for all individual irf restrictions
+%    info_moment [double] array of test checks for all individual moment restrictions
+%
+
+% Copyright (C) 2013-2017 Dynare Team
+%
+% This file is part of Dynare.
+%
+% Dynare is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version.
+%
+% Dynare is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+
+info=[0 0];
+info_irf=[];
+info_moment=[];
+data_irf=[];
+data_moment=[];
+
+endo_prior_restrictions.irf= DynareOptions.endogenous_prior_restrictions.irf;
+endo_prior_restrictions.moment= DynareOptions.endogenous_prior_restrictions.moment;
+
+if ~isempty(endo_prior_restrictions.irf)
+    data_irf=cell(size(endo_prior_restrictions.irf,1),1);
+    if DynareOptions.order>1
+        error('The algorithm for prior (sign) restrictions on irf''s is currently restricted to first-order decision rules')
+        return
+    end
+    varlist=Model.endo_names(DynareResults.dr.order_var,:);
+    if isempty(T)
+        [T,R,SteadyState,infox,Model,DynareOptions,DynareResults] = dynare_resolve(Model,DynareOptions,DynareResults);
+    else % check if T and R are given in the restricted form!!!
+        if size(T,1)<size(varlist,1)
+            varlist=varlist(DynareResults.dr.restrict_var_list,:);
+        end
+        % check if endo_prior_restrictions.irf{:,1} variables are in varlist
+        varlistok=1;
+        for j=1:size(endo_prior_restrictions.irf,1)
+            if isempty(strmatch(endo_prior_restrictions.irf{j,1},varlist,'exact'))
+                varlistok=0;
+            end
+        end
+        if ~varlistok
+            varlist=Model.endo_names(DynareResults.dr.order_var,:);
+            [T,R,SteadyState,infox,Model,DynareOptions,DynareResults] = dynare_resolve(Model,DynareOptions,DynareResults);
+        end
+    end
+    NT=1;
+    for j=1:size(endo_prior_restrictions.irf,1)
+        NT=max(NT,max(endo_prior_restrictions.irf{j,3}));
+    end
+    info_irf=ones(size(endo_prior_restrictions.irf,1),2);
+    for t=1:NT
+        if ~DynareOptions.relative_irf
+            RR = T^(t-1)*R*diag(sqrt(diag(Model.Sigma_e)));
+        else
+            RR = T^(t-1)*R*100;
+        end
+        for j=1:size(endo_prior_restrictions.irf,1)
+            if endo_prior_restrictions.irf{j,3}~=t
+                continue
+            end
+            iendo=strmatch(endo_prior_restrictions.irf{j,1},varlist,'exact');
+            iexo=strmatch(endo_prior_restrictions.irf{j,2},Model.exo_names,'exact');
+            data_irf{j}=[data_irf{j}; [t RR(iendo,iexo)]];
+            if (RR(iendo,iexo)>endo_prior_restrictions.irf{j,4}(1)) && (RR(iendo,iexo)<endo_prior_restrictions.irf{j,4}(2))
+                info_irf(j,:)=info_irf(j,:).*[0, 0];
+            else
+                if RR(iendo,iexo)<endo_prior_restrictions.irf{j,4}(1)
+                    delt = (RR(iendo,iexo)-endo_prior_restrictions.irf{j,4}(1))^2;
+                else
+                    delt = (RR(iendo,iexo)-endo_prior_restrictions.irf{j,4}(2))^2;
+                end
+                info_irf(j,:)=info_irf(j,:).*[49, delt];
+            end
+        end
+    end
+    if any(info_irf)
+        info=[49,sum(info_irf(:,2))];
+    end
+
+end
+
+if ~isempty(endo_prior_restrictions.moment)
+    if DynareOptions.order>1
+        error('The algorithm for prior (sign) restrictions on moments is currently restricted to first-order decision rules')
+        return
+    end
+    data_moment=cell(size(endo_prior_restrictions.moment,1),1);
+    var_list_=endo_prior_restrictions.moment{1,1};
+    for  j=1:size(endo_prior_restrictions.moment,1)
+        tmp=endo_prior_restrictions.moment{j,1};
+        if ~ismember(tmp,cellstr(var_list_))
+            var_list_ = char(var_list_, tmp);
+        end
+        tmp=endo_prior_restrictions.moment{j,2};
+        if ~ismember(tmp,cellstr(var_list_))
+            var_list_ = char(var_list_, tmp);
+        end
+    end
+    NTmax=0;
+    NTmin=0;
+    for j=1:size(endo_prior_restrictions.moment,1)
+        NTmax=max(NTmax,max(endo_prior_restrictions.moment{j,3}));
+        NTmin=min(NTmin,min(endo_prior_restrictions.moment{j,3}));
+    end
+    info_moment=ones(size(endo_prior_restrictions.moment,1),2);
+    nvar = size(var_list_,1);
+    ivar=zeros(nvar,1);
+    for i=1:nvar
+        i_tmp = strmatch(var_list_(i,:),Model.endo_names,'exact');
+        if isempty(i_tmp)
+            error (['One of the variable specified does not exist'])
+        else
+            ivar(i) = i_tmp;
+        end
+    end
+    DynareOptions.ar = max(abs(NTmin),NTmax);
+    [gamma_y,stationary_vars] = th_autocovariances(DynareResults.dr, ivar, Model, DynareOptions,1);
+    for t=NTmin:NTmax
+        RR = gamma_y{abs(t)+1};
+        if t==0
+            RR = RR./(sqrt(diag(RR))*sqrt(diag(RR))')-eye(nvar)+diag(diag(gamma_y{t+1})); % becomes correlation
+        end
+        for j=1:size(endo_prior_restrictions.moment,1)
+            if endo_prior_restrictions.moment{j,3}~=t
+                continue
+            end
+            iendo1 = strmatch(endo_prior_restrictions.moment{j,1},var_list_,'exact');
+            iendo2 = strmatch(endo_prior_restrictions.moment{j,2},var_list_,'exact');
+            if t>0
+                tmp0 = iendo1;
+                iendo1=iendo2;
+                iendo2=tmp0;
+            end
+            data_moment{j}=[data_moment{j}; [t RR(iendo1,iendo2)]];
+            if (RR(iendo1,iendo2)>endo_prior_restrictions.moment{j,4}(1)) && (RR(iendo1,iendo2)<endo_prior_restrictions.moment{j,4}(2))
+                info_moment(j,:)=info_moment(j,:).*[0, 0];
+            else
+                if RR(iendo1,iendo2)<endo_prior_restrictions.moment{j,4}(1)
+                    delt = (RR(iendo1,iendo2)-endo_prior_restrictions.moment{j,4}(1))^2;
+                else
+                    delt = (RR(iendo1,iendo2)-endo_prior_restrictions.moment{j,4}(2))^2;
+                end
+                info_moment(j,:)=info_moment(j,:).*[49, delt];
+            end
+        end
+    end
+    if any(info_moment)
+        info=[49, info(2) + sum(info_moment(:,2))];
+    end
+end
\ No newline at end of file
diff --git a/matlab/ep/ep_problem_2.m b/matlab/ep/ep_problem_2.m
index d31f0e7aa..9168631bf 100644
--- a/matlab/ep/ep_problem_2.m
+++ b/matlab/ep/ep_problem_2.m
@@ -78,7 +78,7 @@ for i = 1:order+1
                 else
                     k1 = (nnodes-1)*(i-1)+k;
                 end
-                if hybrid_order == 2 && (k > 1 || i == order) 
+                if hybrid_order == 2 && (k > 1 || i == order)
                     z = [Y(i_cols_p,1);
                          Y(i_cols_s,1);
                          Y(i_cols_f,k1)+h_correction(i_hc)];
@@ -93,10 +93,10 @@ for i = 1:order+1
                         % in first period we don't keep track of
                         % predetermined variables
                         i_cols_A = [i_cols_As - ny; i_cols_Af];
-                        A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(eq_index,i_cols_1);  
+                        A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(eq_index,i_cols_1);
                     else
                         i_cols_A = [i_cols_Ap; i_cols_As; i_cols_Af];
-                        A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(eq_index,i_cols_j);  
+                        A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(eq_index,i_cols_j);
                     end
                 else
                     d1 = dynamic_model(z,innovation,params,steady_state,i+1);
@@ -180,7 +180,7 @@ for j=1:world_nbr
             nzA{i,j} = [offset_r+ir,offset_c+icA(ic), v]';
         else
             d1 = dynamic_model(Y(i_rows_y,j),x,params, ...
-                                          steady_state,i+1);
+                               steady_state,i+1);
         end
         res(:,i,j) = d1(eq_index);
         i_rows_y = i_rows_y + ny;
diff --git a/matlab/ep/euler_equation_error.m b/matlab/ep/euler_equation_error.m
index 16de7a4b1..7496852fb 100644
--- a/matlab/ep/euler_equation_error.m
+++ b/matlab/ep/euler_equation_error.m
@@ -1,5 +1,22 @@
 function e = euler_equation_error(y0,x,innovations,M,options,oo,pfm,nodes,weights)
 
+% Copyright (C) 2016-2017 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/>.    
+
 dynamic_model = str2func([M.fname '_dynamic']);
 ep = options.ep;
 [y1, info_convergence, endogenousvariablespaths] = extended_path_core(ep.periods, ...
@@ -18,7 +35,7 @@ i_fwrd = find(M.lead_lag_incidence(3,:));
 x1 = [x(2:end,:); zeros(1,M.exo_nbr)];
 for i=1:length(nodes)
     x2 = x1;
-    x2(2,:) = x2(2,:) + nodes(i,:); 
+    x2(2,:) = x2(2,:) + nodes(i,:);
     [y2, info_convergence, endogenousvariablespaths] = ...
         extended_path_core(ep.periods, M.endo_nbr, M.exo_nbr, ...
                            innovations.positive_var_indx, x2, ep.init, ...
@@ -26,7 +43,7 @@ for i=1:length(nodes)
                            ep.stochastic.order, M, pfm, ep.stochastic.algo, ...
                            ep.solve_algo, ep.stack_solve_algo, options.lmmcp, ...
                            options, oo, []);
-    
+
     z = [y0(i_pred); y1; y2(i_fwrd)];
     res(:,i) = dynamic_model(z,x,M.params,oo.steady_state,2);
 end
diff --git a/matlab/ep/extended_path.m b/matlab/ep/extended_path.m
index 03a7e4ed7..13747890b 100644
--- a/matlab/ep/extended_path.m
+++ b/matlab/ep/extended_path.m
@@ -3,7 +3,7 @@ function [ts, DynareResults] = extended_path(initialconditions, samplesize, exog
 % Stochastic simulation of a non linear DSGE model using the Extended Path method (Fair and Taylor 1983). A time
 % series of size T  is obtained by solving T perfect foresight models.
 %
-% INPUTS 
+% INPUTS
 %  o initialconditions      [double]    m*1 array, where m is the number of endogenous variables in the model.
 %  o samplesize             [integer]   scalar, size of the sample to be simulated.
 %  o exogenousvariables     [double]    T*n array, values for the structural innovations.
@@ -11,7 +11,7 @@ function [ts, DynareResults] = extended_path(initialconditions, samplesize, exog
 %  o DynareModel            [struct]    M_
 %  o DynareResults          [struct]    oo_
 %
-% OUTPUTS 
+% OUTPUTS
 %  o ts                     [dseries]   m*samplesize array, the simulations.
 %  o results                [cell]
 %
@@ -19,7 +19,7 @@ function [ts, DynareResults] = extended_path(initialconditions, samplesize, exog
 %
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2009-2016 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -96,7 +96,7 @@ end
 if any(isnan(endogenous_variables_paths(:)))
     sl = find(~isnan(endogenous_variables_paths));
     nn = size(endogenous_variables_paths, 1);
-    endogenous_variables_paths = reshape(endogenous_variables_paths(sl), nn, length(sl)/nn); 
+    endogenous_variables_paths = reshape(endogenous_variables_paths(sl), nn, length(sl)/nn);
 end
 ts = dseries(transpose(endogenous_variables_paths), initial_period, cellstr(DynareModel.endo_names));
 
diff --git a/matlab/ep/extended_path_core.m b/matlab/ep/extended_path_core.m
index 33c42b619..5a99b6f21 100644
--- a/matlab/ep/extended_path_core.m
+++ b/matlab/ep/extended_path_core.m
@@ -1,10 +1,10 @@
 function [y, info_convergence, endogenousvariablespaths] = extended_path_core(periods,endo_nbr,exo_nbr,positive_var_indx, ...
-                                exo_simul,init,initial_conditions,...
-                                steady_state, ...
-                                debug,bytecode_flag,order,M,pfm,algo,solve_algo,stack_solve_algo,...
-                                olmmcp,options,oo,initialguess)
+                                                  exo_simul,init,initial_conditions,...
+                                                  steady_state, ...
+                                                  debug,bytecode_flag,order,M,pfm,algo,solve_algo,stack_solve_algo,...
+                                                  olmmcp,options,oo,initialguess)
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,7 +58,7 @@ if flag
         options.solve_algo = solve_algo;
         options.stack_solve_algo = stack_solve_algo;
         tmp = perfect_foresight_solver_core(M, options, oo);
-        if ~tmp.deterministic_simulation.status 
+        if ~tmp.deterministic_simulation.status
             info_convergence = false;
         else
             info_convergence = true;
diff --git a/matlab/ep/extended_path_homotopy.m b/matlab/ep/extended_path_homotopy.m
index 463003d2b..8036ae50f 100644
--- a/matlab/ep/extended_path_homotopy.m
+++ b/matlab/ep/extended_path_homotopy.m
@@ -1,6 +1,6 @@
 function [info_convergence, endo_simul] = extended_path_homotopy(endo_simul, exo_simul, M, options, oo, pfm, ep, order, algo, method, debug)
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,7 +17,7 @@ function [info_convergence, endo_simul] = extended_path_homotopy(endo_simul, exo
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    
+
 endo_simul0 = endo_simul;
 if ismember(method, [1, 2])
     noconvergence = true;
diff --git a/matlab/ep/extended_path_initialization.m b/matlab/ep/extended_path_initialization.m
index 34d7cdc68..fb8581bc6 100644
--- a/matlab/ep/extended_path_initialization.m
+++ b/matlab/ep/extended_path_initialization.m
@@ -2,21 +2,21 @@ function [initial_conditions, innovations, pfm, ep, verbosity, DynareOptions, Dy
 
 % Initialization of the extended path routines.
 %
-% INPUTS 
+% INPUTS
 %  o initial_conditions     [double]    m*1 array, where m is the number of endogenous variables in the model.
 %  o sample_size            [integer]   scalar, size of the sample to be simulated.
 %  o exogenousvariables     [double]    T*n array, values for the structural innovations.
-%  o DynareOptions          [struct]    options_ 
+%  o DynareOptions          [struct]    options_
 %  o DynareModel            [struct]    M_
 %  o DynareResults          [struct]    oo_
 %
-% OUTPUTS 
+% OUTPUTS
 %
 % ALGORITHM
 %
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -118,7 +118,7 @@ pfm.nnzA = DynareModel.NNZDerivatives(1);
 if ep.stochastic.order > 0
     [nodes,weights,nnodes] = setup_integration_nodes(DynareOptions.ep,pfm);
     pfm.nodes = nodes;
-    pfm.weights = weights; 
+    pfm.weights = weights;
     pfm.nnodes = nnodes;
     % compute number of blocks
     [block_nbr,pfm.world_nbr] = get_block_world_nbr(ep.stochastic.algo,nnodes,ep.stochastic.order,ep.periods);
@@ -134,6 +134,5 @@ if DynareOptions.ep.solve_algo == 10
 elseif DynareOptions.ep.solve_algo == 11
     DynareOptions.mcppath.lb = repmat(lb,block_nbr,1);
     DynareOptions.mcppath.ub = repmat(ub,block_nbr,1);
-end;
+end
 pfm.block_nbr = block_nbr;
-
diff --git a/matlab/ep/extended_path_mc.m b/matlab/ep/extended_path_mc.m
index f03bca8ae..f31ae2dc9 100644
--- a/matlab/ep/extended_path_mc.m
+++ b/matlab/ep/extended_path_mc.m
@@ -3,7 +3,7 @@ function Simulations = extended_path_mc(initialconditions, samplesize, replic, e
 % Stochastic simulation of a non linear DSGE model using the Extended Path method (Fair and Taylor 1983). A time
 % series of size T  is obtained by solving T perfect foresight models.
 %
-% INPUTS 
+% INPUTS
 %  o initialconditions      [double]    m*1 array, where m is the number of endogenous variables in the model.
 %  o samplesize            [integer]   scalar, size of the sample to be simulated.
 %  o exogenousvariables     [double]    T*n array, values for the structural innovations.
@@ -11,7 +11,7 @@ function Simulations = extended_path_mc(initialconditions, samplesize, replic, e
 %  o DynareModel            [struct]    M_
 %  o DynareResults          [struct]    oo_
 %
-% OUTPUTS 
+% OUTPUTS
 %  o ts                     [dseries]   m*samplesize array, the simulations.
 %  o results                [cell]
 %
@@ -19,7 +19,7 @@ function Simulations = extended_path_mc(initialconditions, samplesize, replic, e
 %
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -65,7 +65,7 @@ vexo = NaN(innovations.effective_number_of_shocks, samplesize+1, replic);
 info = NaN(replic, 1);
 
 if ep.parallel
-    % Use the Parallel toolbox.    
+    % Use the Parallel toolbox.
     parfor i=1:replic
         innovations_ = innovations;
         DynareResults_ = DynareResults;
diff --git a/matlab/ep/extended_path_shocks.m b/matlab/ep/extended_path_shocks.m
index 693990340..b642f225b 100644
--- a/matlab/ep/extended_path_shocks.m
+++ b/matlab/ep/extended_path_shocks.m
@@ -1,6 +1,6 @@
-function [shocks, spfm_exo_simul, innovations, DynareResults] = extended_path_shocks(innovations, ep, exogenousvariables, sample_size,DynareModel,DynareOptions, DynareResults); 
+function [shocks, spfm_exo_simul, innovations, DynareResults] = extended_path_shocks(innovations, ep, exogenousvariables, sample_size,DynareModel,DynareOptions, DynareResults)
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ep/setup_integration_nodes.m b/matlab/ep/setup_integration_nodes.m
index 85d1be960..5a6d206c1 100644
--- a/matlab/ep/setup_integration_nodes.m
+++ b/matlab/ep/setup_integration_nodes.m
@@ -1,39 +1,39 @@
 function [nodes,weights,nnodes] = setup_integration_nodes(EpOptions,pfm)
-    if EpOptions.stochastic.order
-        % Compute weights and nodes for the stochastic version of the extended path.
-        switch EpOptions.IntegrationAlgorithm
-          case 'Tensor-Gaussian-Quadrature'
-            % Get the nodes and weights from a univariate Gauss-Hermite quadrature.
-            [nodes0,weights0] = gauss_hermite_weights_and_nodes(EpOptions.stochastic.quadrature.nodes);
-            % Replicate the univariate nodes for each innovation and dates, and, if needed, correlate them. 
-            nodes0 = repmat(nodes0,1,pfm.number_of_shocks*pfm.stochastic_order)*kron(eye(pfm.stochastic_order),pfm.Omega);
-            % Put the nodes and weights in cells
-            for i=1:pfm.number_of_shocks
-                rr(i) = {nodes0(:,i)};
-                ww(i) = {weights0};
-            end
-            % Build the tensorial grid
-            nodes = cartesian_product_of_sets(rr{:});
-            weights = prod(cartesian_product_of_sets(ww{:}),2);
-            nnodes = length(weights);
-          case 'Stroud-Cubature-3'
-            [nodes,weights] = cubature_with_gaussian_weight(pfm.number_of_shocks*pfm.stochastic_order,3,'Stroud')
-            nodes = kron(eye(pfm.stochastic_order),transpose(pfm.Omega))*nodes;
-            weights = weights;
-            nnodes = length(weights);
-          case 'Stroud-Cubature-5'
-            [nodes,weights] = cubature_with_gaussian_weight(pfm.number_of_shocks*pfm.stochastic_order,5,'Stroud')
-            nodes = kron(eye(pfm.stochastic_order),transpose(pfm.Omega))*nodes;
-            weights = weights;
-            nnodes = length(weights);
-          case 'Unscented'
-            p = pfm.number_of_shocks;
-            k = EpOptions.ut.k;
-            C = sqrt(pfm.number_of_shocks + k)*pfm.Omega';
-            nodes = [zeros(1,p); -C; C];
-            weights = [k/(p+k); (1/(2*(p+k)))*ones(2*p,1)];
-            nnodes = 2*p+1;
-          otherwise
-            error('Stochastic extended path:: Unknown integration algorithm!')
+if EpOptions.stochastic.order
+    % Compute weights and nodes for the stochastic version of the extended path.
+    switch EpOptions.IntegrationAlgorithm
+      case 'Tensor-Gaussian-Quadrature'
+        % Get the nodes and weights from a univariate Gauss-Hermite quadrature.
+        [nodes0,weights0] = gauss_hermite_weights_and_nodes(EpOptions.stochastic.quadrature.nodes);
+        % Replicate the univariate nodes for each innovation and dates, and, if needed, correlate them.
+        nodes0 = repmat(nodes0,1,pfm.number_of_shocks*pfm.stochastic_order)*kron(eye(pfm.stochastic_order),pfm.Omega);
+        % Put the nodes and weights in cells
+        for i=1:pfm.number_of_shocks
+            rr(i) = {nodes0(:,i)};
+            ww(i) = {weights0};
         end
+        % Build the tensorial grid
+        nodes = cartesian_product_of_sets(rr{:});
+        weights = prod(cartesian_product_of_sets(ww{:}),2);
+        nnodes = length(weights);
+      case 'Stroud-Cubature-3'
+        [nodes,weights] = cubature_with_gaussian_weight(pfm.number_of_shocks*pfm.stochastic_order,3,'Stroud')
+        nodes = kron(eye(pfm.stochastic_order),transpose(pfm.Omega))*nodes;
+        weights = weights;
+        nnodes = length(weights);
+      case 'Stroud-Cubature-5'
+        [nodes,weights] = cubature_with_gaussian_weight(pfm.number_of_shocks*pfm.stochastic_order,5,'Stroud')
+        nodes = kron(eye(pfm.stochastic_order),transpose(pfm.Omega))*nodes;
+        weights = weights;
+        nnodes = length(weights);
+      case 'Unscented'
+        p = pfm.number_of_shocks;
+        k = EpOptions.ut.k;
+        C = sqrt(pfm.number_of_shocks + k)*pfm.Omega';
+        nodes = [zeros(1,p); -C; C];
+        weights = [k/(p+k); (1/(2*(p+k)))*ones(2*p,1)];
+        nnodes = 2*p+1;
+      otherwise
+        error('Stochastic extended path:: Unknown integration algorithm!')
     end
+end
diff --git a/matlab/ep/setup_stochastic_perfect_foresight_model_solver.m b/matlab/ep/setup_stochastic_perfect_foresight_model_solver.m
index 286bd16ac..732714d4a 100644
--- a/matlab/ep/setup_stochastic_perfect_foresight_model_solver.m
+++ b/matlab/ep/setup_stochastic_perfect_foresight_model_solver.m
@@ -1,6 +1,6 @@
 function pfm = setup_stochastic_perfect_foresight_model_solver(DynareModel,DynareOptions,DynareOutput)
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -16,7 +16,7 @@ function pfm = setup_stochastic_perfect_foresight_model_solver(DynareModel,Dynar
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 pfm.lead_lag_incidence = DynareModel.lead_lag_incidence;
 pfm.ny = DynareModel.endo_nbr;
 pfm.Sigma = DynareModel.Sigma_e;
@@ -71,4 +71,3 @@ pfm.verbose = DynareOptions.ep.verbosity;
 pfm.maxit_ = DynareOptions.simul.maxit;
 pfm.tolerance = DynareOptions.dynatol.f;
 pfm.use_bytecode = DynareOptions.ep.use_bytecode ;
-
diff --git a/matlab/ep/solve_stochastic_perfect_foresight_model.m b/matlab/ep/solve_stochastic_perfect_foresight_model.m
index ab13e3043..742895f91 100644
--- a/matlab/ep/solve_stochastic_perfect_foresight_model.m
+++ b/matlab/ep/solve_stochastic_perfect_foresight_model.m
@@ -1,6 +1,6 @@
 function [flag,endo_simul,err] = solve_stochastic_perfect_foresight_model(endo_simul,exo_simul,pfm,nnodes,order)
 
-% Copyright (C) 2012-2015 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,219 +17,219 @@ function [flag,endo_simul,err] = solve_stochastic_perfect_foresight_model(endo_s
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    flag = 0;
-    err = 0;
-    stop = 0;
+flag = 0;
+err = 0;
+stop = 0;
 
-    params = pfm.params;
-    steady_state = pfm.steady_state;
-    ny = pfm.ny;
-    periods = pfm.periods;
-    dynamic_model = pfm.dynamic_model;
-    lead_lag_incidence = pfm.lead_lag_incidence;
-    nyp = pfm.nyp;
-    nyf = pfm.nyf;
-    i_cols_1 = pfm.i_cols_1;
-    i_cols_A1 = pfm.i_cols_A1;
-    i_cols_j = pfm.i_cols_j;
-    i_cols_T = nonzeros(lead_lag_incidence(1:2,:)');
+params = pfm.params;
+steady_state = pfm.steady_state;
+ny = pfm.ny;
+periods = pfm.periods;
+dynamic_model = pfm.dynamic_model;
+lead_lag_incidence = pfm.lead_lag_incidence;
+nyp = pfm.nyp;
+nyf = pfm.nyf;
+i_cols_1 = pfm.i_cols_1;
+i_cols_A1 = pfm.i_cols_A1;
+i_cols_j = pfm.i_cols_j;
+i_cols_T = nonzeros(lead_lag_incidence(1:2,:)');
 
-    maxit = pfm.maxit_;
-    tolerance = pfm.tolerance;
-    verbose = pfm.verbose;
+maxit = pfm.maxit_;
+tolerance = pfm.tolerance;
+verbose = pfm.verbose;
 
-    number_of_shocks = size(exo_simul,2);
+number_of_shocks = size(exo_simul,2);
 
-    [nodes,weights] = gauss_hermite_weights_and_nodes(nnodes);
+[nodes,weights] = gauss_hermite_weights_and_nodes(nnodes);
 
-    if number_of_shocks>1
-        nodes = repmat(nodes,1,number_of_shocks)*chol(pfm.Sigma);
-        % to be fixed for Sigma ~= I
-        for i=1:number_of_shocks
-            rr(i) = {nodes(:,i)};
-            ww(i) = {weights};
+if number_of_shocks>1
+    nodes = repmat(nodes,1,number_of_shocks)*chol(pfm.Sigma);
+    % to be fixed for Sigma ~= I
+    for i=1:number_of_shocks
+        rr(i) = {nodes(:,i)};
+        ww(i) = {weights};
+    end
+    nodes = cartesian_product_of_sets(rr{:});
+    weights = prod(cartesian_product_of_sets(ww{:}),2);
+    nnodes = nnodes^number_of_shocks;
+else
+    nodes = nodes*sqrt(pfm.Sigma);
+end
+
+innovations = zeros(periods+2,number_of_shocks);
+
+if verbose
+    disp ([' -----------------------------------------------------']);
+    disp (['MODEL SIMULATION :']);
+    fprintf('\n');
+end
+
+z = endo_simul(find(lead_lag_incidence'));
+[d1,jacobian] = dynamic_model(z,exo_simul,params,steady_state,2);
+
+% Each column of Y represents a different world
+% The upper right cells are unused
+% The first row block is ny x 1
+% The second row block is ny x nnodes
+% The third row block is ny x nnodes^2
+% and so on until size ny x nnodes^order
+world_nbr = nnodes^order;
+Y = repmat(endo_simul(:),1,world_nbr);
+
+% The columns of A map the elements of Y such that
+% each block of Y with ny rows are unfolded column wise
+dimension = ny*(sum(nnodes.^(0:order-1),2)+(periods-order)*world_nbr);
+if order == 0
+    i_upd_r = (1:ny*periods);
+    i_upd_y = i_upd_r + ny;
+else
+    i_upd_r = zeros(dimension,1);
+    i_upd_y = i_upd_r;
+    i_upd_r(1:ny) = (1:ny);
+    i_upd_y(1:ny) = ny+(1:ny);
+    i1 = ny+1;
+    i2 = 2*ny;
+    n1 = ny+1;
+    n2 = 2*ny;
+    for i=2:periods
+        k = n1:n2;
+        for j=1:nnodes^min(i-1,order)
+            i_upd_r(i1:i2) = (n1:n2)+(j-1)*ny*periods;
+            i_upd_y(i1:i2) = (n1:n2)+ny+(j-1)*ny*(periods+2);
+            i1 = i2+1;
+            i2 = i2+ny;
         end
-        nodes = cartesian_product_of_sets(rr{:});
-        weights = prod(cartesian_product_of_sets(ww{:}),2);
-        nnodes = nnodes^number_of_shocks;
-    else
-        nodes = nodes*sqrt(pfm.Sigma);
+        n1 = n2+1;
+        n2 = n2+ny;
     end
-
-    innovations = zeros(periods+2,number_of_shocks);
-
-    if verbose
-        disp ([' -----------------------------------------------------']);
-        disp (['MODEL SIMULATION :']);
-        fprintf('\n');
-    end
-
-    z = endo_simul(find(lead_lag_incidence'));
-    [d1,jacobian] = dynamic_model(z,exo_simul,params,steady_state,2);
-
-    % Each column of Y represents a different world
-    % The upper right cells are unused
-    % The first row block is ny x 1
-    % The second row block is ny x nnodes
-    % The third row block is ny x nnodes^2
-    % and so on until size ny x nnodes^order
-    world_nbr = nnodes^order;
-    Y = repmat(endo_simul(:),1,world_nbr);
-
-    % The columns of A map the elements of Y such that
-    % each block of Y with ny rows are unfolded column wise
-    dimension = ny*(sum(nnodes.^(0:order-1),2)+(periods-order)*world_nbr);
-    if order == 0
-        i_upd_r = (1:ny*periods);
-        i_upd_y = i_upd_r + ny;
-    else
-        i_upd_r = zeros(dimension,1);
-        i_upd_y = i_upd_r;
-        i_upd_r(1:ny) = (1:ny);
-        i_upd_y(1:ny) = ny+(1:ny);
-        i1 = ny+1;
-        i2 = 2*ny;
-        n1 = ny+1;
-        n2 = 2*ny;
-        for i=2:periods
-            k = n1:n2;
-            for j=1:nnodes^min(i-1,order)
-                i_upd_r(i1:i2) = (n1:n2)+(j-1)*ny*periods;
-                i_upd_y(i1:i2) = (n1:n2)+ny+(j-1)*ny*(periods+2);
-                i1 = i2+1;
-                i2 = i2+ny;
+end
+icA = [find(lead_lag_incidence(1,:)) find(lead_lag_incidence(2,:))+world_nbr*ny ...
+       find(lead_lag_incidence(3,:))+2*world_nbr*ny]';
+h1 = clock;
+for iter = 1:maxit
+    h2 = clock;
+    A1 = sparse([],[],[],ny*(sum(nnodes.^(0:order-1),2)+1),dimension,(order+1)*world_nbr*nnz(jacobian));
+    res = zeros(ny,periods,world_nbr);
+    i_rows = 1:ny;
+    i_cols = find(lead_lag_incidence');
+    i_cols_p = i_cols(1:nyp);
+    i_cols_s = i_cols(nyp+(1:ny));
+    i_cols_f = i_cols(nyp+ny+(1:nyf));
+    i_cols_A = i_cols;
+    i_cols_Ap = i_cols_p;
+    i_cols_As = i_cols_s;
+    i_cols_Af = i_cols_f - ny;
+    for i = 1:order+1
+        i_w_p = 1;
+        for j = 1:nnodes^(i-1)
+            innovation = exo_simul;
+            if i > 1
+                innovation(i+1,:) = nodes(mod(j-1,nnodes)+1,:);
             end
-            n1 = n2+1;
-            n2 = n2+ny;
-        end
-    end
-    icA = [find(lead_lag_incidence(1,:)) find(lead_lag_incidence(2,:))+world_nbr*ny ...
-           find(lead_lag_incidence(3,:))+2*world_nbr*ny]';
-    h1 = clock;
-    for iter = 1:maxit
-        h2 = clock;
-        A1 = sparse([],[],[],ny*(sum(nnodes.^(0:order-1),2)+1),dimension,(order+1)*world_nbr*nnz(jacobian));
-        res = zeros(ny,periods,world_nbr);
-        i_rows = 1:ny;
-        i_cols = find(lead_lag_incidence');
-        i_cols_p = i_cols(1:nyp);
-        i_cols_s = i_cols(nyp+(1:ny));
-        i_cols_f = i_cols(nyp+ny+(1:nyf));
-        i_cols_A = i_cols;
-        i_cols_Ap = i_cols_p;
-        i_cols_As = i_cols_s;
-        i_cols_Af = i_cols_f - ny;
-        for i = 1:order+1
-            i_w_p = 1;
-            for j = 1:nnodes^(i-1)
-                innovation = exo_simul;
-                if i > 1
-                    innovation(i+1,:) = nodes(mod(j-1,nnodes)+1,:);
-                end
-                if i <= order
-                    for k=1:nnodes
-                        y = [Y(i_cols_p,i_w_p);
-                             Y(i_cols_s,j);
-                             Y(i_cols_f,(j-1)*nnodes+k)];
-                        [d1,jacobian] = dynamic_model(y,innovation,params,steady_state,i+1);
-                        if i == 1
-                            % in first period we don't keep track of
-                            % predetermined variables
-                            i_cols_A = [i_cols_As - ny; i_cols_Af];
-                            A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(:,i_cols_1);
-                        else
-                            i_cols_A = [i_cols_Ap; i_cols_As; i_cols_Af];
-                            A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(:,i_cols_j);
-                        end
-                        res(:,i,j) = res(:,i,j)+weights(k)*d1;
-                        i_cols_Af = i_cols_Af + ny;
-                    end
-                else
+            if i <= order
+                for k=1:nnodes
                     y = [Y(i_cols_p,i_w_p);
                          Y(i_cols_s,j);
-                         Y(i_cols_f,j)];
+                         Y(i_cols_f,(j-1)*nnodes+k)];
                     [d1,jacobian] = dynamic_model(y,innovation,params,steady_state,i+1);
                     if i == 1
                         % in first period we don't keep track of
                         % predetermined variables
                         i_cols_A = [i_cols_As - ny; i_cols_Af];
-                        A1(i_rows,i_cols_A) = jacobian(:,i_cols_1);
+                        A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(:,i_cols_1);
                     else
                         i_cols_A = [i_cols_Ap; i_cols_As; i_cols_Af];
-                        A1(i_rows,i_cols_A) = jacobian(:,i_cols_j);
+                        A1(i_rows,i_cols_A) = A1(i_rows,i_cols_A) + weights(k)*jacobian(:,i_cols_j);
                     end
-                    res(:,i,j) = d1;
+                    res(:,i,j) = res(:,i,j)+weights(k)*d1;
                     i_cols_Af = i_cols_Af + ny;
                 end
-                i_rows = i_rows + ny;
-                if mod(j,nnodes) == 0
-                    i_w_p = i_w_p + 1;
-                end
-                if i > 1
-                    if mod(j,nnodes) == 0
-                        i_cols_Ap = i_cols_Ap + ny;
-                    end
-                    i_cols_As = i_cols_As + ny;
-                end
-            end
-            i_cols_p = i_cols_p + ny;
-            i_cols_s = i_cols_s + ny;
-            i_cols_f = i_cols_f + ny;
-        end
-        nzA = cell(periods,world_nbr);
-        for j=1:world_nbr
-            i_rows_y = find(lead_lag_incidence')+(order+1)*ny;
-            offset_c = ny*(sum(nnodes.^(0:order-1),2)+j-1);
-            offset_r = (j-1)*ny;
-            for i=order+2:periods
-                [d1,jacobian] = dynamic_model(Y(i_rows_y,j), ...
-                                              exo_simul,params, ...
-                                              steady_state,i+1);
-                if i == periods
-                    [ir,ic,v] = find(jacobian(:,i_cols_T));
+            else
+                y = [Y(i_cols_p,i_w_p);
+                     Y(i_cols_s,j);
+                     Y(i_cols_f,j)];
+                [d1,jacobian] = dynamic_model(y,innovation,params,steady_state,i+1);
+                if i == 1
+                    % in first period we don't keep track of
+                    % predetermined variables
+                    i_cols_A = [i_cols_As - ny; i_cols_Af];
+                    A1(i_rows,i_cols_A) = jacobian(:,i_cols_1);
                 else
-                    [ir,ic,v] = find(jacobian(:,i_cols_j));
+                    i_cols_A = [i_cols_Ap; i_cols_As; i_cols_Af];
+                    A1(i_rows,i_cols_A) = jacobian(:,i_cols_j);
                 end
-                nzA{i,j} = [offset_r+ir,offset_c+icA(ic), v]';
                 res(:,i,j) = d1;
-                i_rows_y = i_rows_y + ny;
-                offset_c = offset_c + world_nbr*ny;
-                offset_r = offset_r + world_nbr*ny;
+                i_cols_Af = i_cols_Af + ny;
+            end
+            i_rows = i_rows + ny;
+            if mod(j,nnodes) == 0
+                i_w_p = i_w_p + 1;
+            end
+            if i > 1
+                if mod(j,nnodes) == 0
+                    i_cols_Ap = i_cols_Ap + ny;
+                end
+                i_cols_As = i_cols_As + ny;
             end
         end
-        err = max(abs(res(i_upd_r)));
-        if err < tolerance
-            stop = 1;
-            if verbose
-                fprintf('\n') ;
-                disp([' Total time of simulation        :' num2str(etime(clock,h1))]) ;
-                fprintf('\n') ;
-                disp([' Convergency obtained.']) ;
-                fprintf('\n') ;
-            end
-            flag = 0;% Convergency obtained.
-            endo_simul = reshape(Y(:,1),ny,periods+2);%Y(ny+(1:ny),1);
-                                                      %            figure;plot(Y(16:ny:(periods+2)*ny,:))
-                                                      %            pause
-            break
-        end
-        A2 = [nzA{:}]';
-        A = [A1; sparse(A2(:,1),A2(:,2),A2(:,3),ny*(periods-order-1)*world_nbr,dimension)];
-        dy = -A\res(i_upd_r);
-        Y(i_upd_y) =   Y(i_upd_y) + dy;
+        i_cols_p = i_cols_p + ny;
+        i_cols_s = i_cols_s + ny;
+        i_cols_f = i_cols_f + ny;
     end
-
-    if ~stop
+    nzA = cell(periods,world_nbr);
+    for j=1:world_nbr
+        i_rows_y = find(lead_lag_incidence')+(order+1)*ny;
+        offset_c = ny*(sum(nnodes.^(0:order-1),2)+j-1);
+        offset_r = (j-1)*ny;
+        for i=order+2:periods
+            [d1,jacobian] = dynamic_model(Y(i_rows_y,j), ...
+                                          exo_simul,params, ...
+                                          steady_state,i+1);
+            if i == periods
+                [ir,ic,v] = find(jacobian(:,i_cols_T));
+            else
+                [ir,ic,v] = find(jacobian(:,i_cols_j));
+            end
+            nzA{i,j} = [offset_r+ir,offset_c+icA(ic), v]';
+            res(:,i,j) = d1;
+            i_rows_y = i_rows_y + ny;
+            offset_c = offset_c + world_nbr*ny;
+            offset_r = offset_r + world_nbr*ny;
+        end
+    end
+    err = max(abs(res(i_upd_r)));
+    if err < tolerance
+        stop = 1;
         if verbose
             fprintf('\n') ;
-            disp(['     Total time of simulation        :' num2str(etime(clock,h1))]) ;
+            disp([' Total time of simulation        :' num2str(etime(clock,h1))]) ;
             fprintf('\n') ;
-            disp(['WARNING : maximum number of iterations is reached (modify options_.simul.maxit).']) ;
+            disp([' Convergency obtained.']) ;
             fprintf('\n') ;
         end
-        flag = 1;% more iterations are needed.
-        endo_simul = 1;
+        flag = 0;% Convergency obtained.
+        endo_simul = reshape(Y(:,1),ny,periods+2);%Y(ny+(1:ny),1);
+                                                  %            figure;plot(Y(16:ny:(periods+2)*ny,:))
+                                                  %            pause
+        break
     end
+    A2 = [nzA{:}]';
+    A = [A1; sparse(A2(:,1),A2(:,2),A2(:,3),ny*(periods-order-1)*world_nbr,dimension)];
+    dy = -A\res(i_upd_r);
+    Y(i_upd_y) =   Y(i_upd_y) + dy;
+end
+
+if ~stop
     if verbose
-        disp (['-----------------------------------------------------']) ;
+        fprintf('\n') ;
+        disp(['     Total time of simulation        :' num2str(etime(clock,h1))]) ;
+        fprintf('\n') ;
+        disp(['WARNING : maximum number of iterations is reached (modify options_.simul.maxit).']) ;
+        fprintf('\n') ;
     end
+    flag = 1;% more iterations are needed.
+    endo_simul = 1;
+end
+if verbose
+    disp (['-----------------------------------------------------']) ;
+end
diff --git a/matlab/ep/solve_stochastic_perfect_foresight_model_1.m b/matlab/ep/solve_stochastic_perfect_foresight_model_1.m
index 638a4fa4b..3e0ced538 100644
--- a/matlab/ep/solve_stochastic_perfect_foresight_model_1.m
+++ b/matlab/ep/solve_stochastic_perfect_foresight_model_1.m
@@ -1,6 +1,6 @@
 function [flag,endo_simul,err,y] = solve_stochastic_perfect_foresight_model_1(endo_simul,exo_simul,Options,pfm,order,varargin)
 
-% Copyright (C) 2012-2013 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -83,7 +83,7 @@ end
 % and so on until size ny x nnodes^order
 world_nbr = pfm.world_nbr;
 Y = endo_simul(:,2:end-1);
-Y = repmat(Y,1,world_nbr); 
+Y = repmat(Y,1,world_nbr);
 pfm.y0 = endo_simul(:,1);
 
 % The columns of A map the elements of Y such that
diff --git a/matlab/ep/stroud_judd_7.5.8.m b/matlab/ep/stroud_judd_7.5.8.m
deleted file mode 100644
index 40c9bc08d..000000000
--- a/matlab/ep/stroud_judd_7.5.8.m
+++ /dev/null
@@ -1,9 +0,0 @@
-function [X,w]=stroud_judd_7.5.8(d)
-    
-    E = eye(d);
-    X = cell(2*d,1);
-    m = 1;
-    for i=1:d
-        X{m} = E(:,i);
-        m = m+1;
-        X{m} = -E(:,i);
diff --git a/matlab/ep_residuals.m b/matlab/ep_residuals.m
index 56b554de8..6eea0ef4d 100644
--- a/matlab/ep_residuals.m
+++ b/matlab/ep_residuals.m
@@ -1,23 +1,23 @@
 function r = ep_residuals(x, y, ix, iy, steadystate, dr, maximum_lag, endo_nbr)
 % Inversion of the extended path simulation approach. This routine computes the innovations needed to
-% reproduce the time path of a subset of endogenous variables.    
-%    
+% reproduce the time path of a subset of endogenous variables.
+%
 % INPUTS
-%  o x    [double]   n*1 vector, time t innovations.    
+%  o x    [double]   n*1 vector, time t innovations.
 %  o y    [double]   n*1 vector, time t restricted endogenous variables.
 %  o ix   [integer]  index of control innovations in the full vector of innovations.
-%  o iy   [integer]  index of controlled variables in the full vector of endogenous variables.    
-%  o s    [double]   m*1 vector, endogenous variables at time t-1. 
-%    
-% 
+%  o iy   [integer]  index of controlled variables in the full vector of endogenous variables.
+%  o s    [double]   m*1 vector, endogenous variables at time t-1.
+%
+%
 % OUTPUTS
 %  o r    [double]  n*1 vector of residuals.
-%    
+%
 % ALGORITHM
-%  
+%
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2010 Dynare Team.
+% Copyright (C) 2010-2017 Dynare Team.
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/evaluate_likelihood.m b/matlab/evaluate_likelihood.m
index 39affdc5e..a76534adf 100644
--- a/matlab/evaluate_likelihood.m
+++ b/matlab/evaluate_likelihood.m
@@ -18,7 +18,7 @@ function [llik,parameters] = evaluate_likelihood(parameters)
 % [2] This function use persistent variables for the dataset and the description of the missing observations. Consequently, if this function
 %     is called more than once (by changing the value of parameters) the sample *must not* change.
 
-% Copyright (C) 2009-2012 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -69,6 +69,7 @@ end
 if isempty(dataset)
     [dataset, dataset_info] = makedataset(options_);
 end
+options_=select_qz_criterium_value(options_);
 
 llik = -dsge_likelihood(parameters,dataset,dataset_info,options_,M_,estim_params_,bayestopt_,prior_bounds(bayestopt_,options_.prior_trunc),oo_);
 ldens = evaluate_prior(parameters);
diff --git a/matlab/evaluate_max_dynamic_residual.m b/matlab/evaluate_max_dynamic_residual.m
index 41aa4ec24..9ea67a5fe 100644
--- a/matlab/evaluate_max_dynamic_residual.m
+++ b/matlab/evaluate_max_dynamic_residual.m
@@ -1,6 +1,6 @@
 function err = evaluate_max_dynamic_residual(model_dynamic, Y, exogenous_variables, params, steady_state, periods, ny, max_lag, lead_lag_incidence)
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -16,7 +16,7 @@ function err = evaluate_max_dynamic_residual(model_dynamic, Y, exogenous_variabl
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 i_rows = 1:ny;
 i_cols = find(lead_lag_incidence');
 
diff --git a/matlab/evaluate_planner_objective.m b/matlab/evaluate_planner_objective.m
index 40f186590..f8d03f978 100644
--- a/matlab/evaluate_planner_objective.m
+++ b/matlab/evaluate_planner_objective.m
@@ -1,17 +1,17 @@
 function planner_objective_value = evaluate_planner_objective(M,options,oo)
 
 %function oo1 = evaluate_planner_objective(dr,M,oo,options)
-%  computes value of planner objective function     
-% 
+%  computes value of planner objective function
+%
 % INPUTS
 %   M:        (structure) model description
 %   options:  (structure) options
 %   oo:       (structure) output results
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2007-2015 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,7 +40,7 @@ if nspred > 180
     return
 end
 beta = get_optimal_policy_discount_factor(M.params,M.param_names);
-    
+
 Gy = dr.ghx(nstatic+(1:nspred),:);
 Gu = dr.ghu(nstatic+(1:nspred),:);
 gy(dr.order_var,:) = dr.ghx;
@@ -113,7 +113,7 @@ if ~options.noprint
     disp('Approximated value of planner objective function')
     if options.ramsey_policy
         disp(['    - with initial Lagrange multipliers set to 0: ' ...
-          num2str(planner_objective_value(2)) ])
+              num2str(planner_objective_value(2)) ])
         disp(['    - with initial Lagrange multipliers set to steady state: ' ...
               num2str(planner_objective_value(1)) ])
     elseif options.discretionary_policy
diff --git a/matlab/evaluate_posterior_kernel.m b/matlab/evaluate_posterior_kernel.m
index 96ccac8d5..997962127 100644
--- a/matlab/evaluate_posterior_kernel.m
+++ b/matlab/evaluate_posterior_kernel.m
@@ -2,22 +2,22 @@ function lpkern = evaluate_posterior_kernel(parameters,llik)
 % Evaluate the prior density at parameters.
 %
 % INPUTS
-%    o parameters  a string ('posterior mode','posterior mean','posterior median','prior mode','prior mean') or a vector of values for 
+%    o parameters  a string ('posterior mode','posterior mean','posterior median','prior mode','prior mean') or a vector of values for
 %                  the (estimated) parameters of the model.
-%    
-%    
+%
+%
 % OUTPUTS
 %    o lpkern      [double]  value of the logged posterior kernel.
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 %
 % REMARKS
 % [1] This function cannot evaluate the prior density of a dsge-var model...
-% [2] This function use persistent variables for the dataset and the description of the missing observations. Consequently, if this function 
-%     is called more than once (by changing the value of parameters) the sample *must not* change.    
+% [2] This function use persistent variables for the dataset and the description of the missing observations. Consequently, if this function
+%     is called more than once (by changing the value of parameters) the sample *must not* change.
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/evaluate_prior.m b/matlab/evaluate_prior.m
index b8b2f7b0b..01cede921 100644
--- a/matlab/evaluate_prior.m
+++ b/matlab/evaluate_prior.m
@@ -2,21 +2,21 @@ function [ldens,parameters] = evaluate_prior(parameters)
 % Evaluate the prior density at parameters.
 %
 % INPUTS
-%    o parameters  a string ('posterior mode','posterior mean','posterior median','prior mode','prior mean') or a vector of values for 
+%    o parameters  a string ('posterior mode','posterior mean','posterior median','prior mode','prior mean') or a vector of values for
 %                  the (estimated) parameters of the model.
-%    
-%    
+%
+%
 % OUTPUTS
 %    o ldens       [double]  value of the logged prior density.
 %    o parameters  [double]  vector of values for the estimated parameters.
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 %
 % REMARKS
 % [1] This function cannot evaluate the prior density of a dsge-var model...
 
-% Copyright (C) 2009-2012 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/evaluate_smoother.m b/matlab/evaluate_smoother.m
index 109378662..9ab94654b 100644
--- a/matlab/evaluate_smoother.m
+++ b/matlab/evaluate_smoother.m
@@ -1,4 +1,4 @@
-function [oo_,options_,bayestopt_,Smoothed_variables_declaration_order_deviation_form]=evaluate_smoother(parameters,var_list,M_,oo_,options_,bayestopt_,estim_params_)
+function [oo_,M_,options_,bayestopt_,Smoothed_variables_declaration_order_deviation_form]=evaluate_smoother(parameters,var_list,M_,oo_,options_,bayestopt_,estim_params_)
 % Evaluate the smoother at parameters.
 %
 % INPUTS
@@ -21,13 +21,14 @@ function [oo_,options_,bayestopt_,Smoothed_variables_declaration_order_deviation
 %                              - SmoothedMeasurementErrors
 %                              - FilteredVariablesKStepAhead
 %                              - FilteredVariablesKStepAheadVariances
+%    o M_          [structure]  Definition of the model
+%    o options_    [structure]  Options; returns options_.first_obs
+%    o bayestopt_  [structure]  describing the priors; returns fields like bayestopt_.smoother_var_list from the smoother
 %    o Smoothed_variables_declaration_order_deviation_form
 %                           Smoothed variables from the Kalman smoother in
 %                           order of declaration of variables (M_.endo_names)
 %                           in deviations from their respective mean, i.e.
 %                           without trend and constant part (used for shock_decomposition)
-%    o options_    [structure]  Options; returns options_.first_obs
-%    o bayestopt_  [structure]  describing the priors; returns fields like bayestopt_.smoother_var_list from the smoother 
 %
 % SPECIAL REQUIREMENTS
 %    None
@@ -36,7 +37,7 @@ function [oo_,options_,bayestopt_,Smoothed_variables_declaration_order_deviation
 % [1] This function use persistent variables for the dataset and the description of the missing observations. Consequently, if this function
 %     is called more than once (by changing the value of parameters) the sample *must not* change.
 
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -53,18 +54,17 @@ function [oo_,options_,bayestopt_,Smoothed_variables_declaration_order_deviation
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-persistent dataset_ dataset_info
-
-%store qz_criterium
+% store qz_criterium
 qz_criterium_old=options_.qz_criterium;
 
 if ischar(parameters) && strcmp(parameters,'calibration')
     options_.smoother=1;
 end
 
-if isempty(dataset_) || isempty(bayestopt_)
-    [dataset_,dataset_info,xparam1, hh, M_, options_, oo_, estim_params_,bayestopt_] = dynare_estimation_init(var_list, M_.fname, [], M_, options_, oo_, estim_params_, bayestopt_);
-end
+[dataset_,dataset_info,xparam1, hh, M_, options_, oo_, estim_params_,bayestopt_] = dynare_estimation_init(var_list, M_.fname, [], M_, options_, oo_, estim_params_, bayestopt_);
+
+% set the qz_criterium
+options_=select_qz_criterium_value(options_);
 
 if nargin==0
     parameters = 'posterior_mode';
@@ -105,8 +105,8 @@ end
     DsgeSmoother(parameters,dataset_.nobs,transpose(dataset_.data),dataset_info.missing.aindex,dataset_info.missing.state,M_,oo_,options_,bayestopt_,estim_params_);
 [oo_]=store_smoother_results(M_,oo_,options_,bayestopt_,dataset_,dataset_info,atT,innov,measurement_error,updated_variables,ys,trend_coeff,aK,P,PK,decomp,Trend,state_uncertainty);
 
-if nargout==4
-   Smoothed_variables_declaration_order_deviation_form=atT(oo_.dr.inv_order_var(bayestopt_.smoother_var_list),:);
+if nargout>4
+    Smoothed_variables_declaration_order_deviation_form=atT(oo_.dr.inv_order_var(bayestopt_.smoother_var_list),:);
 end
 
 %reset qz_criterium
diff --git a/matlab/evaluate_static_model.m b/matlab/evaluate_static_model.m
index 922517964..ecf7ebb39 100644
--- a/matlab/evaluate_static_model.m
+++ b/matlab/evaluate_static_model.m
@@ -2,7 +2,7 @@ function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,opt
 
 % function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,options)
 % Evaluates the static model
-%  
+%
 % INPUTS
 %   ys                        vector           initial values used to compute the steady
 %                                                 state
@@ -10,7 +10,7 @@ function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,opt
 %   params                    vector           parameters
 %   M                         struct           model structure
 %   options                   struct           options
-%  
+%
 % OUTPUTS
 %   residuals                 vector           residuals when ys is not
 %                                              the steady state
@@ -20,7 +20,7 @@ function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,opt
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -37,29 +37,29 @@ function [residuals,check1,jacob] = evaluate_static_model(ys,exo_ss,params,M,opt
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    check1 = 0;
-    if options.bytecode
-        [check1, residuals] = bytecode('evaluate','static',ys,...
-                                       exo_ss, params, ys, 1);
-        mexErrCheck('bytecode', check1);
-    else
-        fh_static = str2func([M.fname '_static']);
-        if options.block
-            residuals = zeros(M.endo_nbr,1);
-            for b = 1:length(M.block_structure_stat.block)
-                mfsb = M.block_structure_stat.block(b).variable;
-                % blocks that can be directly evaluated (mfsb is empty)
-                % have zero residuals by construction
-                if M.block_structure_stat.block(b).Simulation_Type ~= 1 && ...
-                   M.block_structure_stat.block(b).Simulation_Type ~= 2
-                    residuals(mfsb) = feval(fh_static,b,ys,exo_ss,params);
-                else
-                    %need to evaluate the recursive blocks to compute the
-                    %temporary terms
-                    feval(fh_static,b,ys,exo_ss,params);
-                end
+check1 = 0;
+if options.bytecode
+    [check1, residuals] = bytecode('evaluate','static',ys,...
+                                   exo_ss, params, ys, 1);
+    mexErrCheck('bytecode', check1);
+else
+    fh_static = str2func([M.fname '_static']);
+    if options.block
+        residuals = zeros(M.endo_nbr,1);
+        for b = 1:length(M.block_structure_stat.block)
+            mfsb = M.block_structure_stat.block(b).variable;
+            % blocks that can be directly evaluated (mfsb is empty)
+            % have zero residuals by construction
+            if M.block_structure_stat.block(b).Simulation_Type ~= 1 && ...
+                    M.block_structure_stat.block(b).Simulation_Type ~= 2
+                residuals(mfsb) = feval(fh_static,b,ys,exo_ss,params);
+            else
+                %need to evaluate the recursive blocks to compute the
+                %temporary terms
+                feval(fh_static,b,ys,exo_ss,params);
             end
-        else
-            residuals = feval(fh_static,ys,exo_ss,params);
         end
+    else
+        residuals = feval(fh_static,ys,exo_ss,params);
     end
+end
diff --git a/matlab/evaluate_steady_state.m b/matlab/evaluate_steady_state.m
index 053d62255..d51c08bc8 100644
--- a/matlab/evaluate_steady_state.m
+++ b/matlab/evaluate_steady_state.m
@@ -22,7 +22,7 @@ function [ys,params,info] = evaluate_steady_state(ys_init,M,options,oo,steadysta
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,309 +39,305 @@ function [ys,params,info] = evaluate_steady_state(ys_init,M,options,oo,steadysta
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    info = 0;
-    check = 0;
+info = 0;
+check = 0;
 
-    steadystate_flag = options.steadystate_flag;
-    params = M.params;
-    exo_ss = [oo.exo_steady_state; oo.exo_det_steady_state];
+steadystate_flag = options.steadystate_flag;
+params = M.params;
+exo_ss = [oo.exo_steady_state; oo.exo_det_steady_state];
 
-    if length(M.aux_vars) > 0
-        h_set_auxiliary_variables = str2func([M.fname '_set_auxiliary_variables']);
-        if ~steadystate_flag
-            ys_init = h_set_auxiliary_variables(ys_init,exo_ss,M.params);
-        end
+if length(M.aux_vars) > 0
+    h_set_auxiliary_variables = str2func([M.fname '_set_auxiliary_variables']);
+    if ~steadystate_flag
+        ys_init = h_set_auxiliary_variables(ys_init,exo_ss,M.params);
     end
+end
 
-    if options.ramsey_policy
-        if steadystate_flag
-            % explicit steady state file
-            [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M, ...
-                                                           options,steadystate_check_flag);
-            %test whether it solves model conditional on the instruments
-            resids = evaluate_static_model(ys,exo_ss,params,M,options);
-            n_multipliers=M.ramsey_eq_nbr;
-            nan_indices=find(isnan(resids(n_multipliers+1:end)));
-
-            if ~isempty(nan_indices)
-                if options.debug
-                    fprintf('\nevaluate_steady_state: The steady state file computation for the Ramsey problem resulted in NaNs.\n')
-                    fprintf('evaluate_steady_state: The steady state was computed conditional on the following initial instrument values: \n')
-                    for ii = 1:size(options.instruments,1);
-                        fprintf('\t %s \t %f \n',options.instruments(ii,:),ys_init(strmatch(options.instruments(ii,:),M.endo_names,'exact')))
-                    end
-                    fprintf('evaluate_steady_state: The problem occured in the following equations: \n')
-                    fprintf('\t Equation(s): ')
-                    for ii=1:length(nan_indices)
-                        fprintf('%d, ',nan_indices(ii));
-                    end
-                    skipline();
-                    fprintf('evaluate_steady_state: If those initial values are not admissable, change them using an initval-block.\n')
-                    skipline(2);
-                end
-                info(1) = 84;
-                info(2) = resids'*resids;
-                return;
-            end
-            
-            if any(imag(ys(n_multipliers+1:end)))
-                if options.debug
-                    fprintf('\nevaluate_steady_state: The steady state file computation for the Ramsey problem resulted in complex numbers.\n')
-                    fprintf('evaluate_steady_state: The steady state was computed conditional on the following initial instrument values: \n')
-                    for ii = 1:size(options.instruments,1);
-                        fprintf('\t %s \t %f \n',options.instruments(ii,:),ys_init(strmatch(options.instruments(ii,:),M.endo_names,'exact')))
-                    end
-                    fprintf('evaluate_steady_state: If those initial values are not admissable, change them using an initval-block.\n')
-                    skipline(2);
-                end
-                info(1) = 86;
-                info(2) = resids'*resids;
-                return;
-            end
-
-            if max(abs(resids(n_multipliers+1:end))) > options.solve_tolf %does it solve for all variables except for the Lagrange multipliers
-                if options.debug
-                    fprintf('\nevaluate_steady_state: The steady state file does not solve the steady state for the Ramsey problem.\n')
-                    fprintf('evaluate_steady_state: Conditional on the following instrument values: \n')
-                    for ii = 1:size(options.instruments,1);
-                        fprintf('\t %s \t %f \n',options.instruments(ii,:),ys_init(strmatch(options.instruments(ii,:),M.endo_names,'exact')))
-                    end
-                    fprintf('evaluate_steady_state: the following equations have non-zero residuals: \n')
-                    for ii=n_multipliers+1:M.endo_nbr
-                        if abs(resids(ii)) > options.solve_tolf
-                            fprintf('\t Equation number %d: %f\n',ii-n_multipliers, resids(ii))
-                        end
-                    end
-                    skipline(2);
-                end
-                info(1) = 85;
-                info(2) = resids'*resids;
-                return;
-            end
-        end
-        if options.debug
-            infrow=find(isinf(ys_init));
-            if ~isempty(infrow)
-                fprintf('\nevaluate_steady_state: The initial values for the steady state of the following variables are Inf:\n');
-                for iter=1:length(infrow)
-                    fprintf('%s\n',M.endo_names(infrow(iter),:));
-                end
-            end
-            nanrow=find(isnan(ys_init));
-            if ~isempty(nanrow)
-                fprintf('\nevaluate_steady_state: The initial values for the steady state of the following variables are NaN:\n');
-                for iter=1:length(nanrow)
-                    fprintf('%s\n',M.endo_names(nanrow(iter),:));
-                end
-            end
-        end
-        %either if no steady state file or steady state file without problems
-        [ys,params,info] = dyn_ramsey_static(ys_init,M,options,oo);
-        if info
-           return;
-        end
-        %check whether steady state really solves the model
+if options.ramsey_policy
+    if steadystate_flag
+        % explicit steady state file
+        [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M, ...
+                                                      options,steadystate_check_flag);
+        %test whether it solves model conditional on the instruments
         resids = evaluate_static_model(ys,exo_ss,params,M,options);
-
         n_multipliers=M.ramsey_eq_nbr;
-        nan_indices_multiplier=find(isnan(resids(1:n_multipliers)));
         nan_indices=find(isnan(resids(n_multipliers+1:end)));
 
         if ~isempty(nan_indices)
             if options.debug
-                fprintf('\nevaluate_steady_state: The steady state computation for the Ramsey problem resulted in NaNs.\n')
-                fprintf('evaluate_steady_state: The steady state computation resulted in the following instrument values: \n')
-                for i = 1:size(options.instruments,1);
-                    fprintf('\t %s \t %f \n',options.instruments(i,:),ys(strmatch(options.instruments(i,:),M.endo_names,'exact')))
+                fprintf('\nevaluate_steady_state: The steady state file computation for the Ramsey problem resulted in NaNs.\n')
+                fprintf('evaluate_steady_state: The steady state was computed conditional on the following initial instrument values: \n')
+                for ii = 1:size(options.instruments,1)
+                    fprintf('\t %s \t %f \n',options.instruments(ii,:),ys_init(strmatch(options.instruments(ii,:),M.endo_names,'exact')))
                 end
                 fprintf('evaluate_steady_state: The problem occured in the following equations: \n')
                 fprintf('\t Equation(s): ')
                 for ii=1:length(nan_indices)
                     fprintf('%d, ',nan_indices(ii));
                 end
-                skipline();
+                skipline()
+                fprintf('evaluate_steady_state: If those initial values are not admissable, change them using an initval-block.\n')
+                skipline(2)
             end
-            info(1) = 82;
-            return;
+            info(1) = 84;
+            info(2) = resids'*resids;
+            return
         end
 
-        if ~isempty(nan_indices_multiplier)
+        if any(imag(ys(n_multipliers+1:end)))
             if options.debug
-                fprintf('\nevaluate_steady_state: The steady state computation for the Ramsey problem resulted in NaNs in the auxiliary equations.\n')
-                fprintf('evaluate_steady_state: The steady state computation resulted in the following instrument values: \n')
-                for i = 1:size(options.instruments,1);
-                    fprintf('\t %s \t %f \n',options.instruments(i,:),ys(strmatch(options.instruments(i,:),M.endo_names,'exact')))
+                fprintf('\nevaluate_steady_state: The steady state file computation for the Ramsey problem resulted in complex numbers.\n')
+                fprintf('evaluate_steady_state: The steady state was computed conditional on the following initial instrument values: \n')
+                for ii = 1:size(options.instruments,1)
+                    fprintf('\t %s \t %f \n',options.instruments(ii,:),ys_init(strmatch(options.instruments(ii,:),M.endo_names,'exact')))
                 end
-                fprintf('evaluate_steady_state: The problem occured in the following equations: \n')
-                fprintf('\t Auxiliary equation(s): ')
-                for ii=1:length(nan_indices_multiplier)
-                    fprintf('%d, ',nan_indices_multiplier(ii));
-                end
-                skipline();
+                fprintf('evaluate_steady_state: If those initial values are not admissable, change them using an initval-block.\n')
+                skipline(2)
             end
-            info(1) = 83;
-            return;
+            info(1) = 86;
+            info(2) = resids'*resids;
+            return
         end
 
-        if max(abs(resids)) > options.solve_tolf %does it solve for all variables including the auxiliary ones
+        if max(abs(resids(n_multipliers+1:end))) > options.solve_tolf %does it solve for all variables except for the Lagrange multipliers
             if options.debug
-                fprintf('\nevaluate_steady_state: The steady state for the Ramsey problem could not be computed.\n')
-                fprintf('evaluate_steady_state: The steady state computation stopped with the following instrument values:: \n')
-                for i = 1:size(options.instruments,1);
-                    fprintf('\t %s \t %f \n',options.instruments(i,:),ys(strmatch(options.instruments(i,:),M.endo_names,'exact')))
-                end
-                fprintf('evaluate_steady_state: The following equations have non-zero residuals: \n')
-                for ii=1:n_multipliers
-                    if abs(resids(ii)) > options.solve_tolf/100
-                        fprintf('\t Auxiliary Ramsey equation number %d: %f\n',ii, resids(ii))
-                    end
+                fprintf('\nevaluate_steady_state: The steady state file does not solve the steady state for the Ramsey problem.\n')
+                fprintf('evaluate_steady_state: Conditional on the following instrument values: \n')
+                for ii = 1:size(options.instruments,1)
+                    fprintf('\t %s \t %f \n',options.instruments(ii,:),ys_init(strmatch(options.instruments(ii,:),M.endo_names,'exact')))
                 end
+                fprintf('evaluate_steady_state: the following equations have non-zero residuals: \n')
                 for ii=n_multipliers+1:M.endo_nbr
-                    if abs(resids(ii)) > options.solve_tolf/100
+                    if abs(resids(ii)) > options.solve_tolf
                         fprintf('\t Equation number %d: %f\n',ii-n_multipliers, resids(ii))
                     end
                 end
-                skipline(2);
+                skipline(2)
             end
-            info(1) = 81;
+            info(1) = 85;
             info(2) = resids'*resids;
-            return;
-        end
-    elseif steadystate_flag
-        % explicit steady state file
-        [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M, ...
-                                                       options,steadystate_check_flag);
-        if size(ys,2)>size(ys,1)
-            error('STEADY: steady_state-file must return a column vector, not a row vector.')
-        end
-        if info(1)
-            return;
-        end
-    elseif (options.bytecode == 0 && options.block == 0)
-        if options.linear == 0
-            % non linear model
-            static_model = str2func([M.fname '_static']);
-            [ys,check] = dynare_solve(@static_problem,...
-                                      ys_init,...
-                                      options, exo_ss, params,...
-                                      M.endo_nbr,...
-                                      static_model);
-            if check && options.debug
-                [ys,check,fvec,fjac] = dynare_solve(@static_problem,...
-                          ys_init,...
-                          options, exo_ss, params,...
-                          M.endo_nbr,...
-                          static_model);
-                [infrow,infcol]=find(isinf(fjac) | isnan(fjac));
-                if ~isempty(infrow)
-                    fprintf('\nSTEADY:  The Jacobian at the initial values contains Inf or NaN. The problem arises from: \n')
-                    display_problematic_vars_Jacobian(infrow,infcol,M,ys_init,'static','STEADY: ')
-                end
-                problematic_equation = find(~isfinite(fvec));                
-                if ~isempty(problematic_equation)
-                    fprintf('\nSTEADY:  numerical initial values or parameters incompatible with the following equations\n')
-                    disp(problematic_equation')
-                    fprintf('Please check for example\n')
-                    fprintf('   i) if all parameters occurring in these equations are defined\n')
-                    fprintf('  ii) that no division by an endogenous variable initialized to 0 occurs\n')
-                end
-            end
-        else
-            % linear model
-            fh_static = str2func([M.fname '_static']);
-            [fvec,jacob] = fh_static(ys_init,exo_ss, ...
-                                     params);
-
-            ii = find(~isfinite(fvec));
-            if ~isempty(ii)
-                ys=fvec;
-                check=1;
-                disp(['STEADY:  numerical initial values or parameters incompatible with the following' ...
-                      ' equations'])
-                disp(ii')
-                disp('Check whether your model is truly linear. Put "resid(1);" before "steady;" to see the problematic equations.\n')
-            elseif isempty(ii) && max(abs(fvec)) > 1e-12
-                ys = ys_init-jacob\fvec;
-                resid = evaluate_static_model(ys,exo_ss,params,M,options);
-                if max(abs(resid)) > 1e-6
-                    check=1;
-                    fprintf('STEADY: No steady state for your model could be found\n')
-                    fprintf('STEADY: Check whether your model is truly linear. Put "resid(1);" before "steady;" to see the problematic equations.\n')
-                end
-
-            else
-                ys = ys_init;
-            end
-            if options.debug
-                if any(any(isinf(jacob) | isnan(jacob)))
-                    [infrow,infcol]=find(isinf(jacob) | isnan(jacob));
-                    fprintf('\nSTEADY:  The Jacobian contains Inf or NaN. The problem arises from: \n\n')
-                    for ii=1:length(infrow)
-                        fprintf('STEADY:  Derivative of Equation %d with respect to Variable %s  (initial value of %s: %g) \n',infrow(ii),deblank(M.endo_names(infcol(ii),:)),deblank(M.endo_names(infcol(ii),:)),ys_init(infcol(ii)))
-                    end
-                    fprintf('Check whether your model is truly linear. Put "resid(1);" before "steady;" to see the problematic equations.\n')
-                end
-            end
-        end
-    else
-        % block or bytecode
-        [ys,check] = dynare_solve_block_or_bytecode(ys_init,exo_ss, params, ...
-                                                    options, M);
-    end
-
-    if check
-        info(1)= 20;
-        %make sure ys contains auxiliary variables in case of problem with dynare_solve
-        if length(M.aux_vars) > 0 && ~steadystate_flag
-            ys = h_set_auxiliary_variables(ys,exo_ss,M.params);
-        end
-        resid = evaluate_static_model(ys,exo_ss,params,M,options);
-        info(2) = resid'*resid ;
-        if isnan(info(2))
-            info(1)=22;
-        end
-        return
-    end
-
-    % If some equations are tagged [static] or [dynamic], verify consistency
-    if M.static_and_dynamic_models_differ
-        % Evaluate residual of *dynamic* model using the steady state
-        % computed on the *static* one
-        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, junk]= bytecode('dynamic','evaluate', z, zx, M.params, ys, 1);
-            mexErrCheck('bytecode', chck);
-        elseif options.block
-            [r, oo.dr] = feval([M.fname '_dynamic'], z', zx, M.params, ys, M.maximum_lag+1, oo.dr);
-        else
-            iyv = M.lead_lag_incidence';
-            iyr0 = find(iyv(:));
-            xys = z(iyr0);
-            r = feval([M.fname '_dynamic'], z(iyr0), zx, M.params, ys, M.maximum_lag + 1);
-        end
-
-        % Fail if residual greater than tolerance
-        if max(abs(r)) > options.solve_tolf
-            info(1) = 25;
             return
         end
     end
+    if options.debug
+        infrow=find(isinf(ys_init));
+        if ~isempty(infrow)
+            fprintf('\nevaluate_steady_state: The initial values for the steady state of the following variables are Inf:\n');
+            for iter=1:length(infrow)
+                fprintf('%s\n',M.endo_names(infrow(iter),:));
+            end
+        end
+        nanrow=find(isnan(ys_init));
+        if ~isempty(nanrow)
+            fprintf('\nevaluate_steady_state: The initial values for the steady state of the following variables are NaN:\n');
+            for iter=1:length(nanrow)
+                fprintf('%s\n',M.endo_names(nanrow(iter),:));
+            end
+        end
+    end
+    %either if no steady state file or steady state file without problems
+    [ys,params,info] = dyn_ramsey_static(ys_init,M,options,oo);
+    if info
+        return
+    end
+    %check whether steady state really solves the model
+    resids = evaluate_static_model(ys,exo_ss,params,M,options);
 
-    if ~isreal(ys)
-        info(1) = 21;
-        info(2) = sum(imag(ys).^2);
-        ys = real(ys);
+    n_multipliers=M.ramsey_eq_nbr;
+    nan_indices_multiplier=find(isnan(resids(1:n_multipliers)));
+    nan_indices=find(isnan(resids(n_multipliers+1:end)));
+
+    if ~isempty(nan_indices)
+        if options.debug
+            fprintf('\nevaluate_steady_state: The steady state computation for the Ramsey problem resulted in NaNs.\n')
+            fprintf('evaluate_steady_state: The steady state computation resulted in the following instrument values: \n')
+            for i = 1:size(options.instruments,1)
+                fprintf('\t %s \t %f \n',options.instruments(i,:),ys(strmatch(options.instruments(i,:),M.endo_names,'exact')))
+            end
+            fprintf('evaluate_steady_state: The problem occured in the following equations: \n')
+            fprintf('\t Equation(s): ')
+            for ii=1:length(nan_indices)
+                fprintf('%d, ',nan_indices(ii));
+            end
+            skipline()
+        end
+        info(1) = 82;
         return
     end
 
-    if ~isempty(find(isnan(ys)))
-        info(1) = 22;
-        info(2) = NaN;
+    if ~isempty(nan_indices_multiplier)
+        if options.debug
+            fprintf('\nevaluate_steady_state: The steady state computation for the Ramsey problem resulted in NaNs in the auxiliary equations.\n')
+            fprintf('evaluate_steady_state: The steady state computation resulted in the following instrument values: \n')
+            for i = 1:size(options.instruments,1)
+                fprintf('\t %s \t %f \n',options.instruments(i,:),ys(strmatch(options.instruments(i,:),M.endo_names,'exact')))
+            end
+            fprintf('evaluate_steady_state: The problem occured in the following equations: \n')
+            fprintf('\t Auxiliary equation(s): ')
+            for ii=1:length(nan_indices_multiplier)
+                fprintf('%d, ',nan_indices_multiplier(ii));
+            end
+            skipline()
+        end
+        info(1) = 83;
         return
     end
 
+    if max(abs(resids)) > options.solve_tolf %does it solve for all variables including the auxiliary ones
+        if options.debug
+            fprintf('\nevaluate_steady_state: The steady state for the Ramsey problem could not be computed.\n')
+            fprintf('evaluate_steady_state: The steady state computation stopped with the following instrument values:: \n')
+            for i = 1:size(options.instruments,1)
+                fprintf('\t %s \t %f \n',options.instruments(i,:),ys(strmatch(options.instruments(i,:),M.endo_names,'exact')))
+            end
+            fprintf('evaluate_steady_state: The following equations have non-zero residuals: \n')
+            for ii=1:n_multipliers
+                if abs(resids(ii)) > options.solve_tolf/100
+                    fprintf('\t Auxiliary Ramsey equation number %d: %f\n',ii, resids(ii))
+                end
+            end
+            for ii=n_multipliers+1:M.endo_nbr
+                if abs(resids(ii)) > options.solve_tolf/100
+                    fprintf('\t Equation number %d: %f\n',ii-n_multipliers, resids(ii))
+                end
+            end
+            skipline(2)
+        end
+        info(1) = 81;
+        info(2) = resids'*resids;
+        return
+    end
+elseif steadystate_flag
+    % explicit steady state file
+    [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M, options,steadystate_check_flag);
+    if size(ys,2)>size(ys,1)
+        error('STEADY: steady_state-file must return a column vector, not a row vector.')
+    end
+    if info(1)
+        return
+    end
+elseif (options.bytecode == 0 && options.block == 0)
+    if options.linear == 0
+        % non linear model
+        static_model = str2func([M.fname '_static']);
+        [ys,check] = dynare_solve(@static_problem,...
+                                  ys_init,...
+                                  options, exo_ss, params,...
+                                  M.endo_nbr,...
+                                  static_model);
+        if check && options.debug
+            [ys,check,fvec,fjac] = dynare_solve(@static_problem,...
+                                                ys_init,...
+                                                options, exo_ss, params,...
+                                                M.endo_nbr,...
+                                                static_model);
+            [infrow,infcol]=find(isinf(fjac) | isnan(fjac));
+            if ~isempty(infrow)
+                fprintf('\nSTEADY:  The Jacobian at the initial values contains Inf or NaN. The problem arises from: \n')
+                display_problematic_vars_Jacobian(infrow,infcol,M,ys_init,'static','STEADY: ')
+            end
+            problematic_equation = find(~isfinite(fvec));
+            if ~isempty(problematic_equation)
+                fprintf('\nSTEADY:  numerical initial values or parameters incompatible with the following equations\n')
+                disp(problematic_equation')
+                fprintf('Please check for example\n')
+                fprintf('   i) if all parameters occurring in these equations are defined\n')
+                fprintf('  ii) that no division by an endogenous variable initialized to 0 occurs\n')
+            end
+        end
+    else
+        % linear model
+        fh_static = str2func([M.fname '_static']);
+        [fvec,jacob] = fh_static(ys_init,exo_ss, ...
+                                 params);
+
+        ii = find(~isfinite(fvec));
+        if ~isempty(ii)
+            ys=fvec;
+            check=1;
+            disp(['STEADY:  numerical initial values or parameters incompatible with the following' ...
+                  ' equations'])
+            disp(ii')
+            disp('Check whether your model is truly linear. Put "resid(1);" before "steady;" to see the problematic equations.')
+        elseif isempty(ii) && max(abs(fvec)) > 1e-12
+            ys = ys_init-jacob\fvec;
+            resid = evaluate_static_model(ys,exo_ss,params,M,options);
+            if max(abs(resid)) > 1e-6
+                check=1;
+                fprintf('STEADY: No steady state for your model could be found\n')
+                fprintf('STEADY: Check whether your model is truly linear. Put "resid(1);" before "steady;" to see the problematic equations.\n')
+            end
+        else
+            ys = ys_init;
+        end
+        if options.debug
+            if any(any(isinf(jacob) | isnan(jacob)))
+                [infrow,infcol]=find(isinf(jacob) | isnan(jacob));
+                fprintf('\nSTEADY:  The Jacobian contains Inf or NaN. The problem arises from: \n\n')
+                for ii=1:length(infrow)
+                    fprintf('STEADY:  Derivative of Equation %d with respect to Variable %s  (initial value of %s: %g) \n',infrow(ii),deblank(M.endo_names(infcol(ii),:)),deblank(M.endo_names(infcol(ii),:)),ys_init(infcol(ii)))
+                end
+                fprintf('Check whether your model is truly linear. Put "resid(1);" before "steady;" to see the problematic equations.\n')
+            end
+        end
+    end
+else
+    % block or bytecode
+    [ys,check] = dynare_solve_block_or_bytecode(ys_init,exo_ss, params, options, M);
+end
+
+if check
+    info(1)= 20;
+    %make sure ys contains auxiliary variables in case of problem with dynare_solve
+    if length(M.aux_vars) > 0 && ~steadystate_flag
+        ys = h_set_auxiliary_variables(ys,exo_ss,M.params);
+    end
+    resid = evaluate_static_model(ys,exo_ss,params,M,options);
+    info(2) = resid'*resid ;
+    if isnan(info(2))
+        info(1)=22;
+    end
+    return
+end
+
+% If some equations are tagged [static] or [dynamic], verify consistency
+if M.static_and_dynamic_models_differ
+    % Evaluate residual of *dynamic* model using the steady state
+    % computed on the *static* one
+    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, junk]= bytecode('dynamic','evaluate', z, zx, M.params, ys, 1);
+        mexErrCheck('bytecode', chck);
+    elseif options.block
+        [r, oo.dr] = feval([M.fname '_dynamic'], z', zx, M.params, ys, M.maximum_lag+1, oo.dr);
+    else
+        iyv = M.lead_lag_incidence';
+        iyr0 = find(iyv(:));
+        xys = z(iyr0);
+        r = feval([M.fname '_dynamic'], z(iyr0), zx, M.params, ys, M.maximum_lag + 1);
+    end
+    % Fail if residual greater than tolerance
+    if max(abs(r)) > options.solve_tolf
+        info(1) = 25;
+        return
+    end
+end
+
+if ~isreal(ys)
+    info(1) = 21;
+    info(2) = sum(imag(ys).^2);
+    ys = real(ys);
+    return
+end
+
+if ~isempty(find(isnan(ys)))
+    info(1) = 22;
+    info(2) = NaN;
+    return
+end
+
 function [resids,jac] = static_problem(y,x,params,nvar,fh_static_model)
-    [r,j] = fh_static_model(y,x,params);
-    resids = r(1:nvar);
-    jac = j(1:nvar,1:nvar);
+[r,j] = fh_static_model(y,x,params);
+resids = r(1:nvar);
+jac = j(1:nvar,1:nvar);
diff --git a/matlab/evaluate_steady_state_file.m b/matlab/evaluate_steady_state_file.m
index 8f67a5b87..67a3b0c4d 100644
--- a/matlab/evaluate_steady_state_file.m
+++ b/matlab/evaluate_steady_state_file.m
@@ -1,14 +1,14 @@
 function [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M,options,steady_state_checkflag)
 % function [ys,params1,info] = evaluate_steady_state_file(ys_init,exo_ss,M,options,steady_state_checkflag)
-% Evaluates steady state files 
-%  
+% Evaluates steady state files
+%
 % INPUTS
 %   ys_init                   vector           initial values used to compute the steady
 %                                                 state
 %   exo_ss                    vector           exogenous steady state
 %   M                         struct           model parameters
 %   options                   struct           options
-%   steady_state_checkflag    boolean          indicator whether to check steady state returned  
+%   steady_state_checkflag    boolean          indicator whether to check steady state returned
 % OUTPUTS
 %   ys                        vector           steady state
 %   params1                   vector           model parameters possibly
@@ -19,7 +19,7 @@ function [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M,options,
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,125 +36,123 @@ function [ys,params,info] = evaluate_steady_state_file(ys_init,exo_ss,M,options,
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    debug = false;
+debug = false;
 
-    ys = [];
-    params = M.params;
-    info = 0;
+ys = [];
+params = M.params;
+info = 0;
 
-    fname = M.fname;
+fname = M.fname;
 
-    if options.steadystate_flag == 1
-        % old format
-        assignin('base','tmp_00_',params);
-        evalin('base','M_.params=tmp_00_; clear(''tmp_00_'')');
-        h_steadystate = str2func([fname '_steadystate']);                       
-        [ys,check] = h_steadystate(ys_init, exo_ss);
-        params1 = evalin('base','M_.params');
-    else % steadystate_flag == 2
-         % new format
-        h_steadystate = str2func([fname '_steadystate2']);                       
-        [ys,params1,check] = h_steadystate(ys_init, exo_ss, params);
-    end            
-    
+if options.steadystate_flag == 1
+    % old format
+    assignin('base','tmp_00_',params);
+    evalin('base','M_.params=tmp_00_; clear(''tmp_00_'')');
+    h_steadystate = str2func([fname '_steadystate']);
+    [ys,check] = h_steadystate(ys_init, exo_ss);
+    params1 = evalin('base','M_.params');
+else % steadystate_flag == 2
+     % new format
+    h_steadystate = str2func([fname '_steadystate2']);
+    [ys,params1,check] = h_steadystate(ys_init, exo_ss, params);
+end
+
+if check
+    info(1) = 19;
+    info(2) = NaN;
+    return
+end
+
+if M.param_nbr > 0
+    updated_params_flag = max(abs(params1-params)) > 1e-12 ...
+        || ~isequal(isnan(params1),isnan(params)); %checks whether numbers or NaN changed
+else
+    updated_params_flag = 0;
+end
+
+h_set_auxiliary_variables = str2func([M.fname '_set_auxiliary_variables']);
+if  isnan(updated_params_flag) || (updated_params_flag  && any(isnan(params(~isnan(params))-params1(~isnan(params))))) %checks if new NaNs were added
+    info(1) = 24;
+    info(2) = NaN;
+    ys = h_set_auxiliary_variables(ys,exo_ss,params);
+    return
+end
+
+if updated_params_flag && ~isreal(params1)
+    info(1) = 23;
+    info(2) = sum(imag(params).^2);
+    ys = h_set_auxiliary_variables(ys,exo_ss,params);
+    return
+end
+
+if updated_params_flag
+    params = params1;
+end
+
+% adding values for auxiliary variables
+if length(M.aux_vars) > 0 && ~options.ramsey_policy
+    if debug
+        ys0 = ys;
+    end
+    ys = h_set_auxiliary_variables(ys,exo_ss,params);
+    if debug
+        ys1 = ys;
+    end
+    ys = h_set_auxiliary_variables(ys,exo_ss,params);
+    if debug
+        ys2 = ys;
+    end
+    if debug
+        ys = h_set_auxiliary_variables(ys,exo_ss,params);
+        ys3 = ys;
+        idx = find(abs(ys0-ys1)>0);
+        if ~isempty(idx)
+            M.endo_names(idx,:)
+        else
+            disp('1-invariant')
+        end
+        idx = find(abs(ys2-ys1)>0);
+        if ~isempty(idx)
+            M.endo_names(idx,:)
+        else
+            disp('2-invariant')
+        end
+        idx = find(abs(ys3-ys3)>0);
+        if ~isempty(idx)
+            M.endo_names(idx,:)
+        else
+            disp('3-invariant')
+        end
+        pause
+    end
+end
+
+check1 = 0;
+if steady_state_checkflag
+    % Check whether the steady state obtained from the _steadystate file is a steady state.
+    [residuals, check] = evaluate_static_model(ys, exo_ss, params, M, options);
     if check
         info(1) = 19;
-        info(2) = NaN;
+        info(2) = check; % to be improved
         return
     end
-    
-    if M.param_nbr > 0
-        updated_params_flag = max(abs(params1-params)) > 1e-12 ...
-            || ~isequal(isnan(params1),isnan(params)); %checks whether numbers or NaN changed
-    else
-        updated_params_flag = 0;
-    end
-
-    h_set_auxiliary_variables = str2func([M.fname '_set_auxiliary_variables']);
-    if  isnan(updated_params_flag) || (updated_params_flag  && any(isnan(params(~isnan(params))-params1(~isnan(params))))) %checks if new NaNs were added
-        info(1) = 24;
-        info(2) = NaN;
-        ys = h_set_auxiliary_variables(ys,exo_ss,params);
+    if max(abs(residuals)) > options.dynatol.f
+        info(1) = 19;
+        info(2) = residuals'*residuals;
         return
     end
-
-    if updated_params_flag && ~isreal(params1)
-        info(1) = 23;
-        info(2) = sum(imag(params).^2);
-        ys = h_set_auxiliary_variables(ys,exo_ss,params);
+    if any(isnan(residuals))
+        info(1) = 22;
         return
     end
-    
-    if updated_params_flag
-        params = params1;
+elseif ~isempty(options.steadystate_partial)
+    ssvar = options.steadystate_partial.ssvar;
+    nov   = length(ssvar);
+    indv  = zeros(nov,1);
+    for i = 1:nov
+        indv(i) = strmatch(ssvar(i),M.endo_names,'exact');
     end
-
-    % adding values for auxiliary variables
-    if length(M.aux_vars) > 0 && ~options.ramsey_policy
-        if debug
-            ys0 = ys;
-        end
-        ys = h_set_auxiliary_variables(ys,exo_ss,params);
-        if debug
-            ys1 = ys;
-        end
-        ys = h_set_auxiliary_variables(ys,exo_ss,params);
-        if debug
-            ys2 = ys;
-        end
-        if debug
-            ys = h_set_auxiliary_variables(ys,exo_ss,params);
-            ys3 = ys;
-            idx = find(abs(ys0-ys1)>0);
-            if ~isempty(idx)
-                M.endo_names(idx,:)
-            else
-                disp('1-invariant')
-            end
-            idx = find(abs(ys2-ys1)>0);
-            if ~isempty(idx)
-                M.endo_names(idx,:)
-            else
-                disp('2-invariant')
-            end
-            idx = find(abs(ys3-ys3)>0);
-            if ~isempty(idx)
-                M.endo_names(idx,:)
-            else
-                disp('3-invariant')
-            end
-            pause
-        end
-    end
-
-    check1 = 0;
-    if steady_state_checkflag
-        % Check whether the steady state obtained from the _steadystate file is a steady state.
-        [residuals, check] = evaluate_static_model(ys, exo_ss, params, M, options);
-        if check
-            info(1) = 19;
-            info(2) = check; % to be improved
-            return;
-        end
-        if max(abs(residuals)) > options.dynatol.f
-            info(1) = 19;
-            info(2) = residuals'*residuals;
-            return
-        end
-        if any(isnan(residuals))
-            info(1) = 22;
-            return
-        end
-    elseif ~isempty(options.steadystate_partial)
-        ssvar = options.steadystate_partial.ssvar;
-        nov   = length(ssvar);
-        indv  = zeros(nov,1);
-        for i = 1:nov
-            indv(i) = strmatch(ssvar(i),M.endo_names,'exact');
-        end
-        [ys,check] = dynare_solve('restricted_steadystate',...
-                                  ys(indv),...
-                                  options, exo_ss,indv);
-    end
-
-    
+    [ys,check] = dynare_solve('restricted_steadystate',...
+                              ys(indv),...
+                              options, exo_ss,indv);
+end
diff --git a/matlab/expand_group.m b/matlab/expand_group.m
new file mode 100644
index 000000000..c20d38c37
--- /dev/null
+++ b/matlab/expand_group.m
@@ -0,0 +1,49 @@
+function expand_group(use_shock_groups,var_list_, ic)
+% function expand_group(use_shock_groups,var_list_, ic)
+% Expands shocks contributions out of a group of shocks
+%
+% INPUTS
+%    use_shock_groups: [char]  name of the group
+%    var_list_:        [char]  list of variables
+%    ic:               [int]   group # to expand
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2016-2017 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/>.
+
+M = evalin('base','M_');
+oo = evalin('base','oo_');
+options = evalin('base','options_');
+mydata=get(findobj(gcf,'tag',['group' int2str(ic)]),'userdata');
+if isfield(mydata,'shock_decomp')
+    options.shock_decomp=mydata.shock_decomp;
+end
+% define expanded group
+label = mydata.shock_group.label;
+shocks = mydata.shock_group.shocks;
+options.shock_decomp.fig_name = [mydata.fig_name '. Expand'];
+options.use_shock_groups = strrep(label,' ','_'); %[use_shock_groups_old int2str(ic)];
+for j=1:length(shocks)
+    M.shock_groups.(options.use_shock_groups).(['group' int2str(j)]).label=shocks{j};
+    M.shock_groups.(options.use_shock_groups).(['group' int2str(j)]).shocks=shocks(j);
+end
+
+options.shock_decomp.interactive=0;
+options.shock_decomp.expand=1;
+plot_shock_decomposition(M,oo,options,var_list_);
diff --git a/matlab/fastgensylv.m b/matlab/fastgensylv.m
index 332e46f28..a8e6e386f 100644
--- a/matlab/fastgensylv.m
+++ b/matlab/fastgensylv.m
@@ -39,7 +39,7 @@ function X = fastgensylv(A, B, C, D, tol,maxit,X0)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -95,19 +95,19 @@ end
 %   B
 %   C
 %   D
-%   block : block number (for storage purpose) 
+%   block : block number (for storage purpose)
 %   tol : convergence criteria
 % OUTPUTS
 %   X solution
-%    
+%
 % ALGORITHM
 %   fixed point method
 %   MARLLINY MONSALVE (2008): "Block linear method for large scale
-%   Sylvester equations", Computational & Applied Mathematics, Vol 27, n°1,
+%   Sylvester equations", Computational & Applied Mathematics, Vol 27, n°1,
 %   p47-59
 %   ||A^-1||.||B||.||C|| < 1 is a suffisant condition:
 %    - to get a unique solution for the Sylvester equation
 %    - to get a convergent fixed-point algorithm
 %
 % SPECIAL REQUIREMENTS
-%   none.  
+%   none.
diff --git a/matlab/ff1_.m b/matlab/ff1_.m
index 4b6b666ce..1ed766d95 100644
--- a/matlab/ff1_.m
+++ b/matlab/ff1_.m
@@ -5,14 +5,14 @@ function y=ff1_(x)
 %
 % INPUTS
 %    x:          argument splitted between endogenous and exogenous
-%        
+%
 % OUTPUTS
 %    y:         'static' function residuals
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2008 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -35,6 +35,3 @@ n1 = size(x,1) - M_.exo_nbr;
 oo_.exo_simul(it_+M_.maximum_lag-M_.maximum_lag,:) = x(n1+1:end)';
 fh = str2func([M_.fname '_static']);
 y=feval(fh,x(1:n1),oo_.exo_simul, M_.params);
-
-
-
diff --git a/matlab/ffill.m b/matlab/ffill.m
index fc72c9f9f..cb8f0d321 100644
--- a/matlab/ffill.m
+++ b/matlab/ffill.m
@@ -7,15 +7,15 @@ function [a,b] = ffill(x,ixc,y)
 %    x:         matrix
 %    ixc:       vector of indices
 %    y:         matrix
-%        
+%
 % OUTPUTS
 %    a:         concatenation results
 %    b:         vector
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/fjaco.m b/matlab/fjaco.m
index 5217ca93a..5f5de0783 100644
--- a/matlab/fjaco.m
+++ b/matlab/fjaco.m
@@ -10,7 +10,7 @@ function fjac = fjaco(f,x,varargin)
 % OUTPUT
 %   fjac      : finite differnce Jacobian
 %
-% Copyright (C) 2010 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,7 +34,7 @@ h = tol.*max(abs(x),1);
 xh1=x+h; xh0=x-h;
 h=xh1-xh0;
 fjac = NaN(length(ff),length(x));
-for j=1:length(x);
+for j=1:length(x)
     xx = x;
     xx(j) = xh1(j); f1=feval(f,xx,varargin{:});
     xx(j) = xh0(j); f0=feval(f,xx,varargin{:});
diff --git a/matlab/flip_plan.m b/matlab/flip_plan.m
index a5a0952a9..5daf19fc7 100644
--- a/matlab/flip_plan.m
+++ b/matlab/flip_plan.m
@@ -15,7 +15,7 @@ function plan = flip_plan(plan, exogenous, endogenous, expectation_type, date, v
 %  plan                   [structure]        Returns a structure containing the updated forecast scenario.
 %
 %
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,71 +31,71 @@ function plan = flip_plan(plan, exogenous, endogenous, expectation_type, date, v
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-  if ~ischar(expectation_type) || size(expectation_type,1) ~= 1
-      error(['in flip_plan the fourth argument should be a string containing the simulation type (''perfect_foresight'' or ''surprise'')']);
-  end
-  exogenous = strtrim(exogenous);
-  ix = find(strcmp(exogenous, plan.endo_names));
-  if  isempty(ix)
-      error(['in flip_plan the second argument ' exogenous ' is not an endogenous variable']);
-  end;
-  endogenous = strtrim(endogenous);
-  iy = find(strcmp(endogenous, plan.exo_names));
-  if  isempty(iy)
-      error(['in flip_plan the third argument ' endogenous ' is not an exogenous variable']);
-  end;
-  sdate = length(date);
-  if sdate > 1
-      if date(1) < plan.date(1) || date(end) > plan.date(end)
-          error(['in flip_plan the fifth argument (date='  date ') must lay inside the plan.date ' plan.date]);
-      end
-  else
-      if date < plan.date(1) || date > plan.date(end)
-          error(['in flip_plan the fifth argument (date='  date ') must lay iside the plan.date ' plan.date]);
-      end
-  end
-  if ~isempty(plan.shock_vars_)
-      common_var = find(iy == plan.shock_vars_);
-      if ~isempty(common_var)
-          common_date = intersect(date, plan.shock_date_{common_var});
-          if ~isempty(common_date)
-              if common_date.length > 1
-                  the_dates = [cell2mat(strings(common_date(1))) ':' cell2mat(strings(common_date(end)))];
-              else
-                  the_dates = cell2mat(strings(common_date));
-              end
-              error(['Impossible case: ' plan.exo_names{plan.shock_vars_(common_var)} ' is used both as a shock and as an endogenous variable to control the path of ' plan.endo_names{ix} ' at the dates ' the_dates]);
-          end
-      end
-  end
-  i_ix = find(ix == plan.constrained_vars_);
-  if isempty(i_ix)
+if ~ischar(expectation_type) || size(expectation_type,1) ~= 1
+    error(['in flip_plan the fourth argument should be a string containing the simulation type (''perfect_foresight'' or ''surprise'')']);
+end
+exogenous = strtrim(exogenous);
+ix = find(strcmp(exogenous, plan.endo_names));
+if  isempty(ix)
+    error(['in flip_plan the second argument ' exogenous ' is not an endogenous variable']);
+end
+endogenous = strtrim(endogenous);
+iy = find(strcmp(endogenous, plan.exo_names));
+if  isempty(iy)
+    error(['in flip_plan the third argument ' endogenous ' is not an exogenous variable']);
+end
+sdate = length(date);
+if sdate > 1
+    if date(1) < plan.date(1) || date(end) > plan.date(end)
+        error(['in flip_plan the fifth argument (date='  date ') must lay inside the plan.date ' plan.date]);
+    end
+else
+    if date < plan.date(1) || date > plan.date(end)
+        error(['in flip_plan the fifth argument (date='  date ') must lay iside the plan.date ' plan.date]);
+    end
+end
+if ~isempty(plan.shock_vars_)
+    common_var = find(iy == plan.shock_vars_);
+    if ~isempty(common_var)
+        common_date = intersect(date, plan.shock_date_{common_var});
+        if ~isempty(common_date)
+            if common_date.length > 1
+                the_dates = [cell2mat(strings(common_date(1))) ':' cell2mat(strings(common_date(end)))];
+            else
+                the_dates = cell2mat(strings(common_date));
+            end
+            error(['Impossible case: ' plan.exo_names{plan.shock_vars_(common_var)} ' is used both as a shock and as an endogenous variable to control the path of ' plan.endo_names{ix} ' at the dates ' the_dates]);
+        end
+    end
+end
+i_ix = find(ix == plan.constrained_vars_);
+if isempty(i_ix)
     if isempty(plan.constrained_vars_)
-       plan.constrained_vars_ = ix;
-       plan.options_cond_fcst_.controlled_varexo  = iy;
-       if strcmp(expectation_type, 'perfect_foresight')
-          plan.constrained_perfect_foresight_ = 1;
-       else
-          plan.constrained_perfect_foresight_ = 0;
-       end
+        plan.constrained_vars_ = ix;
+        plan.options_cond_fcst_.controlled_varexo  = iy;
+        if strcmp(expectation_type, 'perfect_foresight')
+            plan.constrained_perfect_foresight_ = 1;
+        else
+            plan.constrained_perfect_foresight_ = 0;
+        end
     else
-       plan.constrained_vars_ = [plan.constrained_vars_ ; ix];
-       plan.options_cond_fcst_.controlled_varexo  = [plan.options_cond_fcst_.controlled_varexo ; iy];
-       if strcmp(expectation_type, 'perfect_foresight')
-          plan.constrained_perfect_foresight_ = [plan.constrained_perfect_foresight_ ; 1];
-       else
-          plan.constrained_perfect_foresight_ = [plan.constrained_perfect_foresight_ ; 0];
-       end
+        plan.constrained_vars_ = [plan.constrained_vars_ ; ix];
+        plan.options_cond_fcst_.controlled_varexo  = [plan.options_cond_fcst_.controlled_varexo ; iy];
+        if strcmp(expectation_type, 'perfect_foresight')
+            plan.constrained_perfect_foresight_ = [plan.constrained_perfect_foresight_ ; 1];
+        else
+            plan.constrained_perfect_foresight_ = [plan.constrained_perfect_foresight_ ; 0];
+        end
     end
     plan.constrained_date_{length(plan.constrained_date_) + 1} = date;
     plan.constrained_str_date_{length(plan.constrained_str_date_) + 1} = strings(date);
     plan.constrained_int_date_{length(plan.constrained_int_date_) + 1} = date - plan.date(1) + 1;
     plan.constrained_paths_{length(plan.constrained_paths_) + 1} = value;
-  elseif plan.options_cond_fcst_.controlled_varexo(i_ix) == iy % same exogenous and endogenous hard tune
-    [plan.constrained_str_date_{i_ix}, i1, i2] = union(strings(date), plan.constrained_str_date_{i_ix});
-    plan.constrained_date_{i_ix} = [date(i1) plan.constrained_date_{i_ix}(i2)];
-    plan.constrained_int_date_{i_ix} = [date(i1) - plan.date(1) + 1; plan.constrained_int_date_{i_ix}(i2)];
-    plan.constrained_paths_{i_ix} = [value(i1)'; plan.constrained_paths_{i_ix}(i2)];
-  else
+elseif plan.options_cond_fcst_.controlled_varexo(i_ix) == iy % same exogenous and endogenous hard tune
+[plan.constrained_str_date_{i_ix}, i1, i2] = union(strings(date), plan.constrained_str_date_{i_ix});
+plan.constrained_date_{i_ix} = [date(i1) plan.constrained_date_{i_ix}(i2)];
+plan.constrained_int_date_{i_ix} = [date(i1) - plan.date(1) + 1; plan.constrained_int_date_{i_ix}(i2)];
+plan.constrained_paths_{i_ix} = [value(i1)'; plan.constrained_paths_{i_ix}(i2)];
+else
     error(['impossible case you have two conditional forecasts:\n - one involving ' plan.endo_names{plan.options_cond_fcst_.controlled_varexo(i_ix),:} ' as control and ' plan_exo_names{plan.constrained_vars_(ix_)} ' as constrined endogenous\n - the other involving  ' plan.endo_names{plan.options_cond_fcst_.controlled_varexo(iy),:} ' as control and ' plan_exo_names{plan.constrained_vars_(ix)} ' as constrined endogenous\n']);
-  end 
+end
diff --git a/matlab/forcst.m b/matlab/forcst.m
index 9c7654ae6..d760ca892 100644
--- a/matlab/forcst.m
+++ b/matlab/forcst.m
@@ -1,7 +1,7 @@
 function [yf,int_width,int_width_ME]=forcst(dr,y0,horizon,var_list,M_,oo_,options_)
 % function [yf,int_width,int_width_ME]=forecst(dr,y0,horizon,var_list,M_,oo_,options_)
 %   computes mean forecast for a given value of the parameters
-%   computes also confidence band for the forecast    
+%   computes also confidence band for the forecast
 %
 % INPUTS:
 %   dr:          structure containing decision rules
@@ -22,7 +22,7 @@ function [yf,int_width,int_width_ME]=forcst(dr,y0,horizon,var_list,M_,oo_,option
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ ghx1 = dr.ghx(inv_order_var(ivar),:);
 ghu1 = dr.ghu(inv_order_var(ivar),:);
 
 %initialize recursion
-sigma_u = B*M_.Sigma_e*B'; 
+sigma_u = B*M_.Sigma_e*B';
 sigma_u1 = ghu1*M_.Sigma_e*ghu1';
 sigma_y = 0; %no uncertainty about the states
 
diff --git a/matlab/forcst2.m b/matlab/forcst2.m
index 43c2b4c4e..1c0d91b24 100644
--- a/matlab/forcst2.m
+++ b/matlab/forcst2.m
@@ -1,6 +1,6 @@
 function yf=forcst2(y0,horizon,dr,n)
 % function yf=forcst2(y0,horizon,dr,n)
-% 
+%
 % computes forecasts based on first order model solution, given shocks
 % drawn from the shock distribution, but not including measurement error
 % Inputs:
@@ -11,8 +11,8 @@ function yf=forcst2(y0,horizon,dr,n)
 %
 % Outputs:
 %   - yf        [horizon+ykmin_ by endo_nbr by n]   array of forecasts
-% 
-% Copyright (C) 2008-2016 Dynare Team
+%
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -64,4 +64,4 @@ for i=ykmin_+(1:horizon)
 end
 
 yf(dr.order_var,:,:) = yf;
-yf=permute(yf,[2 1 3]);  
+yf=permute(yf,[2 1 3]);
diff --git a/matlab/forcst2a.m b/matlab/forcst2a.m
index 16fcdc143..bbac43b71 100644
--- a/matlab/forcst2a.m
+++ b/matlab/forcst2a.m
@@ -1,6 +1,6 @@
 function yf=forcst2a(y0,dr,e)
 % function yf=forcst2a(y0,dr,e)
-% computes forecasts based on first order model solution, assuming the absence of shocks 
+% computes forecasts based on first order model solution, assuming the absence of shocks
 % Inputs:
 %   - y0        [endo_nbr by maximum_endo_lag]          matrix of starting values
 %   - dr        [structure]                             structure with Dynare decision rules
@@ -9,7 +9,7 @@ function yf=forcst2a(y0,dr,e)
 % Outputs:
 %   - yf        [horizon+maximum_endo_lag,endo_nbr]               matrix of forecasts
 %
-% Copyright (C) 2008-2015 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -48,4 +48,3 @@ for i=ykmin_+(1:horizon)
 end
 
 yf(:,dr.order_var) = yf;
-
diff --git a/matlab/forecast_graphs.m b/matlab/forecast_graphs.m
index be6f49399..5631ff4b4 100644
--- a/matlab/forecast_graphs.m
+++ b/matlab/forecast_graphs.m
@@ -1,14 +1,14 @@
 function forecast_graphs(var_list,M_, oo_,options_)
 % function forecast_graphs(var_list,M_, oo_,options_)
 % Plots the classical forecasts created by dyn_forecast.m
-% 
+%
 % Inputs:
 %   o var_list              character array with variable names
 %   o M_                    model structure
 %   o oo_                   outputs structure
 %   o options_              options structure
 
-% Copyright (C) 2008-2016 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -61,10 +61,10 @@ end
 
 m = 1;
 n_fig = 1;
-hh=dyn_figure(options_,'Name','Forecasts (I)');
+hh=dyn_figure(options_.nodisplay,'Name','Forecasts (I)');
 for j= 1:nvar
-    if m > nc*nr; 
-        dyn_saveas(hh,[ dname '/graphs/forcst' int2str(n_fig)],options_);
+    if m > nc*nr
+        dyn_saveas(hh,[ dname '/graphs/forcst' int2str(n_fig)],options_.nodisplay,options_.graph_format);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fprintf(fidTeX,'\\begin{figure}[H]\n');
             fprintf(fidTeX,'\\centering \n');
@@ -73,15 +73,15 @@ for j= 1:nvar
             fprintf(fidTeX,'\\caption{Mean forecasts and %2.0f\\%% confidence intervals}\n',options_.forecasts.conf_sig*100);
             fprintf(fidTeX,'\\end{figure}\n');
             fprintf(fidTeX,' \n');
-        end       
+        end
         n_fig =n_fig+1;
-        eval(['hh=dyn_figure(options_,''Name'',''Forecasts (' int2str(n_fig) ')'');']);
+        eval(['hh=dyn_figure(options_.nodisplay,''Name'',''Forecasts (' int2str(n_fig) ')'');']);
         m = 1;
     end
     subplot(nr,nc,m);
     vn = deblank(endo_names(i_var(j),:));
     obs = 0;
-% $$$         k = strmatch(vn,varobs,'exact'); 
+% $$$         k = strmatch(vn,varobs,'exact');
 % $$$   if ~isempty(k)
 % $$$       yy = y.(vn)(end-9:end) + repmat(ys(i_var(j)),10,1)+trend(k,:)';
 % $$$       plot(yy);
@@ -100,7 +100,7 @@ for j= 1:nvar
 end
 
 if m > 1
-    dyn_saveas(hh,[dname '/graphs/forcst' int2str(n_fig)],options_);
+    dyn_saveas(hh,[dname '/graphs/forcst' int2str(n_fig)],options_.nodisplay,options_.graph_format);
     if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         fprintf(fidTeX,'\\begin{figure}[H]\n');
         fprintf(fidTeX,'\\centering \n');
@@ -118,17 +118,17 @@ end
 
 if isfield(oo_.forecast,'HPDinf_ME')
     var_names=fieldnames(oo_.forecast.HPDinf_ME);
-    
+
     if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         fidTeX=write_LaTeX_header([M_.dname '/graphs/',fname,'_forcst_ME.tex']);
     end
-    
+
     m = 1;
     n_fig = 1;
-    hh=dyn_figure(options_,'Name','Forecasts including ME (I)');
+    hh=dyn_figure(options_.nodisplay,'Name','Forecasts including ME (I)');
     for j= 1:length(var_names)
-        if m > nc*nr;
-            dyn_saveas(hh,[ dname '/graphs/forcst_ME' int2str(n_fig)],options_);
+        if m > nc*nr
+            dyn_saveas(hh,[ dname '/graphs/forcst_ME' int2str(n_fig)],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fprintf(fidTeX,'\\begin{figure}[H]\n');
                 fprintf(fidTeX,'\\centering \n');
@@ -139,7 +139,7 @@ if isfield(oo_.forecast,'HPDinf_ME')
                 fprintf(fidTeX,' \n');
             end
             n_fig =n_fig+1;
-            eval(['hh=dyn_figure(options_,''Name'',''Forecasts (' int2str(n_fig) ')'');']);
+            eval(['hh=dyn_figure(options_.nodisplay,''Name'',''Forecasts (' int2str(n_fig) ')'');']);
             m = 1;
         end
         subplot(nr,nc,m);
@@ -156,12 +156,12 @@ if isfield(oo_.forecast,'HPDinf_ME')
         hold off
         m = m + 1;
     end
-    
+
     if m > 1
-        dyn_saveas(hh,[dname '/graphs/forcst_ME' int2str(n_fig)],options_);
+        dyn_saveas(hh,[dname '/graphs/forcst_ME' int2str(n_fig)],options_.nodisplay,options_.graph_format);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fprintf(fidTeX,'\\begin{figure}[H]\n');
-            fprintf(fidTeX,'\\centering \n');          
+            fprintf(fidTeX,'\\centering \n');
             fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s/graphs/forcst_ME%d}\n',options_.figures.textwidth*min((m-1)/nc,1),dname,n_fig);
             fprintf(fidTeX,'\\label{Fig:forcst_ME:%d}\n',n_fig);
             fprintf(fidTeX,'\\caption{Mean forecasts and %2.0f\\%% confidence intervals accounting for measurement error}\n',options_.forecasts.conf_sig*100);
@@ -169,10 +169,10 @@ if isfield(oo_.forecast,'HPDinf_ME')
             fprintf(fidTeX,' \n');
         end
     end
-    
+
     if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         write_LaTeX_footer(fidTeX);
-    end   
+    end
 end
 
 
diff --git a/matlab/formdata.m b/matlab/formdata.m
index 06dba8416..b8040515c 100644
--- a/matlab/formdata.m
+++ b/matlab/formdata.m
@@ -11,7 +11,7 @@ function formdata(fname,date)
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2007-2010 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,6 +29,7 @@ function formdata(fname,date)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 global M_ oo_
+
 fid = fopen([fname '_endo.frm'],'w');
 n=size(oo_.endo_simul,1);
 t=size(oo_.endo_simul,2);
@@ -46,11 +47,10 @@ for i=1:n
             fprintf(fid,'%10.5f %10.5f\n',oo_.endo_simul(i,floor(t/4)*4+1:t));
           case 3
             fprintf(fid,'%10.5f %10.5f %10.5f\n',oo_.endo_simul(i,floor(t/4)*4+1:t));
-        end;
-        %else
-        %    fprintf(fid,'\n');
-    end;
-end;
+        end
+    end
+end
+
 fclose(fid);
 
 fid = fopen([fname '_exo.frm'],'w');
@@ -70,10 +70,8 @@ for i=1:n
             fprintf(fid,'%10.5f %10.5f\n',oo_.exo_simul(floor(t/4)*4+1:t,i)');
           case 3
             fprintf(fid,'%10.5f %10.5f %10.5f\n',oo_.exo_simul(floor(t/4)*4+1:t,i)');
-        end;
-        %else
-        %    fprintf(fid,'\n');
-    end;
-end;
-fclose(fid);
-return;
\ No newline at end of file
+        end
+    end
+end
+
+fclose(fid);
\ No newline at end of file
diff --git a/matlab/ftest.m b/matlab/ftest.m
index 97bedb6e5..c433bb453 100644
--- a/matlab/ftest.m
+++ b/matlab/ftest.m
@@ -1,6 +1,6 @@
 function ftest (s1,s2)
 
-% Copyright (C) 2001-2010 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -20,7 +20,7 @@ function ftest (s1,s2)
 global nvx nvy x y lag1
 
 if size(s1,1) ~= 2
-    error ('Spécifiez deux fichiers pour la comparaison.') ;
+    error ('Spécifiez deux fichiers pour la comparaison.') ;
 end
 
 for i = 1:2
@@ -59,7 +59,7 @@ end
 
 for i = 1:size(x,1)
     if ~ strcmp(nvx(i,:),nvy(i,:))
-        error ('FTEST: The two files don''t have the same  variables.') ;       
+        error ('FTEST: The two files don''t have the same  variables.') ;
     end
 end
 
diff --git a/matlab/@dynTimeIndex/display.m b/matlab/fwriten.m
similarity index 79%
rename from matlab/@dynTimeIndex/display.m
rename to matlab/fwriten.m
index 87162fd40..1fd5e1160 100644
--- a/matlab/@dynTimeIndex/display.m
+++ b/matlab/fwriten.m
@@ -1,6 +1,8 @@
-function display(t)
+function fwriten(fid, str)
 
-% Copyright (C) 2013 Dynare Team
+% Writes a line in a file, with newline character at the end of the line.
+
+% Copyright (C) 2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,4 +19,4 @@ function display(t)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-fprintf('%s = <dynTimeIndex: %s>\n', inputname(1), int2str(t.index));
+fwrite(fid, sprintf('%s\n', str));
\ No newline at end of file
diff --git a/matlab/gauss_hermite_weights_and_nodes.m b/matlab/gauss_hermite_weights_and_nodes.m
index a9a75b4e1..646033c06 100644
--- a/matlab/gauss_hermite_weights_and_nodes.m
+++ b/matlab/gauss_hermite_weights_and_nodes.m
@@ -31,7 +31,7 @@ function [nodes,weights] = gauss_hermite_weights_and_nodes(n)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -66,7 +66,7 @@ nodes = sqrt(2)*nodes;
 %$ sum_of_weights = sum(weights);
 %$
 %$ % Expected nodes (taken from Judd (1998, table 7.4).
-%$ enodes = [-2.020182870; -0.9585724646; 0; 0.9585724646;   2.020182870]; 
+%$ enodes = [-2.020182870; -0.9585724646; 0; 0.9585724646;   2.020182870];
 %$
 %$ % Check the results.
 %$ t(1) = dassert(1.0,sum_of_weights,1e-12);
@@ -79,7 +79,7 @@ nodes = sqrt(2)*nodes;
 %$ [nodes,weights] = gauss_hermite_weights_and_nodes(n);
 %$
 %$ sum_of_weights = sum(weights);
-%$ expectation = sum(weights.*nodes); 
+%$ expectation = sum(weights.*nodes);
 %$ variance = sum(weights.*(nodes.^2));
 %$
 %$ % Check the results.
@@ -113,7 +113,7 @@ nodes = sqrt(2)*nodes;
 %$ [nodes,weights] = gauss_hermite_weights_and_nodes(n);
 %$
 %$ sum_of_weights = sum(weights);
-%$ expectation = sum(weights.*nodes*.1); 
+%$ expectation = sum(weights.*nodes*.1);
 %$ variance = sum(weights.*((nodes*.1).^2));
 %$
 %$ % Check the results.
diff --git a/matlab/gauss_legendre_weights_and_nodes.m b/matlab/gauss_legendre_weights_and_nodes.m
index a1b6fc290..074f520d7 100644
--- a/matlab/gauss_legendre_weights_and_nodes.m
+++ b/matlab/gauss_legendre_weights_and_nodes.m
@@ -40,7 +40,7 @@ function [nodes,weights] = gauss_legendre_weights_and_nodes(n,a,b)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -124,7 +124,7 @@ end
 
 %@test:3
 %$ [n,w] = gauss_legendre_weights_and_nodes(9,pi,2*pi);
-%$ % Check that the 
+%$ % Check that the
 %$ t(1) = all(n>pi);
 %$ t(2) = all(n<2*pi);
 %$ t(3) = dassert(sum(w),pi,1e-12);
diff --git a/matlab/gcompare.m b/matlab/gcompare.m
index d8a1e2ae8..6cb02f6a1 100644
--- a/matlab/gcompare.m
+++ b/matlab/gcompare.m
@@ -1,12 +1,12 @@
 function gcompare(s1,s2)
-% GCOMPARE :    GCOMPARE ( [ 'file1' ; 'file2' ] , [ 'var1' ; 'var2' ...] )     
+% GCOMPARE :    GCOMPARE ( [ 'file1' ; 'file2' ] , [ 'var1' ; 'var2' ...] )
 %               This optional command plots the trajectories of a list of
 %               variables in two different simulations. One plot is drawn
 %               for each variable. The trajectories must have been previously
 %               saved by the instruction DYNASAVE. The simulation in file1
 %               is refered to as the base simulation.
 
-% Copyright (C) 2001-2010 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,6 +50,3 @@ end
 
 % 06/18/01 MJ corrected treatment of options_.smpl
 % 06/24/01 MJ removed color specification
-
-
-
diff --git a/matlab/gensylv/gensylv.m b/matlab/gensylv/gensylv.m
index 26624fea7..2920aca4d 100644
--- a/matlab/gensylv/gensylv.m
+++ b/matlab/gensylv/gensylv.m
@@ -3,23 +3,23 @@ function [err, E] = gensylv(kron_prod,A,B,C0,D)
 % Solves a Sylvester equation.
 %
 % INPUTS
-%   kron_prod     
+%   kron_prod
 %   A
 %   B
 %   C
 %   D
-%    
+%
 % OUTPUTS
 %   err      [double] scalar: 1 indicates failure, 0 indicates success
 %   E
-%    
+%
 % ALGORITHM
 %   none.
 %
 % SPECIAL REQUIREMENTS
-%   none.  
+%   none.
 
-% Copyright (C) 1996-2011 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,9 +36,9 @@ function [err, E] = gensylv(kron_prod,A,B,C0,D)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 C = C0;
-for i=1:(kron_prod-1);
-    C  = kron(C0,C); 
-end;
+for i=1:(kron_prod-1)
+    C  = kron(C0,C);
+end
 
 x0 = sylvester3(A,B,C,D);
 E  = sylvester3a(x0,A,B,C,D);
diff --git a/matlab/gensylv/sylvester3.m b/matlab/gensylv/sylvester3.m
index be4d8c574..4e0ab85ee 100644
--- a/matlab/gensylv/sylvester3.m
+++ b/matlab/gensylv/sylvester3.m
@@ -1,7 +1,7 @@
 function x=sylvester3(a,b,c,d)
 % solves a*x+b*x*c=d where d is [n x m x p]
 
-% Copyright (C) 2005-2012 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,21 +23,21 @@ m = size(c,1);
 p = size(d,3);
 x=zeros(n,m,p);
 if n == 1
-    for j=1:p,
+    for j=1:p
         x(:,:,j)=d(:,:,j)./(a*ones(1,m)+b*c);
     end
     return
 end
 if m == 1
-    for j=1:p,
+    for j=1:p
         x(:,:,j) = (a+c*b)\d(:,:,j);
     end
-    return;
+    return
 end
 [u,t]=schur(c);
 if isoctave
     [aa,bb,qq,zz]=qz(full(a),full(b));
-    for j=1:p,
+    for j=1:p
         if octave_ver_less_than('3.4.0')
             d(:,:,j)=qq'*d(:,:,j)*u;
         else
@@ -46,7 +46,7 @@ if isoctave
     end
 else
     [aa,bb,qq,zz]=qz(full(a),full(b),'real'); % available in Matlab version 6.0
-    for j=1:p,
+    for j=1:p
         d(:,:,j)=qq*d(:,:,j)*u;
     end
 end
@@ -58,7 +58,7 @@ while i < m
         if i == 1
             c = zeros(n,1,p);
         else
-            for j=1:p,
+            for j=1:p
                 c(:,:,j) = bb*(x(:,1:i-1,j)*t(1:i-1,i));
             end
         end
@@ -69,7 +69,7 @@ while i < m
             c = zeros(n,1,p);
             c1 = zeros(n,1,p);
         else
-            for j=1:p,
+            for j=1:p
                 c(:,:,j) = bb*(x(:,1:i-1,j)*t(1:i-1,i));
                 c1(:,:,j) = bb*(x(:,1:i-1,j)*t(1:i-1,i+1));
             end
@@ -82,13 +82,13 @@ while i < m
     end
 end
 if i == m
-    for j=1:p,
+    for j=1:p
         c(:,:,j) = bb*(x(:,1:m-1,j)*t(1:m-1,m));
     end
     aabbt = (aa+bb*t(m,m));
     x(:,m,:)=aabbt\squeeze(d(:,m,:)-c);
 end
-for j=1:p,
+for j=1:p
     x(:,:,j)=zz*x(:,:,j)*u';
 end
 
diff --git a/matlab/gensylv/sylvester3a.m b/matlab/gensylv/sylvester3a.m
index 00724dc38..f286c8bdf 100644
--- a/matlab/gensylv/sylvester3a.m
+++ b/matlab/gensylv/sylvester3a.m
@@ -1,7 +1,7 @@
 function [x0, flag]=sylvester3a(x0,a,b,c,dd)
 % solves iteratively ax+bxc=d
 
-% Copyright (C) 2005-2012 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -21,7 +21,7 @@ function [x0, flag]=sylvester3a(x0,a,b,c,dd)
 a_1 = inv(a);
 b = a_1*b;
 flag=0;
-for j=1:size(dd,3),
+for j=1:size(dd,3)
     d = a_1*dd(:,:,j);
     e = 1;
     iter = 1;
diff --git a/matlab/gensylv_fp.m b/matlab/gensylv_fp.m
index 2e5c167b5..51c96fceb 100644
--- a/matlab/gensylv_fp.m
+++ b/matlab/gensylv_fp.m
@@ -7,23 +7,23 @@ function X = gensylv_fp(A, B, C, D, block, tol)
 %   B
 %   C
 %   D
-%   block : block number (for storage purpose) 
+%   block : block number (for storage purpose)
 %   tol : convergence criteria
 % OUTPUTS
 %   X solution
-%    
+%
 % ALGORITHM
 %   fixed point method
 %   MARLLINY MONSALVE (2008): "Block linear method for large scale
-%   Sylvester equations", Computational & Applied Mathematics, Vol 27, n°1,
+%   Sylvester equations", Computational & Applied Mathematics, Vol 27, n°1,
 %   p47-59
 %   ||A^-1||.||B||.||C|| < 1 is a suffisant condition:
 %    - to get a unique solution for the Sylvester equation
 %    - to get a convergent fixed-point algorithm
 %
 % SPECIAL REQUIREMENTS
-%   none.  
-% Copyright (C) 1996-2012 Dynare Team
+%   none.
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,11 +50,11 @@ if isempty(hxo)
     X = zeros(size(B, 2), size(C, 1));
 else
     X = hxo;
-end;
+end
 it_fp = 0;
 maxit_fp = 1000;
 Z = - (B * X * C + D);
-while it_fp < maxit_fp && evol > tol;
+while it_fp < maxit_fp && evol > tol
     %X_old = X;
     %X = - A1 * ( B * X * C + D);
     %evol = max(max(abs(X - X_old)));
@@ -62,12 +62,12 @@ while it_fp < maxit_fp && evol > tol;
     Z_old = Z;
     Z = - (B * X * C + D);
     evol = max(sum(abs(Z - Z_old))); %norm_1
-    %evol = max(sum(abs(Z - Z_old)')); %norm_inf
+                                     %evol = max(sum(abs(Z - Z_old)')); %norm_inf
     it_fp = it_fp + 1;
-end;
+end
 %fprintf('sylvester it_fp=%d evol=%g | ',it_fp,evol);
 if evol < tol
     eval(['hxo_' int2str(block) ' = X;']);
 else
     error(['convergence not achieved in fixed point solution of Sylvester equation after ' int2str(it_fp) ' iterations']);
-end;
\ No newline at end of file
+end
\ No newline at end of file
diff --git a/matlab/getH.m b/matlab/getH.m
index 0db11d8e3..fcee9242e 100644
--- a/matlab/getH.m
+++ b/matlab/getH.m
@@ -13,14 +13,14 @@ function [H, dA, dOm, Hss, gp, d2A, d2Om, H2ss] = getH(A, B, estim_params_,M_,oo
 %                   not (-1 or -2)
 %   indx:           Index of estimated parameters in M_.params
 %   indexo:         Index of estimated standard deviations in M_.exo_names
-%   iv:             Index of considered variables           
-% 
+%   iv:             Index of considered variables
+%
 % Outputs:
 %   H:              dTAU/dTHETA: Jacobian of TAU, vectorized form of
 %                   linearized reduced form state space model, given ys [steady state],
 %                   A [transition matrix], B [matrix of shocks], Sigma [covariance of shocks]
-%                   TAU = [ys; vec(A); dyn_vech(B*Sigma*B')]. 
-%   dA:             [endo_nbr by endo_nbr by (indx+indexo)] Jacobian of transition matrix A            
+%                   TAU = [ys; vec(A); dyn_vech(B*Sigma*B')].
+%   dA:             [endo_nbr by endo_nbr by (indx+indexo)] Jacobian of transition matrix A
 %   dOm:            [endo_nbr by endo_nbr by (indx+indexo)] Jacobian of Omega = (B*Sigma*B')
 %   Hss:            [endo_nbr by (indx)] Jacobian of steady state with respect to estimated
 %                   structural parameters only (indx)
@@ -32,7 +32,7 @@ function [H, dA, dOm, Hss, gp, d2A, d2Om, H2ss] = getH(A, B, estim_params_,M_,oo
 %   H2s:            Hessian of steady state with respect to estimated
 %                   structural parameters only (indx)
 
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -50,23 +50,23 @@ function [H, dA, dOm, Hss, gp, d2A, d2Om, H2ss] = getH(A, B, estim_params_,M_,oo
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 if nargin<7 || isempty(kronflag)
-    kronflag = 0; 
+    kronflag = 0;
 end
 if nargin<8 || isempty(indx)
-    indx = []; 
+    indx = [];
 end
 if nargin<9 || isempty(indexo)
-    indexo = []; 
+    indexo = [];
 end
 if nargin<10 || isempty(iv)
-    iv = (1:length(A))'; 
+    iv = (1:length(A))';
 end
 
 [I,J]=find(M_.lead_lag_incidence');
 yy0=oo_.dr.ys(I);
 param_nbr = length(indx);
 tot_param_nbr = param_nbr + length(indexo);
-if nargout>5,
+if nargout>5
     param_nbr_2 = param_nbr*(param_nbr+1)/2;
     tot_param_nbr_2 = tot_param_nbr*(tot_param_nbr+1)/2;
 end
@@ -75,18 +75,18 @@ m = size(A,1);
 m1=length(iv);
 n = size(B,2);
 
-if kronflag==-1, % perturbation
+if kronflag==-1 % perturbation
     gp=0;
     fun = 'thet2tau';
     params0 = M_.params;
     H = fjaco(fun,[sqrt(diag(M_.Sigma_e(indexo,indexo))); M_.params(indx)], M_, oo_, indx, indexo,0);
-    if nargout>1,
+    if nargout>1
         dOm = zeros(m1,m1,tot_param_nbr);
         dA=zeros(m1,m1,tot_param_nbr);
         Hss=H(iv,length(indexo)+1:end);
         da = H(m+1:m+m*m,:);
         dom = H(m+m*m+1:end,:);
-        for j=1:tot_param_nbr,
+        for j=1:tot_param_nbr
             tmp = dyn_unvech(dom(:,j));
             dOm(:,:,j) = tmp(iv,iv);
             tmp = reshape(da(:,j),m,m);
@@ -94,13 +94,13 @@ if kronflag==-1, % perturbation
         end
         clear da dom tmp
     end
-    if nargout>5,
+    if nargout>5
         H2 = hessian_sparse('thet2tau',[sqrt(diag(M_.Sigma_e(indexo,indexo))); M_.params(indx)], ...
-            options_.gstep,estim_params_,M_, oo_, indx,indexo,0,[],[],[],iv);
+                            options_.gstep,estim_params_,M_, oo_, indx,indexo,0,[],[],[],iv);
         H2ss = zeros(m1,tot_param_nbr,tot_param_nbr);
         iax=find(triu(rand(tot_param_nbr,tot_param_nbr)));
         H2 = H2(:,iax);
-        for j=1:m1,
+        for j=1:m1
             H2ss(j,:,:)=dyn_unvech(full(H2(j,:)));
         end
         H2ss=H2ss(:,length(indexo)+1:end,length(indexo)+1:end);
@@ -109,33 +109,33 @@ if kronflag==-1, % perturbation
         d2A(:,:) = H2(m1+1:m1+m1*m1,:);
         d2Om(:,:) = H2(m1+m1*m1+1:end,:);
         clear H2
-%         tmp0=zeros(m1,m1);
-%         tmp0(iv,iv)=1;
-%         iax=find(tmp0);
-%         d2A=d2a(iax,:);
-%         iax=find(dyn_vech(tmp0));
-%         d2Om=d2om(iax,:);
+        %         tmp0=zeros(m1,m1);
+        %         tmp0(iv,iv)=1;
+        %         iax=find(tmp0);
+        %         d2A=d2a(iax,:);
+        %         iax=find(dyn_vech(tmp0));
+        %         d2Om=d2om(iax,:);
 
     end
-%     assignin('base','M_', M_);
-%     assignin('base','oo_', oo_);
+    %     assignin('base','M_', M_);
+    %     assignin('base','oo_', oo_);
     return
 end
 
-if kronflag==-2,
-    if nargout>5,
+if kronflag==-2
+    if nargout>5
         [residual, g1, g2 ] = feval([M_.fname,'_dynamic'],yy0, oo_.exo_steady_state', ...
-            M_.params, oo_.dr.ys, 1);
+                                    M_.params, oo_.dr.ys, 1);
         g22 = hessian_sparse('thet2tau',[M_.params(indx)],options_.gstep,estim_params_,M_, oo_, indx,[],-1);
         H2ss=full(g22(1:M_.endo_nbr,:));
         H2ss = reshape(H2ss,[M_.endo_nbr param_nbr param_nbr]);
-        for j=1:M_.endo_nbr,
+        for j=1:M_.endo_nbr
             H2ss(j,:,:)=dyn_unvech(dyn_vech(H2ss(j,:,:)));
         end
         g22=g22(M_.endo_nbr+1:end,:);
         inx=find(g22);
         gx22=zeros(length(inx),5);
-        for j=1:length(inx),
+        for j=1:length(inx)
             [i1, i2] = ind2sub(size(g22),inx(j));
             [ig1, ig2] = ind2sub(size(g1),i1);
             [ip1, ip2] = ind2sub([param_nbr param_nbr],i2);
@@ -145,145 +145,135 @@ if kronflag==-2,
         clear gx22;
     else
         [residual, g1 ] = feval([M_.fname,'_dynamic'],yy0, oo_.exo_steady_state', ...
-            M_.params, oo_.dr.ys, 1);        
+                                M_.params, oo_.dr.ys, 1);
     end
     gp = fjaco('thet2tau',[M_.params(indx)],estim_params_,M_, oo_, indx,[],-1);
     Hss=gp(1:M_.endo_nbr,:);
     gp=gp(M_.endo_nbr+1:end,:);
     gp = reshape(gp,[size(g1) param_nbr]);
 else
+    dyssdtheta=zeros(length(oo_.dr.ys),M_.param_nbr);
+    d2yssdtheta=zeros(length(oo_.dr.ys),M_.param_nbr,M_.param_nbr);
+    [residual, gg1] = feval([M_.fname,'_static'],oo_.dr.ys, oo_.exo_steady_state', M_.params);
+    df = feval([M_.fname,'_static_params_derivs'],oo_.dr.ys, repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1]), ...
+               M_.params);
+    dyssdtheta = -gg1\df;
+    if nargout>5
+        [residual, gg1, gg2] = feval([M_.fname,'_static'],oo_.dr.ys, oo_.exo_steady_state', M_.params);
+        [residual, g1, g2, g3] = feval([M_.fname,'_dynamic'],yy0, oo_.exo_steady_state', ...
+                                       M_.params, oo_.dr.ys, 1);
+        [nr, nc]=size(gg2);
 
-% yy0=[];
-% for j=1:size(M_.lead_lag_incidence,1);
-%     yy0 = [ yy0; oo_.dr.ys(find(M_.lead_lag_incidence(j,:)))];
-% end
-dyssdtheta=zeros(length(oo_.dr.ys),M_.param_nbr);
-d2yssdtheta=zeros(length(oo_.dr.ys),M_.param_nbr,M_.param_nbr);
-[residual, gg1] = feval([M_.fname,'_static'],oo_.dr.ys, oo_.exo_steady_state', M_.params);
-df = feval([M_.fname,'_static_params_derivs'],oo_.dr.ys, repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1]), ...
-    M_.params);
-dyssdtheta = -gg1\df;
-if nargout>5,
-    [residual, gg1, gg2] = feval([M_.fname,'_static'],oo_.dr.ys, oo_.exo_steady_state', M_.params);
-    [residual, g1, g2, g3] = feval([M_.fname,'_dynamic'],yy0, oo_.exo_steady_state', ...
-        M_.params, oo_.dr.ys, 1);
-    [nr, nc]=size(gg2);
-
-    [df, gpx, d2f] = feval([M_.fname,'_static_params_derivs'],oo_.dr.ys, oo_.exo_steady_state', ...
-        M_.params);%, oo_.dr.ys, 1, dyssdtheta*0, d2yssdtheta);
-    d2f = get_all_resid_2nd_derivs(d2f,length(oo_.dr.ys),M_.param_nbr);
-
-    if isempty(find(gg2)),
-        for j=1:M_.param_nbr,
-        d2yssdtheta(:,:,j) = -gg1\d2f(:,:,j);
-        end
-    else
-        gam = d2f*0;
-        for j=1:nr,
-            tmp1 = (squeeze(gpx(j,:,:))'*dyssdtheta);
-            gam(j,:,:)=transpose(reshape(gg2(j,:),[nr nr])*dyssdtheta)*dyssdtheta ...
-                + tmp1 + tmp1';
-        end
-        for j=1:M_.param_nbr,
-        d2yssdtheta(:,:,j) = -gg1\(d2f(:,:,j)+gam(:,:,j));
-%         d2yssdtheta(:,:,j) = -gg1\(d2f(:,:,j)+gam(:,:,j)+ squeeze(gpx(:,:,j))*dyssdtheta);
-        end
-        clear tmp1 gpx gam,
-    end
-end
-
-if any(any(isnan(dyssdtheta))),    
-    [U,T] = schur(gg1);
-    qz_criterium=options_.qz_criterium;
-    e1 = abs(ordeig(T)) < qz_criterium-1;
-    k = sum(e1);       % Number non stationary variables.
-%     n = length(e1)-k;  % Number of stationary variables.
-    [U,T] = ordschur(U,T,e1);
-    T = T(k+1:end,k+1:end);
-    dyssdtheta = -U(:,k+1:end)*(T\U(:,k+1:end)')*df;
-    if nargout>5,
-        for j=1:length(indx),
-            d2yssdtheta(:,:,j) = -U(:,k+1:end)*(T\U(:,k+1:end)')*d2f(:,:,j);
+        [df, gpx, d2f] = feval([M_.fname,'_static_params_derivs'],oo_.dr.ys, oo_.exo_steady_state', ...
+                               M_.params);%, oo_.dr.ys, 1, dyssdtheta*0, d2yssdtheta);
+        d2f = get_all_resid_2nd_derivs(d2f,length(oo_.dr.ys),M_.param_nbr);
+        if isempty(find(gg2))
+            for j=1:M_.param_nbr
+                d2yssdtheta(:,:,j) = -gg1\d2f(:,:,j);
+            end
+        else
+            gam = d2f*0;
+            for j=1:nr
+                tmp1 = (squeeze(gpx(j,:,:))'*dyssdtheta);
+                gam(j,:,:)=transpose(reshape(gg2(j,:),[nr nr])*dyssdtheta)*dyssdtheta ...
+                    + tmp1 + tmp1';
+            end
+            for j=1:M_.param_nbr
+                d2yssdtheta(:,:,j) = -gg1\(d2f(:,:,j)+gam(:,:,j));
+            end
+            clear tmp1 gpx gam
         end
     end
-end
-if nargout>5,
-    [df, gp, d2f, gpp, hp] = feval([M_.fname,'_params_derivs'],yy0, oo_.exo_steady_state', ...
-        M_.params, oo_.dr.ys, 1, dyssdtheta, d2yssdtheta);
-    H2ss = d2yssdtheta(oo_.dr.order_var,indx,indx);
-%     nelem=size(g1,2);
-%     g22 = get_all_2nd_derivs(gpp,m,nelem,M_.param_nbr);
-%     g22 = g22(:,:,indx,indx);
-else
-    [df, gp] = feval([M_.fname,'_params_derivs'],yy0, repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1,1]), ...
-        M_.params, oo_.dr.ys, 1, dyssdtheta,d2yssdtheta);
-    [residual, g1, g2 ] = feval([M_.fname,'_dynamic'],yy0, repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1,1]), ...
-        M_.params, oo_.dr.ys, 1);
-end
-
-[nr, nc]=size(g2);
-nc = sqrt(nc);
-Hss = dyssdtheta(oo_.dr.order_var,indx);
-dyssdtheta = dyssdtheta(I,:);
-ns = max(max(M_.lead_lag_incidence)); % retrieve the number of states excluding columns for shocks
-gp2 = gp*0;
-for j=1:nr,
-    [II JJ]=ind2sub([nc nc],find(g2(j,:)));
-    for i=1:nc,
-        is = find(II==i);
-        is = is(find(JJ(is)<=ns));
-        if ~isempty(is),
-            g20=full(g2(j,find(g2(j,:))));
-            gp2(j,i,:)=g20(is)*dyssdtheta(JJ(is),:);
-        end
-    end
-end
-
-gp = gp+gp2;
-gp = gp(:,:,indx);
-
-if nargout>5,
-%     h22 = get_all_hess_derivs(hp,nr,nc,M_.param_nbr);
-    g22 = gpp;
-    gp22 = sparse(nr*nc,param_nbr*param_nbr);
-    tmp1 = reshape(g3,[nr*nc*nc nc]);
-    tmp2=sparse(size(tmp1,1),M_.param_nbr);
-%     tmp2=tmp1*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
-    tmpa=[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
-    tmpa=sparse(tmpa);
-    for j=1:M_.param_nbr,
-        tmp2(:,j)=tmp1*tmpa(:,j);
-    end
-%     tmp2=sparse(tmp2);
-%     [i1 i2]=ind2sub([nc M_.param_nbr],[1:nc*M_.param_nbr]');
-
-    for j=1:nr,
-        tmp0=reshape(g2(j,:),[nc nc]);   
-        tmp0 = tmp0(:,1:ns)*reshape(d2yssdtheta(I,:,:),[ns,M_.param_nbr*M_.param_nbr]);
-        for i=1:nc,
-            indo = sub2ind([nr nc nc], ones(nc,1)*j ,ones(nc,1)*i, (1:nc)');
-            tmpx = (tmp2(indo,:))'*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
-%             gp22(j,i,:,:)=squeeze(tmp1(j,i,:,:))'*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
-            tmpu = (get_hess_deriv(hp,j,i,nc,M_.param_nbr))'*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
-            tmpy = tmpx+tmpu+tmpu'+reshape(tmp0(i,:,:),[M_.param_nbr M_.param_nbr]);
-            tmpy = tmpy + get_2nd_deriv_mat(gpp,j,i,M_.param_nbr);
-            tmpy = tmpy(indx,indx);
-            if any(any(tmpy)),
-                ina = find(triu(tmpy));
-                gp22(sub2ind([nr nc],j,i),ina)=transpose(tmpy(ina));
-%             gp22(j,i,:,:)= reshape(tmpy,[1 1 M_.param_nbr M_.param_nbr]);
 
+    if any(any(isnan(dyssdtheta)))
+        [U,T] = schur(gg1);
+        qz_criterium=options_.qz_criterium;
+        e1 = abs(ordeig(T)) < qz_criterium-1;
+        k = sum(e1);       % Number non stationary variables.
+                           %     n = length(e1)-k;  % Number of stationary variables.
+        [U,T] = ordschur(U,T,e1);
+        T = T(k+1:end,k+1:end);
+        dyssdtheta = -U(:,k+1:end)*(T\U(:,k+1:end)')*df;
+        if nargout>5
+            for j=1:length(indx)
+                d2yssdtheta(:,:,j) = -U(:,k+1:end)*(T\U(:,k+1:end)')*d2f(:,:,j);
             end
         end
-%             gp22(j,:,:,:)=gp22(j,:,:,:)+reshape(tmp0(:,1:ns)*d2yssdtheta(I,:,:),[1 nc M_.param_nbr M_.param_nbr]);
+    end
+    if nargout>5
+        [df, gp, d2f, gpp, hp] = feval([M_.fname,'_params_derivs'],yy0, oo_.exo_steady_state', ...
+                                       M_.params, oo_.dr.ys, 1, dyssdtheta, d2yssdtheta);
+        H2ss = d2yssdtheta(oo_.dr.order_var,indx,indx);
+    else
+        [df, gp] = feval([M_.fname,'_params_derivs'],yy0, repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1,1]), ...
+                         M_.params, oo_.dr.ys, 1, dyssdtheta,d2yssdtheta);
+        [residual, g1, g2 ] = feval([M_.fname,'_dynamic'],yy0, repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1,1]), ...
+                                    M_.params, oo_.dr.ys, 1);
     end
 
-%     g22 = g22+gp22;
-%     g22 = g22(:,:,indx,indx);
-    clear tmp0 tmp1 tmp2 tmpu tmpx tmpy,
+    [nr, nc]=size(g2);
+    nc = sqrt(nc);
+    Hss = dyssdtheta(oo_.dr.order_var,indx);
+    dyssdtheta = dyssdtheta(I,:);
+    ns = max(max(M_.lead_lag_incidence)); % retrieve the number of states excluding columns for shocks
+    gp2 = gp*0;
+    for j=1:nr
+        [II JJ]=ind2sub([nc nc],find(g2(j,:)));
+        for i=1:nc
+            is = find(II==i);
+            is = is(find(JJ(is)<=ns));
+            if ~isempty(is)
+                g20=full(g2(j,find(g2(j,:))));
+                gp2(j,i,:)=g20(is)*dyssdtheta(JJ(is),:);
+            end
+        end
+    end
+
+    gp = gp+gp2;
+    gp = gp(:,:,indx);
+
+    if nargout>5
+        %     h22 = get_all_hess_derivs(hp,nr,nc,M_.param_nbr);
+        g22 = gpp;
+        gp22 = sparse(nr*nc,param_nbr*param_nbr);
+        tmp1 = reshape(g3,[nr*nc*nc nc]);
+        tmp2=sparse(size(tmp1,1),M_.param_nbr);
+        %     tmp2=tmp1*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
+        tmpa=[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
+        tmpa=sparse(tmpa);
+        for j=1:M_.param_nbr
+            tmp2(:,j)=tmp1*tmpa(:,j);
+        end
+        %     tmp2=sparse(tmp2);
+        %     [i1 i2]=ind2sub([nc M_.param_nbr],[1:nc*M_.param_nbr]');
+
+        for j=1:nr
+            tmp0=reshape(g2(j,:),[nc nc]);
+            tmp0 = tmp0(:,1:ns)*reshape(d2yssdtheta(I,:,:),[ns,M_.param_nbr*M_.param_nbr]);
+            for i=1:nc
+                indo = sub2ind([nr nc nc], ones(nc,1)*j ,ones(nc,1)*i, (1:nc)');
+                tmpx = (tmp2(indo,:))'*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
+                %             gp22(j,i,:,:)=squeeze(tmp1(j,i,:,:))'*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
+                tmpu = (get_hess_deriv(hp,j,i,nc,M_.param_nbr))'*[dyssdtheta; zeros(nc-ns,M_.param_nbr)];
+                tmpy = tmpx+tmpu+tmpu'+reshape(tmp0(i,:,:),[M_.param_nbr M_.param_nbr]);
+                tmpy = tmpy + get_2nd_deriv_mat(gpp,j,i,M_.param_nbr);
+                tmpy = tmpy(indx,indx);
+                if any(any(tmpy))
+                    ina = find(triu(tmpy));
+                    gp22(sub2ind([nr nc],j,i),ina)=transpose(tmpy(ina));
+                    %             gp22(j,i,:,:)= reshape(tmpy,[1 1 M_.param_nbr M_.param_nbr]);
+
+                end
+            end
+            %             gp22(j,:,:,:)=gp22(j,:,:,:)+reshape(tmp0(:,1:ns)*d2yssdtheta(I,:,:),[1 nc M_.param_nbr M_.param_nbr]);
+        end
+
+        %     g22 = g22+gp22;
+        %     g22 = g22(:,:,indx,indx);
+        clear tmp0 tmp1 tmp2 tmpu tmpx tmpy
         inx=find(gp22);
         gx22=zeros(length(inx),5);
-        for j=1:length(inx),
+        for j=1:length(inx)
             [i1, i2] = ind2sub(size(gp22),inx(j));
             [ig1, ig2] = ind2sub(size(g1),i1);
             [ip1, ip2] = ind2sub([param_nbr param_nbr],i2);
@@ -292,7 +282,7 @@ if nargout>5,
         g22 = gx22;
         clear gx22 gp22;
 
-end
+    end
 end
 
 
@@ -301,15 +291,14 @@ klen = M_.maximum_endo_lag + M_.maximum_endo_lead + 1;
 k11 = M_.lead_lag_incidence(find([1:klen] ~= M_.maximum_endo_lag+1),:);
 a = g1(:,nonzeros(k11'));
 da = gp(:,nonzeros(k11'),:);
-if nargout > 5,
+if nargout > 5
     indind = ismember(g22(:,2),nonzeros(k11'));
     tmp = g22(indind,:);
     d2a=tmp;
-    for j=1:size(tmp,1),
+    for j=1:size(tmp,1)
         inxinx = find(nonzeros(k11')==tmp(j,2));
         d2a(j,2) = inxinx;
     end
-%     d2a = g22(:,nonzeros(k11'),:,:);
 end
 kstate = oo_.dr.kstate;
 
@@ -319,12 +308,12 @@ Dg1 = zeros(M_.endo_nbr,M_.endo_nbr,param_nbr);
 k1 = find(kstate(:,2) == M_.maximum_endo_lag+2 & kstate(:,3));
 GAM1(:, kstate(k1,1)) = -a(:,kstate(k1,3));
 Dg1(:, kstate(k1,1), :) = -da(:,kstate(k1,3),:);
-if nargout > 5,
+if nargout > 5
     indind = ismember(d2a(:,2),kstate(k1,3));
     tmp = d2a(indind,:);
     tmp(:,end)=-tmp(:,end);
     D2g1 = tmp;
-    for j=1:size(tmp,1),
+    for j=1:size(tmp,1)
         inxinx = (kstate(k1,3)==tmp(j,2));
         D2g1(j,2) = kstate(k1(inxinx),1);
     end
@@ -336,11 +325,11 @@ GAM0 = zeros(M_.endo_nbr,M_.endo_nbr);
 Dg0 = zeros(M_.endo_nbr,M_.endo_nbr,param_nbr);
 GAM0(:,cols_b) = g1(:,cols_j);
 Dg0(:,cols_b,:) = gp(:,cols_j,:);
-if nargout > 5,
+if nargout > 5
     indind = ismember(g22(:,2),cols_j);
     tmp = g22(indind,:);
     D2g0=tmp;
-    for j=1:size(tmp,1),
+    for j=1:size(tmp,1)
         inxinx = (cols_j==tmp(j,2));
         D2g0(j,2) = cols_b(inxinx);
     end
@@ -352,12 +341,12 @@ GAM2 = zeros(M_.endo_nbr,M_.endo_nbr);
 Dg2 = zeros(M_.endo_nbr,M_.endo_nbr,param_nbr);
 GAM2(:, kstate(k2,1)) = -a(:,kstate(k2,4));
 Dg2(:, kstate(k2,1), :) = -da(:,kstate(k2,4),:);
-if nargout > 5,
+if nargout > 5
     indind = ismember(d2a(:,2),kstate(k2,4));
     tmp = d2a(indind,:);
     tmp(:,end)=-tmp(:,end);
     D2g2 = tmp;
-    for j=1:size(tmp,1),
+    for j=1:size(tmp,1)
         inxinx = (kstate(k2,4)==tmp(j,2));
         D2g2(j,2) = kstate(k2(inxinx),1);
     end
@@ -365,13 +354,13 @@ end
 
 GAM3 = -g1(:,length(yy0)+1:end);
 Dg3 = -gp(:,length(yy0)+1:end,:);
-if nargout>5,
+if nargout>5
     cols_ex = [length(yy0)+1:size(g1,2)];
     indind = ismember(g22(:,2),cols_ex);
     tmp = g22(indind,:);
     tmp(:,end)=-tmp(:,end);
     D2g3=tmp;
-    for j=1:size(tmp,1),
+    for j=1:size(tmp,1)
         inxinx = find(cols_ex==tmp(j,2));
         D2g3(j,2) = inxinx;
     end
@@ -380,11 +369,11 @@ end
 
 clear g1 g2 g3 df d2f gpp hp residual gg1 gg2 gp2 dyssdtheta d2yssdtheta
 
-if kronflag==1, % kronecker products
+if kronflag==1 % kronecker products
     Dg0=reshape(Dg0,m^2,param_nbr);
     Dg1=reshape(Dg1,m^2,param_nbr);
     Dg2=reshape(Dg2,m^2,param_nbr);
-    for j=1:param_nbr,
+    for j=1:param_nbr
         Dg3(:,:,j)=Dg3(:,:,j)*M_.Sigma_e;
     end
     Dg3=reshape(Dg3,m*n,param_nbr);
@@ -427,7 +416,7 @@ if kronflag==1, % kronecker products
     H(m*m+1:end,:) = tmpH(Index,:);
 
     Hx = [];
-    if ~isempty(indexo),
+    if ~isempty(indexo)
         dSig = zeros(M_.exo_nbr,M_.exo_nbr);
         dOm = cat(3,zeros(size(dOm,1),size(dOm,1),length(indexo)),dOm);
         for j=1:length(indexo)
@@ -435,7 +424,7 @@ if kronflag==1, % kronecker products
             y = B*dSig*B';
             y = y(nauxe+1:end,nauxe+1:end);
             Hx(:,j) = [zeros((m-nauxe)^2,1); dyn_vech(y)];
-            if nargout>1,
+            if nargout>1
                 dOm(:,:,j) = y;
             end
             dSig(indexo(j),indexo(j)) = 0;
@@ -452,47 +441,47 @@ else % generalized sylvester equation
     c = A;
     elem = zeros(m,m,param_nbr);
     d = elem;
-    for j=1:param_nbr,
+    for j=1:param_nbr
         elem(:,:,j) = (Dg0(:,:,j)-Dg1(:,:,j)*A);
         d(:,:,j) = Dg2(:,:,j)-elem(:,:,j)*A;
     end
     xx=sylvester3(a,b,c,d);
     flag=1;
     icount=0;
-    while flag && icount<4,
+    while flag && icount<4
         [xx, flag]=sylvester3a(xx,a,b,c,d);
         icount=icount+1;
     end
     H=zeros(m1*m1+m1*(m1+1)/2,param_nbr+length(indexo));
-    if nargout>1,
+    if nargout>1
         dOm = zeros(m1,m1,param_nbr+length(indexo));
         dA=zeros(m1,m1,param_nbr+length(indexo));
         dB=zeros(m,n,param_nbr);
     end
-    if ~isempty(indexo),
+    if ~isempty(indexo)
         dSig = zeros(M_.exo_nbr,M_.exo_nbr,length(indexo));
         for j=1:length(indexo)
             dSig(indexo(j),indexo(j),j) = 2*sqrt(M_.Sigma_e(indexo(j),indexo(j)));
             y = B*dSig(:,:,j)*B';
-%             y = y(nauxe+1:end,nauxe+1:end);
-%             H(:,j) = [zeros((m-nauxe)^2,1); dyn_vech(y)];
+            %             y = y(nauxe+1:end,nauxe+1:end);
+            %             H(:,j) = [zeros((m-nauxe)^2,1); dyn_vech(y)];
             H(:,j) = [zeros(m1^2,1); dyn_vech(y(iv,iv))];
-            if nargout>1,
+            if nargout>1
                 dOm(:,:,j) = y(iv,iv);
             end
-%             dSig(indexo(j),indexo(j)) = 0;
+            %             dSig(indexo(j),indexo(j)) = 0;
         end
     end
-    for j=1:param_nbr,
+    for j=1:param_nbr
         x = xx(:,:,j);
         y = inva * (Dg3(:,:,j)-(elem(:,:,j)-GAM1*x)*B);
-        if nargout>1,
+        if nargout>1
             dB(:,:,j) = y;
         end
         y = y*M_.Sigma_e*B'+B*M_.Sigma_e*y';
-%         x = x(nauxe+1:end,nauxe+1:end);
-%         y = y(nauxe+1:end,nauxe+1:end);
-        if nargout>1,
+        %         x = x(nauxe+1:end,nauxe+1:end);
+        %         y = y(nauxe+1:end,nauxe+1:end);
+        if nargout>1
             dA(:,:,j+length(indexo)) = x(iv,iv);
             dOm(:,:,j+length(indexo)) = y(iv,iv);
         end
@@ -515,7 +504,7 @@ else % generalized sylvester equation
 
 end
 
-if nargout > 5,
+if nargout > 5
     H2ss = H2ss(iv,:,:);
     d = zeros(m,m,floor(sqrt(param_nbr_2)));
     %     d2A = zeros(m,m,tot_param_nbr,tot_param_nbr);
@@ -532,9 +521,9 @@ if nargout > 5,
     cumjcount=0;
     jinx = [];
     x2x=sparse(m*m,param_nbr_2);
-%     x2x=[];
-    for i=1:param_nbr,
-        for j=1:i,
+    %     x2x=[];
+    for i=1:param_nbr
+        for j=1:i
             elem1 = (get_2nd_deriv(D2g0,m,m,j,i)-get_2nd_deriv(D2g1,m,m,j,i)*A);
             elem1 = get_2nd_deriv(D2g2,m,m,j,i)-elem1*A;
             elemj0 = Dg0(:,:,j)-Dg1(:,:,j)*A;
@@ -545,24 +534,24 @@ if nargout > 5,
             jcount=jcount+1;
             jinx = [jinx; [j i]];
             d(:,:,jcount) = elem1+elem2;
-            if jcount==floor(sqrt(param_nbr_2)) || (j*i)==param_nbr^2,
-                if (j*i)==param_nbr^2,
+            if jcount==floor(sqrt(param_nbr_2)) || (j*i)==param_nbr^2
+                if (j*i)==param_nbr^2
                     d = d(:,:,1:jcount);
                 end
-%                 d(find(abs(d)<1.e-12))=0;
+                %                 d(find(abs(d)<1.e-12))=0;
                 xx2=sylvester3(a,b,c,d);
                 flag=1;
                 icount=0;
-                while flag && icount<4,
+                while flag && icount<4
                     [xx2, flag]=sylvester3a(xx2,a,b,c,d);
                     icount = icount + 1;
                 end
-%                 inx = find(abs(xx2)>1.e-12);
-%                 xx2(find(abs(xx2)<1.e-12))=0;
+                %                 inx = find(abs(xx2)>1.e-12);
+                %                 xx2(find(abs(xx2)<1.e-12))=0;
                 x2x(:,cumjcount+1:cumjcount+jcount)=reshape(xx2,[m*m jcount]);
                 cumjcount=cumjcount+jcount;
-%                 [i1 i2 i3]=ind2sub(size(xx2),inx);
-%                 x2x = [x2x; [i1 i2 jinx(i3,:) xx2(inx)]];
+                %                 [i1 i2 i3]=ind2sub(size(xx2),inx);
+                %                 x2x = [x2x; [i1 i2 jinx(i3,:) xx2(inx)]];
                 jcount = 0;
                 jinx = [];
             end
@@ -583,27 +572,27 @@ if nargout > 5,
     offset = length(indexo);
     %     d2B = zeros(m,n,tot_param_nbr,tot_param_nbr);
     d2Sig = zeros(M_.exo_nbr,M_.exo_nbr,length(indexo));
-    for j=1:tot_param_nbr,
-        for i=1:j,
+    for j=1:tot_param_nbr
+        for i=1:j
             jcount=jcount+1;
-            if j<=offset,
-                if i==j,
+            if j<=offset
+                if i==j
                     d2Sig(indexo(j),indexo(j),j) = 2;
                     y = B*d2Sig(:,:,j)*B';
-%                     y(abs(y)<1.e-8)=0;
+                    %                     y(abs(y)<1.e-8)=0;
                     d2Om_tmp(:,jcount) = dyn_vech(y(iv,iv));
                 end
             else
                 jind = j-offset;
                 iind = i-offset;
-                if i<=offset,
+                if i<=offset
                     y = dB(:,:,jind)*dSig(:,:,i)*B'+B*dSig(:,:,i)*dB(:,:,jind)';
-%                     y(abs(y)<1.e-8)=0;
+                    %                     y(abs(y)<1.e-8)=0;
                     d2Om_tmp(:,jcount) = dyn_vech(y(iv,iv));
                 else
                     icount=icount+1;
                     x = reshape(x2x(:,icount),[m m]);
-%                     x = get_2nd_deriv(x2x,m,m,iind,jind);%xx2(:,:,jcount);
+                    %                     x = get_2nd_deriv(x2x,m,m,iind,jind);%xx2(:,:,jcount);
                     elem1 = (get_2nd_deriv(D2g0,m,m,iind,jind)-get_2nd_deriv(D2g1,m,m,iind,jind)*A);
                     elem1 = elem1 -( Dg1(:,:,jind)*xx(:,:,iind) + Dg1(:,:,iind)*xx(:,:,jind) );
                     elemj0 = Dg0(:,:,jind)-Dg1(:,:,jind)*A-GAM1*xx(:,:,jind);
@@ -614,13 +603,13 @@ if nargout > 5,
                     %         d2B(:,:,i+length(indexo),j+length(indexo)) = y;
                     y = y*M_.Sigma_e*B'+B*M_.Sigma_e*y'+ ...
                         dB(:,:,jind)*M_.Sigma_e*dB(:,:,iind)'+dB(:,:,iind)*M_.Sigma_e*dB(:,:,jind)';
-%                     x(abs(x)<1.e-8)=0;
+                    %                     x(abs(x)<1.e-8)=0;
                     d2A_tmp(:,jcount) = vec(x(iv,iv));
-%                     y(abs(y)<1.e-8)=0;
+                    %                     y(abs(y)<1.e-8)=0;
                     d2Om_tmp(:,jcount) = dyn_vech(y(iv,iv));
                 end
             end
-            if jcount==ncol || i*j==tot_param_nbr^2,
+            if jcount==ncol || i*j==tot_param_nbr^2
                 d2A(:,cumjcount+1:cumjcount+jcount) = d2A_tmp(:,1:jcount);
                 %         d2A(:,:,j+length(indexo),i+length(indexo)) = x;
                 %         d2A(:,:,i+length(indexo),j+length(indexo)) = x;
@@ -635,7 +624,7 @@ if nargout > 5,
                 %         d2Om = sparse(m1*(m1+1)/2,tot_param_nbr*(tot_param_nbr+1)/2);
                 d2A_tmp = zeros(m1*m1,ncol);
                 d2Om_tmp = zeros(m1*(m1+1)/2,ncol);
-                
+
             end
         end
     end
@@ -643,100 +632,100 @@ end
 
 return
 
-function g22 = get_2nd_deriv(gpp,m,n,i,j),
+function g22 = get_2nd_deriv(gpp,m,n,i,j)
 
 g22=zeros(m,n);
 is=find(gpp(:,3)==i);
 is=is(find(gpp(is,4)==j));
 
-if ~isempty(is),
+if ~isempty(is)
     g22(sub2ind([m,n],gpp(is,1),gpp(is,2)))=gpp(is,5)';
 end
 return
 
-function g22 = get_2nd_deriv_mat(gpp,i,j,n),
+function g22 = get_2nd_deriv_mat(gpp,i,j,n)
 
 g22=zeros(n,n);
 is=find(gpp(:,1)==i);
 is=is(find(gpp(is,2)==j));
 
-if ~isempty(is),
+if ~isempty(is)
     g22(sub2ind([n,n],gpp(is,3),gpp(is,4)))=gpp(is,5)';
     g22(sub2ind([n,n],gpp(is,4),gpp(is,3)))=gpp(is,5)';
 end
 return
 
-function g22 = get_all_2nd_derivs(gpp,m,n,npar,fsparse),
+function g22 = get_all_2nd_derivs(gpp,m,n,npar,fsparse)
 
-if nargin==4 || isempty(fsparse),
+if nargin==4 || isempty(fsparse)
     fsparse=0;
 end
-if fsparse,
+if fsparse
     g22=sparse(m*n,npar*npar);
 else
-g22=zeros(m,n,npar,npar);
+    g22=zeros(m,n,npar,npar);
 end
 % c=ones(npar,npar);
 % c=triu(c);
 % ic=find(c);
 
-for is=1:length(gpp),
-%     d=zeros(npar,npar);
-%     d(gpp(is,3),gpp(is,4))=1;
-%     indx = find(ic==find(d));
-    if fsparse,
+for is=1:length(gpp)
+    %     d=zeros(npar,npar);
+    %     d(gpp(is,3),gpp(is,4))=1;
+    %     indx = find(ic==find(d));
+    if fsparse
         g22(sub2ind([m,n],gpp(is,1),gpp(is,2)),sub2ind([npar,npar],gpp(is,3),gpp(is,4)))=gpp(is,5);
         g22(sub2ind([m,n],gpp(is,1),gpp(is,2)),sub2ind([npar,npar],gpp(is,4),gpp(is,3)))=gpp(is,5);
     else
-    g22(gpp(is,1),gpp(is,2),gpp(is,3),gpp(is,4))=gpp(is,5);
-    g22(gpp(is,1),gpp(is,2),gpp(is,4),gpp(is,3))=gpp(is,5);
-end
+        g22(gpp(is,1),gpp(is,2),gpp(is,3),gpp(is,4))=gpp(is,5);
+        g22(gpp(is,1),gpp(is,2),gpp(is,4),gpp(is,3))=gpp(is,5);
+    end
 end
 
 return
 
-function r22 = get_all_resid_2nd_derivs(rpp,m,npar),
+function r22 = get_all_resid_2nd_derivs(rpp,m,npar)
 
 r22=zeros(m,npar,npar);
 % c=ones(npar,npar);
 % c=triu(c);
 % ic=find(c);
 
-for is=1:length(rpp),
-%     d=zeros(npar,npar);
-%     d(rpp(is,2),rpp(is,3))=1;
-%     indx = find(ic==find(d));
+for is=1:length(rpp)
+    %     d=zeros(npar,npar);
+    %     d(rpp(is,2),rpp(is,3))=1;
+    %     indx = find(ic==find(d));
     r22(rpp(is,1),rpp(is,2),rpp(is,3))=rpp(is,4);
     r22(rpp(is,1),rpp(is,3),rpp(is,2))=rpp(is,4);
 end
 
 return
 
-function h2 = get_all_hess_derivs(hp,r,m,npar),
+function h2 = get_all_hess_derivs(hp,r,m,npar)
 
 h2=zeros(r,m,m,npar);
 
-for is=1:length(hp),
+for is=1:length(hp)
     h2(hp(is,1),hp(is,2),hp(is,3),hp(is,4))=hp(is,5);
     h2(hp(is,1),hp(is,3),hp(is,2),hp(is,4))=hp(is,5);
 end
 
 return
 
-function h2 = get_hess_deriv(hp,i,j,m,npar),
+function h2 = get_hess_deriv(hp,i,j,m,npar)
 
 h2=zeros(m,npar);
 is1=find(hp(:,1)==i);
 is=is1(find(hp(is1,2)==j));
 
-if ~isempty(is),
+if ~isempty(is)
     h2(sub2ind([m,npar],hp(is,3),hp(is,4)))=hp(is,5)';
 end
 
 is=is1(find(hp(is1,3)==j));
 
-if ~isempty(is),
+if ~isempty(is)
     h2(sub2ind([m,npar],hp(is,2),hp(is,4)))=hp(is,5)';
 end
 
-return
+return
\ No newline at end of file
diff --git a/matlab/getIrfShocksIndx.m b/matlab/getIrfShocksIndx.m
index 737bfcfb1..788d58cd1 100644
--- a/matlab/getIrfShocksIndx.m
+++ b/matlab/getIrfShocksIndx.m
@@ -8,7 +8,7 @@ function irf_shocks_indx=getIrfShocksIndx()
 % Outputs:
 %   irf_shocks_indx: [1 by n_irf_shocks] vector storing the indices
 %
-% Copyright (C) 2011-13 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,7 +34,7 @@ else
     for i=1:size(options_.irf_shocks,1)
         irf_shocks_indx(i) = find(strcmp(deblank(options_.irf_shocks(i,:)), cellstr(M_.exo_names)));
     end
-    irf_shocks_indx_unique=unique(irf_shocks_indx);    
+    irf_shocks_indx_unique=unique(irf_shocks_indx);
     if options_.debug && (length(irf_shocks_indx_unique) ~= length(irf_shocks_indx))
         fprintf('\nSTOCH_SIMUL: Warning: The IRFs for some shocks have been requested twice.\n')
         fprintf('STOCH_SIMUL: The redundant entries will be ignored.\n')
diff --git a/matlab/getJJ.m b/matlab/getJJ.m
index b7686a035..7f934b81a 100644
--- a/matlab/getJJ.m
+++ b/matlab/getJJ.m
@@ -2,7 +2,7 @@ function [JJ, H, gam, gp, dA, dOm, dYss] = getJJ(A, B, estim_params_, M_,oo_,opt
 % function [JJ, H, gam, gp, dA, dOm, dYss] = getJJ(A, B, estim_params_, M_,oo_,options_,kronflag,indx,indexo,mf,nlags,useautocorr)
 % computes derivatives of 1st and 2nd order moments of observables with
 % respect to estimated parameters
-% 
+%
 % Inputs:
 %   A:              Transition matrix of lagged states from Kalman filter
 %   B:              Matrix in state transition equation mapping shocks today to
@@ -19,25 +19,25 @@ function [JJ, H, gam, gp, dA, dOm, dYss] = getJJ(A, B, estim_params_, M_,oo_,opt
 %                   correlations
 %   useautocorr:    Indicator on whether to use correlations (1) instead of
 %                   covariances (0)
-% 
+%
 % Outputs:
-%   JJ:             Jacobian of 1st and 2nd order moments of observables, i.e.  dgam/dTHETA 
+%   JJ:             Jacobian of 1st and 2nd order moments of observables, i.e.  dgam/dTHETA
 %                   (see below for definition of gam)
 %   H:              dTAU/dTHETA: Jacobian of TAU, vectorized form of
 %                   linearized reduced form state space model, given ys [steady state],
 %                   A [transition matrix], B [matrix of shocks], Sigma [covariance of shocks]
 %                   TAU = [ys; vec(A); dyn_vech(B*Sigma*B')].
-%   gam:            vector of theoretical moments of observed variables mf [JJ is the Jacobian of gam]. 
-%                   gam = [ys(mf); dyn_vech(GAM{1}); vec(GAM{j+1})]; for j=1:ar and where 
+%   gam:            vector of theoretical moments of observed variables mf [JJ is the Jacobian of gam].
+%                   gam = [ys(mf); dyn_vech(GAM{1}); vec(GAM{j+1})]; for j=1:ar and where
 %                   GAM is the first output of th_autocovariances
 %   gp:             Jacobian of linear rational expectation matrices [i.e.
 %                   Jacobian of dynamic model] with respect to estimated
 %                   structural parameters only (indx)
-%   dA:             [endo_nbr by endo_nbr by (indx+indexo)] Jacobian of transition matrix A           
+%   dA:             [endo_nbr by endo_nbr by (indx+indexo)] Jacobian of transition matrix A
 %   dOm:            Jacobian of Omega = (B*Sigma*B')
 %   dYss            Jacobian of steady state with respect to estimated structural parameters only (indx)
 
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,22 +55,22 @@ function [JJ, H, gam, gp, dA, dOm, dYss] = getJJ(A, B, estim_params_, M_,oo_,opt
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 if nargin<8 || isempty(indx)
-%     indx = [1:M_.param_nbr];
-end,
+    %     indx = [1:M_.param_nbr];
+end
 if nargin<9 || isempty(indexo)
     indexo = [];
-end,
+end
 if nargin<11 || isempty(nlags)
-    nlags=3; 
+    nlags=3;
 end
 if nargin<12 || isempty(useautocorr)
-    useautocorr=0; 
+    useautocorr=0;
 end
 
 %   if useautocorr,
 warning('off','MATLAB:divideByZero')
 %   end
-if kronflag == -1,
+if kronflag == -1
     fun = 'thet2tau';
     params0 = M_.params;
     para0 = get_all_parameters(estim_params_, M_);
@@ -87,7 +87,7 @@ if kronflag == -1,
     dYss = H(1:M_.endo_nbr,offset+1:end);
     dA = reshape(H(M_.orig_endo_nbr+[1:numel(A)],:),[size(A),size(H,2)]);
     dOm = dA*0;
-    for j=1:size(H,2),
+    for j=1:size(H,2)
         dOm(:,:,j) = dyn_unvech(H(M_.endo_nbr+numel(A)+1:end,j));
     end
     assignin('base','M_', M_);
@@ -109,13 +109,13 @@ else
     sdy = sqrt(diag(GAM));
     sy = sdy*sdy';
     %   end
-    
+
     %   BB = dOm*0;
     %   for j=1:length(indx),
     %     BB(:,:,j)= dA(:,:,j)*GAM*A'+A*GAM*dA(:,:,j)'+dOm(:,:,j);
     %   end
     %   XX =  lyapunov_symm_mr(A,BB,options_.qz_criterium,options_.lyapunov_complex_threshold,0);
-    for j=1:length(indexo),
+    for j=1:length(indexo)
         dum =  lyapunov_symm(A,dOm(:,:,j),options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold,2,options_.debug);
         %     dum =  XX(:,:,j);
         k = find(abs(dum) < 1e-12);
@@ -130,7 +130,7 @@ else
         else
             dumm = dyn_vech(dum(mf,mf));
         end
-        for i=1:nlags,
+        for i=1:nlags
             dum1 = A^i*dum;
             if useautocorr
                 dum1 = (dum1.*sy-dsy.*(A^i*GAM))./(sy.*sy);
@@ -140,7 +140,7 @@ else
         JJ(:,j) = dumm;
     end
     nexo = length(indexo);
-    for j=1:length(indx),
+    for j=1:length(indx)
         dum =  lyapunov_symm(A,dA(:,:,j+nexo)*GAM*A'+A*GAM*dA(:,:,j+nexo)'+dOm(:,:,j+nexo),options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold,2,options_.debug);
         %     dum =  XX(:,:,j);
         k = find(abs(dum) < 1e-12);
@@ -155,9 +155,9 @@ else
         else
             dumm = dyn_vech(dum(mf,mf));
         end
-        for i=1:nlags,
+        for i=1:nlags
             dum1 = A^i*dum;
-            for ii=1:i,
+            for ii=1:i
                 dum1 = dum1 + A^(ii-1)*dA(:,:,j+nexo)*A^(i-ii)*GAM;
             end
             if useautocorr
@@ -167,27 +167,27 @@ else
         end
         JJ(:,j+nexo) = dumm;
     end
-    
+
     JJ = [ [zeros(length(mf),nexo) dYss(mf,:)]; JJ];
-    
+
 end
-if nargout >2,
+if nargout >2
     %     sy=sy(mf,mf);
     options_.ar=nlags;
     nodecomposition = 1;
     [GAM,stationary_vars] = th_autocovariances(oo_.dr,oo_.dr.order_var(mf),M_,options_,nodecomposition);
     sy=sqrt(diag(GAM{1}));
     sy=sy*sy';
-    if useautocorr,
+    if useautocorr
         sy=sy-diag(diag(sy))+eye(length(mf));
         GAM{1}=GAM{1}./sy;
     else
-        for j=1:nlags,
+        for j=1:nlags
             GAM{j+1}=GAM{j+1}.*sy;
         end
     end
     gam = dyn_vech(GAM{1});
-    for j=1:nlags,
+    for j=1:nlags
         gam = [gam; vec(GAM{j+1})];
     end
 end
diff --git a/matlab/get_Hessian.m b/matlab/get_Hessian.m
index a42b3c812..fe74848dd 100644
--- a/matlab/get_Hessian.m
+++ b/matlab/get_Hessian.m
@@ -10,7 +10,7 @@ function [Hess] = get_Hessian(T,R,Q,H,P,Y,DT,DYss,DOm,DH,DP,D2T,D2Yss,D2Om,D2H,D
 % NOTE: the derivative matrices (D2T,D2Om ...) are 4-dim. arrays with last
 % two dimensions equal to the number of structural parameters
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,146 +28,146 @@ function [Hess] = get_Hessian(T,R,Q,H,P,Y,DT,DYss,DOm,DH,DP,D2T,D2Yss,D2Om,D2H,D
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-    k = size(DT,3);                                 % number of structural parameters
-    smpl = size(Y,2);                               % Sample size.
-    pp   = size(Y,1);                               % Maximum number of observed variables.
-    mm   = size(T,2);                               % Number of state variables.
-    a    = zeros(mm,1);                             % State vector.
-    Om   = R*Q*transpose(R);                        % Variance of R times the vector of structural innovations.
-    t    = 0;                                       % Initialization of the time index.
-    oldK = 0;
-    notsteady   = 1;                                % Steady state flag.
-    F_singular  = 1;
+k = size(DT,3);                                 % number of structural parameters
+smpl = size(Y,2);                               % Sample size.
+pp   = size(Y,1);                               % Maximum number of observed variables.
+mm   = size(T,2);                               % Number of state variables.
+a    = zeros(mm,1);                             % State vector.
+Om   = R*Q*transpose(R);                        % Variance of R times the vector of structural innovations.
+t    = 0;                                       % Initialization of the time index.
+oldK = 0;
+notsteady   = 1;                                % Steady state flag.
+F_singular  = 1;
 
-    Hess  = zeros(k,k);                             % Initialization of the Hessian
-    Da    = zeros(mm,k);                             % State vector.
-    Dv = zeros(length(mf),k);
-    D2a    = zeros(mm,k,k);                             % State vector.
-    D2v = zeros(length(mf),k,k);
+Hess  = zeros(k,k);                             % Initialization of the Hessian
+Da    = zeros(mm,k);                             % State vector.
+Dv = zeros(length(mf),k);
+D2a    = zeros(mm,k,k);                             % State vector.
+D2v = zeros(length(mf),k,k);
+
+C = zeros(length(mf),mm);
+for ii=1:length(mf); C(ii,mf(ii))=1;end         % SELECTION MATRIX IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
+dC = zeros(length(mf),mm,k);
+d2C = zeros(length(mf),mm,k,k);
+
+s   = zeros(pp,1);                      % CONSTANT TERM IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
+ds  = zeros(pp,1,k);
+d2s = zeros(pp,1,k,k);
 
-    C = zeros(length(mf),mm);
-    for ii=1:length(mf); C(ii,mf(ii))=1;end         % SELECTION MATRIX IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
-    dC = zeros(length(mf),mm,k);
-    d2C = zeros(length(mf),mm,k,k);
-    
-    s   = zeros(pp,1);                      % CONSTANT TERM IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
-    ds  = zeros(pp,1,k);
-    d2s = zeros(pp,1,k,k);
-    
 %     for ii = 1:k
-%         DOm = DR(:,:,ii)*Q*transpose(R) + R*DQ(:,:,ii)*transpose(R) + R*Q*transpose(DR(:,:,ii)); 
+%         DOm = DR(:,:,ii)*Q*transpose(R) + R*DQ(:,:,ii)*transpose(R) + R*Q*transpose(DR(:,:,ii));
 %     end
-    
-    while notsteady & t<smpl
-        t  = t+1;
-        v  = Y(:,t)-a(mf);
-        F  = P(mf,mf) + H;
-        if rcond(F) < kalman_tol
-            if ~all(abs(F(:))<kalman_tol)
-                return
-            else
-                a = T*a;
-                P = T*P*transpose(T)+Om;
-            end
+
+while notsteady & t<smpl
+    t  = t+1;
+    v  = Y(:,t)-a(mf);
+    F  = P(mf,mf) + H;
+    if rcond(F) < kalman_tol
+        if ~all(abs(F(:))<kalman_tol)
+            return
         else
-            F_singular = 0;
-            iF     = inv(F);
-            K      = P(:,mf)*iF;
-
-            [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K);
-            [D2K,D2F,D2P1] = computeD2Kalman(T,DT,D2T,D2Om,P,DP,D2P,DH,mf,iF,K,DK);
-            tmp = (a+K*v);
-
-    for ii = 1:k
-        Dv(:,ii)   = -Da(mf,ii) - DYss(mf,ii);
-      %  dai = da(:,:,ii);
-        dKi  = DK(:,:,ii);
-        diFi = -iF*DF(:,:,ii)*iF;
-        dtmpi = Da(:,ii)+dKi*v+K*Dv(:,ii);
-            
-        
-        for jj = 1:ii
-            dFj    = DF(:,:,jj);
-            diFj   = -iF*DF(:,:,jj)*iF;
-            dKj  = DK(:,:,jj);
-            d2Kij  = D2K(:,:,jj,ii);
-            d2Fij  = D2F(:,:,jj,ii);
-            d2iFij = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
-            dtmpj = Da(:,jj)+dKj*v+K*Dv(:,jj);
-
-            d2vij  = -D2Yss(mf,jj,ii)  - D2a(mf,jj,ii); 
-            d2tmpij = D2a(:,jj,ii) + d2Kij*v + dKj*Dv(:,ii) + dKi*Dv(:,jj) + K*d2vij;
-            D2a(:,jj,ii) = D2T(:,:,jj,ii)*tmp + DT(:,:,jj)*dtmpi + DT(:,:,ii)*dtmpj + T*d2tmpij;            
-
-            Hesst(ii,jj) = getHesst_ij(v,Dv(:,ii),Dv(:,jj),d2vij,iF,diFi,diFj,d2iFij,dFj,d2Fij);
+            a = T*a;
+            P = T*P*transpose(T)+Om;
         end
-        Da(:,ii)   = DT(:,:,ii)*tmp + T*dtmpi;
-    end
-%                     vecDPmf = reshape(DP(mf,mf,:),[],k);
-%                     iPmf = inv(P(mf,mf));
-                    if t>=start
-                        Hess = Hess + Hesst;
-                    end
-            a      = T*(a+K*v);                   
-            P      = T*(P-K*P(mf,:))*transpose(T)+Om;
-            DP     = DP1;
-            D2P     = D2P1;
-        end
-        notsteady = max(max(abs(K-oldK))) > riccati_tol;
-        oldK = K;
-    end
+    else
+        F_singular = 0;
+        iF     = inv(F);
+        K      = P(:,mf)*iF;
 
-    if F_singular
-        error('The variance of the forecast error remains singular until the end of the sample')
-    end
+        [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K);
+        [D2K,D2F,D2P1] = computeD2Kalman(T,DT,D2T,D2Om,P,DP,D2P,DH,mf,iF,K,DK);
+        tmp = (a+K*v);
 
-    
-    if t < smpl
-        t0 = t+1;
-        while t < smpl
-            t = t+1;
-            v = Y(:,t)-a(mf);
-            tmp = (a+K*v);
-            for ii = 1:k,
-                Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
-                dKi  = DK(:,:,ii);
-                diFi = -iF*DF(:,:,ii)*iF;
-                dtmpi = Da(:,ii)+dKi*v+K*Dv(:,ii);
-                
-                for jj = 1:ii,
-                    dFj    = DF(:,:,jj);
-                    diFj   = -iF*DF(:,:,jj)*iF;
-                    dKj  = DK(:,:,jj);
-                    d2Kij  = D2K(:,:,jj,ii);
-                    d2Fij  = D2F(:,:,jj,ii);
-                    d2iFij = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
-                    dtmpj = Da(:,jj)+dKj*v+K*Dv(:,jj);
-                    
-                    d2vij  = -D2Yss(mf,jj,ii)  - D2a(mf,jj,ii);
-                    d2tmpij = D2a(:,jj,ii) + d2Kij*v + dKj*Dv(:,ii) + dKi*Dv(:,jj) + K*d2vij;
-                    D2a(:,jj,ii) = D2T(:,:,jj,ii)*tmp + DT(:,:,jj)*dtmpi + DT(:,:,ii)*dtmpj + T*d2tmpij;            
-                    
-                    Hesst(ii,jj) = getHesst_ij(v,Dv(:,ii),Dv(:,jj),d2vij,iF,diFi,diFj,d2iFij,dFj,d2Fij);
-                end
-                Da(:,ii)   = DT(:,:,ii)*tmp + T*dtmpi;
+        for ii = 1:k
+            Dv(:,ii)   = -Da(mf,ii) - DYss(mf,ii);
+            %  dai = da(:,:,ii);
+            dKi  = DK(:,:,ii);
+            diFi = -iF*DF(:,:,ii)*iF;
+            dtmpi = Da(:,ii)+dKi*v+K*Dv(:,ii);
+
+
+            for jj = 1:ii
+                dFj    = DF(:,:,jj);
+                diFj   = -iF*DF(:,:,jj)*iF;
+                dKj  = DK(:,:,jj);
+                d2Kij  = D2K(:,:,jj,ii);
+                d2Fij  = D2F(:,:,jj,ii);
+                d2iFij = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
+                dtmpj = Da(:,jj)+dKj*v+K*Dv(:,jj);
+
+                d2vij  = -D2Yss(mf,jj,ii)  - D2a(mf,jj,ii);
+                d2tmpij = D2a(:,jj,ii) + d2Kij*v + dKj*Dv(:,ii) + dKi*Dv(:,jj) + K*d2vij;
+                D2a(:,jj,ii) = D2T(:,:,jj,ii)*tmp + DT(:,:,jj)*dtmpi + DT(:,:,ii)*dtmpj + T*d2tmpij;
+
+                Hesst(ii,jj) = getHesst_ij(v,Dv(:,ii),Dv(:,jj),d2vij,iF,diFi,diFj,d2iFij,dFj,d2Fij);
             end
-            if t>=start
-                Hess = Hess + Hesst;
-            end
-            a = T*(a+K*v);
+            Da(:,ii)   = DT(:,:,ii)*tmp + T*dtmpi;
         end
-%         Hess = Hess + .5*(smpl+t0-1)*(vecDPmf' * kron(iPmf,iPmf) * vecDPmf);
-        %         for ii = 1:k;
-        %             for jj = 1:ii
-        %              H(ii,jj) = trace(iPmf*(.5*DP(mf,mf,ii)*iPmf*DP(mf,mf,jj) + Dv(:,ii)*Dv(:,jj)'));
-        %             end
-        %         end
+        %                     vecDPmf = reshape(DP(mf,mf,:),[],k);
+        %                     iPmf = inv(P(mf,mf));
+        if t>=start
+            Hess = Hess + Hesst;
+        end
+        a      = T*(a+K*v);
+        P      = T*(P-K*P(mf,:))*transpose(T)+Om;
+        DP     = DP1;
+        D2P     = D2P1;
     end
-    
+    notsteady = max(max(abs(K-oldK))) > riccati_tol;
+    oldK = K;
+end
+
+if F_singular
+    error('The variance of the forecast error remains singular until the end of the sample')
+end
+
+
+if t < smpl
+    t0 = t+1;
+    while t < smpl
+        t = t+1;
+        v = Y(:,t)-a(mf);
+        tmp = (a+K*v);
+        for ii = 1:k
+            Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
+            dKi  = DK(:,:,ii);
+            diFi = -iF*DF(:,:,ii)*iF;
+            dtmpi = Da(:,ii)+dKi*v+K*Dv(:,ii);
+
+            for jj = 1:ii
+                dFj    = DF(:,:,jj);
+                diFj   = -iF*DF(:,:,jj)*iF;
+                dKj  = DK(:,:,jj);
+                d2Kij  = D2K(:,:,jj,ii);
+                d2Fij  = D2F(:,:,jj,ii);
+                d2iFij = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
+                dtmpj = Da(:,jj)+dKj*v+K*Dv(:,jj);
+
+                d2vij  = -D2Yss(mf,jj,ii)  - D2a(mf,jj,ii);
+                d2tmpij = D2a(:,jj,ii) + d2Kij*v + dKj*Dv(:,ii) + dKi*Dv(:,jj) + K*d2vij;
+                D2a(:,jj,ii) = D2T(:,:,jj,ii)*tmp + DT(:,:,jj)*dtmpi + DT(:,:,ii)*dtmpj + T*d2tmpij;
+
+                Hesst(ii,jj) = getHesst_ij(v,Dv(:,ii),Dv(:,jj),d2vij,iF,diFi,diFj,d2iFij,dFj,d2Fij);
+            end
+            Da(:,ii)   = DT(:,:,ii)*tmp + T*dtmpi;
+        end
+        if t>=start
+            Hess = Hess + Hesst;
+        end
+        a = T*(a+K*v);
+    end
+    %         Hess = Hess + .5*(smpl+t0-1)*(vecDPmf' * kron(iPmf,iPmf) * vecDPmf);
+    %         for ii = 1:k;
+    %             for jj = 1:ii
+    %              H(ii,jj) = trace(iPmf*(.5*DP(mf,mf,ii)*iPmf*DP(mf,mf,jj) + Dv(:,ii)*Dv(:,jj)'));
+    %             end
+    %         end
+end
+
 Hess = Hess + tril(Hess,-1)';
 
-Hess = -Hess/2;  
-% end of main function    
+Hess = -Hess/2;
+% end of main function
 
 function Hesst_ij = getHesst_ij(e,dei,dej,d2eij,iS,diSi,diSj,d2iSij,dSj,d2Sij);
 % computes (i,j) term in the Hessian
@@ -178,11 +178,11 @@ Hesst_ij = trace(diSi*dSj + iS*d2Sij) + e'*d2iSij*e + 2*(dei'*diSj*e + dei'*iS*d
 
 function [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K)
 
-            k      = size(DT,3);
-            tmp    = P-K*P(mf,:);
+k      = size(DT,3);
+tmp    = P-K*P(mf,:);
 
 for ii = 1:k
-    DF(:,:,ii)  = DP(mf,mf,ii) + DH(:,:,ii); 
+    DF(:,:,ii)  = DP(mf,mf,ii) + DH(:,:,ii);
     DiF(:,:,ii) = -iF*DF(:,:,ii)*iF;
     DK(:,:,ii)  = DP(:,mf,ii)*iF + P(:,mf)*DiF(:,:,ii);
     Dtmp        = DP(:,:,ii) - DK(:,:,ii)*P(mf,:) - K*DP(mf,:,ii);
@@ -191,12 +191,12 @@ end
 
 % end of computeDKalman
 
-function [d2K,d2S,d2P1] = computeD2Kalman(A,dA,d2A,d2Om,P0,dP0,d2P0,DH,mf,iF,K0,dK0);
+function [d2K,d2S,d2P1] = computeD2Kalman(A,dA,d2A,d2Om,P0,dP0,d2P0,DH,mf,iF,K0,dK0)
 % computes the second derivatives of the Kalman matrices
 % note: A=T in main func.
-        
-            k      = size(dA,3);
-            tmp    = P0-K0*P0(mf,:);
+
+k      = size(dA,3);
+tmp    = P0-K0*P0(mf,:);
 [ns,no] = size(K0);
 
 % CPC = C*P0*C'; CPC = .5*(CPC+CPC');iF = inv(CPC);
@@ -225,34 +225,31 @@ for ii = 1:k
         d2Aij = d2A(:,:,jj,ii);
         d2Pij = d2P0(:,:,jj,ii);
         d2Omij = d2Om(:,:,jj,ii);
-       
-    % second order
-    
-    d2Fij = d2Pij(mf,mf) ;
-    
-%     d2APC = d2Aij*P0*C' + A*d2Pij*C' + A*P0*d2Cij' + dAi*dPj*C' + dAj*dPi*C' + A*dPj*dCi' + A*dPi*dCj' + dAi*P0*dCj' + dAj*P0*dCi';
-    d2APC = d2Pij(:,mf);
-    
-    d2iF = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
-    
-    d2Kij= d2Pij(:,mf)*iF + P0(:,mf)*d2iF + dP0(:,mf,jj)*diFi + dP0(:,mf,ii)*diFj;
-        
-    d2KCP = d2Kij*P0(mf,:) + K0*d2Pij(mf,:) + dKi*dP0(mf,:,jj) + dKj*dP0(mf,:,ii) ;
-    
-    dtmpi        = dP0(:,:,ii) - dK0(:,:,ii)*P0(mf,:) - K0*dP0(mf,:,ii);
-    dtmpj        = dP0(:,:,jj) - dK0(:,:,jj)*P0(mf,:) - K0*dP0(mf,:,jj);
-    d2tmp = d2Pij - d2KCP;
 
-    d2AtmpA = d2Aij*tmp*A' + A*d2tmp*A' + A*tmp*d2Aij' + dAi*dtmpj*A' + dAj*dtmpi*A' + A*dtmpj*dAi' + A*dtmpi*dAj' + dAi*tmp*dAj' + dAj*tmp*dAi';
+        % second order
 
-    d2K(:,:,ii,jj)  = d2Kij; %#ok<NASGU>
-    d2P1(:,:,ii,jj) = d2AtmpA  + d2Omij;  %#ok<*NASGU>
-    d2S(:,:,ii,jj)  = d2Fij;
-%     d2iS(:,:,ii,jj) = d2iF;
+        d2Fij = d2Pij(mf,mf) ;
+
+        %     d2APC = d2Aij*P0*C' + A*d2Pij*C' + A*P0*d2Cij' + dAi*dPj*C' + dAj*dPi*C' + A*dPj*dCi' + A*dPi*dCj' + dAi*P0*dCj' + dAj*P0*dCi';
+        d2APC = d2Pij(:,mf);
+
+        d2iF = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
+
+        d2Kij= d2Pij(:,mf)*iF + P0(:,mf)*d2iF + dP0(:,mf,jj)*diFi + dP0(:,mf,ii)*diFj;
+
+        d2KCP = d2Kij*P0(mf,:) + K0*d2Pij(mf,:) + dKi*dP0(mf,:,jj) + dKj*dP0(mf,:,ii) ;
+
+        dtmpi        = dP0(:,:,ii) - dK0(:,:,ii)*P0(mf,:) - K0*dP0(mf,:,ii);
+        dtmpj        = dP0(:,:,jj) - dK0(:,:,jj)*P0(mf,:) - K0*dP0(mf,:,jj);
+        d2tmp = d2Pij - d2KCP;
+
+        d2AtmpA = d2Aij*tmp*A' + A*d2tmp*A' + A*tmp*d2Aij' + dAi*dtmpj*A' + dAj*dtmpi*A' + A*dtmpj*dAi' + A*dtmpi*dAj' + dAi*tmp*dAj' + dAj*tmp*dAi';
+
+        d2K(:,:,ii,jj)  = d2Kij; %#ok<NASGU>
+        d2P1(:,:,ii,jj) = d2AtmpA  + d2Omij;  %#ok<*NASGU>
+        d2S(:,:,ii,jj)  = d2Fij;
+        %     d2iS(:,:,ii,jj) = d2iF;
     end
 end
 
 % end of computeD2Kalman
-
-
-            
\ No newline at end of file
diff --git a/matlab/get_all_parameters.m b/matlab/get_all_parameters.m
index f92415770..289b6a679 100644
--- a/matlab/get_all_parameters.m
+++ b/matlab/get_all_parameters.m
@@ -4,18 +4,18 @@ function xparam1=get_all_parameters(estim_params_,M_)
 % gets parameters values from M_.params into xparam1 (inverse mapping to set_all_parameters)
 % This is called if a model was calibrated before estimation to back out
 % parameter values
-% 
+%
 % INPUTS
-%	 estim_params_:  Dynare structure describing the estimated parameters.
-%    M_:             Dynare structure describing the model. 
+%        estim_params_:  Dynare structure describing the estimated parameters.
+%    M_:             Dynare structure describing the model.
 %
 % OUTPUTS
 %    xparam1:       N*1 double vector of parameters from calibrated model that are to be estimated
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -100,5 +100,5 @@ offset = nvx+ncx+nvn+ncn;
 
 % structural parameters
 if np
-     xparam1(offset+1:end)=M_.params(estim_params_.param_vals(:,1));
+    xparam1(offset+1:end)=M_.params(estim_params_.param_vals(:,1));
 end
\ No newline at end of file
diff --git a/matlab/get_dynare_random_generator_state.m b/matlab/get_dynare_random_generator_state.m
index 513919c22..b2789b054 100644
--- a/matlab/get_dynare_random_generator_state.m
+++ b/matlab/get_dynare_random_generator_state.m
@@ -1,12 +1,12 @@
 function [state_u,state_n] = get_dynare_random_generator_state()
 % Get state of Matlab/Octave random generator depending on matlab
-% (octave) version. 
+% (octave) version.
 % In older versions, Matlab kept one generator for uniformly distributed numbers and
-% one for normally distributed numbers. 
+% one for normally distributed numbers.
 % For backward compatibility, we return two vectors, but, in recent
 % versions of Matlab and in Octave, we return two identical vectors.
 
-% Copyright (C) 2010-2013 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,22 +23,22 @@ function [state_u,state_n] = get_dynare_random_generator_state()
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    matlab_random_streams = ~(isoctave || matlab_ver_less_than('7.7'));
+matlab_random_streams = ~(isoctave || matlab_ver_less_than('7.7'));
 
-    if matlab_random_streams% Use new matlab interface.
-        if matlab_ver_less_than('7.12')
-            s = RandStream.getDefaultStream();
-        else
-            s = RandStream.getGlobalStream();
-        end
-        if isequal(s.Type,'legacy')
-            state_u = rand('state');
-            state_n = randn('state');
-        else            
-            state_u = s.State;
-            state_n = state_u;
-        end
-    else% Use old matlab interface.
+if matlab_random_streams% Use new matlab interface.
+    if matlab_ver_less_than('7.12')
+        s = RandStream.getDefaultStream();
+    else
+        s = RandStream.getGlobalStream();
+    end
+    if isequal(s.Type,'legacy')
         state_u = rand('state');
         state_n = randn('state');
-    end
\ No newline at end of file
+    else
+        state_u = s.State;
+        state_n = state_u;
+    end
+else% Use old matlab interface.
+    state_u = rand('state');
+    state_n = randn('state');
+end
\ No newline at end of file
diff --git a/matlab/get_file_extension.m b/matlab/get_file_extension.m
index d922b36ac..dad9ee0ac 100644
--- a/matlab/get_file_extension.m
+++ b/matlab/get_file_extension.m
@@ -2,16 +2,16 @@ function ext = get_file_extension(file)
 
 % returns the extension of a file.
 %
-% INPUTS 
+% INPUTS
 %  o file      string, name of the file
 %
-% OUTPUTS 
+% OUTPUTS
 %  o ext       string, extension.
 %
-% REMARKS 
+% REMARKS
 %  If the provided file name has no extension, the routine will return an empty array.
-    
-% Copyright (C) 2013-2015 Dynare Team
+
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/get_moments_size.m b/matlab/get_moments_size.m
index aa8087c02..6515c39b8 100644
--- a/matlab/get_moments_size.m
+++ b/matlab/get_moments_size.m
@@ -4,14 +4,14 @@ function s=get_moments_size(options)
 %
 % INPUTS
 %    options: structure of Dynare options
-%    
+%
 % OUTPUTS
 %    s: size of moments for a given model and options
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2011 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/get_name_of_the_last_mh_file.m b/matlab/get_name_of_the_last_mh_file.m
index 763435125..e6732a2ef 100644
--- a/matlab/get_name_of_the_last_mh_file.m
+++ b/matlab/get_name_of_the_last_mh_file.m
@@ -1,17 +1,17 @@
 function [mhname,info] = get_name_of_the_last_mh_file(M_)
 % This function returns the name of the last mh file and test if the metropolis was completed.
 %
-% INPUTS 
-%   M_       [structure]   Dynare structure specifying the model.     
+% INPUTS
+%   M_       [structure]   Dynare structure specifying the model.
 %
-% OUTPUTS 
-%  mhname    [string]      Name of the last mh file (with complete path).  
+% OUTPUTS
+%  mhname    [string]      Name of the last mh file (with complete path).
 %  info      [integer]     Scalar. If info is equal to 1 then the predicted name of the last
-%                          metropolis hastings matches the name of the name of the last mh 
-%                          file. Otherwise info is equal to zero (a likely reason for this is 
+%                          metropolis hastings matches the name of the name of the last mh
+%                          file. Otherwise info is equal to zero (a likely reason for this is
 %                          that the mcmc simulations were not completed).
 
-% Copyright (C) 2008-2013 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/get_new_or_existing_ei_index.m b/matlab/get_new_or_existing_ei_index.m
index 39bec99a3..a6b3b85e1 100644
--- a/matlab/get_new_or_existing_ei_index.m
+++ b/matlab/get_new_or_existing_ei_index.m
@@ -17,7 +17,7 @@ function indx = get_new_or_existing_ei_index(substructure_name, name1, name2)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -38,7 +38,7 @@ global estimation_info
 
 if eval(['isempty(estimation_info.' substructure_name ')'])
     indx = 1;
-    return;
+    return
 end
 
 if isempty(name2) % parameter or std() statement
diff --git a/matlab/get_optimal_policy_discount_factor.m b/matlab/get_optimal_policy_discount_factor.m
index 67931b8ab..89b605b3b 100644
--- a/matlab/get_optimal_policy_discount_factor.m
+++ b/matlab/get_optimal_policy_discount_factor.m
@@ -2,18 +2,18 @@ function discount_factor=get_optimal_policy_discount_factor(params,param_names)
 
 %function discount_factor=get_optimal_policy_discount_factor(M)
 %  get the value of Ramsey policy discount factor
-% 
+%
 % INPUTS
-%   params:             (vector) value of parameters    
+%   params:             (vector) value of parameters
 %   param_names:        (char array) list of parameter names
-%    
+%
 % OUTPUTS
 %   discount_factor     (double) discount factor
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2007-2011 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,4 +30,4 @@ function discount_factor=get_optimal_policy_discount_factor(params,param_names)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    discount_factor = params(find(strcmp('optimal_policy_discount_factor',cellstr(param_names))));
+discount_factor = params(find(strcmp('optimal_policy_discount_factor',cellstr(param_names))));
diff --git a/matlab/get_param_by_name.m b/matlab/get_param_by_name.m
index 795ac88df..b06ab5f07 100644
--- a/matlab/get_param_by_name.m
+++ b/matlab/get_param_by_name.m
@@ -1,7 +1,7 @@
 function x = get_param_by_name(pname)
 % function x = get_param_by_name(pname)
 % returns the value of a parameter identified by its name
-%  
+%
 % INPUTS:
 %   pname:  parameter name
 %
@@ -11,7 +11,7 @@ function x = get_param_by_name(pname)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2006-2009 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/get_posterior_parameters.m b/matlab/get_posterior_parameters.m
index 495f36565..e10616d20 100644
--- a/matlab/get_posterior_parameters.m
+++ b/matlab/get_posterior_parameters.m
@@ -2,18 +2,18 @@ function xparam = get_posterior_parameters(type,field1)
 
 % function xparam = get_posterior_parameters(type)
 % Selects (estimated) parameters (posterior mode or posterior mean).
-% 
-% INPUTS 
+%
+% INPUTS
 %   o type       [char]     = 'mode' or 'mean'.
 %   o field_1    [char]     optional field like 'mle_'.
-%  
-% OUTPUTS 
-%   o xparam     vector of estimated parameters  
+%
+% OUTPUTS
+%   o xparam     vector of estimated parameters
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ function xparam = get_posterior_parameters(type,field1)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-global estim_params_ oo_ options_ M_ 
+global estim_params_ oo_ options_ M_
 
 if nargin<2
     field1='posterior_';
diff --git a/matlab/get_subsamples_range_indx.m b/matlab/get_subsamples_range_indx.m
index 1d114c686..56c87f286 100644
--- a/matlab/get_subsamples_range_indx.m
+++ b/matlab/get_subsamples_range_indx.m
@@ -16,7 +16,7 @@ function range_indx = get_subsamples_range_indx(subsamples_indx, range_label)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,5 +39,5 @@ range_indx = find(strcmp(range_label, estimation_info.subsamples(subsamples_indx
 
 if size(range_indx,2) ~= 1
     error(['Error: Index not found in estimation_info.subsamples(' ...
-        num2str(subsamples_indx) ').range_index for label ' range_label]);
+           num2str(subsamples_indx) ').range_index for label ' range_label]);
 end
diff --git a/matlab/get_variables_list.m b/matlab/get_variables_list.m
index 5d6a93c84..b72479b37 100644
--- a/matlab/get_variables_list.m
+++ b/matlab/get_variables_list.m
@@ -1,22 +1,22 @@
 function [ivar,vartan,options_] = get_variables_list(options_,M_)
 % This function builds a vector of indices in varlist or varobs.
-% 
-% INPUTS 
-%   o options_   [structure]  Describes global options. 
+%
+% INPUTS
+%   o options_   [structure]  Describes global options.
 %   o M_         [structure]  Describes the model.
-% OUTPUTS 
+% OUTPUTS
 %   o ivar       [integer]    nvar*1 vector of indices (nvar is the number
 %                             of variables).
 %   o vartan     [char]       array of characters (with nvar rows).
 %   o options_   [structure]  Describes global options.
-% 
-% ALGORITHM 
-%   None.       
+%
+% ALGORITHM
+%   None.
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2007-2012 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/get_variance_of_endogenous_variables.m b/matlab/get_variance_of_endogenous_variables.m
index 005ceb8e0..965319b1b 100644
--- a/matlab/get_variance_of_endogenous_variables.m
+++ b/matlab/get_variance_of_endogenous_variables.m
@@ -6,14 +6,14 @@ function vx1 = get_variance_of_endogenous_variables(dr,i_var)
 % INPUTS
 %    dr:        structure of decisions rules for stochastic simulations
 %    i_var:     indices of a variables list
-%        
+%
 % OUTPUTS
 %    vx1:       variance-covariance matrix
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2012 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -48,7 +48,7 @@ n = length(i_var);
 [vx,u] = lyapunov_symm(A,B*Sigma_e*B',options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold, [], options_.debug);
 
 if size(u,2) > 0
-    i_stat = find(any(abs(ghx*u) < options_.Schur_vec_tol,2)); %only set those variances of objective function for which variance is finite     
+    i_stat = find(any(abs(ghx*u) < options_.Schur_vec_tol,2)); %only set those variances of objective function for which variance is finite
     ghx = ghx(i_stat,:);
     ghu = ghu(i_stat,:);
 else
@@ -57,4 +57,3 @@ end
 
 vx1 = Inf*ones(n,n);
 vx1(i_stat,i_stat) = ghx*vx*ghx'+ghu*Sigma_e*ghu';
-
diff --git a/matlab/global_initialization.m b/matlab/global_initialization.m
index e8d1627e2..d26b488c8 100644
--- a/matlab/global_initialization.m
+++ b/matlab/global_initialization.m
@@ -11,7 +11,7 @@ function global_initialization()
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -165,9 +165,9 @@ options_.nocorr = 0;
 options_.periods = 0;
 options_.noprint = 0;
 options_.SpectralDensity.trigger = 0;
-options_.SpectralDensity.plot  = 1; 
-options_.SpectralDensity.cutoff  = 150; 
-options_.SpectralDensity.sdl = 0.01; 
+options_.SpectralDensity.plot  = 1;
+options_.SpectralDensity.cutoff  = 150;
+options_.SpectralDensity.sdl = 0.01;
 options_.nofunctions = false;
 
 options_.bandpass.indicator = 0;
@@ -282,7 +282,7 @@ particle.resampling.number_of_partitions = 200;
 particle.mixture_state_variables = 5 ;
 particle.mixture_structural_shocks = 1 ;
 particle.mixture_measurement_shocks = 1 ;
-% Online approach 
+% Online approach
 particle.liu_west_delta = 0.99 ;
 particle.liu_west_chol_sigma_bar = .01 ;
 % Options for setting the weights in conditional particle filters.
@@ -471,7 +471,7 @@ options_.sub_draws = [];
 options_.gradient_method = 2; %used by csminwel and newrat
 options_.gradient_epsilon = 1e-6; %used by csminwel and newrat
 options_.posterior_sampler_options.sampling_opt = []; %extended set of options for individual posterior samplers
-% Random Walk Metropolis-Hastings
+                                                      % Random Walk Metropolis-Hastings
 options_.posterior_sampler_options.posterior_sampling_method = 'random_walk_metropolis_hastings';
 options_.posterior_sampler_options.rwmh.proposal_distribution = 'rand_multivariate_normal';
 options_.posterior_sampler_options.rwmh.student_degrees_of_freedom = 3;
@@ -525,8 +525,8 @@ options_.estimation.moments_posterior_density.indicator = 1;
 options_.estimation.moments_posterior_density.gridpoints = 2^9;
 options_.estimation.moments_posterior_density.bandwidth = 0; % Rule of thumb optimal bandwidth parameter.
 options_.estimation.moments_posterior_density.kernel_function = 'gaussian'; % Gaussian kernel for Fast Fourrier Transform approximaton.
-% Misc
-% options_.conf_sig = 0.6;
+                                                                            % Misc
+                                                                            % options_.conf_sig = 0.6;
 oo_.exo_simul = [];
 oo_.endo_simul = [];
 ys0_ = [];
@@ -568,6 +568,9 @@ options_.homotopy_force_continue = 0;
 % numerical hessian
 hessian.use_penalized_objective = false;
 
+% Robust prediction error covariance (kalman filter)
+options_.rescale_prediction_error_covariance = false;
+
 options_.hessian = hessian;
 
 %csminwel optimization routine
@@ -629,7 +632,7 @@ options_.simpsa = simpsa;
 %solveopt optimizer
 solveopt.minimizer_indicator=-1; %use minimizer
 solveopt.TolX=1e-6; %accuracy of argument
-solveopt.TolFun=1e-6; %accuracy of function 
+solveopt.TolFun=1e-6; %accuracy of function
 solveopt.MaxIter=15000;
 solveopt.verbosity=1;
 solveopt.TolXConstraint=1.e-8;
@@ -722,7 +725,14 @@ options_.discretionary_tol = 1e-7;
 % Shock decomposition
 options_.parameter_set = [];
 options_.use_shock_groups = '';
-options_.colormap = '';
+options_.shock_decomp.colormap = '';
+options_.shock_decomp.init_state = 0;
+
+% Shock decomposition realtime
+options_.shock_decomp.forecast = 0;
+options_.shock_decomp.presample = NaN;
+options_.shock_decomp.save_realtime = 0; % saves memory
+options_ = set_default_plot_shock_decomposition_options(options_);
 
 % Nonlinearfilters
 options_.nonlinear_filter = [];
@@ -831,4 +841,3 @@ set_dynare_seed('default');
 if isfield(options_, 'global_init_file')
     run(options_.global_init_file);
 end
-
diff --git a/matlab/graph_decomp.m b/matlab/graph_decomp.m
index 2edd40ef5..f2c670549 100644
--- a/matlab/graph_decomp.m
+++ b/matlab/graph_decomp.m
@@ -1,7 +1,7 @@
 function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
 %function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
 % Plots the results from the shock_decomposition command
-% 
+%
 % Inputs
 %   z               [n_var*(nshock+2)*nperiods]     shock decomposition array, see shock_decomposition.m for details
 %   shock_names     [endo_nbr*string length]        shock names from M_.exo_names
@@ -11,7 +11,7 @@ function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel
 %   DynareModel     [structure]                     Dynare model structure
 %   DynareOptions   [structure]                     Dynare options structure
 
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,46 +28,111 @@ function []=graph_decomp(z,shock_names,endo_names,i_var,initial_date,DynareModel
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-new_colormap = DynareOptions.colormap;
+GraphDirectoryName = CheckPath('graphs',DynareModel.dname);
+new_colormap = DynareOptions.plot_shock_decomp.colormap;
 
 % number of components equals number of shocks + 1 (initial conditions)
 comp_nbr = size(z,2)-1;
 
+SteadyState=[];
+fig_mode='';
+fig_mode1='';
+% fig_name='';
+% screen_shocks=0;
+opts_decomp = DynareOptions.plot_shock_decomp;
+if isfield(opts_decomp,'steady_state')
+    SteadyState = opts_decomp.steady_state;
+end
+if ~isempty(opts_decomp.type)
+    fig_mode = opts_decomp.type;
+    fig_mode1 = ['_' fig_mode];
+    fig_mode = [fig_mode '_'];
+end
+fig_name_long = opts_decomp.fig_name;
+
+use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+screen_shocks = opts_decomp.screen_shocks;
+if use_shock_groups | comp_nbr<=18
+    screen_shocks=0;
+end
+if use_shock_groups
+    shock_groups = DynareModel.shock_groups.(use_shock_groups);
+    shock_ind = fieldnames(shock_groups);
+end
+if screen_shocks
+    fig_name_long = [fig_name_long ' SCREEN'];
+end
+
+fig_name=strrep(fig_name_long, '(given ', '');
+fig_name=strrep(fig_name, '(vintage ', '');
+fig_name=regexprep(fig_name, ' ', '_');
+fig_name=strrep(fig_name, '.', '');
+fig_name=strrep(fig_name, '-', '');
+fig_name=strrep(fig_name, ')', '');
+fig_name=strrep(fig_name, '(', '');
+
+interactive = opts_decomp.interactive;
+
+
 gend = size(z,3);
 if isempty(initial_date)
     x = 0:gend;
+    freq = 1;
 else
     freq = initial_date.freq;
-    initial_period = initial_date.time(1) + initial_date.time(2)/freq;
+    initial_period = initial_date.time(1) + (initial_date.time(2)-1)/freq;
     x = initial_period-1/freq:(1/freq):initial_period+(gend-1)/freq;
 end
 
 nvar = length(i_var);
 
 %% write LaTeX-Header
-if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
-    fidTeX = fopen([DynareModel.fname '_shock_decomp.tex'],'w');
+if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
+    fidTeX = fopen([GraphDirectoryName, filesep, DynareModel.fname '_shock_decomp' fig_mode1 fig_name '.tex'],'w');
     fprintf(fidTeX,'%% TeX eps-loader file generated by Dynare''s graph_decomp.m.\n');
     fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
     fprintf(fidTeX,' \n');
 end
 
+if opts_decomp.vintage && opts_decomp.realtime>1
+    preamble_txt = 'Shock decomposition';
+else
+    preamble_txt = 'Historical shock decomposition';
+end
+
+if ~(screen_shocks && comp_nbr>18)
+    screen_shocks=0;
+end
+comp_nbr0=comp_nbr;
 %%plot decomposition
 for j=1:nvar
     z1 = squeeze(z(i_var(j),:,:));
+    if screen_shocks
+        [junk, isort] = sort(mean(abs(z1(1:end-2,:)')), 'descend');
+        labels = char(char(shock_names(isort(1:16),:)),'Others', 'Initial values');
+        zres = sum(z1(isort(17:end),:),1);
+        z1 = [z1(isort(1:16),:); zres; z1(comp_nbr0:end,:)];
+        comp_nbr=18;
+        func = @(x) colorspace('RGB->Lab',x);
+        new_colormap = distinguishable_colors(size(z1,1)-1,'w',func);
+        new_colormap(end,:) = [0.7 0.7 0.7];
+    else
+        labels = char(char(shock_names),'Initial values');
+    end
     xmin = x(1);
-    xmax = x(end);
-    ix = z1 > 0;
-    ymax = max(sum(z1.*ix));
-    ix = z1 < 0;
-    ymin = min(sum(z1.*ix));
+    xmax = x(end)+1/freq;
+    ix = z1(1:comp_nbr,:) > 0;
+    ymax = max(sum(z1(1:comp_nbr,:).*ix))*1.1;
+    ix = z1(1:comp_nbr,:) < 0;
+    ymin = min(sum(z1(1:comp_nbr,:).*ix))*1.1;
     if ymax-ymin < 1e-6
         continue
     end
-    fhandle = dyn_figure(DynareOptions,'Name',['Shock decomposition: ',endo_names(i_var(j),:)]);
-    ax=axes('Position',[0.1 0.1 0.6 0.8]);
-    plot(ax,x(2:end),z1(end,:),'k-','LineWidth',2)
-    axis(ax,[xmin xmax ymin ymax]);
+    fhandle = dyn_figure(DynareOptions.plot_shock_decomp.nodisplay,'Name',[preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': ' deblank(endo_names(i_var(j),:)) '.'], 'PaperPositionMode', 'auto','PaperOrientation','landscape','renderermode','auto');
+    set(fhandle,'position' ,[50 50 1500 750])
+    ax=axes('Position',[0.1 0.1 0.6 0.8],'box','on');
+    %     plot(ax,x(2:end),z1(end,:),'k-','LineWidth',2)
+    %     axis(ax,[xmin xmax ymin ymax]);
     hold on;
     for i=1:gend
         i_1 = i-1;
@@ -76,16 +141,39 @@ for j=1:nvar
         for k = 1:comp_nbr
             zz = z1(k,i);
             if zz > 0
-                fill([x(i) x(i) x(i+1) x(i+1)],[yp yp+zz yp+zz yp],k);
+                fill([x(i) x(i) x(i+1) x(i+1)]+(1/freq/2),[yp yp+zz yp+zz yp],k);
                 yp = yp+zz;
             else
-                fill([x(i) x(i) x(i+1) x(i+1)],[ym ym+zz ym+zz ym],k);
+                fill([x(i) x(i) x(i+1) x(i+1)]+(1/freq/2),[ym ym+zz ym+zz ym],k);
                 ym = ym+zz;
             end
             hold on;
         end
     end
     plot(ax,x(2:end),z1(end,:),'k-','LineWidth',2)
+    if ~isempty(SteadyState)
+        plot(ax,[xmin xmax],[0 0],'--','linewidth',1,'color',[0.7 0.7 0.7])
+        if ymin+SteadyState(i_var(j))<0 && ymax+SteadyState(i_var(j))>0
+            plot(ax,[xmin xmax],SteadyState(i_var(j))*[-1 -1],'k--','linewidth',1)
+            ytick=get(ax,'ytick');
+            ytick1=ytick-SteadyState(i_var(j));
+            ind1=min(find(ytick1>=ymin));
+            ind2=max(find(ytick1<=ymax));
+            dytick=ytick(2)-ytick(1);
+            if ind1>1
+                ytick1  = [ytick1(ind1:end) ytick1(end)+dytick:dytick:ymax];
+            elseif ind2<length(ytick)
+                ytick1= [sort(ytick1(1)-dytick:-dytick:ymin) ytick1(1:ind2)];
+            end
+            set(ax,'ytick',ytick1),
+        else
+            ytick1=get(ax,'ytick');
+        end
+        ylabel = ytick1'+SteadyState(i_var(j));
+        ylabel(abs(ylabel)<eps)=0;
+        set(ax,'yticklabel',num2str(ylabel,'%4.2g'))
+    end
+    set(ax,'xlim',[xmin xmax]);
     hold off;
 
     axes('Position',[0.75 0.1 0.2 0.8]);
@@ -94,34 +182,51 @@ for j=1:nvar
     hold on;
     y1 = 0;
     height = 1/comp_nbr;
-    labels = char(char(shock_names),'Initial values');
 
-    for i=1:comp_nbr
-        fill([0 0 0.2 0.2],[y1 y1+0.7*height y1+0.7*height y1],i);
+    for i=comp_nbr:-1:1
+        %     for i=1:comp_nbr
+        hl = fill([0 0 0.2 0.2],[y1 y1+0.7*height y1+0.7*height y1],i);
         hold on
-        text(0.3,y1+0.3*height,labels(i,:),'Interpreter','none');
+        ht = text(0.3,y1+0.3*height,labels(i,:),'Interpreter','none');
         hold on
+        if interactive & (~isoctave & use_shock_groups)
+            mydata.fig_name = DynareOptions.plot_shock_decomp.fig_name(2:end);
+            mydata.use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+            mydata.shock_group = shock_groups.(shock_ind{i});
+            mydata.shock_decomp = DynareOptions.plot_shock_decomp;
+            if ~isempty(mydata.shock_group.shocks{1})
+                c = uicontextmenu;
+                hl.UIContextMenu=c;
+                browse_menu = uimenu(c,'Label','Browse group');
+                expand_menu = uimenu(c,'Label','Expand group','Callback',['expand_group(''' mydata.use_shock_groups ''',''' deblank(mydata.shock_decomp.orig_varlist(j,:)) ''',' int2str(i) ')']);
+                set(expand_menu,'UserData',mydata,'Tag',['group' int2str(i)]);
+                for jmember = mydata.shock_group.shocks
+                    uimenu('parent',browse_menu,'Label',char(jmember))
+                end
+                ht.UIContextMenu=c;
+            end
+        end
         y1 = y1 + height;
     end
 
     if ~isempty(new_colormap)
         colormap(new_colormap)
     end
-    dyn_saveas(fhandle,[DynareModel.fname,'_shock_decomposition_',deblank(endo_names(i_var(j),:))],DynareOptions);
     hold off
-    if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
+    dyn_saveas(fhandle,[GraphDirectoryName, filesep, DynareModel.fname,'_shock_decomposition_',deblank(endo_names(i_var(j),:)),fig_mode1,fig_name],DynareOptions.plot_shock_decomp.nodisplay,DynareOptions.plot_shock_decomp.graph_format);
+    if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
         fprintf(fidTeX,'\\begin{figure}[H]\n');
         fprintf(fidTeX,'\\centering \n');
-        fprintf(fidTeX,['\\includegraphics[width=0.8\\textwidth]{%s_shock_decomposition_%s}\n'],DynareModel.fname,deblank(endo_names(i_var(j),:)));
-        fprintf(fidTeX,'\\label{Fig:shock_decomp:%s}\n',deblank(endo_names(i_var(j),:)));
-        fprintf(fidTeX,'\\caption{Historical shock decomposition: $ %s $}\n',deblank(DynareModel.endo_names_tex(i_var(j),:)));
+        fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s/graphs/%s_shock_decomposition_%s}\n',DynareModel.fname,DynareModel.fname,[deblank(endo_names(i_var(j),:)) fig_mode1 fig_name]);
+        fprintf(fidTeX,'\\label{Fig:shock_decomp:%s}\n',[fig_mode deblank(endo_names(i_var(j),:)) fig_name]);
+        fprintf(fidTeX,['\\caption{' preamble_txt fig_name_long strrep(fig_mode1, '_',  ' ') ': $ %s $.}\n'],deblank(DynareModel.endo_names_tex(i_var(j),:)));
         fprintf(fidTeX,'\\end{figure}\n');
         fprintf(fidTeX,' \n');
-    end    
+    end
 end
 
 %% write LaTeX-Footer
-if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
+if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
     fprintf(fidTeX,' \n');
     fprintf(fidTeX,'%% End of TeX file.\n');
     fclose(fidTeX);
diff --git a/matlab/graph_decomp_detail.m b/matlab/graph_decomp_detail.m
new file mode 100644
index 000000000..75951a411
--- /dev/null
+++ b/matlab/graph_decomp_detail.m
@@ -0,0 +1,245 @@
+function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
+%function []=graph_decomp_detail(z,shock_names,endo_names,i_var,initial_date,DynareModel,DynareOptions)
+% Plots the results from the shock_decomposition command
+%
+% Inputs
+%   z               [n_var*(nshock+2)*nperiods]     shock decomposition array, see shock_decomposition.m for details
+%   shock_names     [endo_nbr*string length]        shock names from M_.exo_names
+%   endo_names      [exo_nbr*string length]         variable names from M_.endo_names
+%   i_var           [n_var*1]                       vector indices of requested variables in M_.endo_names and z
+%   initial_date    [dseries object]                first period of decomposition to plot
+%   DynareModel     [structure]                     Dynare model structure
+%   DynareOptions   [structure]                     Dynare options structure
+
+% Copyright (C) 2010-2017 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/>.
+
+GraphDirectoryName = CheckPath('graphs',DynareModel.dname);
+% interactive = 0;
+fig_mode='';
+fig_mode1='';
+% fig_name='';
+% screen_shocks=0;
+use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+if use_shock_groups
+    shock_groups = DynareModel.shock_groups.(use_shock_groups);
+    shock_ind = fieldnames(shock_groups);
+end
+
+% number of components equals number of shocks + 1 (initial conditions)
+comp_nbr = size(z,2)-1;
+
+opts_decomp = DynareOptions.plot_shock_decomp;
+
+interactive = opts_decomp.interactive;
+if ~isempty(opts_decomp.type)
+    fig_mode = opts_decomp.type;
+    fig_mode1 = ['_' fig_mode];
+    fig_mode = [fig_mode '_'];
+end
+screen_shocks = opts_decomp.screen_shocks;
+if DynareOptions.plot_shock_decomp.use_shock_groups | comp_nbr<=18
+    screen_shocks=0;
+end
+fig_name_long = opts_decomp.fig_name;
+%         fig_name = ['_' fig_name];
+
+if screen_shocks
+    %     fig_name1 = [fig_name1 '_screen'];
+    fig_name_long = [fig_name_long ' SCREEN'];
+end
+
+fig_name=strrep(fig_name_long, '(given ', '');
+fig_name=strrep(fig_name, '(vintage ', '');
+fig_name=regexprep(fig_name, ' ', '_');
+fig_name=strrep(fig_name, '.', '');
+fig_name=strrep(fig_name, '-', '');
+fig_name=strrep(fig_name, ')', '');
+fig_name=strrep(fig_name, '(', '');
+% fig_name1 = [fig_name];
+% fig_name = [fig_name '_'];
+
+gend = size(z,3);
+if isempty(initial_date)
+    x = 0:gend;
+    freq = 1;
+else
+    freq = initial_date.freq;
+    initial_period = initial_date.time(1) + (initial_date.time(2)-1)/freq;
+    x = initial_period-1/freq:(1/freq):initial_period+(gend-1)/freq;
+end
+
+ind_yrs = find(floor(x)==x);
+dind_tick = 1;
+if floor(length(ind_yrs)/3)
+    dind_tick = floor(length(ind_yrs)/3);
+    xind_tick = x(ind_yrs(1)):dind_tick:x(ind_yrs(end))+(length(ind_yrs)-(dind_tick*3+1));
+else
+    xind_tick = x(ind_yrs(1)):dind_tick:x(ind_yrs(end))+(length(ind_yrs)-(dind_tick+1));
+end
+% xind_tick = floor(x(1))-floor(dind_tick/2):dind_tick:ceil(x(end))+ceil(dind_tick/2);
+if abs(floor(x(1))-xind_tick(1))-abs(ceil(x(end))-xind_tick(end))>1
+    xind_tick = xind_tick-1;
+end
+if abs(floor(x(1))-xind_tick(1))-abs(ceil(x(end))-xind_tick(end))<-1
+    xind_tick = xind_tick+1;
+end
+% xind_tick = [x(ind_yrs(1))-floor(dind_tick/2):dind_tick:x(ind_yrs(end))+floor(dind_tick/2)]+1;
+% xind_tick = x(ind_yrs(1))-1:dind_tick:x(ind_yrs(end))+1;
+% xind_tick = x(ind_yrs(1))-1:dind_tick:x(ind_yrs(end))+dind_tick;
+
+nvar = length(i_var);
+
+%% write LaTeX-Header
+if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
+    fidTeX = fopen([GraphDirectoryName, filesep, DynareModel.fname '_shock_decomp' fig_mode1 fig_name '_detail.tex'],'w');
+    fprintf(fidTeX,'%% TeX eps-loader file generated by Dynare''s graph_decomp_detail.m.\n');
+    fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
+    fprintf(fidTeX,' \n');
+end
+
+if opts_decomp.vintage && opts_decomp.realtime>1
+    preamble_txt = 'Shock decomposition';
+else
+    preamble_txt = 'Historical shock decomposition';
+end
+
+ncol=3;
+nrow=ceil(comp_nbr/ncol);
+ntotrow = nrow;
+nrow = min(ntotrow, 6);
+nfigs = ceil(ntotrow/nrow);
+labels = char(char(shock_names),'Initial values');
+if ~(screen_shocks && comp_nbr>18)
+    screen_shocks=0;
+end
+comp_nbr0=comp_nbr;
+%%plot decomposition
+for j=1:nvar
+    z1 = squeeze(z(i_var(j),:,:));
+    if screen_shocks,
+        [junk, isort] = sort(mean(abs(z1(1:end-2,:)')), 'descend');
+        labels = char(char(shock_names(isort(1:16),:)),'Others', 'Initial values');
+        zres = sum(z1(isort(17:end),:),1);
+        z1 = [z1(isort(1:16),:); zres; z1(comp_nbr0:end,:)];
+        comp_nbr=18;
+        nfigs=1;
+    end
+    xmin = x(1);
+    xmin = min(xmin, xind_tick(1));
+    xmax = x(end)+1/freq;
+    xmax = max(xmax, xind_tick(end));
+    ix = z1(1:comp_nbr,:) > 0;
+    ymax = max(sum(z1(1:comp_nbr,:).*ix))*1.1;
+    ix = z1(1:comp_nbr,:) < 0;
+    ymin = min(sum(z1(1:comp_nbr,:).*ix))*1.1;
+    if ymax-ymin < 1e-6
+        continue
+    end
+    for jf = 1:nfigs
+        fhandle = dyn_figure(DynareOptions.plot_shock_decomp.nodisplay,'Name',[preamble_txt fig_name_long strrep(fig_mode1, '_', ' ') ': ' deblank(endo_names(i_var(j),:)) ' (detail).'],'position',[200 100 650 850], 'PaperPositionMode', 'auto','PaperOrientation','portrait','renderermode','auto');
+        a0=zeros(1,4);
+        a0(3)=inf;
+        a0(4)=-inf;
+        for ic=1+nrow*ncol*(jf-1):min(nrow*ncol*jf,comp_nbr)
+            i = ic-nrow*ncol*(jf-1);
+            zz = z1(ic,:);
+            zz(2,:)=z1(end,:)-zz;
+            ipos=zz>0;
+            ineg=zz<0;
+            hax = subplot(nrow,ncol,i); set(gca,'box','on')
+            hbar = bar(x(2:end),(zz.*ipos)','stacked');
+            colormap([0.15 0.15 0.15;0.85 0.85 0.85]),
+            set(hbar,'edgecolor','flat');
+            hold on,
+            hbar = bar(x(2:end),(zz.*ineg)','stacked');
+            colormap([0.15 0.15 0.15;0.85 0.85 0.85]),
+            set(hbar,'edgecolor','flat');
+            title(deblank(labels(ic,:)),'Interpreter','none'),
+            axis tight;
+            a=axis;
+            set(gca,'Xtick',xind_tick)
+            set(gca,'xlim',[xmin xmax])
+            a0(3)=min(a(3),a0(3));
+            a0(4)=max(a(4),a0(4));
+            set(gca,'ylim',a0(3:4))
+            hold on, h1=plot(x(2:end),z1(end,:),'k-','LineWidth',2);
+            if interactive & (~isoctave & use_shock_groups)
+                mydata.fig_name = DynareOptions.plot_shock_decomp.fig_name(2:end);
+                mydata.use_shock_groups = DynareOptions.plot_shock_decomp.use_shock_groups;
+                mydata.shock_group = shock_groups.(shock_ind{ic});
+                mydata.shock_decomp = DynareOptions.plot_shock_decomp;
+                if ~isempty(mydata.shock_group.shocks{1})
+                    c = uicontextmenu;
+                    hax.UIContextMenu=c;
+                    browse_menu = uimenu(c,'Label','Browse group');
+                    expand_menu = uimenu(c,'Label','Expand group','Callback',['expand_group(''' mydata.use_shock_groups ''',''' deblank(mydata.shock_decomp.orig_varlist(j,:)) ''',' int2str(ic) ')']);
+                    set(expand_menu,'UserData',mydata,'Tag',['group' int2str(ic)]);
+                    for jmember = mydata.shock_group.shocks
+                        uimenu('parent',browse_menu,'Label',char(jmember))
+                    end
+                end
+            end
+        end
+        for isub=1:i
+            subplot(nrow,ncol,isub),
+            set(gca,'ylim',a0(3:4))
+        end
+
+        % make legend
+        axes('Position',[0.1 0.01 0.8 0.02],'units','normalized');
+        axis([0 1 0 1]);
+        axis off;
+        hold on;
+        x1 = 0;
+        width = 1/2;
+        mylabels = {'Individual contrib.','Residual contrib.'};
+
+        for i=1:2
+            %     for i=1:comp_nbr
+            hl = fill([x1 x1 x1+0.3*width x1+0.3*width],[0 1 1 0],i);
+            hold on
+            ht = text(x1+0.4*width,0.3,mylabels{i},'Interpreter','none');
+            hold on
+            x1 = x1 + width;
+        end
+
+
+        if nfigs>1
+            suffix = ['_detail_' int2str(jf)];
+        else
+            suffix = ['_detail'];
+        end
+        dyn_saveas(fhandle,[GraphDirectoryName, filesep, DynareModel.fname,'_shock_decomposition_',deblank(endo_names(i_var(j),:)),fig_mode1,fig_name suffix],DynareOptions.plot_shock_decomp.nodisplay,DynareOptions.plot_shock_decomp.graph_format);
+        if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
+            fprintf(fidTeX,'\\begin{figure}[H]\n');
+            fprintf(fidTeX,'\\centering \n');
+            fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s/graphs/%s_shock_decomposition_%s}\n',DynareModel.fname,DynareModel.fname,[deblank(endo_names(i_var(j),:)) fig_mode1 fig_name suffix]);
+            fprintf(fidTeX,'\\label{Fig:shock_decomp_detail:%s}\n',[fig_mode deblank(endo_names(i_var(j),:)) fig_name suffix]);
+            fprintf(fidTeX,['\\caption{' preamble_txt fig_name_long strrep(fig_mode1, '_',  ' ') ': $ %s $ (detail).}\n'],deblank(DynareModel.endo_names_tex(i_var(j),:)));
+            fprintf(fidTeX,'\\end{figure}\n');
+            fprintf(fidTeX,' \n');
+        end
+    end
+end
+
+%% write LaTeX-Footer
+if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.plot_shock_decomp.graph_format)))
+    fprintf(fidTeX,' \n');
+    fprintf(fidTeX,'%% End of TeX file.\n');
+    fclose(fidTeX);
+end
diff --git a/matlab/gsa/Morris_Measure_Groups.m b/matlab/gsa/Morris_Measure_Groups.m
index 5b6c30720..1271ed1b6 100644
--- a/matlab/gsa/Morris_Measure_Groups.m
+++ b/matlab/gsa/Morris_Measure_Groups.m
@@ -5,24 +5,29 @@ function [SAmeas, OutMatrix] = Morris_Measure_Groups(NumFact, Sample, Output, p,
 % -------------------------------------------------------------------------
 % INPUTS
 % -------------------------------------------------------------------------
-% Group [NumFactor, NumGroups] := Matrix describing the groups. 
-% Each column represents one group. 
+% Group [NumFactor, NumGroups] := Matrix describing the groups.
+% Each column represents one group.
 % The element of each column are zero if the factor is not in the
 % group. Otherwise it is 1.
 %
-% Sample := Matrix of the Morris sampled trajectories 
+% Sample := Matrix of the Morris sampled trajectories
 %
 % Output := Matrix of the output(s) values in correspondence of each point
 % of each trajectory
 %
 % k = Number of factors
 % -------------------------------------------------------------------------
-% OUTPUTS 
+% OUTPUTS
 % OutMatrix (NumFactor*NumOutputs, 3)= [Mu*, Mu, StDev]
 % for each output it gives the three measures of each factor
 % -------------------------------------------------------------------------
+%
+% Written by Jessica Cariboni and Francesca Campolongo
+% Joint Research Centre, The European Commission,
+%
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2005 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,17 +44,17 @@ function [SAmeas, OutMatrix] = Morris_Measure_Groups(NumFact, Sample, Output, p,
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin==0,
-  skipline()
-  disp('[SAmeas, OutMatrix] = Morris_Measure_Groups(NumFact, Sample, Output, p, Group);')
-  return
+if nargin==0
+    skipline()
+    disp('[SAmeas, OutMatrix] = Morris_Measure_Groups(NumFact, Sample, Output, p, Group);')
+    return
 end
 
 OutMatrix=[];
 if nargin < 5, Group=[]; end
 
 NumGroups = size(Group,2);
-if nargin < 4 | isempty(p),
+if nargin < 4 | isempty(p)
     p = 4;
 end
 Delt = p/(2*p-2);
@@ -58,45 +63,45 @@ if NumGroups ~ 0
     sizea = NumGroups;      % Number of groups
     GroupMat=Group;
     GroupMat = GroupMat';
-else 
-    sizea = NumFact; 
+else
+    sizea = NumFact;
 end
 r=size(Sample,1)/(sizea+1);     % Number of trajectories
 
 % For Each Output
 for k=1:size(Output,2)
-    
+
     OutValues=Output(:,k);
-  
+
     % For each r trajectory
     for i=1:r
-    
+
         % For each step j in the trajectory
         % Read the orientation matrix fact for the r-th sampling
         % Read the corresponding output values
-        Single_Sample = Sample(i+(i-1)*sizea:i+(i-1)*sizea+sizea,:); 
-        Single_OutValues = OutValues(i+(i-1)*sizea:i+(i-1)*sizea+sizea,:); 
+        Single_Sample = Sample(i+(i-1)*sizea:i+(i-1)*sizea+sizea,:);
+        Single_OutValues = OutValues(i+(i-1)*sizea:i+(i-1)*sizea+sizea,:);
         A = (Single_Sample(2:sizea+1,:)-Single_Sample(1:sizea,:))';
         Delta = A(find(A));
 
         % For each point of the fixed trajectory compute the values of the Morris function. The function
         % is partitioned in four parts, from order zero to order 4th.
-        for j=1:sizea   % For each point in the trajectory i.e for each factor   
-            % matrix of factor which changes
-            if NumGroups ~ 0;
+        for j=1:sizea   % For each point in the trajectory i.e for each factor
+                        % matrix of factor which changes
+            if NumGroups ~ 0
                 AuxFind (:,1) = A(:,j);
-%                 AuxFind(find(A(:,j)),1)=1;
-%                 Pippo = sum((Group - repmat(AuxFind,1,NumGroups)),1);
-%                 Change_factor(j,i) = find(Pippo==0);   
-                Change_factor = find(abs(AuxFind)>1e-010); 
+                %                 AuxFind(find(A(:,j)),1)=1;
+                %                 Pippo = sum((Group - repmat(AuxFind,1,NumGroups)),1);
+                %                 Change_factor(j,i) = find(Pippo==0);
+                Change_factor = find(abs(AuxFind)>1e-010);
                 % If we deal with groups we can only estimate the new mu*
                 % measure since factors in the same groups can move in
                 % opposite direction and the definition of the standard
-                % Morris mu cannopt be applied. 
+                % Morris mu cannopt be applied.
                 % In the new version the elementary effect is defined with
                 % the absolute value.
-                %SAmeas(find(GroupMat(Change_factor(j,i),:)),i) = abs((Single_OutValues(j) - Single_OutValues(j+1) )/Delt); %(2/3));   
-                SAmeas(i,Change_factor') = abs((Single_OutValues(j) - Single_OutValues(j+1) )/Delt);   
+                %SAmeas(find(GroupMat(Change_factor(j,i),:)),i) = abs((Single_OutValues(j) - Single_OutValues(j+1) )/Delt); %(2/3));
+                SAmeas(i,Change_factor') = abs((Single_OutValues(j) - Single_OutValues(j+1) )/Delt);
             else
                 Change_factor(j,i) = find(Single_Sample(j+1,:)-Single_Sample(j,:));
                 % If no groups --> we compute both the original and
@@ -105,41 +110,41 @@ for k=1:size(Output,2)
                     SAmeas(Change_factor(j,i),i) = (Single_OutValues(j+1) - Single_OutValues(j) )/Delt; %(2/3);
                 else                                         %=> -Delta
                     SAmeas(Change_factor(j,i),i) = (Single_OutValues(j) - Single_OutValues(j+1) )/Delt; %(2/3);
-                end 
+                end
             end
         end   %for j=1:sizea
-    
+
     end     %for i=1:r
-   
+
     if NumGroups ~ 0
         SAmeas = SAmeas';
     end
 
     % Compute Mu AbsMu and StDev
     if any(any(isnan(SAmeas)))
-      for j=1:NumFact,
-        SAm = SAmeas(j,:);
-        SAm = SAm(find(~isnan(SAm)));
-        rr=length(SAm);
-        AbsMu(j,1) = sum(abs(SAm),2)/rr;
-      if NumGroups == 0
-        Mu(j,1) = sum(SAm,2)/rr;
-        StDev(j,1) = sum((SAm - repmat(Mu(j),1,rr)).^2/(rr*(rr-1)),2).^0.5;
-      end
-      end
+        for j=1:NumFact
+            SAm = SAmeas(j,:);
+            SAm = SAm(find(~isnan(SAm)));
+            rr=length(SAm);
+            AbsMu(j,1) = sum(abs(SAm),2)/rr;
+            if NumGroups == 0
+                Mu(j,1) = sum(SAm,2)/rr;
+                StDev(j,1) = sum((SAm - repmat(Mu(j),1,rr)).^2/(rr*(rr-1)),2).^0.5;
+            end
+        end
     else
-      AbsMu = sum(abs(SAmeas),2)/r;
-      if NumGroups == 0
-        Mu = sum(SAmeas,2)/r;
-        StDev = sum((SAmeas - repmat(Mu,1,r)).^2/(r*(r-1)),2).^0.5;
-      end
+        AbsMu = sum(abs(SAmeas),2)/r;
+        if NumGroups == 0
+            Mu = sum(SAmeas,2)/r;
+            StDev = sum((SAmeas - repmat(Mu,1,r)).^2/(r*(r-1)),2).^0.5;
+        end
     end
 
     % Define the output Matrix - if we have groups we cannot define the old
     % measure mu, only mu* makes sense
     if NumGroups > 0
-        OutMatrix = [OutMatrix; AbsMu];   
+        OutMatrix = [OutMatrix; AbsMu];
     else
-        OutMatrix = [OutMatrix; AbsMu, Mu, StDev];   
+        OutMatrix = [OutMatrix; AbsMu, Mu, StDev];
     end
 end     % For Each Output
diff --git a/matlab/gsa/Sampling_Function_2.m b/matlab/gsa/Sampling_Function_2.m
index 9c3fea877..48a8187df 100644
--- a/matlab/gsa/Sampling_Function_2.m
+++ b/matlab/gsa/Sampling_Function_2.m
@@ -1,42 +1,42 @@
 function [Outmatrix, OutFact] = Sampling_Function_2(p, k, r, UB, LB, GroupMat)
 %[Outmatrix, OutFact] = Sampling_Function_2(p, k, r, UB, LB, GroupMat)
-%	Inputs: k (1,1)                      := number of factors examined or number of groups examined.
+%       Inputs: k (1,1)                      := number of factors examined or number of groups examined.
 %                                           In case the groups are chosen the number of factors is stores in NumFact and
-%                                           sizea becomes the number of created groups. 
+%                                           sizea becomes the number of created groups.
 %           NumFact (1,1)                := number of factors examined in the case when groups are chosen
-%	    	r (1,1)                      := sample size  
+%               r (1,1)                      := sample size
 %           p (1,1)                      := number of intervals considered in [0, 1]
-%           UB(sizea,1)                  := Upper Bound for each factor 
-%           LB(sizea,1)                  := Lower Bound for each factor 
+%           UB(sizea,1)                  := Upper Bound for each factor
+%           LB(sizea,1)                  := Lower Bound for each factor
 %           GroupNumber(1,1)             := Number of groups (eventually 0)
-%           GroupMat(NumFact,GroupNumber):= Matrix which describes the chosen groups. Each column represents a group and its elements 
+%           GroupMat(NumFact,GroupNumber):= Matrix which describes the chosen groups. Each column represents a group and its elements
 %                                           are set to 1 in correspondence of the factors that belong to the fixed group. All
 %                                           the other elements are zero.
-%   Local Variables:  
-%	    	sizeb (1,1)         := sizea+1
+%   Local Variables:
+%               sizeb (1,1)         := sizea+1
 %           sizec (1,1)         := 1
-%           randmult (sizea,1)  := vector of random +1 and -1  
-%           perm_e(1,sizea)     := vector of sizea random permutated indeces    
+%           randmult (sizea,1)  := vector of random +1 and -1
+%           perm_e(1,sizea)     := vector of sizea random permutated indeces
 %           fact(sizea)         := vector containing the factor varied within each traj
-% 	        DDo(sizea,sizea)    := D*       in Morris, 1991   
-%	        A(sizeb,sizea)      := Jk+1,k   in Morris, 1991
-%	        B(sizeb,sizea)      := B        in Morris, 1991
-%	        Po(sizea,sizea)     := P*       in Morris, 1991
+%               DDo(sizea,sizea)    := D*       in Morris, 1991
+%               A(sizeb,sizea)      := Jk+1,k   in Morris, 1991
+%               B(sizeb,sizea)      := B        in Morris, 1991
+%               Po(sizea,sizea)     := P*       in Morris, 1991
 %           Bo(sizeb,sizea)     := B*       in Morris, 1991
-%	        Ao(sizeb,sizec)     := Jk+1,1   in Morris, 1991
-%	        xo(sizec,sizea)     := x*       in Morris, 1991 (starting point for the trajectory)
+%               Ao(sizeb,sizec)     := Jk+1,1   in Morris, 1991
+%               xo(sizec,sizea)     := x*       in Morris, 1991 (starting point for the trajectory)
 %           In(sizeb,sizea)     := for each loop orientation matrix. It corresponds to a trajectory
 %                                  of k step in the parameter space and it provides a single elementary
-%                                  effect per factor 
+%                                  effect per factor
 %           MyInt()
-%           Fact(sizea,1)       := for each loop vector indicating which factor or group of factors has been changed 
+%           Fact(sizea,1)       := for each loop vector indicating which factor or group of factors has been changed
 %                                  in each step of the trajectory
 %           AuxMat(sizeb,sizea) := Delta*0.5*((2*B - A) * DD0 + A) in Morris, 1991. The AuxMat is used as in Morris design
 %                                  for single factor analysis, while it constitutes an intermediate step for the group analysis.
 %
-%	Output: Outmatrix(sizeb*r, sizea) := for the entire sample size computed In(i,j) matrices
+%       Output: Outmatrix(sizeb*r, sizea) := for the entire sample size computed In(i,j) matrices
 %           OutFact(sizea*r,1)        := for the entire sample size computed Fact(i,1) vectors
-%           
+%
 %   Note: B0 is constructed as in Morris design when groups are not considered. When groups are considered the routine
 %         follows the following steps:
 %           1- Creation of P0 and DD0 matrices defined in Morris for the groups. This means that the dimensions of these
@@ -44,14 +44,19 @@ function [Outmatrix, OutFact] = Sampling_Function_2(p, k, r, UB, LB, GroupMat)
 %           2- Creation of AuxMat matrix with (GroupNumber+1,GroupNumber) elements.
 %           3- Definition of GroupB0 starting from AuxMat, GroupMat and P0.
 %           4- The final B0 for groups is obtained as [ones(sizeb,1)*x0' + GroupB0]. The P0 permutation is present in GroupB0
-%              and it's not necessary to permute the matrix (ones(sizeb,1)*x0') because it's already randomly created. 
+%              and it's not necessary to permute the matrix (ones(sizeb,1)*x0') because it's already randomly created.
 %   Reference:
 %   A. Saltelli, K. Chan, E.M. Scott, "Sensitivity Analysis" on page 68 ss
 %
 %   F. Campolongo, J. Cariboni, JRC - IPSC Ispra, Varese, IT
 %   Last Update: 15 November 2005 by J.Cariboni
+%
+% Written by Jessica Cariboni and Francesca Campolongo
+% Joint Research Centre, The European Commission,
+%
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2005 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -77,76 +82,76 @@ GroupNumber = size(GroupMat,2);
 
 if GroupNumber ~ 0;
     sizea = size(GroupMat,2);
-end    
+end
 
 sizeb = sizea + 1;
 sizec = 1;
 Outmatrix = [];
 OutFact = [];
 
-% For each i generate a trajectory  
+% For each i generate a trajectory
 for i=1:r
-    
+
     % Construct DD0 - OLD VERSION - it does not need communication toolbox
     % RAND(N,M) is an NXM matrix with random entries, chosen from a uniform distribution on the interval (0.0,1.0).
     % Note that DD0 tells if the factor have to be increased or ddecreased
     % by Delta.
-    randmult = ones(k,1);           
-    v = rand(k,1);                  
+    randmult = ones(k,1);
+    v = rand(k,1);
     randmult (find(v < 0.5))=-1;
     randmult = repmat(randmult,1,k);
     DD0 = randmult .* eye(k);
-    
+
     % Construct DD0 - NEW VERSION - it needs communication toolbox
     % randsrc(m) generates an m-by-m matrix, each of whose entries independently takes the value -1 with probability 1/2,
     % and 1 with probability 1/2.
-    % DD0 = randsrc(NumFact) .* eye(NumFact);      
-    
+    % DD0 = randsrc(NumFact) .* eye(NumFact);
+
     % Construct B (lower triangular)
     B = ones(sizeb,sizea);
     for j = 1:sizea
-       B(1:j,j)=0;    
+        B(1:j,j)=0;
     end
-    
+
     % Construct A0, A
     A0 = ones(sizeb,1);
     A = ones(sizeb,NumFact);
 
     % Construct the permutation matrix P0. In each column of P0 one randomly chosen element equals 1
-    % while all the others equal zero. 
+    % while all the others equal zero.
     % P0 tells the order in which order factors are changed in each
     % trajectory. P0 is created as it follows:
     % 1) All the elements of P0 are set equal to zero ==> P0 = zeros (sizea, sizea);
-    % 2) The function randperm create a random permutation of integer 1:sizea, without repetitions ==> perm_e; 
-    % 3) In each column of P0 the element indicated in perm_e is set equal to one.    
-    % Note that P0 is then used reading it by rows. 
+    % 2) The function randperm create a random permutation of integer 1:sizea, without repetitions ==> perm_e;
+    % 3) In each column of P0 the element indicated in perm_e is set equal to one.
+    % Note that P0 is then used reading it by rows.
     P0 = zeros (sizea, sizea);
     perm_e = randperm(sizea);               % RANDPERM(n) is a random permutation of the integers from 1 to n.
     for j = 1:sizea
-        P0(perm_e(j),j) = 1;    
-    end    
-    
-    % When groups are present the random permutation is done only on B. The effect is the same since 
-    % the added part (A0*x0') is completely random. 
+        P0(perm_e(j),j) = 1;
+    end
+
+    % When groups are present the random permutation is done only on B. The effect is the same since
+    % the added part (A0*x0') is completely random.
     if GroupNumber ~ 0
         B = B * (GroupMat*P0')';
     end
-    
+
     % Compute AuxMat both for single factors and groups analysis. For Single factors analysis
     % AuxMat is added to (A0*X0) and then permutated through P0. When groups are active AuxMat is
     % used to build GroupB0. AuxMat is created considering DD0. If the element on DD0 diagonal
-    % is 1 then AuxMat will start with zero and add Delta. If the element on DD0 diagonal is -1 
+    % is 1 then AuxMat will start with zero and add Delta. If the element on DD0 diagonal is -1
     % then DD0 will start Delta and goes to zero.
     AuxMat = Delta*0.5*((2*B - A) * DD0 + A);
-    
+
     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     % a --> Define the random vector x0 for the factors. Note that x0 takes value in the hypercube
-    % [0,...,1-Delta]*[0,...,1-Delta]*[0,...,1-Delta]*[0,...,1-Delta] 
+    % [0,...,1-Delta]*[0,...,1-Delta]*[0,...,1-Delta]*[0,...,1-Delta]
     MyInt = repmat([0:(1/(p-1)):(1-Delta)],NumFact,1);     % Construct all possible values of the factors
-    
+
     % OLD VERSION - it needs communication toolbox
-    % w = randint(NumFact,1,[1,size(MyInt,2)]);              
-    
+    % w = randint(NumFact,1,[1,size(MyInt,2)]);
+
     % NEW VERSION - construct a version of random integers
     % 1) create a vector of random integers
     % 2) divide [0,1] into the needed steps
@@ -155,21 +160,21 @@ for i=1:r
     v = repmat(rand(NumFact,1),1,size(MyInt,2)+1);     % 1)
     IntUsed = repmat([0:1/size(MyInt,2):1],NumFact,1); % 2)
     DiffAuxVec = IntUsed - v;                          % 3)
-    
+
     for ii = 1:size(DiffAuxVec,1)
         w(1,ii) = max(find(DiffAuxVec(ii,:)<0));       % 4)
     end
-    x0 = MyInt(1,w)';                                  % Define x0    
-    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
+    x0 = MyInt(1,w)';                                  % Define x0
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     % b --> Compute the matrix B*, here indicated as B0. Each row in B0 is a
-    % trajectory for Morris Calculations. The dimension of B0 is (Numfactors+1,Numfactors) 
+    % trajectory for Morris Calculations. The dimension of B0 is (Numfactors+1,Numfactors)
     if GroupNumber ~ 0
         B0 = (A0*x0' + AuxMat);
     else
         B0 = (A0*x0' + AuxMat)*P0;
     end
-    
-    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     % c --> Compute values in the original intervals
     % B0 has values x(i,j) in [0, 1/(p -1), 2/(p -1), ... , 1].
     % To obtain values in the original intervals [LB, UB] we compute
@@ -182,8 +187,8 @@ for i=1:r
         Fact(1,j) = find(P0(j,:));
     end
     Fact(1,sizea+1) = 0;
-    
+
     Outmatrix = [Outmatrix; In];
     OutFact = [OutFact; Fact'];
-    
+
 end
\ No newline at end of file
diff --git a/matlab/gsa/cumplot.m b/matlab/gsa/cumplot.m
index 79aae60df..70fe1f475 100644
--- a/matlab/gsa/cumplot.m
+++ b/matlab/gsa/cumplot.m
@@ -1,7 +1,12 @@
-function h = cumplot(x);
+function h = cumplot(x)
 %function h =cumplot(x)
 
-% Copyright (C) 2012 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -24,6 +29,6 @@ y=[0:n n]./n;
 h0 = stairs(x,y);
 grid on,
 
-if nargout,
+if nargout
     h=h0;
 end
diff --git a/matlab/gsa/filt_mc_.m b/matlab/gsa/filt_mc_.m
index 3c79676d8..b2dfb0411 100644
--- a/matlab/gsa/filt_mc_.m
+++ b/matlab/gsa/filt_mc_.m
@@ -11,12 +11,10 @@ function [rmse_MC, ixx] = filt_mc_(OutDir,options_gsa_,dataset_,dataset_info)
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2016 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,6 +37,8 @@ global bayestopt_ estim_params_ M_ options_ oo_
 vvarvecm = options_gsa_.var_rmse;
 if options_.TeX
     vvarvecm_tex = options_gsa_.var_rmse_tex;
+else
+    vvarvecm_tex = [];
 end
 loadSA   = options_gsa_.load_rmse;
 pfilt    = options_gsa_.pfilt_rmse;
@@ -57,51 +57,52 @@ skipline(2)
 disp('Starting sensitivity analysis')
 disp('for the fit of EACH observed series ...')
 skipline()
-disp('Deleting old SA figures...')
-a=dir([OutDir,filesep,'*.*']);
-tmp1='0';
-if options_.opt_gsa.ppost,
-    tmp=['_rmse_post'];
-else
-    if options_.opt_gsa.pprior
-        tmp=['_rmse_prior'];
+if ~options_.nograph
+    disp('Deleting old SA figures...')
+    a=dir([OutDir,filesep,'*.*']);
+    tmp1='0';
+    if options_.opt_gsa.ppost
+        tmp=['_rmse_post'];
     else
-        tmp=['_rmse_mc'];
+        if options_.opt_gsa.pprior
+            tmp=['_rmse_prior'];
+        else
+            tmp=['_rmse_mc'];
+        end
+        if options_gsa_.lik_only
+            tmp1 = [tmp,'_post_SA'];
+            tmp = [tmp,'_lik_SA'];
+        end
     end
-    if options_gsa_.lik_only,
-        tmp1 = [tmp,'_post_SA'];
-        tmp = [tmp,'_lik_SA'];
+    for j=1:length(a)
+        if strmatch([fname_,tmp],a(j).name)
+            disp(a(j).name)
+            delete([OutDir,filesep,a(j).name])
+        end
+        if strmatch([fname_,tmp1],a(j).name)
+            disp(a(j).name)
+            delete([OutDir,filesep,a(j).name])
+        end
     end
+    disp('done !')
 end
-for j=1:length(a),
-    if strmatch([fname_,tmp],a(j).name),
-        disp(a(j).name)
-        delete([OutDir,filesep,a(j).name])
-    end,
-    if strmatch([fname_,tmp1],a(j).name),
-        disp(a(j).name)
-        delete([OutDir,filesep,a(j).name])
-    end,
-end
-disp('done !')
-
 
 nshock=estim_params_.nvx + estim_params_.nvn + estim_params_.ncx + estim_params_.ncn;
 npar=estim_params_.np;
-if ~isempty(options_.mode_file),
-    load(options_.mode_file,'xparam1'),
+if ~isempty(options_.mode_file)
+    load(options_.mode_file,'xparam1')
 end
-if options_.opt_gsa.ppost,
+if options_.opt_gsa.ppost
     c=load([fname_,'_mean.mat'],'xparam1');
     xparam1_mean=c.xparam1;
     clear c
-elseif ~isempty(options_.mode_file) && exist([fname_,'_mean.mat'])==2,
+elseif ~isempty(options_.mode_file) && exist([fname_,'_mean.mat'])==2
     c=load([fname_,'_mean.mat'],'xparam1');
     xparam1_mean=c.xparam1;
     clear c
 end
 
-if options_.opt_gsa.ppost,
+if options_.opt_gsa.ppost
     fnamtmp=[fname_,'_post'];
     DirectoryName = CheckPath('metropolis',M_.dname);
 else
@@ -113,7 +114,17 @@ else
         DirectoryName = CheckPath(['gsa' filesep 'mc'],M_.dname);
     end
 end
-if ~loadSA,
+if loadSA
+    tmplist =load([OutDir,filesep,fnamtmp, '.mat'],'vvarvecm');
+    if isempty(fieldnames(tmplist))
+        disp('WARNING: cannot load results since the list of variables used is not present in the mat file')
+        loadSA=0;
+    elseif ~isequal(tmplist.vvarvecm,vvarvecm)
+        disp('WARNING: cannot load results since the list of variables in the mat file differs from the one requested.')
+        loadSA=0;
+    end
+end
+if ~loadSA
     if exist('xparam1','var')
         M_ = set_all_parameters(xparam1,estim_params_,M_);
         ys_mode=steady_(M_,options_,oo_);
@@ -128,19 +139,26 @@ if ~loadSA,
     data_index = dataset_info.missing.aindex;
     missing_value = dataset_info.missing.state;
     for jx=1:gend
-        data_indx(jx,data_index{jx})=true; 
+        data_indx(jx,data_index{jx})=true;
     end
     %stock_gend=data_info.gend;
     %stock_data = data_info.data;
     load([DirectoryName filesep M_.fname '_data.mat']);
     filfilt = dir([DirectoryName filesep M_.fname '_filter_step_ahead*.mat']);
-    filsmooth = dir([DirectoryName filesep M_.fname '_smooth*.mat']);
+    temp_smooth_file_list = dir([DirectoryName filesep M_.fname '_smooth*.mat']);
+    jfile=0;
+    for j=1:length(temp_smooth_file_list)
+        if isempty(strfind(temp_smooth_file_list(j).name,'smoothed')),
+            jfile=jfile+1;
+            filsmooth(jfile)=temp_smooth_file_list(j);
+        end
+    end
     filupdate = dir([DirectoryName filesep M_.fname '_update*.mat']);
     filparam = dir([DirectoryName filesep M_.fname '_param*.mat']);
     x=[];
     logpo2=[];
     sto_ys=[];
-    for j=1:length(filparam),
+    for j=1:length(filparam)
         %load([DirectoryName filesep M_.fname '_param',int2str(j),'.mat']);
         if isempty(strmatch([M_.fname '_param_irf'],filparam(j).name))
             load([DirectoryName filesep filparam(j).name]);
@@ -155,63 +173,63 @@ if ~loadSA,
     if options_.opt_gsa.ppost || (options_.opt_gsa.ppost==0 && options_.opt_gsa.lik_only==0)
         skipline()
         disp('Computing RMSE''s...')
-        for i=1:size(vvarvecm,1),
+        for i=1:size(vvarvecm,1)
             vj=deblank(vvarvecm(i,:));
-            
+
             jxj(i) = strmatch(vj,lgy_(dr_.order_var,:),'exact');
             js(i) = strmatch(vj,lgy_,'exact');
             yss(i,:,:)=repmat(sto_ys(:,js(i))',[gend,1]);
         end
         if exist('xparam1','var')
             [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK] = DsgeSmoother(xparam1,gend,Y,data_index,missing_value,M_,oo_,options_,bayestopt_,estim_params_);
-            y0 = transpose( squeeze(aK(1,jxj,1:gend)));% + kron(ys_mode(js),ones(1,gend)));
+            y0 = reshape( squeeze(aK(1,jxj,1:gend)),[gend length(jxj)]);% + kron(ys_mode(js),ones(1,gend)));
             yobs = transpose( ahat(jxj,:));% + kron(ys_mode(js),ones(1,gend)));
             rmse_mode = sqrt(mean((yobs(istart:end,:)-y0(istart:end,:)).^2));
             r2_mode = 1-sum((yobs(istart:end,:)-y0(istart:end,:)).^2)./sum(yobs(istart:end,:).^2);
         end
         y0=-yss;
         nbb=0;
-        for j=1:length(filfilt),
+        for j=1:length(filfilt)
             load([DirectoryName filesep M_.fname '_filter_step_ahead',num2str(j),'.mat']);
             nb = size(stock,4);
-            y0(:,:,nbb+1:nbb+nb)=y0(:,:,nbb+1:nbb+nb)+squeeze(stock(1,js,1:gend,:));
+            y0(:,:,nbb+1:nbb+nb)=y0(:,:,nbb+1:nbb+nb)+reshape(stock(1,js,1:gend,:),[length(js) gend nb]);
             nbb=nbb+nb;
             clear stock;
         end
         yobs=-yss;
         nbb=0;
-        for j=1:length(filupdate),
+        for j=1:length(filupdate)
             load([DirectoryName filesep M_.fname '_update',num2str(j),'.mat']);
             nb = size(stock,3);
-            yobs(:,:,nbb+1:nbb+nb)=yobs(:,:,nbb+1:nbb+nb)+squeeze(stock(js,1:gend,:));
+            yobs(:,:,nbb+1:nbb+nb)=yobs(:,:,nbb+1:nbb+nb)+reshape(stock(js,1:gend,:),[length(js) gend nb]);
             nbb=nbb+nb;
             clear stock;
         end
         y0M=mean(y0,2);
         rmse_MC=zeros(nruns,length(js));
         r2_MC=zeros(nruns,length(js));
-        for j=1:nruns,
+        for j=1:nruns
             rmse_MC(j,:) = sqrt(mean((yobs(:,istart:end,j)'-y0(:,istart:end,j)').^2));
             r2_MC(j,:) = 1-mean((yobs(:,istart:end,j)'-y0(:,istart:end,j)').^2)./mean((yobs(:,istart:end,j)').^2);
         end
         if exist('xparam1_mean','var')
             %eval(['rmse_pmean(i) = sqrt(mean((',vj,'(fobs-1+istart:fobs-1+nobs)-y0M(istart:end-1)).^2));'])
             [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK] = DsgeSmoother(xparam1_mean,gend,Y,data_index,missing_value,M_,oo_,options_,bayestopt_,estim_params_);
-            y0 = transpose( squeeze(aK(1,jxj,1:gend)));% + kron(ys_mean(js),ones(1,gend)));
+            y0 = reshape( squeeze(aK(1,jxj,1:gend)),[gend length(jxj)]);% + kron(ys_mean(js),ones(1,gend)));
             yobs = transpose( ahat(jxj,:));% + kron(ys_mean(js),ones(1,gend)));
             rmse_pmean = sqrt(mean((yobs(istart:end,:)-y0(istart:end,:)).^2));
             r2_pmean = 1-mean((yobs(istart:end,:)-y0(istart:end,:)).^2)./mean(yobs(istart:end,:).^2);
         end
         clear stock_filter;
     end
-    for j=1:nruns,
+    for j=1:nruns
         lnprior(j,1) = priordens(x(j,:)',bayestopt_.pshape,bayestopt_.p6,bayestopt_.p7,bayestopt_.p3,bayestopt_.p4);
     end
     likelihood=logpo2(:)-lnprior(:);
     disp('... done!')
-    
+
     if options_.opt_gsa.ppost
-        save([OutDir,filesep,fnamtmp,'.mat'], 'x', 'logpo2', 'likelihood', 'rmse_MC', 'r2_MC')
+        save([OutDir,filesep,fnamtmp,'.mat'], 'x', 'logpo2', 'likelihood', 'rmse_MC', 'r2_MC', 'vvarvecm')
         if exist('xparam1_mean','var')
             save([OutDir,filesep,fnamtmp, '.mat'], 'rmse_pmean', 'r2_pmean','-append')
         end
@@ -222,7 +240,7 @@ if ~loadSA,
         if options_.opt_gsa.lik_only
             save([OutDir,filesep,fnamtmp, '.mat'], 'x', 'logpo2','likelihood', '-append')
         else
-            save([OutDir,filesep,fnamtmp, '.mat'], 'x', 'logpo2','likelihood', 'rmse_MC', 'r2_MC','-append')
+            save([OutDir,filesep,fnamtmp, '.mat'], 'x', 'logpo2','likelihood', 'rmse_MC', 'r2_MC', 'vvarvecm','-append')
             if exist('xparam1_mean','var')
                 save([OutDir,filesep,fnamtmp, '.mat'], 'rmse_pmean', 'r2_pmean','-append')
             end
@@ -235,7 +253,7 @@ else
     if options_.opt_gsa.lik_only && options_.opt_gsa.ppost==0
         load([OutDir,filesep,fnamtmp, '.mat'],'x','logpo2','likelihood');
     else
-        load([OutDir,filesep,fnamtmp, '.mat'],'x','logpo2','likelihood','rmse_MC','rmse_mode','rmse_pmean', 'r2_MC', 'r2_mode','r2_pmean');
+        load([OutDir,filesep,fnamtmp, '.mat'],'x','logpo2','likelihood','rmse_MC','rmse_mode','rmse_pmean', 'r2_MC', 'vvarvecm', 'r2_mode','r2_pmean');
     end
     lnprior=logpo2(:)-likelihood(:);
     nruns=size(x,1);
@@ -248,6 +266,34 @@ if ~options_.opt_gsa.ppost
     [dum, ipost]=sort(-logpo2);
     [dum, ilik]=sort(-likelihood);
 end
+
+%% visual scatter analysis!
+if options_.opt_gsa.ppost
+    tmp_title='R2 Posterior:';
+    atitle='R2 Posterior:';
+    asname='r2_post';
+else
+    if options_.opt_gsa.pprior
+        tmp_title='R2 Prior:';
+        atitle='R2 Prior:';
+        asname='r2_prior';
+    else
+        tmp_title='R2 MC:';
+        atitle='R2 MC:';
+        asname='r2_mc';
+    end
+end
+options_scatter.param_names = vvarvecm;
+options_scatter.param_names_tex = vvarvecm_tex;
+options_scatter.fname_ = fname_;
+options_scatter.OutputDirectoryName = OutDir;
+options_scatter.amcf_name = asname;
+options_scatter.amcf_title = atitle;
+options_scatter.title = tmp_title;
+scatter_analysis(r2_MC, x,options_scatter, options_);
+%% end of visual scatter analysis
+
+
 if ~options_.opt_gsa.ppost && options_.opt_gsa.lik_only
     if options_.opt_gsa.pprior
         anam='rmse_prior_post';
@@ -266,6 +312,7 @@ if ~options_.opt_gsa.ppost && options_.opt_gsa.lik_only
     else
         [pnames]=get_LaTeX_parameter_names(M_,options_,estim_params_,bayestopt_);
         options_mcf.param_names = char(pnames);
+        options_mcf.param_names_tex = [];
     end
     options_mcf.fname_ = fname_;
     options_mcf.OutputDirectoryName = OutDir;
@@ -275,7 +322,7 @@ if ~options_.opt_gsa.ppost && options_.opt_gsa.lik_only
     options_mcf.beha_title = 'better posterior kernel';
     options_mcf.nobeha_title = 'worse posterior kernel';
     mcf_analysis(x, ipost(1:nfilt), ipost(nfilt+1:end), options_mcf, options_);
-    
+
     if options_.opt_gsa.pprior
         anam = 'rmse_prior_lik';
         atitle = 'RMSE prior: Log Likelihood Kernel';
@@ -289,14 +336,14 @@ if ~options_.opt_gsa.ppost && options_.opt_gsa.lik_only
     options_mcf.beha_title = 'better likelihood';
     options_mcf.nobeha_title = 'worse likelihood';
     mcf_analysis(x, ilik(1:nfilt), ilik(nfilt+1:end), options_mcf, options_);
-    
+
 else
-    if options_.opt_gsa.ppost,
+    if options_.opt_gsa.ppost
         rmse_txt=rmse_pmean;
         r2_txt=r2_pmean;
     else
-        if options_.opt_gsa.pprior || ~exist('rmse_pmean'),
-            if exist('rmse_mode'),
+        if options_.opt_gsa.pprior || ~exist('rmse_pmean')
+            if exist('rmse_mode')
                 rmse_txt=rmse_mode;
                 r2_txt=r2_mode;
             else
@@ -309,28 +356,28 @@ else
             r2_txt=r2_pmean;
         end
     end
-    for i=1:size(vvarvecm,1),
+    for i=1:size(vvarvecm,1)
         [dum, ixx(:,i)]=sort(rmse_MC(:,i));
     end
     PP=ones(npar+nshock,size(vvarvecm,1));
     PPV=ones(size(vvarvecm,1),size(vvarvecm,1),npar+nshock);
     SS=zeros(npar+nshock,size(vvarvecm,1));
-    for j=1:npar+nshock,
-        for i=1:size(vvarvecm,1),
+    for j=1:npar+nshock
+        for i=1:size(vvarvecm,1)
             [H,P,KSSTAT] = smirnov(x(ixx(nfilt0(i)+1:end,i),j),x(ixx(1:nfilt0(i),i),j), alpha);
             [H1,P1,KSSTAT1] = smirnov(x(ixx(nfilt0(i)+1:end,i),j),x(ixx(1:nfilt0(i),i),j),alpha,1);
             [H2,P2,KSSTAT2] = smirnov(x(ixx(nfilt0(i)+1:end,i),j),x(ixx(1:nfilt0(i),i),j),alpha,-1);
-            if H1 & H2==0,
+            if H1 & H2==0
                 SS(j,i)=1;
-            elseif H1==0,
+            elseif H1==0
                 SS(j,i)=-1;
             else
                 SS(j,i)=0;
             end
             PP(j,i)=P;
         end
-        for i=1:size(vvarvecm,1),
-            for l=1:size(vvarvecm,1),
+        for i=1:size(vvarvecm,1)
+            for l=1:size(vvarvecm,1)
                 if l~=i && PP(j,i)<alpha && PP(j,l)<alpha
                     [H,P,KSSTAT] = smirnov(x(ixx(1:nfilt0(i),i),j),x(ixx(1:nfilt0(l),l),j), alpha);
                     %[H1,P1,KSSTAT1] = smirnov(x(ixx(1:nfilt0(i),i),j),x(:,j), alpha);
@@ -346,9 +393,9 @@ else
             end
         end
     end
-    if ~options_.nograph,
+    if ~options_.nograph
         ifig=0;
-        for i=1:size(vvarvecm,1),
+        for i=1:size(vvarvecm,1)
             if options_.opt_gsa.ppost
                 temp_name='RMSE Posterior: Log Prior';
             else
@@ -358,9 +405,9 @@ else
                     temp_name='RMSE MC: Log Prior';
                 end
             end
-            if mod(i,9)==1,
+            if mod(i,9)==1
                 ifig=ifig+1;
-                hh=dyn_figure(options_,'name',[temp_name,' ',int2str(ifig)]);
+                hh=dyn_figure(options_.nodisplay,'name',[temp_name,' ',int2str(ifig)]);
             end
             subplot(3,3,i-9*(ifig-1))
             h=cumplot(lnprior(ixx(1:nfilt0(i),i)));
@@ -376,21 +423,27 @@ else
                     annotation('textbox', [0.55,0,0.35,0.05],'String', 'Log-prior for WORSE R2', 'Color','Red','horizontalalignment','center');
                 end
                 if options_.opt_gsa.ppost
-                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_post_lnprior',int2str(ifig)],options_);
-                    create_TeX_loader(options_,[OutDir '/' fname_ '_rmse_post_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_post_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1))
+                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_post_lnprior',int2str(ifig)],options_.nodisplay,options_.graph_format);
+                    if options_.TeX
+                        create_TeX_loader(options_,[OutDir '/' fname_ '_rmse_post_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_post_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1))
+                    end
                 else
                     if options_.opt_gsa.pprior
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_lnprior',int2str(ifig) ],options_);
-                        create_TeX_loader(options_,[OutDir '/' fname_ '_rmse_prior_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_prior_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1))
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_lnprior',int2str(ifig) ],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir '/' fname_ '_rmse_prior_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_prior_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1))
+                        end
                     else
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_lnprior',int2str(ifig) ],options_);
-                        create_TeX_loader(options_,[OutDir '/' fname_ '_rmse_mc_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_mc_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1))
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_lnprior',int2str(ifig) ],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir '/' fname_ '_rmse_mc_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_mc_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1))
+                        end
                     end
                 end
             end
         end
         ifig=0;
-        for i=1:size(vvarvecm,1),
+        for i=1:size(vvarvecm,1)
             if options_.opt_gsa.ppost
                 temp_name='RMSE Posterior: Log Likelihood';
             else
@@ -400,9 +453,9 @@ else
                     temp_name='RMSE MC: Log Likelihood';
                 end
             end
-            if mod(i,9)==1,
+            if mod(i,9)==1
                 ifig=ifig+1;
-                hh = dyn_figure(options_,'Name',[temp_name,' ',int2str(ifig)]);
+                hh = dyn_figure(options_.nodisplay,'Name',[temp_name,' ',int2str(ifig)]);
             end
             subplot(3,3,i-9*(ifig-1))
             h=cumplot(likelihood(ixx(1:nfilt0(i),i)));
@@ -412,7 +465,7 @@ else
             h=cumplot(likelihood(ixx(nfilt0(i)+1:end,i)));
             set(h,'color','red','linewidth',2)
             title(vvarvecm(i,:),'interpreter','none')
-            if options_.opt_gsa.ppost==0,
+            if options_.opt_gsa.ppost==0
                 set(gca,'xlim',[min( likelihood(ixx(1:nfilt0(i),i)) ) max( likelihood(ixx(1:nfilt0(i),i)) )])
             end
             if mod(i,9)==0 || i==size(vvarvecm,1)
@@ -421,21 +474,27 @@ else
                     annotation('textbox', [0.55,0,0.35,0.05],'String', 'Log-likelihood for WORSE R2', 'Color','Red','horizontalalignment','center');
                 end
                 if options_.opt_gsa.ppost
-                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_post_lnlik',int2str(ifig) ],options_);
-                    create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_post_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_post_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_post_lnlik',int2str(ifig) ],options_.nodisplay,options_.graph_format);
+                    if options_.TeX
+                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_post_lnprior',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_post_lnprior',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                    end
                 else
                     if options_.opt_gsa.pprior
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_lnlik',int2str(ifig)],options_);
-                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_lnlik',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_prior_lnlik',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_lnlik',int2str(ifig)],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_lnlik',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_prior_lnlik',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        end
                     else
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_lnlik',int2str(ifig) ],options_);
-                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_lnlik',int2str(ifig) ],ifig,[temp_name,' ',int2str(ifig)],'rmse_mc_lnlik',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_lnlik',int2str(ifig) ],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_lnlik',int2str(ifig) ],ifig,[temp_name,' ',int2str(ifig)],'rmse_mc_lnlik',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        end
                     end
                 end
             end
         end
         ifig=0;
-        for i=1:size(vvarvecm,1),
+        for i=1:size(vvarvecm,1)
             if options_.opt_gsa.ppost
                 temp_name='RMSE Posterior: Log Posterior';
             else
@@ -445,9 +504,9 @@ else
                     temp_name='RMSE MC: Log Posterior';
                 end
             end
-            if mod(i,9)==1,
+            if mod(i,9)==1
                 ifig=ifig+1;
-                hh = dyn_figure(options_,'Name',[temp_name,' ',int2str(ifig)]);
+                hh = dyn_figure(options_.nodisplay,'Name',[temp_name,' ',int2str(ifig)]);
             end
             subplot(3,3,i-9*(ifig-1))
             h=cumplot(logpo2(ixx(1:nfilt0(i),i)));
@@ -457,7 +516,7 @@ else
             h=cumplot(logpo2(ixx(nfilt0(i)+1:end,i)));
             set(h,'color','red','linewidth',2)
             title(vvarvecm(i,:),'interpreter','none')
-            if options_.opt_gsa.ppost==0,
+            if options_.opt_gsa.ppost==0
                 set(gca,'xlim',[min( logpo2(ixx(1:nfilt0(i),i)) ) max( logpo2(ixx(1:nfilt0(i),i)) )])
             end
             if mod(i,9)==0 || i==size(vvarvecm,1)
@@ -466,21 +525,27 @@ else
                     annotation('textbox', [0.55,0,0.35,0.05],'String', 'Log-posterior for WORSE R2', 'Color','Red','horizontalalignment','center');
                 end
                 if options_.opt_gsa.ppost
-                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_post_lnpost',int2str(ifig) ],options_);
-                    create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_post_lnpost',int2str(ifig) ],ifig,[temp_name,' ',int2str(ifig)],'rmse_post_lnpost',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_post_lnpost',int2str(ifig) ],options_.nodisplay,options_.graph_format);
+                    if options_.TeX
+                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_post_lnpost',int2str(ifig) ],ifig,[temp_name,' ',int2str(ifig)],'rmse_post_lnpost',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                    end
                 else
                     if options_.opt_gsa.pprior
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_lnpost',int2str(ifig)],options_);
-                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_lnpost',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_prior_lnpost',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_lnpost',int2str(ifig)],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_lnpost',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_prior_lnpost',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        end
                     else
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_lnpost',int2str(ifig)],options_);
-                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_lnpost',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_mc_lnpost',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_lnpost',int2str(ifig)],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_lnpost',int2str(ifig)],ifig,[temp_name,' ',int2str(ifig)],'rmse_mc_lnpost',options_.figures.textwidth*min((i-9*(ifig-1))/3,1));
+                        end
                     end
                 end
             end
         end
     end
-    
+
     if options_.TeX
         [pnames,pnames_tex]=get_LaTeX_parameter_names(M_,options_,estim_params_,bayestopt_);
         param_names = char(pnames);
@@ -488,9 +553,10 @@ else
     else
         [pnames]=get_LaTeX_parameter_names(M_,options_,estim_params_,bayestopt_);
         param_names = char(pnames);
+        param_names_tex = [];
     end
 
-    
+
     skipline()
     title_string='RMSE over the MC sample:';
     data_mat=[min(rmse_MC)' max(rmse_MC)'];
@@ -500,7 +566,7 @@ else
         headers_tex=strvcat('\text{Variable}','\text{min yr RMSE}','\text{max yr RMSE}');
         dyn_latex_table(M_,options_,title_string,'RMSE_MC',headers_tex,vvarvecm_tex,data_mat,0,15,5);
     end
-    
+
     invar = find( std(rmse_MC)./mean(rmse_MC)<=0.0001 );
     if ~isempty(invar)
         skipline(2)
@@ -509,10 +575,12 @@ else
         disp('These variables are excluded from SA')
         disp('[Unless you treat these series as exogenous, there is something wrong in your estimation !]')
     end
+    vvarvecm0=vvarvecm;
+
     ivar = find( std(rmse_MC)./mean(rmse_MC)>0.0001 );
     vvarvecm=vvarvecm(ivar,:);
     rmse_MC=rmse_MC(:,ivar);
-    
+
     skipline()
     % if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
     disp(['Sample filtered the ',num2str(pfilt*100),'% best RMSE''s for each observed series ...' ])
@@ -522,11 +590,11 @@ else
     % figure, boxplot(rmse_MC)
     % set(gca,'xticklabel',vvarvecm)
     % saveas(gcf,[fname_,'_SA_RMSE'])
-    
+
     skipline(2)
     disp('RMSE ranges after filtering:')
     title_string='RMSE ranges after filtering:';
-    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
+    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior
         headers=strvcat('Variable','min','max','min','max','posterior mode');
         headers_tex=strvcat('\text{Variable}','\text{min}','\text{max}','\text{min}','\text{max}','\text{posterior mode}');
     else
@@ -534,12 +602,12 @@ else
         headers_tex=strvcat('\text{Variable}','\text{min}','\text{max}','\text{min}','\text{max}','\text{posterior mean}');
     end
     data_mat=NaN(size(vvarvecm,1),5);
-    for j=1:size(vvarvecm,1),
+    for j=1:size(vvarvecm,1)
         data_mat(j,:)=[min(rmse_MC(ixx(1:nfilt0(j),j),j)) ...
-            max(rmse_MC(ixx(1:nfilt0(j),j),j))  ...
-            min(rmse_MC(ixx(nfilt0(j)+1:end,j),j)) ...
-            max(rmse_MC(ixx(nfilt0(j)+1:end,j),j)) ...
-            rmse_txt(j)];
+                       max(rmse_MC(ixx(1:nfilt0(j),j),j))  ...
+                       min(rmse_MC(ixx(nfilt0(j)+1:end,j),j)) ...
+                       max(rmse_MC(ixx(nfilt0(j)+1:end,j),j)) ...
+                       rmse_txt(j)];
     end
     %get formatting for additional header line
     val_width=15;
@@ -554,7 +622,7 @@ else
     if any(data_mat) < 0 %add one character for minus sign
         values_length = values_length+1;
     end
-    
+
     headers_length = max(size(deblank(headers(2:end,:)),2));
     if ~isempty(val_width)
         val_width = max(max(headers_length,values_length)+2,val_width);
@@ -563,24 +631,24 @@ else
     end
     value_format  = sprintf('%%%d.%df',val_width,val_precis);
     header_string_format  = sprintf('%%%ds',val_width);
-    
-    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
+
+    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior
         optional_header=sprintf([label_format_leftbound,header_string_format,header_string_format,header_string_format,header_string_format],'','',['best ',num2str(pfilt*100),'% filtered'],'','remaining 90%');
     else
         optional_header=sprintf([label_format_leftbound,header_string_format,header_string_format,header_string_format,header_string_format],'','','best  filtered','','remaining');
     end
     dyntable(options_,title_string,headers,vvarvecm,data_mat, 0, val_width, val_precis,optional_header);
     if options_.TeX
-        if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
+        if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior
             optional_header={[' & \multicolumn{2}{c}{best ',num2str(pfilt*100),' filtered} & \multicolumn{2}{c}{remaining 90\%}\\']};
         else
             optional_header={[' & \multicolumn{2}{c}{best filtered} & \multicolumn{2}{c}{remaining}\\']};
         end
         dyn_latex_table(M_,options_,title_string,'RMSE_ranges_after_filtering',headers_tex,vvarvecm_tex,data_mat,0,val_width,val_precis,optional_header);
     end
-    
+
     %%%%% R2 table
-    
+    vvarvecm=vvarvecm0;
     skipline()
     title_string='R2 over the MC sample:';
     data_mat=[min(r2_MC)' max(r2_MC)'];
@@ -590,16 +658,17 @@ else
         headers_tex=strvcat('\text{Variable}','\text{min yr R2}','\text{max yr R2}');
         dyn_latex_table(M_,options_,title_string,'R2_MC',headers_tex,vvarvecm_tex,data_mat,0,15,5);
     end
-    
+
     r2_MC=r2_MC(:,ivar);
-    
+    vvarvecm=vvarvecm(ivar,:);
+
     skipline()
     disp(['Sample filtered the ',num2str(pfilt*100),'% best R2''s for each observed series ...' ])
-    
+
     skipline()
     disp('R2 ranges after filtering:')
     title_string='R2 ranges after filtering:';
-    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
+    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior
         headers=strvcat('Variable','min','max','min','max','posterior mode');
         headers_tex=strvcat('\text{Variable}','\text{min}','\text{max}','\text{min}','\text{max}','\text{posterior mode}');
     else
@@ -607,12 +676,12 @@ else
         headers_tex=strvcat('\text{Variable}','\text{min}','\text{max}','\text{min}','\text{max}','\text{posterior mean}');
     end
     data_mat=NaN(size(vvarvecm,1),5);
-    for j=1:size(vvarvecm,1),
+    for j=1:size(vvarvecm,1)
         data_mat(j,:)=[min(r2_MC(ixx(1:nfilt0(j),j),j)) ...
-            max(r2_MC(ixx(1:nfilt0(j),j),j))  ...
-            min(r2_MC(ixx(nfilt0(j)+1:end,j),j)) ...
-            max(r2_MC(ixx(nfilt0(j)+1:end,j),j)) ...
-            r2_txt(j)];
+                       max(r2_MC(ixx(1:nfilt0(j),j),j))  ...
+                       min(r2_MC(ixx(nfilt0(j)+1:end,j),j)) ...
+                       max(r2_MC(ixx(nfilt0(j)+1:end,j),j)) ...
+                       r2_txt(j)];
     end
     %get formatting for additional header line
     val_width=15;
@@ -627,7 +696,7 @@ else
     if any(data_mat) < 0 %add one character for minus sign
         values_length = values_length+1;
     end
-    
+
     headers_length = max(size(deblank(headers(2:end,:)),2));
     if ~isempty(val_width)
         val_width = max(max(headers_length,values_length)+2,val_width);
@@ -636,32 +705,32 @@ else
     end
     value_format  = sprintf('%%%d.%df',val_width,val_precis);
     header_string_format  = sprintf('%%%ds',val_width);
-    
-    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
+
+    if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior
         optional_header=sprintf([label_format_leftbound,header_string_format,header_string_format,header_string_format,header_string_format],'','',['best ',num2str(pfilt*100),'% filtered'],'','remaining 90%');
     else
         optional_header=sprintf([label_format_leftbound,header_string_format,header_string_format,header_string_format,header_string_format],'','','best  filtered','','remaining');
     end
     dyntable(options_,title_string,headers,vvarvecm,data_mat, 0, val_width, val_precis,optional_header);
     if options_.TeX
-        if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior,
+        if options_.opt_gsa.ppost==0 && options_.opt_gsa.pprior
             optional_header={[' & \multicolumn{2}{c}{best ',num2str(pfilt*100),' filtered} & \multicolumn{2}{c}{remaining 90\%}\\']};
         else
             optional_header={[' & \multicolumn{2}{c}{best filtered} & \multicolumn{2}{c}{remaining}\\']};
         end
         dyn_latex_table(M_,options_,title_string,'R2_ranges_after_filtering',headers_tex,vvarvecm_tex,data_mat,0,val_width,val_precis,optional_header);
     end
-    
-    
+
+
     %%%%  R2 table
     SP=zeros(npar+nshock,size(vvarvecm,1));
-    for j=1:size(vvarvecm,1),
+    for j=1:size(vvarvecm,1)
         ns=find(PP(:,j)<alpha);
         SP(ns,j)=ones(size(ns));
         SS(:,j)=SS(:,j).*SP(:,j);
     end
-    
-    for j=1:npar+nshock, %estim_params_.np,
+
+    for j=1:npar+nshock %estim_params_.np,
         nsp(j)=length(find(SP(j,:)));
     end
     snam0=param_names(find(nsp==0),:);
@@ -673,7 +742,7 @@ else
     % snam2=bayestopt_.name(find(nsp>1));
     % snam=bayestopt_.name(find(nsp>0));
     nsnam=(find(nsp>1));
-    
+
     skipline(2)
     disp('These parameters do not affect significantly the fit of ANY observed series:')
     disp(snam0)
@@ -683,11 +752,11 @@ else
     skipline()
     disp('These parameters affect MORE THAN ONE observed series: trade off exists!')
     disp(snam2)
-    
-    
+
+
     %pnam=bayestopt_.name(end-estim_params_.np+1:end);
     pnam=bayestopt_.name;
-    
+
     % plot trade-offs
     if ~options_.nograph
         a00=jet(size(vvarvecm,1));
@@ -714,7 +783,7 @@ else
         options_mcf.param_names_tex = param_names_tex;
         options_mcf.fname_ = fname_;
         options_mcf.OutputDirectoryName = OutDir;
-        for iy=1:size(vvarvecm,1),
+        for iy=1:size(vvarvecm,1)
             options_mcf.amcf_name = [asname '_' deblank(vvarvecm(iy,:)) '_map' ];
             options_mcf.amcf_title = [atitle ' ' deblank(vvarvecm(iy,:))];
             options_mcf.beha_title = ['better fit of ' deblank(vvarvecm(iy,:))];
@@ -722,21 +791,21 @@ else
             options_mcf.title = ['the fit of ' deblank(vvarvecm(iy,:))];
             mcf_analysis(x, ixx(1:nfilt0(iy),iy), ixx(nfilt0(iy)+1:end,iy), options_mcf, options_);
         end
-        for iy=1:size(vvarvecm,1),
+        for iy=1:size(vvarvecm,1)
             ipar = find(any(squeeze(PPV(iy,:,:))<alpha));
-            for ix=1:ceil(length(ipar)/5),
-                hh = dyn_figure(options_,'name',[temp_name,' observed variable ',deblank(vvarvecm(iy,:))]);
-                for j=1+5*(ix-1):min(length(ipar),5*ix),
+            for ix=1:ceil(length(ipar)/5)
+                hh = dyn_figure(options_.nodisplay,'name',[temp_name,' observed variable ',deblank(vvarvecm(iy,:))]);
+                for j=1+5*(ix-1):min(length(ipar),5*ix)
                     subplot(2,3,j-5*(ix-1))
                     %h0=cumplot(x(:,nsnam(j)+nshock));
                     h0=cumplot(x(:,ipar(j)));
                     set(h0,'color',[0 0 0])
                     hold on,
                     iobs=find(squeeze(PPV(iy,:,ipar(j)))<alpha);
-                    for i=1:size(vvarvecm,1),
+                    for i=1:size(vvarvecm,1)
                         %h0=cumplot(x(ixx(1:nfilt,np(i)),nsnam(j)+nshock));
                         %                 h0=cumplot(x(ixx(1:nfilt0(np(i)),np(i)),nsnam(j)));
-                        if any(iobs==i) || i==iy,
+                        if any(iobs==i) || i==iy
                             h0=cumplot(x(ixx(1:nfilt0(i),i),ipar(j)));
                             if ~isoctave
                                 hcmenu = uicontextmenu;
@@ -768,24 +837,30 @@ else
                 %h0=legend({'base',vnam{np}}',0);
                 %set(findobj(get(h0,'children'),'type','text'),'interpreter','none')
                 if options_.opt_gsa.ppost
-                    dyn_saveas(hh,[ OutDir filesep fname_ '_rmse_post_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],options_);
-                    create_TeX_loader(options_,[ OutDir filesep fname_ '_rmse_post_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],ix,[temp_name,' observed variable $',deblank(vvarvecm_tex(iy,:)) '$'],['rmse_post_' deblank(vvarvecm(iy,:))],1)
+                    dyn_saveas(hh,[ OutDir filesep fname_ '_rmse_post_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],options_.nodisplay,options_.graph_format);
+                    if options_.TeX
+                        create_TeX_loader(options_,[ OutDir filesep fname_ '_rmse_post_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],ix,[temp_name,' observed variable $',deblank(vvarvecm_tex(iy,:)) '$'],['rmse_post_' deblank(vvarvecm(iy,:))],1)
+                    end
                 else
                     if options_.opt_gsa.pprior
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_' deblank(vvarvecm(iy,:)) '_' int2str(ix) ],options_);
-                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_' deblank(vvarvecm(iy,:)) '_' int2str(ix) ],ix,[temp_name,' observed variable $',deblank(vvarvecm_tex(iy,:)) '$'],['rmse_prior_' deblank(vvarvecm(iy,:))],1)
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_' deblank(vvarvecm(iy,:)) '_' int2str(ix) ],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_' deblank(vvarvecm(iy,:)) '_' int2str(ix) ],ix,[temp_name,' observed variable $',deblank(vvarvecm_tex(iy,:)) '$'],['rmse_prior_' deblank(vvarvecm(iy,:))],1)
+                        end
                     else
-                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],options_);
-                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],ix,[temp_name,' observed variable $',deblank(vvarvecm_tex(iy,:)) '$'],['rmse_mc_' deblank(vvarvecm(iy,:))],1)
+                        dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],options_.nodisplay,options_.graph_format);
+                        if options_.TeX
+                            create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_' deblank(vvarvecm(iy,:)) '_' int2str(ix)],ix,[temp_name,' observed variable $',deblank(vvarvecm_tex(iy,:)) '$'],['rmse_mc_' deblank(vvarvecm(iy,:))],1)
+                        end
                     end
                 end
             end
         end
-        
+
         % now I plot by individual parameters
-        for ix=1:ceil(length(nsnam)/5),
-            hh = dyn_figure(options_,'name',[temp_name,' estimated params and shocks ',int2str(ix)]);
-            for j=1+5*(ix-1):min(size(snam2,1),5*ix),
+        for ix=1:ceil(length(nsnam)/5)
+            hh = dyn_figure(options_.nodisplay,'name',[temp_name,' estimated params and shocks ',int2str(ix)]);
+            for j=1+5*(ix-1):min(size(snam2,1),5*ix)
                 subplot(2,3,j-5*(ix-1))
                 %h0=cumplot(x(:,nsnam(j)+nshock));
                 h0=cumplot(x(:,nsnam(j)));
@@ -794,10 +869,10 @@ else
                 npx=find(SP(nsnam(j),:)==0);
                 %a0=jet(nsp(nsnam(j)));
                 %             a0=a00(np,:);
-                for i=1:size(vvarvecm,1),
+                for i=1:size(vvarvecm,1)
                     %h0=cumplot(x(ixx(1:nfilt,np(i)),nsnam(j)+nshock));
                     %                 h0=cumplot(x(ixx(1:nfilt0(np(i)),np(i)),nsnam(j)));
-                    if any(npx==i),
+                    if any(npx==i)
                         h0=cumplot(x(ixx(1:nfilt0(i),i),nsnam(j))*NaN);
                     else
                         h0=cumplot(x(ixx(1:nfilt0(i),i),nsnam(j)));
@@ -829,79 +904,85 @@ else
             %h0=legend({'base',vnam{np}}',0);
             %set(findobj(get(h0,'children'),'type','text'),'interpreter','none')
             if options_.opt_gsa.ppost
-                dyn_saveas(hh,[ OutDir filesep fname_ '_rmse_post_params_' int2str(ix)],options_);
-                create_TeX_loader(options_,[ OutDir filesep fname_ '_rmse_post_params_' int2str(ix)],ix,[temp_name,' estimated params and shocks ',int2str(ix)],'rmse_post_params',1)
+                dyn_saveas(hh,[ OutDir filesep fname_ '_rmse_post_params_' int2str(ix)],options_.nodisplay,options_.graph_format);
+                if options_.TeX
+                    create_TeX_loader(options_,[ OutDir filesep fname_ '_rmse_post_params_' int2str(ix)],ix,[temp_name,' estimated params and shocks ',int2str(ix)],'rmse_post_params',1)
+                end
             else
                 if options_.opt_gsa.pprior
-                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_params_' int2str(ix) ],options_);
-                    create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_params_' int2str(ix) ],ix,[temp_name,' estimated params and shocks ',int2str(ix)],'rmse_prior_params',1)
+                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_prior_params_' int2str(ix) ],options_.nodisplay,options_.graph_format);
+                    if options_.TeX
+                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_prior_params_' int2str(ix) ],ix,[temp_name,' estimated params and shocks ',int2str(ix)],'rmse_prior_params',1)
+                    end
                 else
-                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_params_' int2str(ix)],options_);
-                    create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_params_' int2str(ix)],ix,[temp_name,' estimated params and shocks ',int2str(ix)],'rmse_mc_params',1)
+                    dyn_saveas(hh,[OutDir filesep fname_ '_rmse_mc_params_' int2str(ix)],options_.nodisplay,options_.graph_format);
+                    if options_.TeX
+                        create_TeX_loader(options_,[OutDir filesep fname_ '_rmse_mc_params_' int2str(ix)],ix,[temp_name,' estimated params and shocks ',int2str(ix)],'rmse_mc_params',1)
+                    end
                 end
             end
         end
     end
-    
-%     for j=1:size(SP,2),
-%         nsx(j)=length(find(SP(:,j)));
-%     end
-    
-%     skipline(2)
-%     disp('Sensitivity table (significance and direction):')
-%     vav=char(zeros(1, size(param_names,2)+3 ));
-%     ibl = 12-size(vvarvecm,2);
-%     for j=1:size(vvarvecm,1),
-%         vav = [vav, char(zeros(1,ibl)),vvarvecm(j,:)];
-%     end
-%     disp(vav)
-%     for j=1:npar+nshock, %estim_params_.np,
-%         %disp([param_names(j,:), sprintf('%8.5g',SP(j,:))])
-%         disp([param_names(j,:),'   ', sprintf('%12.3g',PP(j,:))])
-%         disp([char(zeros(1, size(param_names,2)+3 )),sprintf('    (%6g)',SS(j,:))])
-%     end
-    
-    
-%     skipline()
-%     disp('Starting bivariate analysis:')
-%     
-%     for i=1:size(vvarvecm,1)
-%         if options_.opt_gsa.ppost
-%             fnam = ['rmse_post_',deblank(vvarvecm(i,:))];
-%         else
-%             if options_.opt_gsa.pprior
-%                 fnam = ['rmse_prior_',deblank(vvarvecm(i,:))];
-%             else
-%                 fnam = ['rmse_mc_',deblank(vvarvecm(i,:))];
-%             end
-%         end
-%         stab_map_2(x(ixx(1:nfilt0(i),i),:),alpha2,pvalue,fnam, OutDir,[],[temp_name ' observed variable ' deblank(vvarvecm(i,:))]);
-%         
-%         %     [pc,latent,explained] = pcacov(c0);
-%         %     %figure, bar([explained cumsum(explained)])
-%         %     ifig=0;
-%         %     j2=0;
-%         %     for j=1:npar+nshock,
-%         %         i2=find(abs(pc(:,j))>alphaPC);
-%         %         if ~isempty(i2),
-%         %             j2=j2+1;
-%         %             if mod(j2,12)==1,
-%         %                 ifig=ifig+1;
-%         %                 figure('name',['PCA of the filtered sample ',deblank(vvarvecm(i,:)),' ',num2str(ifig)]),
-%         %             end
-%         %             subplot(3,4,j2-(ifig-1)*12)
-%         %             bar(pc(i2,j)),
-%         %             set(gca,'xticklabel',bayestopt_.name(i2)),
-%         %             set(gca,'xtick',[1:length(i2)])
-%         %             title(['PC ',num2str(j),'. Explained ',num2str(explained(j)),'%'])
-%         %         end
-%         %         if (mod(j2,12)==0 | j==(npar+nshock)) & j2,
-%         %             saveas(gcf,[fname_,'_SA_PCA_',deblank(vvarvecm(i,:)),'_',int2str(ifig)])
-%         %         end
-%         %     end
-%         %     close all
-%     end
-    
+
+    %     for j=1:size(SP,2),
+    %         nsx(j)=length(find(SP(:,j)));
+    %     end
+
+    %     skipline(2)
+    %     disp('Sensitivity table (significance and direction):')
+    %     vav=char(zeros(1, size(param_names,2)+3 ));
+    %     ibl = 12-size(vvarvecm,2);
+    %     for j=1:size(vvarvecm,1),
+    %         vav = [vav, char(zeros(1,ibl)),vvarvecm(j,:)];
+    %     end
+    %     disp(vav)
+    %     for j=1:npar+nshock, %estim_params_.np,
+    %         %disp([param_names(j,:), sprintf('%8.5g',SP(j,:))])
+    %         disp([param_names(j,:),'   ', sprintf('%12.3g',PP(j,:))])
+    %         disp([char(zeros(1, size(param_names,2)+3 )),sprintf('    (%6g)',SS(j,:))])
+    %     end
+
+
+    %     skipline()
+    %     disp('Starting bivariate analysis:')
+    %
+    %     for i=1:size(vvarvecm,1)
+    %         if options_.opt_gsa.ppost
+    %             fnam = ['rmse_post_',deblank(vvarvecm(i,:))];
+    %         else
+    %             if options_.opt_gsa.pprior
+    %                 fnam = ['rmse_prior_',deblank(vvarvecm(i,:))];
+    %             else
+    %                 fnam = ['rmse_mc_',deblank(vvarvecm(i,:))];
+    %             end
+    %         end
+    %         stab_map_2(x(ixx(1:nfilt0(i),i),:),alpha2,pvalue,fnam, OutDir,[],[temp_name ' observed variable ' deblank(vvarvecm(i,:))]);
+    %
+    %         %     [pc,latent,explained] = pcacov(c0);
+    %         %     %figure, bar([explained cumsum(explained)])
+    %         %     ifig=0;
+    %         %     j2=0;
+    %         %     for j=1:npar+nshock,
+    %         %         i2=find(abs(pc(:,j))>alphaPC);
+    %         %         if ~isempty(i2),
+    %         %             j2=j2+1;
+    %         %             if mod(j2,12)==1,
+    %         %                 ifig=ifig+1;
+    %         %                 figure('name',['PCA of the filtered sample ',deblank(vvarvecm(i,:)),' ',num2str(ifig)]),
+    %         %             end
+    %         %             subplot(3,4,j2-(ifig-1)*12)
+    %         %             bar(pc(i2,j)),
+    %         %             set(gca,'xticklabel',bayestopt_.name(i2)),
+    %         %             set(gca,'xtick',[1:length(i2)])
+    %         %             title(['PC ',num2str(j),'. Explained ',num2str(explained(j)),'%'])
+    %         %         end
+    %         %         if (mod(j2,12)==0 | j==(npar+nshock)) & j2,
+    %         %             saveas(gcf,[fname_,'_SA_PCA_',deblank(vvarvecm(i,:)),'_',int2str(ifig)])
+    %         %         end
+    %         %     end
+    %         %     close all
+    %     end
+
 end
 
 function []=create_TeX_loader(options_,figpath,label_number,caption,label_name,scale_factor)
@@ -925,7 +1006,7 @@ end
 function [pnames,pnames_tex]=get_LaTeX_parameter_names(M_,options_,estim_params_,bayestopt_)
 np=size(bayestopt_.name,1);
 pnames=cell(np,1);
-pnames_tex=cell(np,1);    
+pnames_tex=cell(np,1);
 for ii=1:length(bayestopt_.name)
     if options_.TeX
         [param_name_temp, param_name_tex_temp]= get_the_name(ii,options_.TeX,M_,estim_params_,options_);
@@ -936,4 +1017,3 @@ for ii=1:length(bayestopt_.name)
         pnames{ii,1} = param_name_temp;
     end
 end
-
diff --git a/matlab/gsa/ghx2transition.m b/matlab/gsa/ghx2transition.m
index 46b463e36..df404577a 100644
--- a/matlab/gsa/ghx2transition.m
+++ b/matlab/gsa/ghx2transition.m
@@ -3,13 +3,10 @@ function [A,B] = ghx2transition(mm,iv,ic,aux)
 %
 % Adapted by M. Ratto (from kalman_transition_matrix.m)
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
+% marco.ratto@ec.europa.eu
 %
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,10 +25,10 @@ function [A,B] = ghx2transition(mm,iv,ic,aux)
 
 global oo_ M_
 
-  [nr1, nc1] = size(mm);
-  ghx = mm(:, [1:(nc1-M_.exo_nbr)]);
-  ghu = mm(:, [(nc1-M_.exo_nbr+1):end] );
-  if nargin == 1
+[nr1, nc1] = size(mm);
+ghx = mm(:, [1:(nc1-M_.exo_nbr)]);
+ghu = mm(:, [(nc1-M_.exo_nbr+1):end] );
+if nargin == 1
     oo_.dr.ghx = ghx;
     oo_.dr.ghu = ghu;
     endo_nbr = M_.endo_nbr;
@@ -43,18 +40,18 @@ global oo_ M_
     k = find(aux(:,2) > nspred);
     aux(:,2) = aux(:,2) + nstatic;
     aux(k,2) = aux(k,2) + M_.nfwrd;
-  end
-  n_iv = length(iv);
-  n_ir1 = size(aux,1);
-  nr = n_iv + n_ir1;
-  
-  A = zeros(nr,nr);
-  B = zeros(nr,M_.exo_nbr);
-  
-  i_n_iv = 1:n_iv;
-  A(i_n_iv,ic) = ghx(iv,:);
-  if n_ir1 > 0
+end
+n_iv = length(iv);
+n_ir1 = size(aux,1);
+nr = n_iv + n_ir1;
+
+A = zeros(nr,nr);
+B = zeros(nr,M_.exo_nbr);
+
+i_n_iv = 1:n_iv;
+A(i_n_iv,ic) = ghx(iv,:);
+if n_ir1 > 0
     A(n_iv+1:end,:) = sparse(aux(:,1),aux(:,2),ones(n_ir1,1),n_ir1,nr);
-  end
-  
-  B(i_n_iv,:) = ghu(iv,:);
+end
+
+B(i_n_iv,:) = ghu(iv,:);
diff --git a/matlab/gsa/gsa_plotmatrix.m b/matlab/gsa/gsa_plotmatrix.m
index 4caadf407..1a12a7e8b 100644
--- a/matlab/gsa/gsa_plotmatrix.m
+++ b/matlab/gsa/gsa_plotmatrix.m
@@ -1,8 +1,13 @@
 function gsa_plotmatrix(type,varargin)
 % function gsa_plotmatrix(type,varargin)
-% extended version of the standard MATLAB plotmatrix 
+% extended version of the standard MATLAB plotmatrix
+%
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2012 European Commission
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,45 +38,45 @@ end
 iexplosive = iunstable(~ismember(iunstable,[iindeterm;iwrong]));
 
 switch type
-    case 'all'
-        x=[lpmat0 lpmat];
-        NumberOfDraws=size(x,1);
-        B=NumberOfDraws;
-    case 'stable'
-        x=[lpmat0(istable,:) lpmat(istable,:)];
-        NumberOfDraws=size(x,1);
-        B=NumberOfDraws;
-    case 'nosolution'
-        x=[lpmat0(iunstable,:) lpmat(iunstable,:)];
-        NumberOfDraws=size(x,1);
-        B=NumberOfDraws;
-    case 'unstable'
-        x=[lpmat0(iexplosive,:) lpmat(iexplosive,:)];
-        NumberOfDraws=size(x,1);
-        B=NumberOfDraws;
-    case 'indeterm'
-        x=[lpmat0(iindeterm,:) lpmat(iindeterm,:)];
-        NumberOfDraws=size(x,1);
-        B=NumberOfDraws;
-    case 'wrong'
-        x=[lpmat0(iwrong,:) lpmat(iwrong,:)];
-        NumberOfDraws=size(x,1);
-        B=NumberOfDraws;
-        
+  case 'all'
+    x=[lpmat0 lpmat];
+    NumberOfDraws=size(x,1);
+    B=NumberOfDraws;
+  case 'stable'
+    x=[lpmat0(istable,:) lpmat(istable,:)];
+    NumberOfDraws=size(x,1);
+    B=NumberOfDraws;
+  case 'nosolution'
+    x=[lpmat0(iunstable,:) lpmat(iunstable,:)];
+    NumberOfDraws=size(x,1);
+    B=NumberOfDraws;
+  case 'unstable'
+    x=[lpmat0(iexplosive,:) lpmat(iexplosive,:)];
+    NumberOfDraws=size(x,1);
+    B=NumberOfDraws;
+  case 'indeterm'
+    x=[lpmat0(iindeterm,:) lpmat(iindeterm,:)];
+    NumberOfDraws=size(x,1);
+    B=NumberOfDraws;
+  case 'wrong'
+    x=[lpmat0(iwrong,:) lpmat(iwrong,:)];
+    NumberOfDraws=size(x,1);
+    B=NumberOfDraws;
+
 end
 
-if isempty(x),
+if isempty(x)
     disp('Empty parameter set!')
     return
 end
 
-for j=1:length(varargin),
+for j=1:length(varargin)
     jcol(j)=strmatch(varargin{j},bayestopt_.name,'exact');
 end
 
 [H,AX,BigA,P,PAx]=plotmatrix(x(:,jcol));
 
-for j=1:length(varargin),
+for j=1:length(varargin)
     %      axes(AX(1,j)), title(varargin{j})
     %      axes(AX(j,1)), ylabel(varargin{j})
     %      set(AX(1,j),'title',varargin{j}),
@@ -79,15 +84,15 @@ for j=1:length(varargin),
     set(get(AX(end,j),'xlabel'),'string',varargin{j})
 end
 
-if options_.opt_gsa.pprior==0,
+if options_.opt_gsa.pprior==0
     xparam1=xparam1(jcol);
-    for j=1:length(varargin),
-        for i=1:j-1,
-            axes(AX(j,i)),
+    for j=1:length(varargin)
+        for i=1:j-1
+            axes(AX(j,i))
             hold on, plot(xparam1(i),xparam1(j),'*r')
         end
-        for i=j+1:length(varargin),
-            axes(AX(j,i)),
+        for i=j+1:length(varargin)
+            axes(AX(j,i))
             hold on, plot(xparam1(i),xparam1(j),'*r')
         end
     end
diff --git a/matlab/gsa/gsa_skewness.m b/matlab/gsa/gsa_skewness.m
index 01c8186a6..dfb6ccfb9 100644
--- a/matlab/gsa/gsa_skewness.m
+++ b/matlab/gsa/gsa_skewness.m
@@ -1,6 +1,11 @@
-function s=gsa_skewness(y),
+function s=gsa_skewness(y)
 
-% Copyright (C) 2012 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -19,6 +24,6 @@ function s=gsa_skewness(y),
 
 % y=stand_(y);
 % s=mean(y.^3);
-    m2=mean((y-mean(y)).^2);
-    m3=mean((y-mean(y)).^3);
-    s=m3/m2^1.5;
\ No newline at end of file
+m2=mean((y-mean(y)).^2);
+m3=mean((y-mean(y)).^3);
+s=m3/m2^1.5;
\ No newline at end of file
diff --git a/matlab/gsa/gsa_speed.m b/matlab/gsa/gsa_speed.m
index d0845c57f..135036ad2 100644
--- a/matlab/gsa/gsa_speed.m
+++ b/matlab/gsa/gsa_speed.m
@@ -1,15 +1,12 @@
-function [tadj, iff] = gsa_speed(A,B,mf,p),
+function [tadj, iff] = gsa_speed(A,B,mf,p)
 % [tadj, iff] = gsa_speed(A,B,mf,p),
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,25 +33,25 @@ tadj=iff;
 disp('Computing speed of adjustement ...')
 h = dyn_waitbar(0,'Speed of adjustement...');
 
-for i=1:nrun,
-  irf=zeros(nvar,nshock);
-  a=squeeze(A(:,:,i));
-  b=squeeze(B(:,:,i));
-  IFF=inv(eye(nstate)-a)*b;
-  iff(:,:,i)=IFF(mf,:);
-  IF=IFF-b;
-  
-  t=0;
-  while any(any(irf<0.5))
-    t=t+1;
-    IFT=((eye(nstate)-a^(t+1))*inv(eye(nstate)-a))*b-b;
-    irf=IFT(mf,:)./(IF(mf,:)+eps);
-    irf = irf.*(abs(IF(mf,:))>1.e-7)+(abs(IF(mf,:))<=1.e-7);
-    %irf=ft(mf,:);
-    tt=(irf>0.5).*t;
-    tadj(:,:,i)=((tt-tadj(:,:,i))==tt).*tt+tadj(:,:,i);
-  end
-  dyn_waitbar(i/nrun,h)
+for i=1:nrun
+    irf=zeros(nvar,nshock);
+    a=squeeze(A(:,:,i));
+    b=squeeze(B(:,:,i));
+    IFF=inv(eye(nstate)-a)*b;
+    iff(:,:,i)=IFF(mf,:);
+    IF=IFF-b;
+
+    t=0;
+    while any(any(irf<0.5))
+        t=t+1;
+        IFT=((eye(nstate)-a^(t+1))*inv(eye(nstate)-a))*b-b;
+        irf=IFT(mf,:)./(IF(mf,:)+eps);
+        irf = irf.*(abs(IF(mf,:))>1.e-7)+(abs(IF(mf,:))<=1.e-7);
+        %irf=ft(mf,:);
+        tt=(irf>0.5).*t;
+        tadj(:,:,i)=((tt-tadj(:,:,i))==tt).*tt+tadj(:,:,i);
+    end
+    dyn_waitbar(i/nrun,h)
 end
 skipline()
 disp('.. done !')
diff --git a/matlab/gsa/log_trans_.m b/matlab/gsa/log_trans_.m
index da34bd480..c60119793 100644
--- a/matlab/gsa/log_trans_.m
+++ b/matlab/gsa/log_trans_.m
@@ -1,6 +1,11 @@
 function [yy, xdir, isig, lam]=log_trans_(y0,xdir0,isig,lam)
 
-% Copyright (C) 2012 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,62 +22,64 @@ function [yy, xdir, isig, lam]=log_trans_(y0,xdir0,isig,lam)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin==4,
+if nargin==4
     % inverse transformation
     yy = (exp(y0)-lam)*isig;
     return
 end
 
-if nargin==1,
-  xdir0='';
+if nargin==1
+    xdir0='';
 end
 f=@(lam,y)gsa_skewness(log(y+lam));
 isig=1;
 if ~(max(y0)<0 | min(y0)>0)
-  if gsa_skewness(y0)<0,
-    isig=-1;
-    y0=-y0;
-  end
-  n=hist(y0,10);
-  if n(1)>20*n(end),
-    try lam=fzero(f,[-min(y0)+10*eps -min(y0)+abs(median(y0))],[],y0);
-    catch
-      yl(1)=f(-min(y0)+10*eps,y0);
-      yl(2)=f(-min(y0)+abs(median(y0)),y0);
-      if abs(yl(1))<abs(yl(2))
-        lam=-min(y0)+eps;
-      else
-        lam = -min(y0)+abs(median(y0)); %abs(100*(1+min(y0)));
-      end
+    if gsa_skewness(y0)<0,
+        isig=-1;
+        y0=-y0;
     end
-    yy = log(y0+lam);
-    xdir=[xdir0,'_logskew'];
-  else
-    isig=0;
-    lam=0;
-    yy = log(y0.^2);
-    xdir=[xdir0,'_logsquared'];
-  end
-else
-  if max(y0)<0
-    isig=-1;    
-    y0=-y0;
-    %yy=log(-y0);
-    xdir=[xdir0,'_minuslog'];
-  elseif min(y0)>0
-    %yy=log(y0);
-    xdir=[xdir0,'_log'];
-  end
-  try lam=fzero(f,[-min(y0)+10*eps -min(y0)+median(y0)],[],y0);
-  catch
-    yl(1)=f(-min(y0)+10*eps,y0);
-      yl(2)=f(-min(y0)+abs(median(y0)),y0);
-    if abs(yl(1))<abs(yl(2))
-      lam=-min(y0)+eps;
+    n=hist(y0,10);
+    if n(1)>20*n(end)
+        try
+            lam=fzero(f,[-min(y0)+10*eps -min(y0)+abs(median(y0))],[],y0);
+        catch
+            yl(1)=f(-min(y0)+10*eps,y0);
+            yl(2)=f(-min(y0)+abs(median(y0)),y0);
+            if abs(yl(1))<abs(yl(2))
+                lam=-min(y0)+eps;
+            else
+                lam = -min(y0)+abs(median(y0)); %abs(100*(1+min(y0)));
+            end
+        end
+        yy = log(y0+lam);
+        xdir=[xdir0,'_logskew'];
     else
-        lam = -min(y0)+abs(median(y0)); %abs(100*(1+min(y0)));
+        isig=0;
+        lam=0;
+        yy = log(y0.^2);
+        xdir=[xdir0,'_logsquared'];
     end
-  end
-  lam = max(lam,0);
-  yy = log(y0+lam);
+else
+    if max(y0)<0
+        isig=-1;
+        y0=-y0;
+        %yy=log(-y0);
+        xdir=[xdir0,'_minuslog'];
+    elseif min(y0)>0
+        %yy=log(y0);
+        xdir=[xdir0,'_log'];
+    end
+    try
+        lam=fzero(f,[-min(y0)+10*eps -min(y0)+median(y0)],[],y0);
+    catch
+        yl(1)=f(-min(y0)+10*eps,y0);
+        yl(2)=f(-min(y0)+abs(median(y0)),y0);
+        if abs(yl(1))<abs(yl(2))
+            lam=-min(y0)+eps;
+        else
+            lam = -min(y0)+abs(median(y0)); %abs(100*(1+min(y0)));
+        end
+    end
+    lam = max(lam,0);
+    yy = log(y0+lam);
 end
diff --git a/matlab/gsa/map_calibration.m b/matlab/gsa/map_calibration.m
index c9d95c4ce..c7f707d49 100644
--- a/matlab/gsa/map_calibration.m
+++ b/matlab/gsa/map_calibration.m
@@ -1,6 +1,11 @@
 function map_calibration(OutputDirectoryName, Model, DynareOptions, DynareResults, EstimatedParameters, BayesInfo)
 
-% Copyright (C) 2014-2016 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2014-2016 European Commission
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,7 +28,7 @@ np = EstimatedParameters.np;
 nshock = EstimatedParameters.nvx + EstimatedParameters.nvn + EstimatedParameters.ncx + EstimatedParameters.ncn;
 pnames=cell(np,1);
 pnames_tex=cell(np,1);
-for jj=1:np        
+for jj=1:np
     if DynareOptions.TeX
         [param_name_temp, param_name_tex_temp]= get_the_name(nshock+jj, DynareOptions.TeX, Model, EstimatedParameters, DynareOptions);
         pnames_tex{jj,1} = strrep(param_name_tex_temp,'$','');
@@ -53,10 +58,10 @@ options_mcf.OutputDirectoryName = OutputDirectoryName;
 skipline()
 disp('Sensitivity analysis for calibration criteria')
 
-if DynareOptions.opt_gsa.ppost,
+if DynareOptions.opt_gsa.ppost
     filetoload=dir([Model.dname filesep 'metropolis' filesep fname_ '_param_irf*.mat']);
     lpmat=[];
-    for j=1:length(filetoload),
+    for j=1:length(filetoload)
         load([Model.dname filesep 'metropolis' filesep fname_ '_param_irf',int2str(j),'.mat'])
         lpmat = [lpmat; stock];
         clear stock
@@ -84,34 +89,34 @@ nbr_moment_restrictions = size(DynareOptions.endogenous_prior_restrictions.momen
 
 if init
     mat_irf=cell(nbr_irf_restrictions,1);
-    for ij=1:nbr_irf_restrictions,
+    for ij=1:nbr_irf_restrictions
         mat_irf{ij}=NaN(Nsam,length(DynareOptions.endogenous_prior_restrictions.irf{ij,3}));
     end
-    
+
     mat_moment=cell(nbr_moment_restrictions,1);
-    for ij=1:nbr_moment_restrictions,
+    for ij=1:nbr_moment_restrictions
         mat_moment{ij}=NaN(Nsam,length(DynareOptions.endogenous_prior_restrictions.moment{ij,3}));
     end
-    
+
     irestrictions = [1:Nsam];
     h = dyn_waitbar(0,'Please wait...');
-    for j=1:Nsam,
+    for j=1:Nsam
         Model = set_all_parameters(lpmat(j,:)',EstimatedParameters,Model);
-        if nbr_moment_restrictions,
+        if nbr_moment_restrictions
             [Tt,Rr,SteadyState,info,Model,DynareOptions,DynareResults] = dynare_resolve(Model,DynareOptions,DynareResults);
         else
             [Tt,Rr,SteadyState,info,Model,DynareOptions,DynareResults] = dynare_resolve(Model,DynareOptions,DynareResults,'restrict');
         end
-        if info(1)==0,
+        if info(1)==0
             [info, info_irf, info_moment, data_irf, data_moment]=endogenous_prior_restrictions(Tt,Rr,Model,DynareOptions,DynareResults);
             if ~isempty(info_irf)
-                for ij=1:nbr_irf_restrictions,
+                for ij=1:nbr_irf_restrictions
                     mat_irf{ij}(j,:)=data_irf{ij}(:,2)';
                 end
                 indx_irf(j,:)=info_irf(:,1);
             end
             if ~isempty(info_moment)
-                for ij=1:nbr_moment_restrictions,
+                for ij=1:nbr_moment_restrictions
                     mat_moment{ij}(j,:)=data_moment{ij}(:,2)';
                 end
                 indx_moment(j,:)=info_moment(:,1);
@@ -122,7 +127,7 @@ if init
         dyn_waitbar(j/Nsam,h,['MC iteration ',int2str(j),'/',int2str(Nsam)])
     end
     dyn_waitbar_close(h);
-    
+
     irestrictions=irestrictions(find(irestrictions));
     xmat=lpmat(irestrictions,:);
     skipline()
@@ -131,36 +136,36 @@ if init
 else
     load([OutputDirectoryName,filesep,fname_,'_',type,'_restrictions'],'xmat','mat_irf','mat_moment','irestrictions','indx_irf','indx_moment','endo_prior_restrictions');
 end
-if ~isempty(indx_irf),
+if ~isempty(indx_irf)
     skipline()
     disp('Deleting old IRF calibration plots ...')
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_irf_calib*.eps']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_irf_calib*.fig']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_irf_calib*.pdf']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_irf_restrictions.eps']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_irf_restrictions.fig']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_irf_restrictions.pdf']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     disp('done !')
     skipline()
-  
+
     % For single legend search which has maximum nbr of restrictions
     all_irf_couples = cellstr([char(endo_prior_restrictions.irf(:,1)) char(endo_prior_restrictions.irf(:,2))]);
     irf_couples = unique(all_irf_couples);
@@ -183,21 +188,21 @@ if ~isempty(indx_irf),
         time_matrix{plot_indx(ij)} = [time_matrix{plot_indx(ij)} endo_prior_restrictions.irf{ij,3}];
     end
     iplot_indx = ones(size(plot_indx));
-    
+
     indx_irf = indx_irf(irestrictions,:);
-    if ~DynareOptions.nograph,
-        h1=dyn_figure(DynareOptions,'name',[type ' evaluation of irf restrictions']);
+    if ~DynareOptions.nograph
+        h1=dyn_figure(DynareOptions.nodisplay,'name',[type ' evaluation of irf restrictions']);
         nrow=ceil(sqrt(nbr_irf_couples));
         ncol=nrow;
-        if nrow*(nrow-1)>nbr_irf_couples,
+        if nrow*(nrow-1)>nbr_irf_couples
             ncol=nrow-1;
         end
     end
-    for ij=1:nbr_irf_restrictions,
+    for ij=1:nbr_irf_restrictions
         mat_irf{ij}=mat_irf{ij}(irestrictions,:);
         irf_matrix{plot_indx(ij)} = [irf_matrix{plot_indx(ij)} mat_irf{ij}];
         indx_irf_matrix(:,plot_indx(ij)) = indx_irf_matrix(:,plot_indx(ij)) + indx_irf(:,ij);
-        for ik=1:size(mat_irf{ij},2),
+        for ik=1:size(mat_irf{ij},2)
             [Mean,Median,Var,HPD,Distrib] = ...
                 posterior_moments(mat_irf{ij}(:,ik),0,DynareOptions.mh_conf_sig);
             irf_mean{plot_indx(ij)} = [irf_mean{plot_indx(ij)}; Mean];
@@ -208,12 +213,12 @@ if ~isempty(indx_irf),
         end
         leg = num2str(endo_prior_restrictions.irf{ij,3}(1));
         aleg = num2str(endo_prior_restrictions.irf{ij,3}(1));
-        if size(mat_irf{ij},2)>1,
+        if size(mat_irf{ij},2)>1
             leg = [leg,':' ,num2str(endo_prior_restrictions.irf{ij,3}(end))];
             aleg = [aleg,'-' ,num2str(endo_prior_restrictions.irf{ij,3}(end))];
             iplot_indx(ij)=0;
         end
-        if ~DynareOptions.nograph && length(time_matrix{plot_indx(ij)})==1,
+        if ~DynareOptions.nograph && length(time_matrix{plot_indx(ij)})==1
             set(0,'currentfigure',h1),
             subplot(nrow,ncol, plot_indx(ij)),
             hc = cumplot(mat_irf{ij}(:,ik));
@@ -255,16 +260,16 @@ if ~isempty(indx_irf),
         if ~isempty(indx1) && ~isempty(indx2)
             mcf_analysis(xmat(:,nshock+1:end), indx1, indx2, options_mcf, DynareOptions);
         end
-        
+
         %         [proba, dproba] = stab_map_1(xmat, indx1, indx2, aname, 0);
         %         indplot=find(proba<pvalue_ks);
         %         if ~isempty(indplot)
         %             stab_map_1(xmat, indx1, indx2, aname, 1, indplot, OutputDirectoryName,[],atitle);
         %         end
     end
-    for ij=1:nbr_irf_couples,
-        if length(time_matrix{ij})>1,
-            if ~DynareOptions.nograph,
+    for ij=1:nbr_irf_couples
+        if length(time_matrix{ij})>1
+            if ~DynareOptions.nograph
                 set(0,'currentfigure',h1);
                 subplot(nrow,ncol, ij)
                 itmp = (find(plot_indx==ij));
@@ -272,7 +277,7 @@ if ~isempty(indx_irf),
                 a=axis;
                 delete(htmp);
                 tmp=[];
-                for ir=1:length(itmp),
+                for ir=1:length(itmp)
                     for it=1:length(endo_prior_restrictions.irf{itmp(ir),3})
                         temp_index = find(time_matrix{ij}==endo_prior_restrictions.irf{itmp(ir),3}(it));
                         tmp(temp_index,:) = endo_prior_restrictions.irf{itmp(ir),4};
@@ -288,14 +293,14 @@ if ~isempty(indx_irf),
                 plot(time_matrix{ij},irf_median{ij},'k','linewidth',2)
                 plot(time_matrix{ij},[irf_distrib{ij}],'k-')
                 plot(a(1:2),[0 0],'r')
-                hold off,
+                hold off
                 axis([max(1,a(1)) a(2:4)])
-                box on,
+                box on
                 %set(gca,'xtick',sort(time_matrix{ij}))
                 itmp = min(itmp);
                 title([endo_prior_restrictions.irf{itmp,1},' vs ',endo_prior_restrictions.irf{itmp,2}],'interpreter','none'),
             end
-            if any(iplot_indx.*plot_indx==ij),
+            if any(iplot_indx.*plot_indx==ij)
                 % MCF of the couples with logical AND
                 itmp = min(find(plot_indx==ij));
                 indx1 = find(indx_irf_matrix(:,ij)==0);
@@ -319,8 +324,8 @@ if ~isempty(indx_irf),
             end
         end
     end
-    if ~DynareOptions.nograph,
-        dyn_saveas(h1,[OutputDirectoryName,filesep,fname_,'_',type,'_irf_restrictions'],DynareOptions);
+    if ~DynareOptions.nograph
+        dyn_saveas(h1,[OutputDirectoryName,filesep,fname_,'_',type,'_irf_restrictions'],DynareOptions.nodisplay,DynareOptions.graph_format);
         create_TeX_loader(DynareOptions,[OutputDirectoryName,filesep,fname_,'_',type,'_irf_restrictions'],[type ' evaluation of irf restrictions'],'irf_restrictions',type,DynareOptions.figures.textwidth*min(ij/ncol,1))
     end
     skipline()
@@ -330,32 +335,32 @@ if ~isempty(indx_moment)
     skipline()
     disp('Deleting old MOMENT calibration plots ...')
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_moment_calib*.eps']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_moment_calib*.fig']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_moment_calib*.pdf']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_moment_restrictions.eps']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_moment_restrictions.fig']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     a=dir([OutputDirectoryName,filesep,fname_,'_',type,'_moment_restrictions.pdf']);
-    for j=1:length(a),
+    for j=1:length(a)
         delete([OutputDirectoryName,filesep,a(j).name]);
     end
     disp('done !')
     skipline()
-    
+
     %get parameter names including standard deviations
     np=size(BayesInfo.name,1);
     name=cell(np,1);
@@ -397,22 +402,22 @@ if ~isempty(indx_moment)
         time_matrix{plot_indx(ij)} = [time_matrix{plot_indx(ij)} endo_prior_restrictions.moment{ij,3}];
     end
     iplot_indx = ones(size(plot_indx));
-    
+
     indx_moment = indx_moment(irestrictions,:);
-    if ~DynareOptions.nograph,
-        h2=dyn_figure(DynareOptions,'name',[type ' evaluation of moment restrictions']);
+    if ~DynareOptions.nograph
+        h2=dyn_figure(DynareOptions.nodisplay,'name',[type ' evaluation of moment restrictions']);
         nrow=ceil(sqrt(nbr_moment_couples));
         ncol=nrow;
-        if nrow*(nrow-1)>nbr_moment_couples,
+        if nrow*(nrow-1)>nbr_moment_couples
             ncol=nrow-1;
         end
     end
-    
-    for ij=1:nbr_moment_restrictions,
+
+    for ij=1:nbr_moment_restrictions
         mat_moment{ij}=mat_moment{ij}(irestrictions,:);
         moment_matrix{plot_indx(ij)} = [moment_matrix{plot_indx(ij)} mat_moment{ij}];
         indx_moment_matrix(:,plot_indx(ij)) = indx_moment_matrix(:,plot_indx(ij)) + indx_moment(:,ij);
-        for ik=1:size(mat_moment{ij},2),
+        for ik=1:size(mat_moment{ij},2)
             [Mean,Median,Var,HPD,Distrib] = ...
                 posterior_moments(mat_moment{ij}(:,ik),0,DynareOptions.mh_conf_sig);
             moment_mean{plot_indx(ij)} = [moment_mean{plot_indx(ij)}; Mean];
@@ -423,12 +428,12 @@ if ~isempty(indx_moment)
         end
         leg = num2str(endo_prior_restrictions.moment{ij,3}(1));
         aleg = num2str(endo_prior_restrictions.moment{ij,3}(1));
-        if size(mat_moment{ij},2)>1,
+        if size(mat_moment{ij},2)>1
             leg = [leg,':' ,num2str(endo_prior_restrictions.moment{ij,3}(end))];
             aleg = [aleg,'_' ,num2str(endo_prior_restrictions.moment{ij,3}(end))];
             iplot_indx(ij)=0;
         end
-        if ~DynareOptions.nograph && length(time_matrix{plot_indx(ij)})==1,
+        if ~DynareOptions.nograph && length(time_matrix{plot_indx(ij)})==1
             set(0,'currentfigure',h2);
             subplot(nrow,ncol,plot_indx(ij)),
             hc = cumplot(mat_moment{ij}(:,ik));
@@ -438,10 +443,10 @@ if ~isempty(indx_moment)
             x2val=min(endo_prior_restrictions.moment{ij,4}(2),a(2));
             hp = patch([x1val x2val x2val x1val],a([3 3 4 4]),'b');
             set(hp,'FaceColor', [0.7 0.8 1])
-            hold all,
+            hold all
             hc = cumplot(mat_moment{ij}(:,ik));
             set(hc,'color','k','linewidth',2)
-            hold off,
+            hold off
             title([endo_prior_restrictions.moment{ij,1},' vs ',endo_prior_restrictions.moment{ij,2},'(',leg,')'],'interpreter','none'),
             %         if ij==maxij
             %             leg1 = num2str(endo_prior_restrictions.moment{ij,3}(:));
@@ -465,15 +470,15 @@ if ~isempty(indx_moment)
         if ~isempty(indx1) && ~isempty(indx2)
             mcf_analysis(xmat, indx1, indx2, options_mcf, DynareOptions);
         end
-        
+
         %         [proba, dproba] = stab_map_1(xmat, indx1, indx2, aname, 0);
         %         indplot=find(proba<pvalue_ks);
         %         if ~isempty(indplot)
         %             stab_map_1(xmat, indx1, indx2, aname, 1, indplot, OutputDirectoryName,[],atitle);
         %         end
     end
-    for ij=1:nbr_moment_couples,
-        if length(time_matrix{ij})>1,
+    for ij=1:nbr_moment_couples
+        if length(time_matrix{ij})>1
             if ~DynareOptions.nograph
                 itmp = (find(plot_indx==ij));
                 set(0,'currentfigure',h2);
@@ -482,7 +487,7 @@ if ~isempty(indx_moment)
                 a=axis;
                 delete(htmp);
                 tmp=[];
-                for ir=1:length(itmp),
+                for ir=1:length(itmp)
                     for it=1:length(endo_prior_restrictions.moment{itmp(ir),3})
                         temp_index = find(time_matrix{ij}==endo_prior_restrictions.moment{itmp(ir),3}(it));
                         tmp(temp_index,:) = endo_prior_restrictions.moment{itmp(ir),4};
@@ -493,19 +498,19 @@ if ~isempty(indx_moment)
                 tmp(isinf(tmp(:,2)),2)=a(4);
                 hp = patch([time_matrix{ij} time_matrix{ij}(end:-1:1)],[tmp(:,1); tmp(end:-1:1,2)],'b');
                 set(hp,'FaceColor',[0.7 0.8 1])
-                hold on,
+                hold on
                 plot(time_matrix{ij},[max(moment_matrix{ij})' min(moment_matrix{ij})'],'k--','linewidth',2)
                 plot(time_matrix{ij},moment_median{ij},'k','linewidth',2)
                 plot(time_matrix{ij},[moment_distrib{ij}],'k-')
                 plot(a(1:2),[0 0],'r')
-                hold off,
+                hold off
                 axis(a)
-                box on,
+                box on
                 set(gca,'xtick',sort(time_matrix{ij}))
                 itmp = min(itmp);
                 title([endo_prior_restrictions.moment{itmp,1},' vs ',endo_prior_restrictions.moment{itmp,2}],'interpreter','none'),
             end
-            if any(iplot_indx.*plot_indx==ij),
+            if any(iplot_indx.*plot_indx==ij)
                 % MCF of the couples with logical AND
                 itmp = min(find(plot_indx==ij));
                 indx1 = find(indx_moment_matrix(:,ij)==0);
@@ -529,11 +534,11 @@ if ~isempty(indx_moment)
             end
         end
     end
-    if ~DynareOptions.nograph,
-        dyn_saveas(h2,[OutputDirectoryName,filesep,fname_,'_',type,'_moment_restrictions'],DynareOptions);
+    if ~DynareOptions.nograph
+        dyn_saveas(h2,[OutputDirectoryName,filesep,fname_,'_',type,'_moment_restrictions'],DynareOptions.nodisplay,DynareOptions.graph_format);
         create_TeX_loader(DynareOptions,[OutputDirectoryName,filesep,fname_,'_',type,'_moment_restrictions'],[type ' evaluation of moment restrictions'],'moment_restrictions',type,DynareOptions.figures.textwidth*min(ij/ncol,1))
     end
-    
+
     skipline()
 end
 return
diff --git a/matlab/gsa/map_ident_.m b/matlab/gsa/map_ident_.m
index 535f4bf33..fa23574dd 100644
--- a/matlab/gsa/map_ident_.m
+++ b/matlab/gsa/map_ident_.m
@@ -1,6 +1,11 @@
 function map_ident_(OutputDirectoryName,opt_gsa)
 
-% Copyright (C) 2012-2016 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2012-2016 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -26,24 +31,24 @@ ntra   = opt_gsa.morris_ntra;
 itrans = opt_gsa.trans_ident;
 
 np = estim_params_.np;
-if opt_gsa.load_ident_files,
-  gsa_flag=0;
+if opt_gsa.load_ident_files
+    gsa_flag=0;
 else
-  gsa_flag=-2;
+    gsa_flag=-2;
 end
 
 pnames = M_.param_names(estim_params_.param_vals(:,1),:);
-    if opt_gsa.pprior,
+if opt_gsa.pprior
 
-filetoload=[OutputDirectoryName '/' fname_ '_prior'];
-    else
-filetoload=[OutputDirectoryName '/' fname_ '_mc'];
-    end
-load(filetoload,'lpmat','lpmat0','istable','T','yys','nspred','nboth','nfwrd')
-if ~isempty(lpmat0),
-  lpmatx=lpmat0(istable,:);
+    filetoload=[OutputDirectoryName '/' fname_ '_prior'];
 else
-  lpmatx=[];
+    filetoload=[OutputDirectoryName '/' fname_ '_mc'];
+end
+load(filetoload,'lpmat','lpmat0','istable','T','yys','nspred','nboth','nfwrd')
+if ~isempty(lpmat0)
+    lpmatx=lpmat0(istable,:);
+else
+    lpmatx=[];
 end
 Nsam = size(lpmat,1);
 nshock = size(lpmat0,2);
@@ -51,140 +56,140 @@ npT = np+nshock;
 
 fname_ = M_.fname;
 
-if opt_gsa.load_ident_files==0,
-  % th moments
-%     options_.ar = min(3,options_.ar);
+if opt_gsa.load_ident_files==0
+    % th moments
+    %     options_.ar = min(3,options_.ar);
 
-  mss = yys(bayestopt_.mfys,:);
-  mss = teff(mss(:,istable),Nsam,istable);
-  yys = teff(yys(oo_.dr.order_var,istable),Nsam,istable);
-  if exist('T'),
-      [vdec, cc, ac] = mc_moments(T, lpmatx, oo_.dr);
-  else
-      return,
-  end
-
-
-  if opt_gsa.morris==2,
-   pdraws = dynare_identification(options_.options_ident,[lpmatx lpmat(istable,:)]);
-%    [pdraws, TAU, GAM] = dynare_identification(options_.options_ident,[lpmatx lpmat(istable,:)]);
-    if ~isempty(pdraws) && max(max(abs(pdraws-[lpmatx lpmat(istable,:)])))==0,
-      disp(['Sample check OK ', num2str(max(max(abs(pdraws-[lpmatx lpmat(istable,:)]))))]),
-      clear pdraws;
+    mss = yys(bayestopt_.mfys,:);
+    mss = teff(mss(:,istable),Nsam,istable);
+    yys = teff(yys(oo_.dr.order_var,istable),Nsam,istable);
+    if exist('T')
+        [vdec, cc, ac] = mc_moments(T, lpmatx, oo_.dr);
+    else
+        return
     end
-%     for j=1:length(istable), gas(:,j)=[vech(cc(:,:,j)); vec(ac(:,:,j))];  end
-%     if ~isempty(mss),
-%     gas = [mss(istable,:)'; gas];
-%     end
-%     if max(max(abs(GAM-gas)))<=1.e-8,
-%       disp(['Moments check OK ',num2str(max(max(abs(GAM-gas))))]),
-      clear GAM gas
-%     end
-  end
-  if opt_gsa.morris~=1 & M_.exo_nbr>1,
-    ifig=0;
-    for j=1:M_.exo_nbr,
-      if mod(j,6)==1
-        hh=dyn_figure(options_,'name',['Variance decomposition shocks']);
-        ifig=ifig+1;
-        iplo=0;
-      end
-      iplo=iplo+1;
-      subplot(2,3,iplo)
-      myboxplot(squeeze(vdec(:,j,:))',[],'.',[],10)
-      %     boxplot(squeeze(vdec(:,j,:))','whis',10,'symbol','.r')
-      set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:size(options_.varobs,1)])
-      set(gca,'xlim',[0.5 size(options_.varobs,1)+0.5])
-      set(gca,'ylim',[-2 102])
-      for ip=1:size(options_.varobs,1),
-        text(ip,-4,deblank(options_.varobs(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-      end
-      xlabel(' ')
-      ylabel(' ')
-      title(M_.exo_names(j,:),'interpreter','none')
-      if mod(j,6)==0 | j==M_.exo_nbr,
-        dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_vdec_exo_',int2str(ifig)],options_);  
-        create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_vdec_exo_',int2str(ifig)],ifig,['Variance decomposition shocks'],'vdec_exo',options_.figures.textwidth*min(iplo/3,1))
-      end
-    end
-  end
-  for j=1:size(cc,1)
-    cc(j,j,:)=stand_(squeeze(log(cc(j,j,:))))./2;
-  end
-  [vdec, j0, ir_vdec, ic_vdec] = teff(vdec,Nsam,istable);
-  [cc, j0, ir_cc, ic_cc] = teff(cc,Nsam,istable);
-  [ac, j0, ir_ac, ic_ac] = teff(ac,Nsam,istable);
 
-  [nr1, nc1, nnn] = size(T);
+
+    if opt_gsa.morris==2
+        pdraws = dynare_identification(options_.options_ident,[lpmatx lpmat(istable,:)]);
+        %    [pdraws, TAU, GAM] = dynare_identification(options_.options_ident,[lpmatx lpmat(istable,:)]);
+        if ~isempty(pdraws) && max(max(abs(pdraws-[lpmatx lpmat(istable,:)])))==0
+            disp(['Sample check OK ', num2str(max(max(abs(pdraws-[lpmatx lpmat(istable,:)]))))]),
+            clear pdraws;
+        end
+        %     for j=1:length(istable), gas(:,j)=[vech(cc(:,:,j)); vec(ac(:,:,j))];  end
+        %     if ~isempty(mss),
+        %     gas = [mss(istable,:)'; gas];
+        %     end
+        %     if max(max(abs(GAM-gas)))<=1.e-8,
+        %       disp(['Moments check OK ',num2str(max(max(abs(GAM-gas))))]),
+        clear GAM gas
+        %     end
+    end
+    if opt_gsa.morris~=1 & M_.exo_nbr>1
+        ifig=0;
+        for j=1:M_.exo_nbr
+            if mod(j,6)==1
+                hh=dyn_figure(options_.nodisplay,'name',['Variance decomposition shocks']);
+                ifig=ifig+1;
+                iplo=0;
+            end
+            iplo=iplo+1;
+            subplot(2,3,iplo)
+            myboxplot(squeeze(vdec(:,j,:))',[],'.',[],10)
+            %     boxplot(squeeze(vdec(:,j,:))','whis',10,'symbol','.r')
+            set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:size(options_.varobs,1)])
+            set(gca,'xlim',[0.5 size(options_.varobs,1)+0.5])
+            set(gca,'ylim',[-2 102])
+            for ip=1:size(options_.varobs,1)
+                text(ip,-4,deblank(options_.varobs(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+            end
+            xlabel(' ')
+            ylabel(' ')
+            title(M_.exo_names(j,:),'interpreter','none')
+            if mod(j,6)==0 | j==M_.exo_nbr
+                dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_vdec_exo_',int2str(ifig)],options_.nodisplay,options_.graph_format);
+                create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_vdec_exo_',int2str(ifig)],ifig,['Variance decomposition shocks'],'vdec_exo',options_.figures.textwidth*min(iplo/3,1))
+            end
+        end
+    end
+    for j=1:size(cc,1)
+        cc(j,j,:)=stand_(squeeze(log(cc(j,j,:))))./2;
+    end
+    [vdec, j0, ir_vdec, ic_vdec] = teff(vdec,Nsam,istable);
+    [cc, j0, ir_cc, ic_cc] = teff(cc,Nsam,istable);
+    [ac, j0, ir_ac, ic_ac] = teff(ac,Nsam,istable);
+
+    [nr1, nc1, nnn] = size(T);
     endo_nbr = M_.endo_nbr;
     nstatic = M_.nstatic;
     nspred = M_.nspred;
     iv = (1:endo_nbr)';
     ic = [ nstatic+(1:nspred) endo_nbr+(1:size(oo_.dr.ghx,2)-nspred) ]';
-  
+
     dr.ghx = T(:, [1:(nc1-M_.exo_nbr)],1);
     dr.ghu = T(:, [(nc1-M_.exo_nbr+1):end], 1);
     [Aa,Bb] = kalman_transition_matrix(dr,iv,ic,M_.exo_nbr);
-%     bayestopt_.restrict_var_list, ...
-%     bayestopt_.restrict_columns, ...
-%     bayestopt_.restrict_aux, M_.exo_nbr);
-  A = zeros(size(Aa,1),size(Aa,2)+size(Aa,1),length(istable));
-  % Sig(estim_params_.var_exo(:,1))=lpmatx(1,:).^2;
-  if ~isempty(lpmatx),
-      set_shocks_param(lpmatx(1,:));
-  end
-  A(:,:,1)=[Aa, triu(Bb*M_.Sigma_e*Bb')];
-  for j=2:length(istable),
-    dr.ghx = T(:, [1:(nc1-M_.exo_nbr)],j);
-    dr.ghu = T(:, [(nc1-M_.exo_nbr+1):end], j);
-    [Aa,Bb] = kalman_transition_matrix(dr, iv, ic, M_.exo_nbr);
-%       bayestopt_.restrict_var_list, ...
-%       bayestopt_.restrict_columns, ...
-%       bayestopt_.restrict_aux, M_.exo_nbr);
-    if ~isempty(lpmatx),
-        set_shocks_param(lpmatx(j,:));
+    %     bayestopt_.restrict_var_list, ...
+    %     bayestopt_.restrict_columns, ...
+    %     bayestopt_.restrict_aux, M_.exo_nbr);
+    A = zeros(size(Aa,1),size(Aa,2)+size(Aa,1),length(istable));
+    % Sig(estim_params_.var_exo(:,1))=lpmatx(1,:).^2;
+    if ~isempty(lpmatx)
+        set_shocks_param(lpmatx(1,:));
     end
-    A(:,:,j)=[Aa, triu(Bb*M_.Sigma_e*Bb')];
-  end
-  clear T;
-  clear lpmatx;
+    A(:,:,1)=[Aa, triu(Bb*M_.Sigma_e*Bb')];
+    for j=2:length(istable)
+        dr.ghx = T(:, [1:(nc1-M_.exo_nbr)],j);
+        dr.ghu = T(:, [(nc1-M_.exo_nbr+1):end], j);
+        [Aa,Bb] = kalman_transition_matrix(dr, iv, ic, M_.exo_nbr);
+        %       bayestopt_.restrict_var_list, ...
+        %       bayestopt_.restrict_columns, ...
+        %       bayestopt_.restrict_aux, M_.exo_nbr);
+        if ~isempty(lpmatx)
+            set_shocks_param(lpmatx(j,:));
+        end
+        A(:,:,j)=[Aa, triu(Bb*M_.Sigma_e*Bb')];
+    end
+    clear T
+    clear lpmatx
 
-  [nr,nc,nn]=size(A);
-  io=bayestopt_.mf2;
-  % T1=A(io,1:nr,:);
-  % ino=find(~ismember([1:nr],io));
-  % T2=A(ino,1:nr,:);
-  R=A(:,nr+1:nc,:);
-%   [tadj, iff] = gsa_speed(A(1:nr,1:nr,:),R,io,0.5);
-%   [tadj, j0, ir_tadj, ic_tadj] = teff(tadj,Nsam,istable);
-%   [iff, j0, ir_if, ic_if] = teff(iff,Nsam,istable);
+    [nr,nc,nn]=size(A);
+    io=bayestopt_.mf2;
+    % T1=A(io,1:nr,:);
+    % ino=find(~ismember([1:nr],io));
+    % T2=A(ino,1:nr,:);
+    R=A(:,nr+1:nc,:);
+    %   [tadj, iff] = gsa_speed(A(1:nr,1:nr,:),R,io,0.5);
+    %   [tadj, j0, ir_tadj, ic_tadj] = teff(tadj,Nsam,istable);
+    %   [iff, j0, ir_if, ic_if] = teff(iff,Nsam,istable);
 
 
-  [yt, j0]=teff(A,Nsam,istable);
-  yt = [yys yt];
-  if opt_gsa.morris==2,
-%     iii=find(std(yt(istable,:))>1.e-8);
-%     if max(max(abs(TAU-yt(istable,iii)')))<= 1.e-8,
-%       err = max(max(abs(TAU-yt(istable,iii)')));
-%       disp(['Model check OK ',num2str(err)]),
-      clear TAU A
-%     end
-  else
-    clear A,
-  end
-  % [yt1, j01]=teff(T1,Nsam,istable);
-  % [yt2, j02]=teff(T2,Nsam,istable);
-  % [ytr, j0r]=teff(R,Nsam,istable);
-  %
-  % yt=[yt1 yt2 ytr];
-  save([OutputDirectoryName,'/',fname_,'_main_eff.mat'],'ac','cc','vdec','yt','mss')
+    [yt, j0]=teff(A,Nsam,istable);
+    yt = [yys yt];
+    if opt_gsa.morris==2
+        %     iii=find(std(yt(istable,:))>1.e-8);
+        %     if max(max(abs(TAU-yt(istable,iii)')))<= 1.e-8,
+        %       err = max(max(abs(TAU-yt(istable,iii)')));
+        %       disp(['Model check OK ',num2str(err)]),
+        clear TAU A
+        %     end
+    else
+        clear A
+    end
+    % [yt1, j01]=teff(T1,Nsam,istable);
+    % [yt2, j02]=teff(T2,Nsam,istable);
+    % [ytr, j0r]=teff(R,Nsam,istable);
+    %
+    % yt=[yt1 yt2 ytr];
+    save([OutputDirectoryName,'/',fname_,'_main_eff.mat'],'ac','cc','vdec','yt','mss')
 else
-  if opt_gsa.morris==2,
-%    [pdraws, TAU, GAM] = dynare_identification([1:npT]); %,[lpmatx lpmat(istable,:)]);
-%    [pdraws, TAU, GAM] = dynare_identification(options_.options_ident);
-   pdraws = dynare_identification(options_.options_ident);
-  end
-  load([OutputDirectoryName,'/',fname_,'_main_eff.mat'],'ac','cc','vdec','yt','mss')
+    if opt_gsa.morris==2
+        %    [pdraws, TAU, GAM] = dynare_identification([1:npT]); %,[lpmatx lpmat(istable,:)]);
+        %    [pdraws, TAU, GAM] = dynare_identification(options_.options_ident);
+        pdraws = dynare_identification(options_.options_ident);
+    end
+    load([OutputDirectoryName,'/',fname_,'_main_eff.mat'],'ac','cc','vdec','yt','mss')
 end
 
 %   for j=1:nr,
@@ -200,1354 +205,1353 @@ end
 %   end
 %   yt = yt(:,j0);
 
-if opt_gsa.morris==1,
-  %OutputDir = CheckPath('gsa/screen');
-  if ~isempty(vdec),
-  if opt_gsa.load_ident_files==0,
-  SAMorris = [];
-  for i=1:size(vdec,2),
-    [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], vdec(:,i),nliv);
-  end
-  SAvdec = squeeze(SAMorris(:,1,:))';
-  save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'SAvdec','vdec','ir_vdec','ic_vdec')
-  else
-    load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAvdec','vdec','ir_vdec','ic_vdec')
-  end
-  
-  hh = dyn_figure(options_,'name','Screening identification: variance decomposition');
-%   boxplot(SAvdec,'whis',10,'symbol','r.')
-  myboxplot(SAvdec,[],'.',[],10)
-  set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-  set(gca,'xlim',[0.5 npT+0.5])
-  ydum = get(gca,'ylim');
-  set(gca,'ylim',[0 ydum(2)])
-  set(gca,'position',[0.13 0.2 0.775 0.7])
-  for ip=1:npT,
-    text(ip,-2,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-  end
-  xlabel(' ')
-  title('Elementary effects variance decomposition')
-  dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morris_vdec'],options_);
-  create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_morris_vdec'],1,'Screening identification: variance decomposition','morris_vdec',1)
-  else
-  save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'vdec')
-    
-  end
+if opt_gsa.morris==1
+    %OutputDir = CheckPath('gsa/screen');
+    if ~isempty(vdec)
+        if opt_gsa.load_ident_files==0
+            SAMorris = [];
+            for i=1:size(vdec,2)
+                [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], vdec(:,i),nliv);
+            end
+            SAvdec = squeeze(SAMorris(:,1,:))';
+            save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'SAvdec','vdec','ir_vdec','ic_vdec')
+        else
+            load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAvdec','vdec','ir_vdec','ic_vdec')
+        end
 
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['EET variance decomposition observed variables']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_vdec==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAvdec(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAvdec(iv,:),[],'.',[],3)
-%       else
-%         plot(SAvdec(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-2,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_vdec_varobs_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_vdec_varobs_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_vdec_varobs_',int2str(ifig)]);
-%       close(gcf)
-%     end
-%   end
-% 
-%   ifig = 0;
-%   for j=1:M_.exo_nbr,
-%     if mod(j,6)==1
-%       figure('name',['EET variance decomposition shocks']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ic_vdec==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAvdec(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAvdec(iv,:),[],'.',[],3)
-%       else
-%         plot(SAvdec(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-2,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(M_.exo_names(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==M_.exo_nbr,
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_vdec_exo_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_vdec_exo_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_vdec_exo_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-
-  if opt_gsa.load_ident_files==0,
-  SAMorris = [];
-  ccac = [mss cc ac];
-  for i=1:size(ccac,2),
-    [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], [ccac(:,i)],nliv);
-  end
-  SAcc = squeeze(SAMorris(:,1,:))';
-  SAcc = SAcc./(max(SAcc')'*ones(1,npT));
-  save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'SAcc','cc','ir_cc','ic_cc','-append')
-  save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'ac','ir_ac','ic_ac','-append')
-  else
-    load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAcc','cc','ir_cc','ic_cc')
-    load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'ac','ir_ac','ic_ac')
-  end
-  
-  hh=dyn_figure(options_,'name','Screening identification: theoretical moments');
-%   boxplot(SAcc,'whis',10,'symbol','r.')
-  myboxplot(SAcc,[],'.',[],10)
-  set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-  set(gca,'xlim',[0.5 npT+0.5])
-  ydum = get(gca,'ylim');
-  set(gca,'ylim',[0 1])
-  set(gca,'position',[0.13 0.2 0.775 0.7])
-  for ip=1:npT,
-    text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-  end
-  xlabel(' ')
-  title('Elementary effects in the moments')
-  dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morris_moments'],options_);
-  create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_morris_moments'],1,'Screening identification: theoretical moments','morris_moments',1)
-
-%   close(gcf),
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% MORRIS FOR DERIVATIVES  
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-% if opt_gsa.load_ident_files==0,
-%     for j=1:npT,
-%   SAMorris = [];
-%   ddd=NaN(size(lpmat,1),size(JJ,1));
-%   ddd(istable,:) = squeeze(JJ(:,j,:))';
-%   for i=1:size(ddd,2),
-%     [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], [ddd(:,i)],nliv);
-%   end
-%   SAddd(:,:,j) = squeeze(SAMorris(:,1,:))';
-%   SAddd(:,:,j) = SAddd(:,:,j)./(max(SAddd(:,:,j)')'*ones(1,npT));
-%   sad(:,j) = median(SAddd(find(~isnan(squeeze(SAddd(:,1,j)))),:,j))'; 
-%     end
-%   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAddd','sad','-append')
-%   else
-%     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAddd','sad')
-%   end
-%   figure,
-%   contourf(sad,10), colorbar
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%   set(gca,'yticklabel',' ','fontsize',10,'ytick',[1:npT])
-%   for ip=1:npT,
-%     text(ip,0.9,['D(',bayestopt_.name{ip},')'],'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%     text(0.9,ip,[bayestopt_.name{ip}],'rotation',0,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   [m,im]=max(sad);
-%   iii = find((im-[1:npT])==0);
-%   disp('Most identified params')
-%   disp(bayestopt_.name(iii))
-  
-  
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% END OF MORRIS FOR DERIVATIVES  
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-  
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['EET cross-correlations']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_cc==j);
-%     iv = [iv; find(ic_cc==j)];
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAcc(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAcc(iv,:),[],'.',[],3)
-%       else
-%         plot(SAcc(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_cc_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_cc_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_cc_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-
-%   if opt_gsa.load_ident_files==0,
-%   SAMorris = [];
-%   for i=1:size(ac,2),
-%     [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], ac(:,i),nliv);
-%   end
-%   %end
-%   SAac = squeeze(SAMorris(:,1,:))';
-%   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAac','ac','ir_ac','ic_ac','-append')
-%   else
-%     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAac','ac','ir_ac','ic_ac')
-%   end
-%   figure,
-% %   boxplot(SAac,'whis',10,'symbol','r.')
-%   myboxplot(SAac,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:npT,
-%     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title('EET All auto-correlations')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_ac'])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_ac']);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_ac']);
-%   close(gcf),
-
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['EET auto-correlations']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_ac==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAac(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAac(iv,:),[],'.',[],3)
-%       else
-%         plot(SAac(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_ac_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_ac_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_ac_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-%   if opt_gsa.load_ident_files==0,
-%   js=0;
-%   %for j=1:size(tadj,1),
-%   SAMorris = [];
-%   for i=1:size(tadj,2),
-%     js=js+1;
-%     [SAmeas, SAMorris(:,:,js)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], tadj(:,i),nliv);
-%   end
-%   %end
-%   SAM = squeeze(SAMorris(nshock+1:end,1,:));
-%   for j=1:js,
-%     SAtadj(:,j)=SAM(:,j)./(max(SAM(:,j))+eps);
-%   end
-%   SAtadj = SAtadj';
-%   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAtadj','tadj','ir_tadj','ic_tadj','-append')
-%   else
-%     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAtadj','tadj','ir_tadj','ic_tadj')
-%   end
-%   if opt_gsa.load_ident_files==0,
-%   js=0;
-%   SAMorris = [];
-%   for i=1:size(iff,2),
-%     js=js+1;
-%     [SAmeas, SAMorriss(:,:,js)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], iff(:,i),nliv);
-%   end
-%   SAM = squeeze(SAMorriss(nshock+1:end,1,:));
-%   for j=1:js,
-%     SAIF(:,j)=SAM(:,j)./(max(SAM(:,j))+eps);
-%   end
-%   SAIF = SAIF';
-%   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAIF','iff','ir_if','ic_if','-append')
-%   else
-%     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAIF','iff','ir_if','ic_if')
-%   end
-%   figure,
-%   %bar(SAtadj),
-% %   boxplot(SAtadj,'whis',10,'symbol','r.')
-%   myboxplot(SAtadj,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 np+0.5])
-%   set(gca,'ylim',[0 1])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title('All half-life')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_tadj'])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_tadj']);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_tadj']);
-%   close(gcf),
-
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['EET speed of adjustment observed variables']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_tadj==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAtadj(iv,:),[],'.',[],3)
-%       else
-%         plot(SAtadj(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_tadj_varobs_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_tadj_varobs_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_tadj_varobs_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-%   ifig = 0;
-%   for j=1:M_.exo_nbr,
-%     if mod(j,6)==1
-%       figure('name',['EET speed of adjustment shocks']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ic_tadj==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAtadj(iv,:),[],'.',[],3)
-%       else
-%         plot(SAtadj(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(M_.exo_names(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==M_.exo_nbr,
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_tadj_exo_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_tadj_exo_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_tadj_exo_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-%   figure,
-%   %bar(SAIF),
-% %   boxplot(SAIF,'whis',10,'symbol','r.')
-%   myboxplot(SAIF,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 np+0.5])
-%   set(gca,'ylim',[0 1])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   ylabel('Elementary Effects')
-%   title('Steady state gains (impact factors)')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_gain'])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_gain']);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_gain']);
-%   close(gcf),
-  %figure, bar(SAIF'), title('All Gain Relationships')
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['EET steady state gain observed series']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_if==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAIF(iv,:),'whis',10,'symbol','r.');
-%         myboxplot(SAIF(iv,:),[],'.',[],10)
-%       else
-%         plot(SAIF(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_gain_varobs_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_gain_varobs_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_gain_varobs_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-% 
-%   ifig = 0;
-%   for j=1:M_.exo_nbr,
-%     if mod(j,6)==1
-%       figure('name',['EET steady state gain shocks']);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ic_if==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAIF(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAIF(iv,:),[],'.',[],3)
-%       else
-%         plot(SAIF(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(M_.exo_names(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==M_.exo_nbr,
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_gain_exo_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_gain_exo_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_gain_exo_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-
-  if opt_gsa.load_ident_files==0,
-  SAMorris = [];
-  for j=1:j0,
-    [SAmeas, SAMorris(:,:,j)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], yt(:,j),nliv);
-  end
-
-%   SAM = squeeze(SAMorris(nshock+1:end,1,:));
-  SAM = squeeze(SAMorris(1:end,1,:));
-  for j=1:j0
-    SAnorm(:,j)=SAM(:,j)./max(SAM(:,j));
-    irex(j)=length(find(SAnorm(:,j)>0.01));
-  end
-  [dum, irel]=sort(irex);
-
-%   SAMmu = squeeze(SAMorris(nshock+1:end,2,:));
-  SAMmu = squeeze(SAMorris(1:end,2,:));
-  for j=1:j0
-    SAmunorm(:,j)=SAMmu(:,j)./max(SAM(:,j));  % normalised w.r.t. mu*
-  end
-%   SAMsig = squeeze(SAMorris(nshock+1:end,3,:));
-  SAMsig = squeeze(SAMorris(1:end,3,:));
-  for j=1:j0
-    SAsignorm(:,j)=SAMsig(:,j)./max(SAMsig(:,j));
-  end
-    save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'SAnorm','SAmunorm','SAsignorm','-append')
-  else
-    load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAnorm','SAmunorm','SAsignorm')
-  end
-  hh=dyn_figure(options_,'name','Screening identification: model'); %bar(SAnorm(:,irel))
-%   boxplot(SAnorm','whis',10,'symbol','r.')
-  myboxplot(SAnorm',[],'.',[],10)
-  set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-  set(gca,'xlim',[0.5 npT+0.5])
-  set(gca,'ylim',[0 1])
-  set(gca,'position',[0.13 0.2 0.775 0.7])
-  xlabel(' ')
-  for ip=1:npT,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-    text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-  end
-  xlabel(' ')
-  title('Elementary effects in the model')
-  dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morris_par'],options_);
-  create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_morris_par'],1,'Screening identification: model','morris_par',1)
-
-%   hh=dyn_figure(options_); %bar(SAmunorm(:,irel))
-% %   boxplot(SAmunorm','whis',10,'symbol','r.')
-%   myboxplot(SAmunorm',[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   set(gca,'ylim',[-1 1])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   xlabel(' ')
-%   for ip=1:npT,
-%     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title('\mu in the model')
-%   dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morrismu_par'],options_);
-% 
-%   hh=dyn_figure(options_); %bar(SAsignorm(:,irel))
-% %   boxplot(SAsignorm','whis',10,'symbol','r.')
-%   myboxplot(SAsignorm',[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   set(gca,'ylim',[0 1])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   xlabel(' ')
-%   for ip=1:npT,
-%     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title('\sigma in the model')
-%   dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morrissig_par'],options_);
-
-  %     figure, bar(SAnorm(:,irel)')
-  %     set(gca,'xtick',[1:j0])
-  %     set(gca,'xlim',[0.5 j0+0.5])
-  %     title('Elementary effects relationships')
-  %     saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_redform'])
-  %     eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_redform']);
-  %     eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_redform']);
-
-elseif opt_gsa.morris==3,
-    return
-    
-  np=estim_params_.np;
-  na=(4*np+1)*opt_gsa.Nsam;
-  for j=1:j0,
-    [idex(j,:), yd(j,:)] = spop_ide(lpmat, yt(:,j), opt_gsa.Nsam, 5-1);
-  end
-  iok=find(~isnan(yt(1:opt_gsa.Nsam,1)));
-  yr=NaN*ones(size(lpmat,1),j0);
-  for j=1:j0,
-    ys(j,:)=yd(j,:)./max(yd(j,:));
-    [dum, is]=sort(yt(iok,j));
-    yr(iok(is),j)=[1:length(iok)]'./length(iok);
-    yr(istable(length(iok)+1:end),j) = interp1(yt(iok,j),yr(iok,j),yt(istable(length(iok)+1:end),j),'','extrap');
-    ineg=find(yr(:,j)<0);
-    if any(ineg),
-      [dum, is]=sort(yr(ineg,j));
-      yr(ineg(is),j)=-[length(ineg):-1:1]./length(iok);
-
-    end
-    [idex_r(j,:), yd_r(j,:)] = spop_ide(lpmat, yr(:,j), opt_gsa.Nsam, 5-1);
-    ys_r(j,:)=yd_r(j,:)./max(yd_r(j,:));
-
-  end,
-  figure, bar((idex.*ys)./opt_gsa.Nsam), title('Relationships')
-  figure, bar((idex.*ys)'./opt_gsa.Nsam), title('Parameters')
-  figure, bar((idex_r.*ys_r)./opt_gsa.Nsam), title('Relationships rank')
-  figure, bar((idex_r.*ys_r)'./opt_gsa.Nsam), title('Parameters rank')
-  [v0,d0]=eig(corrcoef(yt(iok,:)));
-  ee=diag(d0);
-  ee=ee([end:-1:1])./j0;
-  i0=length(find(ee>0.01));
-  v0=v0(:,[end:-1:1]);
-  for j=1:i0,
-    [idex_pc(j,:), yd_pc(j,:)] = spop_ide(lpmat, yt*v0(:,j), opt_gsa.Nsam, 5-1);
-  end
-  for j=1:i0,
-    ys_pc(j,:)=yd_pc(j,:)./max(yd_pc(j,:));
-  end,
-  figure, bar((idex_pc.*ys_pc)./opt_gsa.Nsam), title('Relationships PCA')
-  figure, bar((idex_pc.*ys_pc)'./opt_gsa.Nsam), title('Parameters PCA')
-
-  [vr,dr]=eig(corrcoef(yr(iok,:)));
-  er=diag(dr);
-  er=er([end:-1:1])./j0;
-  ir0=length(find(er>0.01));
-  vr=vr(:,[end:-1:1]);
-  for j=1:ir0,
-    [idex_pcr(j,:), yd_pcr(j,:)] = spop_ide(lpmat, yr*vr(:,j), opt_gsa.Nsam, 5-1);
-  end
-  for j=1:ir0,
-    ys_pcr(j,:)=yd_pcr(j,:)./max(yd_pcr(j,:));
-  end,
-  figure, bar((idex_pcr.*ys_pcr)./opt_gsa.Nsam), title('Relationships rank PCA')
-  figure, bar((idex_pcr.*ys_pcr)'./opt_gsa.Nsam), title('Parameters rank PCA')
-  
-elseif opt_gsa.morris==2,   % ISKREV staff
-  return,
-
-  
-else,  % main effects analysis
-  
-  if itrans==0,
-    fsuffix = '';
-  elseif itrans==1,
-    fsuffix = '_log';
-  else
-    fsuffix = '_rank';
-  end
-  
-  imap=[1:npT];
-
-  if isempty(lpmat0),
-      x0=lpmat(istable,:);
-  else
-      
-      x0=[lpmat0(istable,:), lpmat(istable,:)];
-  end
-  nrun=length(istable);
-  nest=min(250,nrun);
-  nfit=min(1000,nrun);
-  
-%   opt_gsa.load_ident_files=0;
-  
-%   if opt_gsa.load_ident_files==0,
-%   try 
-%     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAvdec','vdec','ir_vdec','ic_vdec');
-%   catch
-%     EET=[];
-%   end
-%   SAvdec=zeros(size(vdec,2),npT);
-% 
-%   for j=1:size(vdec,2),
-%     if itrans==0,
-%       y0 = vdec(istable,j);
-%     elseif itrans==1,
-%       y0 = log_trans_(vdec(istable,j));
-%     else
-%       y0 = trank(vdec(istable,j));
-%     end
-%     if ~isempty(EET),
-% %       imap=find(EET.SAvdec(j,:));
-% %       [dum, isort]=sort(-EET.SAvdec(j,:));
-%       imap=find(EET.SAvdec(j,:) >= (0.1.*max(EET.SAvdec(j,:))) );
-%     end
-%   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
-%       2, [],[],[],0,[OutputDirectoryName,'/map_vdec',fsuffix,int2str(j)], pnames);
-%   if nfit>nest,
-%     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
-%         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_vdec',fsuffix,int2str(j)], pnames);
-%   end
-%     
-%     SAvdec(j,imap)=gsa_(j).si;
-%     imap_vdec{j}=imap;
-%   end
-%   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_vdec','SAvdec','vdec','ir_vdec','ic_vdec','-append')
-%   else
-%   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_vdec','SAvdec','vdec','ir_vdec','ic_vdec')
-%   end
-%   figure,
-% %   boxplot(SAvdec,'whis',10,'symbol','r.')
-%   myboxplot(SAvdec,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:npT,
-%     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects variance decomposition ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_vdec',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix]);
-%   close(gcf),
-% 
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['Main effects observed variance decomposition ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_vdec==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAvdec(iv,:),'whis',10,'symbol','r.');
-%         myboxplot(SAvdec(iv,:),[],'.',[],10)
-%       else
-%         plot(SAvdec(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_vdec',fsuffix,'_varobs_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_varobs_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_varobs_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-% 
-%   ifig = 0;
-%   for j=1:M_.exo_nbr,
-%     if mod(j,6)==1
-%       figure('name',['Main effects shocks variance decomposition ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ic_vdec==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAvdec(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAvdec(iv,:),[],'.',[],10)
-%       else
-%         plot(SAvdec(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',3,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%       set(gca,'fontsize',10)
-%     end
-%     title(M_.exo_names(j,:),'interpreter','none','fontsize',10)
-%     if mod(j,6)==0 | j==M_.exo_nbr
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_vdec',fsuffix,'_exo_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_exo_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_exo_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-
-  if opt_gsa.load_ident_files==0,
-  try 
-    EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAcc','ir_cc','ic_cc');
-  catch
-    EET=[];
-  end
-  ccac = stand_([mss cc ac]);
-  [pcc, dd] = eig(cov(ccac(istable,:)));
-  [latent, isort] = sort(-diag(dd));
-  latent = -latent;
-  figure, bar(latent)
-  title('Eigenvalues in PCA')
-  pcc=pcc(:,isort);
-  ccac = ccac*pcc;
-%   npca = min(40, max(find(cumsum(latent)./length(latent)<0.99))+1);
-  npca = max(find(cumsum(latent)./length(latent)<0.99))+1;
-  siPCA = (EET.SAcc'*abs(pcc'))';
-%   siPCA = siPCA./(max(siPCA')'*ones(1,npT)).*(latent*ones(1,npT));
-  siPCA = siPCA./(max(siPCA')'*ones(1,npT));
-%   siPCA = sum(siPCA,1);
-%   siPCA = siPCA./max(siPCA);
-  SAcc=zeros(size(ccac,2),npT);
-  for j=1:npca, %size(ccac,2),
-    if itrans==0,
-      y0 = ccac(istable,j);
-    elseif itrans==1,
-      y0 = log_trans_(ccac(istable,j));
+        hh = dyn_figure(options_.nodisplay,'name','Screening identification: variance decomposition');
+        %   boxplot(SAvdec,'whis',10,'symbol','r.')
+        myboxplot(SAvdec,[],'.',[],10)
+        set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+        set(gca,'xlim',[0.5 npT+0.5])
+        ydum = get(gca,'ylim');
+        set(gca,'ylim',[0 ydum(2)])
+        set(gca,'position',[0.13 0.2 0.775 0.7])
+        for ip=1:npT
+            text(ip,-2,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+        end
+        xlabel(' ')
+        title('Elementary effects variance decomposition')
+        dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morris_vdec'],options_.nodisplay,options_.graph_format);
+        create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_morris_vdec'],1,'Screening identification: variance decomposition','morris_vdec',1)
     else
-      y0 = trank(ccac(istable,j));
+        save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'vdec')
+
     end
-    if ~isempty(EET),
-%       imap=find(EET.SAvdec(j,:));
-%       [dum, isort]=sort(-EET.SAvdec(j,:));
-      imap=find(siPCA(j,:) >= (0.1.*max(siPCA(j,:))) );
-%       imap=find(EET.SAcc(j,:) >= (0.1.*max(EET.SAcc(j,:))) );
+
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['EET variance decomposition observed variables']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_vdec==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAvdec(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAvdec(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAvdec(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-2,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_vdec_varobs_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_vdec_varobs_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_vdec_varobs_',int2str(ifig)]);
+    %       close(gcf)
+    %     end
+    %   end
+    %
+    %   ifig = 0;
+    %   for j=1:M_.exo_nbr,
+    %     if mod(j,6)==1
+    %       figure('name',['EET variance decomposition shocks']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ic_vdec==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAvdec(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAvdec(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAvdec(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-2,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(M_.exo_names(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==M_.exo_nbr,
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_vdec_exo_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_vdec_exo_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_vdec_exo_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+
+    if opt_gsa.load_ident_files==0
+        SAMorris = [];
+        ccac = [mss cc ac];
+        for i=1:size(ccac,2)
+            [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], [ccac(:,i)],nliv);
+        end
+        SAcc = squeeze(SAMorris(:,1,:))';
+        SAcc = SAcc./(max(SAcc')'*ones(1,npT));
+        save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'SAcc','cc','ir_cc','ic_cc','-append')
+        save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'ac','ir_ac','ic_ac','-append')
+    else
+        load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAcc','cc','ir_cc','ic_cc')
+        load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'ac','ir_ac','ic_ac')
     end
-  gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
-      2, [],[],[],0,[OutputDirectoryName,'/map_cc',fsuffix,int2str(j)], pnames);
-%   if nfit>nest,
-%     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
-%         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_cc',fsuffix,int2str(j)], pnames);
-%   end
-    SAcc(j,imap)=gsa_(j).si;
-    imap_cc{j}=imap;
 
-  end
-  save([OutputDirectoryName,'/map_cc',fsuffix,'.mat'],'gsa_')
-  save([OutputDirectoryName,'/',fname_,'_main_eff.mat'],'imap_cc','SAcc','ccac','-append')
-  else
-    load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_cc','SAcc','ccac')
-    
-  end
-%   figure,
-% %   boxplot(SAcc,'whis',10,'symbol','r.')
-%   myboxplot(SAcc,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:npT,
-%     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   ylabel(' ')
-%   title(['Main effects moments''s PCA ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_cc',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
-%   close(gcf),
+    hh=dyn_figure(options_.nodisplay,'name','Screening identification: theoretical moments');
+    %   boxplot(SAcc,'whis',10,'symbol','r.')
+    myboxplot(SAcc,[],'.',[],10)
+    set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    set(gca,'xlim',[0.5 npT+0.5])
+    ydum = get(gca,'ylim');
+    set(gca,'ylim',[0 1])
+    set(gca,'position',[0.13 0.2 0.775 0.7])
+    for ip=1:npT
+        text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    end
+    xlabel(' ')
+    title('Elementary effects in the moments')
+    dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morris_moments'],options_.nodisplay,options_.graph_format);
+    create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_morris_moments'],1,'Screening identification: theoretical moments','morris_moments',1)
 
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['Main effects cross-covariances ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_cc==j);
-%     iv = [iv; find(ic_cc==j)];
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAcc(iv,:),'whis',10,'symbol','r.');
-%         myboxplot(SAcc(iv,:),[],'.',[],10)
-%       else
-%         plot(SAcc(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%       set(gca,'fontsize',10)
-%     end
-%     title(options_.varobs(j,:),'interpreter','none','fontsize',10)
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_cc',fsuffix,'_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_cc',fsuffix,'_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_cc',fsuffix,'_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-% 
-%   if opt_gsa.load_ident_files==0,
-%   try 
-%     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAac','ir_ac','ic_ac');
-%   catch
-%     EET=[];
-%   end
-%   SAac=zeros(size(ac,2),npT);
-%   for j=1:size(ac,2),
-%     if itrans==0,
-%       y0 = ac(istable,j);
-%     elseif itrans==1,
-%       y0 = log_trans_(ac(istable,j));
-%     else
-%       y0 = trank(ac(istable,j));
-%     end
-%     if ~isempty(EET),
-%       imap=find(EET.SAac(j,:) >= (0.1.*max(EET.SAac(j,:))) );
-%     end
-% %     gsa_(j) = gsa_sdp_dyn( y0, lpmat(istable,:), ...
-% %       gsa_flag, [],[],[],0,[OutputDirectoryName,'/map_ac',fsuffix,int2str(j)], pnames);
-%   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
-%       2, [],[],[],0,[OutputDirectoryName,'/map_ac',fsuffix,int2str(j)], pnames);
-%   if nfit>nest,
-%     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
-%         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_ac',fsuffix,int2str(j)], pnames);
-%   end
-%     SAac(j,imap)=gsa_(j).si;
-%     imap_ac{j}=imap;
-% 
-%   end
-%   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_ac','SAac','ac','ir_ac','ic_ac','-append')
-%   else
-%   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_ac','SAac','ac','ir_ac','ic_ac')
-%   end
-% 
-%   figure,
-% %   boxplot(SAac,'whis',10,'symbol','r.')
-%   myboxplot(SAac,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects 1 lag auto-covariances ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_ac',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix]);
-%   close(gcf),
-% 
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['Main effects auto-covariances ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo = 0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_ac==j);
-%     %iv = [iv; find(ic_ac==j)];
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAac(iv,:),'whis',10,'symbol','r.');
-%         myboxplot(SAac(iv,:),[],'.',[],10)
-%       else
-%         plot(SAac(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 npT+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:npT,
-%         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%       set(gca,'fontsize',10)
-%     end
-%     title(options_.varobs(j,:),'interpreter','none','fontsize',10)
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_ac',fsuffix,'_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix,'_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix,'_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-  
-%   x0=x0(:,nshock+1:end);
-  imap=[1:npT];
+    %   close(gcf),
 
-%   if opt_gsa.load_ident_files==0,
-%   try 
-%     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAtadj','ir_tadj','ic_tadj');
-%     ny=size(EET.SAtadj,1);
-%   catch
-%     EET=[];
-%   end
-%   SAtadj=zeros(size(tadj,2),np);
-%   for j=1:size(tadj,2),
-%     if itrans==0,
-%       y0 = tadj(istable,j);
-%     elseif itrans==1,
-%       y0 = log_trans_(tadj(istable,j));
-%     else
-%       y0 = trank(tadj(istable,j));
-%     end
-%     if ~isempty(EET),
-%       if size(tadj,2)~=ny,
-%         jj=find(EET.ir_tadj==ir_tadj(j));
-%         jj=jj(find(EET.ic_tadj(jj)==ic_tadj(j)));
-%         if ~isempty(jj),
-%           imap=find(EET.SAtadj(jj,:) >= (0.1.*max(EET.SAtadj(jj,:))) );
-%         else
-%           imap=[1:np];
-%         end
-%       else
-%         imap=find(EET.SAtadj(j,:) >= (0.1.*max(EET.SAtadj(j,:))) );
-%       end
-%     end
-% %     gsa_(j) = gsa_sdp_dyn( y0, lpmat(istable,:), ...
-% %       gsa_flag, [],[],[],0,[OutputDirectoryName,'/map_tadj',fsuffix,int2str(j)], pnames);
-%   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
-%       2, [],[],[],0,[OutputDirectoryName,'/map_tadj',fsuffix,int2str(j)], pnames);
-%   if nfit>nest,
-%     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
-%         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_tadj',fsuffix,int2str(j)], pnames);
-%   end
-%     SAtadj(j,imap)=gsa_(j).si;
-%     imap_tadj{j}=imap;
-% 
-%   end
-%   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_tadj','SAtadj','tadj','ir_tadj','ic_tadj','-append')
-%   else
-%   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_tadj','SAtadj','tadj','ir_tadj','ic_tadj')
-%   end
-% 
-%   figure,
-% %   boxplot(SAtadj,'whis',10,'symbol','r.')
-%   myboxplot(SAtadj,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 np+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects speed of adjustment ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_tadj',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix]);
-%   close(gcf),
-% 
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['Main effects observed speed adjustment ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo = 0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_tadj==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAtadj(iv,:),[],'.',[],10)
-%       else
-%         plot(SAtadj(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_tadj',fsuffix,'_varobs_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_varobs_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_varobs_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-% 
-%   ifig = 0;
-%   for j=1:M_.exo_nbr,
-%     if mod(j,6)==1
-%       figure('name',['Main effects shocks speed of adjustment ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ic_tadj==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAtadj(iv,:),[],'.',[],10)
-%       else
-%         plot(SAtadj(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(M_.exo_names(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==M_.exo_nbr,
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_tadj',fsuffix,'_exo_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_exo_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_exo_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-% 
-% 
-%   if opt_gsa.load_ident_files==0,
-%   try 
-%     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAIF','ir_if','ic_if');
-%   catch
-%     EET=[];
-%   end
-%   SAif=zeros(size(iff,2),np);
-%   for j=1:size(iff,2),
-%     if itrans==0,
-%       y0 = iff(istable,j);
-%     elseif itrans==1,
-%       y0 = log_trans_(iff(istable,j));
-%     else
-%       y0 = trank(iff(istable,j));
-%     end
-%     if ~isempty(EET),
-%       imap=find(EET.SAIF(j,:) >= (0.1.*max(EET.SAIF(j,:))) );
-%     end
-% %     gsa_(j) = gsa_sdp_dyn( y0, lpmat(istable,:), ...
-% %       gsa_flag, [],[],[],0,[OutputDirectoryName,'/map_if',fsuffix,int2str(j)], pnames);
-%   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
-%       2, [],[],[],0,[OutputDirectoryName,'/map_if',fsuffix,int2str(j)], pnames);
-%   if nfit>nest,
-%     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
-%         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_if',fsuffix,int2str(j)], pnames);
-%   end
-%     SAif(j,imap)=gsa_(j).si;
-%     imap_if{j}=imap;
-%     
-%   end
-%   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_if','SAif','iff','ir_if','ic_if','-append')
-%   else
-%   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_if','SAif','iff','ir_if','ic_if')
-%   end
-% 
-%   figure,
-% %   boxplot(SAif,'whis',10,'symbol','r.')
-%   myboxplot(SAif,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 np+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects impact factors ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_if',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_if',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_if',fsuffix]);
-%   close(gcf),
-% 
-%   ifig = 0;
-%   for j=1:size(options_.varobs,1)
-%     if mod(j,6)==1
-%       figure('name',['Main effects observed impact factors ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo = 0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ir_if==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAif(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAif(iv,:),[],'.',[],10)
-%       else
-%         plot(SAif(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(options_.varobs(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==size(options_.varobs,1)
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_if',fsuffix,'_varobs_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_varobs_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_varobs_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-% 
-%   ifig = 0;
-%   for j=1:M_.exo_nbr,
-%     if mod(j,6)==1
-%       figure('name',['Main effects shocks impact factors ',fsuffix]);
-%       ifig=ifig+1;
-%       iplo=0;
-%     end
-%     iplo=iplo+1;
-%     subplot(3,2,iplo)
-%     iv = find(ic_if==j);
-%     if ~isempty(iv)
-%       if length(iv)>1
-% %         boxplot(SAif(iv,:),'whis',3,'symbol','r.');
-%         myboxplot(SAif(iv,:),[],'.',[],10)
-%       else
-%         plot(SAif(iv,:),'r.');
-%       end
-%       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%       set(gca,'xlim',[0.5 np+0.5])
-%       ydum = get(gca,'ylim');
-%       set(gca,'ylim',[0 ydum(2)])
-%       for ip=1:np,
-%         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%       end
-%       xlabel(' ')
-%     end
-%     title(M_.exo_names(j,:),'interpreter','none')
-%     if mod(j,6)==0 | j==M_.exo_nbr
-%       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_if',fsuffix,'_exo_',int2str(ifig)])
-%       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_exo_',int2str(ifig)]);
-%       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_exo_',int2str(ifig)]);
-%       close(gcf),
-%     end
-%   end
-%   SAmom = [SAvdec' SAcc' SAac']';
-%   SAdyn = [SAtadj' SAif']';
-%   SAall = [SAmom(:,nshock+1:end)' SAdyn']';
-%   
-%   figure,
-%   %   boxplot(SAtadj,'whis',10,'symbol','r.')
-%   myboxplot(SAmom,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-%   set(gca,'xlim',[0.5 npT+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:npT,
-%     %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects theoretical moments ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_moments',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
-% %   close(gcf),
-%   
-%   figure,
-%   %   boxplot(SAtadj,'whis',10,'symbol','r.')
-%   myboxplot(SAdyn,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 np+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects short-long term dynamics ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_dynamics',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_dynamics',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_dynamics',fsuffix]);
-% %   close(gcf),
-% 
-%   figure,
-%   %   boxplot(SAtadj,'whis',10,'symbol','r.')
-%   myboxplot(SAall,[],'.',[],10)
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
-%   set(gca,'xlim',[0.5 np+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:np,
-%     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-% %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Main effects all ',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_ALL',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_ALL',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_ALL',fsuffix]);
-% %   close(gcf),
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % MORRIS FOR DERIVATIVES
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-%   for j=1:size(SAall,1),
-%     SAallN(j,:)=SAall(j,:)./max(SAall(j,:));
-%   end
-%   SAmean=mean(SAallN);
-%   for j=1:size(SAmom,1),
-%     SAmomN(j,:)=SAmom(j,1:nshock)./max(SAmom(j,1:nshock));
-%   end
-%   SAmomN(find(isnan(SAmomN)))=0;
-%   SAmeanexo=mean(SAmomN(:,1:nshock));
+    % if opt_gsa.load_ident_files==0,
+    %     for j=1:npT,
+    %   SAMorris = [];
+    %   ddd=NaN(size(lpmat,1),size(JJ,1));
+    %   ddd(istable,:) = squeeze(JJ(:,j,:))';
+    %   for i=1:size(ddd,2),
+    %     [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], [ddd(:,i)],nliv);
+    %   end
+    %   SAddd(:,:,j) = squeeze(SAMorris(:,1,:))';
+    %   SAddd(:,:,j) = SAddd(:,:,j)./(max(SAddd(:,:,j)')'*ones(1,npT));
+    %   sad(:,j) = median(SAddd(find(~isnan(squeeze(SAddd(:,1,j)))),:,j))';
+    %     end
+    %   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAddd','sad','-append')
+    %   else
+    %     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAddd','sad')
+    %   end
+    %   figure,
+    %   contourf(sad,10), colorbar
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %   set(gca,'yticklabel',' ','fontsize',10,'ytick',[1:npT])
+    %   for ip=1:npT,
+    %     text(ip,0.9,['D(',bayestopt_.name{ip},')'],'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %     text(0.9,ip,[bayestopt_.name{ip}],'rotation',0,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   [m,im]=max(sad);
+    %   iii = find((im-[1:npT])==0);
+    %   disp('Most identified params')
+    %   disp(bayestopt_.name(iii))
 
-%   figure, bar(latent'*SAcc),
-  hh=dyn_figure(options_,'Name',['Identifiability indices in the ',fsuffix,' moments.']);
-  bar(sum(SAcc)),
-  set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
-  set(gca,'xlim',[0.5 npT+0.5])
-  ydum = get(gca,'ylim');
-  set(gca,'ylim',[0 ydum(2)])
-  set(gca,'position',[0.13 0.2 0.775 0.7])
-  for ip=1:npT,
-    text(ip,-0.02*(ydum(2)),bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % END OF MORRIS FOR DERIVATIVES
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['EET cross-correlations']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_cc==j);
+    %     iv = [iv; find(ic_cc==j)];
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAcc(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAcc(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAcc(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_cc_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_cc_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_cc_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+
+    %   if opt_gsa.load_ident_files==0,
+    %   SAMorris = [];
+    %   for i=1:size(ac,2),
+    %     [SAmeas, SAMorris(:,:,i)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], ac(:,i),nliv);
+    %   end
+    %   %end
+    %   SAac = squeeze(SAMorris(:,1,:))';
+    %   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAac','ac','ir_ac','ic_ac','-append')
+    %   else
+    %     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAac','ac','ir_ac','ic_ac')
+    %   end
+    %   figure,
+    % %   boxplot(SAac,'whis',10,'symbol','r.')
+    %   myboxplot(SAac,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:npT,
     %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-  end
-  xlabel(' ')
-  title(['Identifiability indices in the ',fsuffix,' moments.'],'interpreter','none')
-  dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_ident_ALL',fsuffix],options_);
-  create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_ident_ALL',fsuffix],1,['Identifiability indices in the ',fsuffix,' moments.'],['ident_ALL',fsuffix]',1)
+    %   end
+    %   xlabel(' ')
+    %   title('EET All auto-correlations')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_ac'])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_ac']);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_ac']);
+    %   close(gcf),
 
-%   figure, bar(SAmeanexo),
-%   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:nshock])
-%   set(gca,'xlim',[0.5 nshock+0.5])
-%   ydum = get(gca,'ylim');
-%   set(gca,'ylim',[0 ydum(2)])
-%   set(gca,'position',[0.13 0.2 0.775 0.7])
-%   for ip=1:nshock,
-%     %     text(ip,-0.02*(ydum(2)),deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%     text(ip,-0.02*(ydum(2)),bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
-%   end
-%   xlabel(' ')
-%   title(['Identifiability indices for shocks',fsuffix],'interpreter','none')
-%   saveas(gcf,[OutputDirectoryName,'/',fname_,'_ident_SHOCKS',fsuffix])
-%   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_ident_SHOCKS',fsuffix]);
-%   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_ident_SHOCKS',fsuffix]);
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['EET auto-correlations']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_ac==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAac(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAac(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAac(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_ac_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_ac_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_ac_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+    %   if opt_gsa.load_ident_files==0,
+    %   js=0;
+    %   %for j=1:size(tadj,1),
+    %   SAMorris = [];
+    %   for i=1:size(tadj,2),
+    %     js=js+1;
+    %     [SAmeas, SAMorris(:,:,js)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], tadj(:,i),nliv);
+    %   end
+    %   %end
+    %   SAM = squeeze(SAMorris(nshock+1:end,1,:));
+    %   for j=1:js,
+    %     SAtadj(:,j)=SAM(:,j)./(max(SAM(:,j))+eps);
+    %   end
+    %   SAtadj = SAtadj';
+    %   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAtadj','tadj','ir_tadj','ic_tadj','-append')
+    %   else
+    %     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAtadj','tadj','ir_tadj','ic_tadj')
+    %   end
+    %   if opt_gsa.load_ident_files==0,
+    %   js=0;
+    %   SAMorris = [];
+    %   for i=1:size(iff,2),
+    %     js=js+1;
+    %     [SAmeas, SAMorriss(:,:,js)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], iff(:,i),nliv);
+    %   end
+    %   SAM = squeeze(SAMorriss(nshock+1:end,1,:));
+    %   for j=1:js,
+    %     SAIF(:,j)=SAM(:,j)./(max(SAM(:,j))+eps);
+    %   end
+    %   SAIF = SAIF';
+    %   save([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAIF','iff','ir_if','ic_if','-append')
+    %   else
+    %     load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAIF','iff','ir_if','ic_if')
+    %   end
+    %   figure,
+    %   %bar(SAtadj),
+    % %   boxplot(SAtadj,'whis',10,'symbol','r.')
+    %   myboxplot(SAtadj,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 np+0.5])
+    %   set(gca,'ylim',[0 1])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title('All half-life')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_tadj'])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_tadj']);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_tadj']);
+    %   close(gcf),
+
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['EET speed of adjustment observed variables']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_tadj==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAtadj(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAtadj(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_tadj_varobs_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_tadj_varobs_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_tadj_varobs_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+    %   ifig = 0;
+    %   for j=1:M_.exo_nbr,
+    %     if mod(j,6)==1
+    %       figure('name',['EET speed of adjustment shocks']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ic_tadj==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAtadj(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAtadj(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(M_.exo_names(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==M_.exo_nbr,
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_tadj_exo_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_tadj_exo_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_tadj_exo_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+    %   figure,
+    %   %bar(SAIF),
+    % %   boxplot(SAIF,'whis',10,'symbol','r.')
+    %   myboxplot(SAIF,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 np+0.5])
+    %   set(gca,'ylim',[0 1])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   ylabel('Elementary Effects')
+    %   title('Steady state gains (impact factors)')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_gain'])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_gain']);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_gain']);
+    %   close(gcf),
+    %figure, bar(SAIF'), title('All Gain Relationships')
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['EET steady state gain observed series']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_if==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAIF(iv,:),'whis',10,'symbol','r.');
+    %         myboxplot(SAIF(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAIF(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_gain_varobs_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_gain_varobs_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_gain_varobs_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %
+    %   ifig = 0;
+    %   for j=1:M_.exo_nbr,
+    %     if mod(j,6)==1
+    %       figure('name',['EET steady state gain shocks']);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ic_if==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAIF(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAIF(iv,:),[],'.',[],3)
+    %       else
+    %         plot(SAIF(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(M_.exo_names(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==M_.exo_nbr,
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_gain_exo_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_gain_exo_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_gain_exo_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+
+    if opt_gsa.load_ident_files==0
+        SAMorris = [];
+        for j=1:j0
+            [SAmeas, SAMorris(:,:,j)] = Morris_Measure_Groups(npT, [lpmat0 lpmat], yt(:,j),nliv);
+        end
+
+        %   SAM = squeeze(SAMorris(nshock+1:end,1,:));
+        SAM = squeeze(SAMorris(1:end,1,:));
+        for j=1:j0
+            SAnorm(:,j)=SAM(:,j)./max(SAM(:,j));
+            irex(j)=length(find(SAnorm(:,j)>0.01));
+        end
+        [dum, irel]=sort(irex);
+
+        %   SAMmu = squeeze(SAMorris(nshock+1:end,2,:));
+        SAMmu = squeeze(SAMorris(1:end,2,:));
+        for j=1:j0
+            SAmunorm(:,j)=SAMmu(:,j)./max(SAM(:,j));  % normalised w.r.t. mu*
+        end
+        %   SAMsig = squeeze(SAMorris(nshock+1:end,3,:));
+        SAMsig = squeeze(SAMorris(1:end,3,:));
+        for j=1:j0
+            SAsignorm(:,j)=SAMsig(:,j)./max(SAMsig(:,j));
+        end
+        save([OutputDirectoryName,'/',fname_,'_morris_IDE.mat'],'SAnorm','SAmunorm','SAsignorm','-append')
+    else
+        load([OutputDirectoryName,'/',fname_,'_morris_IDE'],'SAnorm','SAmunorm','SAsignorm')
+    end
+    hh=dyn_figure(options_.nodisplay,'name','Screening identification: model'); %bar(SAnorm(:,irel))
+                                                                                %   boxplot(SAnorm','whis',10,'symbol','r.')
+    myboxplot(SAnorm',[],'.',[],10)
+    set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    set(gca,'xlim',[0.5 npT+0.5])
+    set(gca,'ylim',[0 1])
+    set(gca,'position',[0.13 0.2 0.775 0.7])
+    xlabel(' ')
+    for ip=1:npT
+        %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+        text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    end
+    xlabel(' ')
+    title('Elementary effects in the model')
+    dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morris_par'],options_.nodisplay,options_.graph_format);
+    create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_morris_par'],1,'Screening identification: model','morris_par',1)
+
+    %   hh=dyn_figure(options_.nodisplay); %bar(SAmunorm(:,irel))
+    % %   boxplot(SAmunorm','whis',10,'symbol','r.')
+    %   myboxplot(SAmunorm',[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   set(gca,'ylim',[-1 1])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   xlabel(' ')
+    %   for ip=1:npT,
+    %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title('\mu in the model')
+    %   dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morrismu_par'],options_.nodisplay,options_.graph_format);
+    %
+    %   hh=dyn_figure(options_.nodisplay); %bar(SAsignorm(:,irel))
+    % %   boxplot(SAsignorm','whis',10,'symbol','r.')
+    %   myboxplot(SAsignorm',[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   set(gca,'ylim',[0 1])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   xlabel(' ')
+    %   for ip=1:npT,
+    %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title('\sigma in the model')
+    %   dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_morrissig_par'],options_.nodisplay,options_.graph_format);
+
+    %     figure, bar(SAnorm(:,irel)')
+    %     set(gca,'xtick',[1:j0])
+    %     set(gca,'xlim',[0.5 j0+0.5])
+    %     title('Elementary effects relationships')
+    %     saveas(gcf,[OutputDirectoryName,'/',fname_,'_morris_redform'])
+    %     eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_morris_redform']);
+    %     eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_morris_redform']);
+
+elseif opt_gsa.morris==3
+    return
+
+    np=estim_params_.np;
+    na=(4*np+1)*opt_gsa.Nsam;
+    for j=1:j0
+        [idex(j,:), yd(j,:)] = spop_ide(lpmat, yt(:,j), opt_gsa.Nsam, 5-1);
+    end
+    iok=find(~isnan(yt(1:opt_gsa.Nsam,1)));
+    yr=NaN*ones(size(lpmat,1),j0);
+    for j=1:j0,
+        ys(j,:)=yd(j,:)./max(yd(j,:));
+        [dum, is]=sort(yt(iok,j));
+        yr(iok(is),j)=[1:length(iok)]'./length(iok);
+        yr(istable(length(iok)+1:end),j) = interp1(yt(iok,j),yr(iok,j),yt(istable(length(iok)+1:end),j),'','extrap');
+        ineg=find(yr(:,j)<0);
+        if any(ineg)
+            [dum, is]=sort(yr(ineg,j));
+            yr(ineg(is),j)=-[length(ineg):-1:1]./length(iok);
+        end
+        [idex_r(j,:), yd_r(j,:)] = spop_ide(lpmat, yr(:,j), opt_gsa.Nsam, 5-1);
+        ys_r(j,:)=yd_r(j,:)./max(yd_r(j,:));
+
+    end,
+    figure, bar((idex.*ys)./opt_gsa.Nsam), title('Relationships')
+    figure, bar((idex.*ys)'./opt_gsa.Nsam), title('Parameters')
+    figure, bar((idex_r.*ys_r)./opt_gsa.Nsam), title('Relationships rank')
+    figure, bar((idex_r.*ys_r)'./opt_gsa.Nsam), title('Parameters rank')
+    [v0,d0]=eig(corrcoef(yt(iok,:)));
+    ee=diag(d0);
+    ee=ee([end:-1:1])./j0;
+    i0=length(find(ee>0.01));
+    v0=v0(:,[end:-1:1]);
+    for j=1:i0
+        [idex_pc(j,:), yd_pc(j,:)] = spop_ide(lpmat, yt*v0(:,j), opt_gsa.Nsam, 5-1);
+    end
+    for j=1:i0
+        ys_pc(j,:)=yd_pc(j,:)./max(yd_pc(j,:));
+    end,
+    figure, bar((idex_pc.*ys_pc)./opt_gsa.Nsam), title('Relationships PCA')
+    figure, bar((idex_pc.*ys_pc)'./opt_gsa.Nsam), title('Parameters PCA')
+
+    [vr,dr]=eig(corrcoef(yr(iok,:)));
+    er=diag(dr);
+    er=er([end:-1:1])./j0;
+    ir0=length(find(er>0.01));
+    vr=vr(:,[end:-1:1]);
+    for j=1:ir0
+        [idex_pcr(j,:), yd_pcr(j,:)] = spop_ide(lpmat, yr*vr(:,j), opt_gsa.Nsam, 5-1);
+    end
+    for j=1:ir0
+        ys_pcr(j,:)=yd_pcr(j,:)./max(yd_pcr(j,:));
+    end
+    figure, bar((idex_pcr.*ys_pcr)./opt_gsa.Nsam), title('Relationships rank PCA')
+    figure, bar((idex_pcr.*ys_pcr)'./opt_gsa.Nsam), title('Parameters rank PCA')
+
+elseif opt_gsa.morris==2   % ISKREV staff
+    return
+
+
+else  % main effects analysis
+
+    if itrans==0
+        fsuffix = '';
+    elseif itrans==1
+        fsuffix = '_log';
+    else
+        fsuffix = '_rank';
+    end
+
+    imap=[1:npT];
+
+    if isempty(lpmat0)
+        x0=lpmat(istable,:);
+    else
+
+        x0=[lpmat0(istable,:), lpmat(istable,:)];
+    end
+    nrun=length(istable);
+    nest=min(250,nrun);
+    nfit=min(1000,nrun);
+
+    %   opt_gsa.load_ident_files=0;
+
+    %   if opt_gsa.load_ident_files==0,
+    %   try
+    %     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAvdec','vdec','ir_vdec','ic_vdec');
+    %   catch
+    %     EET=[];
+    %   end
+    %   SAvdec=zeros(size(vdec,2),npT);
+    %
+    %   for j=1:size(vdec,2),
+    %     if itrans==0,
+    %       y0 = vdec(istable,j);
+    %     elseif itrans==1,
+    %       y0 = log_trans_(vdec(istable,j));
+    %     else
+    %       y0 = trank(vdec(istable,j));
+    %     end
+    %     if ~isempty(EET),
+    % %       imap=find(EET.SAvdec(j,:));
+    % %       [dum, isort]=sort(-EET.SAvdec(j,:));
+    %       imap=find(EET.SAvdec(j,:) >= (0.1.*max(EET.SAvdec(j,:))) );
+    %     end
+    %   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
+    %       2, [],[],[],0,[OutputDirectoryName,'/map_vdec',fsuffix,int2str(j)], pnames);
+    %   if nfit>nest,
+    %     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
+    %         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_vdec',fsuffix,int2str(j)], pnames);
+    %   end
+    %
+    %     SAvdec(j,imap)=gsa_(j).si;
+    %     imap_vdec{j}=imap;
+    %   end
+    %   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_vdec','SAvdec','vdec','ir_vdec','ic_vdec','-append')
+    %   else
+    %   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_vdec','SAvdec','vdec','ir_vdec','ic_vdec')
+    %   end
+    %   figure,
+    % %   boxplot(SAvdec,'whis',10,'symbol','r.')
+    %   myboxplot(SAvdec,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:npT,
+    %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects variance decomposition ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_vdec',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix]);
+    %   close(gcf),
+    %
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects observed variance decomposition ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_vdec==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAvdec(iv,:),'whis',10,'symbol','r.');
+    %         myboxplot(SAvdec(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAvdec(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_vdec',fsuffix,'_varobs_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_varobs_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_varobs_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %
+    %   ifig = 0;
+    %   for j=1:M_.exo_nbr,
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects shocks variance decomposition ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ic_vdec==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAvdec(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAvdec(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAvdec(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',3,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %       set(gca,'fontsize',10)
+    %     end
+    %     title(M_.exo_names(j,:),'interpreter','none','fontsize',10)
+    %     if mod(j,6)==0 | j==M_.exo_nbr
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_vdec',fsuffix,'_exo_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_exo_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_vdec',fsuffix,'_exo_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+    if opt_gsa.load_ident_files==0
+        try
+            EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAcc','ir_cc','ic_cc');
+        catch
+            EET=[];
+        end
+        ccac = stand_([mss cc ac]);
+        [pcc, dd] = eig(cov(ccac(istable,:)));
+        [latent, isort] = sort(-diag(dd));
+        latent = -latent;
+        figure, bar(latent)
+        title('Eigenvalues in PCA')
+        pcc=pcc(:,isort);
+        ccac = ccac*pcc;
+        %   npca = min(40, max(find(cumsum(latent)./length(latent)<0.99))+1);
+        npca = max(find(cumsum(latent)./length(latent)<0.99))+1;
+        siPCA = (EET.SAcc'*abs(pcc'))';
+        %   siPCA = siPCA./(max(siPCA')'*ones(1,npT)).*(latent*ones(1,npT));
+        siPCA = siPCA./(max(siPCA')'*ones(1,npT));
+        %   siPCA = sum(siPCA,1);
+        %   siPCA = siPCA./max(siPCA);
+        SAcc=zeros(size(ccac,2),npT);
+        for j=1:npca %size(ccac,2),
+            if itrans==0
+                y0 = ccac(istable,j);
+            elseif itrans==1
+                y0 = log_trans_(ccac(istable,j));
+            else
+                y0 = trank(ccac(istable,j));
+            end
+            if ~isempty(EET)
+                %       imap=find(EET.SAvdec(j,:));
+                %       [dum, isort]=sort(-EET.SAvdec(j,:));
+                imap=find(siPCA(j,:) >= (0.1.*max(siPCA(j,:))) );
+                %       imap=find(EET.SAcc(j,:) >= (0.1.*max(EET.SAcc(j,:))) );
+            end
+            gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
+                              2, [],[],[],0,[OutputDirectoryName,'/map_cc',fsuffix,int2str(j)], pnames);
+            %   if nfit>nest,
+            %     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
+            %         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_cc',fsuffix,int2str(j)], pnames);
+            %   end
+            SAcc(j,imap)=gsa_(j).si;
+            imap_cc{j}=imap;
+
+        end
+        save([OutputDirectoryName,'/map_cc',fsuffix,'.mat'],'gsa_')
+        save([OutputDirectoryName,'/',fname_,'_main_eff.mat'],'imap_cc','SAcc','ccac','-append')
+    else
+        load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_cc','SAcc','ccac')
+
+    end
+    %   figure,
+    % %   boxplot(SAcc,'whis',10,'symbol','r.')
+    %   myboxplot(SAcc,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:npT,
+    %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   ylabel(' ')
+    %   title(['Main effects moments''s PCA ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_cc',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
+    %   close(gcf),
+
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects cross-covariances ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_cc==j);
+    %     iv = [iv; find(ic_cc==j)];
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAcc(iv,:),'whis',10,'symbol','r.');
+    %         myboxplot(SAcc(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAcc(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %       set(gca,'fontsize',10)
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none','fontsize',10)
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_cc',fsuffix,'_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_cc',fsuffix,'_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_cc',fsuffix,'_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %
+    %   if opt_gsa.load_ident_files==0,
+    %   try
+    %     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAac','ir_ac','ic_ac');
+    %   catch
+    %     EET=[];
+    %   end
+    %   SAac=zeros(size(ac,2),npT);
+    %   for j=1:size(ac,2),
+    %     if itrans==0,
+    %       y0 = ac(istable,j);
+    %     elseif itrans==1,
+    %       y0 = log_trans_(ac(istable,j));
+    %     else
+    %       y0 = trank(ac(istable,j));
+    %     end
+    %     if ~isempty(EET),
+    %       imap=find(EET.SAac(j,:) >= (0.1.*max(EET.SAac(j,:))) );
+    %     end
+    % %     gsa_(j) = gsa_sdp_dyn( y0, lpmat(istable,:), ...
+    % %       gsa_flag, [],[],[],0,[OutputDirectoryName,'/map_ac',fsuffix,int2str(j)], pnames);
+    %   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
+    %       2, [],[],[],0,[OutputDirectoryName,'/map_ac',fsuffix,int2str(j)], pnames);
+    %   if nfit>nest,
+    %     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
+    %         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_ac',fsuffix,int2str(j)], pnames);
+    %   end
+    %     SAac(j,imap)=gsa_(j).si;
+    %     imap_ac{j}=imap;
+    %
+    %   end
+    %   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_ac','SAac','ac','ir_ac','ic_ac','-append')
+    %   else
+    %   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_ac','SAac','ac','ir_ac','ic_ac')
+    %   end
+    %
+    %   figure,
+    % %   boxplot(SAac,'whis',10,'symbol','r.')
+    %   myboxplot(SAac,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects 1 lag auto-covariances ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_ac',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix]);
+    %   close(gcf),
+    %
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects auto-covariances ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo = 0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_ac==j);
+    %     %iv = [iv; find(ic_ac==j)];
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAac(iv,:),'whis',10,'symbol','r.');
+    %         myboxplot(SAac(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAac(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 npT+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:npT,
+    %         text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %       set(gca,'fontsize',10)
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none','fontsize',10)
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_ac',fsuffix,'_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix,'_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_ac',fsuffix,'_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+
+    %   x0=x0(:,nshock+1:end);
+    imap=[1:npT];
+
+    %   if opt_gsa.load_ident_files==0,
+    %   try
+    %     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAtadj','ir_tadj','ic_tadj');
+    %     ny=size(EET.SAtadj,1);
+    %   catch
+    %     EET=[];
+    %   end
+    %   SAtadj=zeros(size(tadj,2),np);
+    %   for j=1:size(tadj,2),
+    %     if itrans==0,
+    %       y0 = tadj(istable,j);
+    %     elseif itrans==1,
+    %       y0 = log_trans_(tadj(istable,j));
+    %     else
+    %       y0 = trank(tadj(istable,j));
+    %     end
+    %     if ~isempty(EET),
+    %       if size(tadj,2)~=ny,
+    %         jj=find(EET.ir_tadj==ir_tadj(j));
+    %         jj=jj(find(EET.ic_tadj(jj)==ic_tadj(j)));
+    %         if ~isempty(jj),
+    %           imap=find(EET.SAtadj(jj,:) >= (0.1.*max(EET.SAtadj(jj,:))) );
+    %         else
+    %           imap=[1:np];
+    %         end
+    %       else
+    %         imap=find(EET.SAtadj(j,:) >= (0.1.*max(EET.SAtadj(j,:))) );
+    %       end
+    %     end
+    % %     gsa_(j) = gsa_sdp_dyn( y0, lpmat(istable,:), ...
+    % %       gsa_flag, [],[],[],0,[OutputDirectoryName,'/map_tadj',fsuffix,int2str(j)], pnames);
+    %   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
+    %       2, [],[],[],0,[OutputDirectoryName,'/map_tadj',fsuffix,int2str(j)], pnames);
+    %   if nfit>nest,
+    %     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
+    %         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_tadj',fsuffix,int2str(j)], pnames);
+    %   end
+    %     SAtadj(j,imap)=gsa_(j).si;
+    %     imap_tadj{j}=imap;
+    %
+    %   end
+    %   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_tadj','SAtadj','tadj','ir_tadj','ic_tadj','-append')
+    %   else
+    %   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_tadj','SAtadj','tadj','ir_tadj','ic_tadj')
+    %   end
+    %
+    %   figure,
+    % %   boxplot(SAtadj,'whis',10,'symbol','r.')
+    %   myboxplot(SAtadj,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 np+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects speed of adjustment ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_tadj',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix]);
+    %   close(gcf),
+    %
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects observed speed adjustment ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo = 0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_tadj==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAtadj(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAtadj(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_tadj',fsuffix,'_varobs_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_varobs_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_varobs_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %
+    %   ifig = 0;
+    %   for j=1:M_.exo_nbr,
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects shocks speed of adjustment ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ic_tadj==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAtadj(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAtadj(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAtadj(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(M_.exo_names(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==M_.exo_nbr,
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_tadj',fsuffix,'_exo_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_exo_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_tadj',fsuffix,'_exo_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %
+    %
+    %   if opt_gsa.load_ident_files==0,
+    %   try
+    %     EET=load([OutputDirectoryName,'/SCREEN/',fname_,'_morris_IDE'],'SAIF','ir_if','ic_if');
+    %   catch
+    %     EET=[];
+    %   end
+    %   SAif=zeros(size(iff,2),np);
+    %   for j=1:size(iff,2),
+    %     if itrans==0,
+    %       y0 = iff(istable,j);
+    %     elseif itrans==1,
+    %       y0 = log_trans_(iff(istable,j));
+    %     else
+    %       y0 = trank(iff(istable,j));
+    %     end
+    %     if ~isempty(EET),
+    %       imap=find(EET.SAIF(j,:) >= (0.1.*max(EET.SAIF(j,:))) );
+    %     end
+    % %     gsa_(j) = gsa_sdp_dyn( y0, lpmat(istable,:), ...
+    % %       gsa_flag, [],[],[],0,[OutputDirectoryName,'/map_if',fsuffix,int2str(j)], pnames);
+    %   gsa_(j) = gsa_sdp(y0(1:nest), x0(1:nest,imap), ...
+    %       2, [],[],[],0,[OutputDirectoryName,'/map_if',fsuffix,int2str(j)], pnames);
+    %   if nfit>nest,
+    %     gsa_(j) = gsa_sdp(y0(1:nfit), x0(1:nfit,imap), ...
+    %         -2, gsa_(j).nvr*nest^3/nfit^3,[],[],0,[OutputDirectoryName,'/map_if',fsuffix,int2str(j)], pnames);
+    %   end
+    %     SAif(j,imap)=gsa_(j).si;
+    %     imap_if{j}=imap;
+    %
+    %   end
+    %   save([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_if','SAif','iff','ir_if','ic_if','-append')
+    %   else
+    %   load([OutputDirectoryName,'/',fname_,'_main_eff'],'imap_if','SAif','iff','ir_if','ic_if')
+    %   end
+    %
+    %   figure,
+    % %   boxplot(SAif,'whis',10,'symbol','r.')
+    %   myboxplot(SAif,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 np+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects impact factors ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_if',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_if',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_if',fsuffix]);
+    %   close(gcf),
+    %
+    %   ifig = 0;
+    %   for j=1:size(options_.varobs,1)
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects observed impact factors ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo = 0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ir_if==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAif(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAif(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAif(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(options_.varobs(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==size(options_.varobs,1)
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_if',fsuffix,'_varobs_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_varobs_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_varobs_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %
+    %   ifig = 0;
+    %   for j=1:M_.exo_nbr,
+    %     if mod(j,6)==1
+    %       figure('name',['Main effects shocks impact factors ',fsuffix]);
+    %       ifig=ifig+1;
+    %       iplo=0;
+    %     end
+    %     iplo=iplo+1;
+    %     subplot(3,2,iplo)
+    %     iv = find(ic_if==j);
+    %     if ~isempty(iv)
+    %       if length(iv)>1
+    % %         boxplot(SAif(iv,:),'whis',3,'symbol','r.');
+    %         myboxplot(SAif(iv,:),[],'.',[],10)
+    %       else
+    %         plot(SAif(iv,:),'r.');
+    %       end
+    %       set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %       set(gca,'xlim',[0.5 np+0.5])
+    %       ydum = get(gca,'ylim');
+    %       set(gca,'ylim',[0 ydum(2)])
+    %       for ip=1:np,
+    %         text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %       end
+    %       xlabel(' ')
+    %     end
+    %     title(M_.exo_names(j,:),'interpreter','none')
+    %     if mod(j,6)==0 | j==M_.exo_nbr
+    %       saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_if',fsuffix,'_exo_',int2str(ifig)])
+    %       eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_exo_',int2str(ifig)]);
+    %       eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_if',fsuffix,'_exo_',int2str(ifig)]);
+    %       close(gcf),
+    %     end
+    %   end
+    %   SAmom = [SAvdec' SAcc' SAac']';
+    %   SAdyn = [SAtadj' SAif']';
+    %   SAall = [SAmom(:,nshock+1:end)' SAdyn']';
+    %
+    %   figure,
+    %   %   boxplot(SAtadj,'whis',10,'symbol','r.')
+    %   myboxplot(SAmom,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    %   set(gca,'xlim',[0.5 npT+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:npT,
+    %     %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects theoretical moments ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_moments',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_moments',fsuffix]);
+    % %   close(gcf),
+    %
+    %   figure,
+    %   %   boxplot(SAtadj,'whis',10,'symbol','r.')
+    %   myboxplot(SAdyn,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 np+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects short-long term dynamics ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_dynamics',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_dynamics',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_dynamics',fsuffix]);
+    % %   close(gcf),
+    %
+    %   figure,
+    %   %   boxplot(SAtadj,'whis',10,'symbol','r.')
+    %   myboxplot(SAall,[],'.',[],10)
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
+    %   set(gca,'xlim',[0.5 np+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:np,
+    %     text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    % %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Main effects all ',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_map_ALL',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_map_ALL',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_map_ALL',fsuffix]);
+    % %   close(gcf),
+
+    %   for j=1:size(SAall,1),
+    %     SAallN(j,:)=SAall(j,:)./max(SAall(j,:));
+    %   end
+    %   SAmean=mean(SAallN);
+    %   for j=1:size(SAmom,1),
+    %     SAmomN(j,:)=SAmom(j,1:nshock)./max(SAmom(j,1:nshock));
+    %   end
+    %   SAmomN(find(isnan(SAmomN)))=0;
+    %   SAmeanexo=mean(SAmomN(:,1:nshock));
+
+    %   figure, bar(latent'*SAcc),
+    hh=dyn_figure(options_.nodisplay,'Name',['Identifiability indices in the ',fsuffix,' moments.']);
+    bar(sum(SAcc))
+    set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:npT])
+    set(gca,'xlim',[0.5 npT+0.5])
+    ydum = get(gca,'ylim');
+    set(gca,'ylim',[0 ydum(2)])
+    set(gca,'position',[0.13 0.2 0.775 0.7])
+    for ip=1:npT
+        text(ip,-0.02*(ydum(2)),bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+        %     text(ip,-0.02,bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    end
+    xlabel(' ')
+    title(['Identifiability indices in the ',fsuffix,' moments.'],'interpreter','none')
+    dyn_saveas(hh,[OutputDirectoryName,'/',fname_,'_ident_ALL',fsuffix],options_.nodisplay,options_.graph_format);
+    create_TeX_loader(options_,[OutputDirectoryName,'/',fname_,'_ident_ALL',fsuffix],1,['Identifiability indices in the ',fsuffix,' moments.'],['ident_ALL',fsuffix]',1)
+
+    %   figure, bar(SAmeanexo),
+    %   set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:nshock])
+    %   set(gca,'xlim',[0.5 nshock+0.5])
+    %   ydum = get(gca,'ylim');
+    %   set(gca,'ylim',[0 ydum(2)])
+    %   set(gca,'position',[0.13 0.2 0.775 0.7])
+    %   for ip=1:nshock,
+    %     %     text(ip,-0.02*(ydum(2)),deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %     text(ip,-0.02*(ydum(2)),bayestopt_.name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
+    %   end
+    %   xlabel(' ')
+    %   title(['Identifiability indices for shocks',fsuffix],'interpreter','none')
+    %   saveas(gcf,[OutputDirectoryName,'/',fname_,'_ident_SHOCKS',fsuffix])
+    %   eval(['print -depsc2 ' OutputDirectoryName '/' fname_ '_ident_SHOCKS',fsuffix]);
+    %   eval(['print -dpdf ' OutputDirectoryName '/' fname_ '_ident_SHOCKS',fsuffix]);
 end
 
 return
diff --git a/matlab/gsa/mc_moments.m b/matlab/gsa/mc_moments.m
index b2ea93538..b7464a7e0 100644
--- a/matlab/gsa/mc_moments.m
+++ b/matlab/gsa/mc_moments.m
@@ -1,6 +1,6 @@
 function [vdec, cc, ac] = mc_moments(mm, ss, dr)
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -19,19 +19,19 @@ function [vdec, cc, ac] = mc_moments(mm, ss, dr)
 
 global options_ M_ estim_params_ oo_
 
-  [nr1, nc1, nsam] = size(mm);
-  nobs=size(options_.varobs,2);
-  disp('Computing theoretical moments ...')
-  h = dyn_waitbar(0,'Theoretical moments ...');
-  vdec = zeros(nobs,M_.exo_nbr,nsam);
-  cc = zeros(nobs,nobs,nsam);
-  ac = zeros(nobs,nobs*options_.ar,nsam);
-  
-  for j=1:nsam,
+[nr1, nc1, nsam] = size(mm);
+nobs=size(options_.varobs,2);
+disp('Computing theoretical moments ...')
+h = dyn_waitbar(0,'Theoretical moments ...');
+vdec = zeros(nobs,M_.exo_nbr,nsam);
+cc = zeros(nobs,nobs,nsam);
+ac = zeros(nobs,nobs*options_.ar,nsam);
+
+for j=1:nsam
     oo_.dr.ghx = mm(:, [1:(nc1-M_.exo_nbr)],j);
     oo_.dr.ghu = mm(:, [(nc1-M_.exo_nbr+1):end], j);
-    if ~isempty(ss),
-      set_shocks_param(ss(j,:));
+    if ~isempty(ss)
+        set_shocks_param(ss(j,:));
     end
     [vdec(:,:,j), corr, autocorr, z, zz] = th_moments(oo_.dr,options_.varobs);
     cc(:,:,j)=triu(corr);
@@ -41,7 +41,7 @@ global options_ M_ estim_params_ oo_
     end
     ac(:,:,j)=dum;
     dyn_waitbar(j/nsam,h)
-  end
-  dyn_waitbar_close(h)
-  skipline()
-  disp('... done !')
+end
+dyn_waitbar_close(h)
+skipline()
+disp('... done !')
diff --git a/matlab/gsa/mcf_analysis.m b/matlab/gsa/mcf_analysis.m
index b01ba58e0..c4de17b8f 100644
--- a/matlab/gsa/mcf_analysis.m
+++ b/matlab/gsa/mcf_analysis.m
@@ -1,85 +1,84 @@
-function indmcf = mcf_analysis(lpmat, ibeha, inobeha, options_mcf, DynareOptions)
-%
-% Written by Marco Ratto
-% Joint Research Centre, The European Commission,
-% marco.ratto@jrc.ec.europa.eu
-%
-
-% Copyright (C) 2014 European Commission
-% Copyright (C) 2016 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/>.
-
-pvalue_ks = options_mcf.pvalue_ks;
-pvalue_corr = options_mcf.pvalue_corr;
-alpha2 = options_mcf.alpha2;
-param_names = options_mcf.param_names;
-
-if DynareOptions.TeX
-    if ~isfield(options_mcf,'param_names_tex')
-        param_names_tex = options_mcf.param_names;
-    else
-        param_names_tex = options_mcf.param_names_tex;
-    end
-end
-amcf_name = options_mcf.amcf_name;
-amcf_title = options_mcf.amcf_title;
-beha_title = options_mcf.beha_title;
-nobeha_title = options_mcf.nobeha_title;
-title = options_mcf.title;
-fname_ = options_mcf.fname_;
-xparam1=[];
-if isfield(options_mcf,'xparam1'),
-    xparam1=options_mcf.xparam1;
-end    
-OutputDirectoryName = options_mcf.OutputDirectoryName;
-
-[proba, dproba] = stab_map_1(lpmat, ibeha, inobeha, [],0);
-%         indindet=find(dproba>ksstat);
-indmcf=find(proba<pvalue_ks);
-[tmp,jtmp] = sort(proba(indmcf),2,'ascend');
-indmcf = indmcf(jtmp);
-if ~isempty(indmcf)
-    skipline()
-    headers=char('Parameter','d-stat','p-value');
-    labels=char(param_names(indmcf,:));
-    data_mat=[dproba(indmcf)' proba(indmcf)'];
-    options_temp.noprint=0;
-    dyntable(options_temp,['Smirnov statistics in driving ', title],headers,labels,data_mat,size(labels,2)+2,16,3);
-    if DynareOptions.TeX
-        labels_TeX=param_names_tex(indmcf,:);
-        M_temp.dname=OutputDirectoryName ;
-        M_temp.fname=fname_;
-        dyn_latex_table(M_temp,options_temp,['Smirnov statistics in driving ', strrep(title,'_','\\_')],amcf_name,headers,labels_TeX,data_mat,size(labels,2)+2,16,6);
-    end
-end
-    
-
-if length(ibeha)>10 && length(inobeha)>10,
-    indcorr1 = stab_map_2(lpmat(ibeha,:),alpha2, pvalue_corr, beha_title);
-    indcorr2 = stab_map_2(lpmat(inobeha,:),alpha2, pvalue_corr, nobeha_title);
-    indcorr = union(indcorr1(:), indcorr2(:));
-    indcorr = indcorr(~ismember(indcorr(:),indmcf));
-    indmcf = [indmcf(:); indcorr(:)];
-end
-if ~isempty(indmcf) && ~DynareOptions.nograph,
-    skipline()
-    xx=[];
-    if ~ isempty(xparam1), xx=xparam1(indmcf); end
-    scatter_mcf(lpmat(ibeha,indmcf),lpmat(inobeha,indmcf), param_names(indmcf,:), ...
-        '.', [fname_,'_',amcf_name], OutputDirectoryName, amcf_title,xx, DynareOptions, ...
-        beha_title, nobeha_title)
-end
+function indmcf = mcf_analysis(lpmat, ibeha, inobeha, options_mcf, DynareOptions)
+%
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+%
+
+% Copyright (C) 2014 European Commission
+% Copyright (C) 2016-2017 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/>.
+
+pvalue_ks = options_mcf.pvalue_ks;
+pvalue_corr = options_mcf.pvalue_corr;
+alpha2 = options_mcf.alpha2;
+param_names = options_mcf.param_names;
+
+if DynareOptions.TeX
+    if ~isfield(options_mcf,'param_names_tex')
+        param_names_tex = options_mcf.param_names;
+    else
+        param_names_tex = options_mcf.param_names_tex;
+    end
+end
+amcf_name = options_mcf.amcf_name;
+amcf_title = options_mcf.amcf_title;
+beha_title = options_mcf.beha_title;
+nobeha_title = options_mcf.nobeha_title;
+title = options_mcf.title;
+fname_ = options_mcf.fname_;
+xparam1=[];
+if isfield(options_mcf,'xparam1')
+    xparam1=options_mcf.xparam1;
+end
+OutputDirectoryName = options_mcf.OutputDirectoryName;
+
+[proba, dproba] = stab_map_1(lpmat, ibeha, inobeha, [],0);
+indmcf=find(proba<pvalue_ks);
+[tmp,jtmp] = sort(proba(indmcf),2,'ascend');
+indmcf = indmcf(jtmp);
+if ~isempty(indmcf)
+    skipline()
+    headers=char('Parameter','d-stat','p-value');
+    labels=char(param_names(indmcf,:));
+    data_mat=[dproba(indmcf)' proba(indmcf)'];
+    options_temp.noprint=0;
+    dyntable(options_temp,['Smirnov statistics in driving ', title],headers,labels,data_mat,size(labels,2)+2,16,3);
+    if DynareOptions.TeX
+        labels_TeX=param_names_tex(indmcf,:);
+        M_temp.dname=OutputDirectoryName ;
+        M_temp.fname=fname_;
+        dyn_latex_table(M_temp,options_temp,['Smirnov statistics in driving ', strrep(title,'_','\\_')],amcf_name,headers,labels_TeX,data_mat,size(labels,2)+2,16,6);
+    end
+end
+
+
+if length(ibeha)>10 && length(inobeha)>10
+    indcorr1 = stab_map_2(lpmat(ibeha,:),alpha2, pvalue_corr, beha_title);
+    indcorr2 = stab_map_2(lpmat(inobeha,:),alpha2, pvalue_corr, nobeha_title);
+    indcorr = union(indcorr1(:), indcorr2(:));
+    indcorr = indcorr(~ismember(indcorr(:),indmcf));
+    indmcf = [indmcf(:); indcorr(:)];
+end
+if ~isempty(indmcf) && ~DynareOptions.nograph
+    skipline()
+    xx=[];
+    if ~ isempty(xparam1), xx=xparam1(indmcf); end
+    scatter_mcf(lpmat(ibeha,indmcf),lpmat(inobeha,indmcf), param_names(indmcf,:), ...
+                '.', [fname_,'_',amcf_name], OutputDirectoryName, amcf_title,xx, DynareOptions, ...
+                beha_title, nobeha_title)
+end
diff --git a/matlab/gsa/myboxplot.m b/matlab/gsa/myboxplot.m
index b83e5af13..a83ca922c 100644
--- a/matlab/gsa/myboxplot.m
+++ b/matlab/gsa/myboxplot.m
@@ -1,7 +1,12 @@
 function sout = myboxplot (data,notched,symbol,vertical,maxwhisker)
 %  sout = myboxplot (data,notched,symbol,vertical,maxwhisker)
 
-% Copyright (C) 2012 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,11 +35,11 @@ if notched==1, notched=0.25; end
 a=1-notched;
 
 % ## figure out how many data sets we have
-if iscell(data), 
-  nc = length(data);
+if iscell(data)
+    nc = length(data);
 else
-%   if isvector(data), data = data(:); end
-  nc = size(data,2);
+    %   if isvector(data), data = data(:); end
+    nc = size(data,2);
 end
 
 % ## compute statistics
@@ -58,21 +63,21 @@ for i=1:nc
     else
         col = data(:,i);
     end
-%   ## Skip missing data
-% % % % % % %   col(isnan(col) | isna (col)) = [];
-  col(isnan(col)) = [];
+    %   ## Skip missing data
+    % % % % % % %   col(isnan(col) | isna (col)) = [];
+    col(isnan(col)) = [];
 
-  %   ## Remember the data length
-  nd = length(col);
-  box(i) = nd;
-  if (nd > 1)
-%     ## min,max and quartiles
-%     s(1:5,i) = statistics(col)(1:5);
-s(1,i)=min(col);
-s(5,i)=max(col);
-s(2,i)=myprctilecol(col,25);
-s(3,i)=myprctilecol(col,50);
-s(4,i)=myprctilecol(col,75);
+    %   ## Remember the data length
+    nd = length(col);
+    box(i) = nd;
+    if (nd > 1)
+        %     ## min,max and quartiles
+        %     s(1:5,i) = statistics(col)(1:5);
+        s(1,i)=min(col);
+        s(5,i)=max(col);
+        s(2,i)=myprctilecol(col,25);
+        s(3,i)=myprctilecol(col,50);
+        s(4,i)=myprctilecol(col,75);
 
 
 
@@ -81,37 +86,37 @@ s(4,i)=myprctilecol(col,75);
 
 
 
-%     ## confidence interval for the median
-    est = 1.57*(s(4,i)-s(2,i))/sqrt(nd);
-    s(6,i) = max([s(3,i)-est, s(2,i)]);
-    s(7,i) = min([s(3,i)+est, s(4,i)]);
-%     ## whiskers out to the last point within the desired inter-quartile range
-    IQR = maxwhisker*(s(4,i)-s(2,i));
-    whisker_y(:,i) = [min(col(col >= s(2,i)-IQR)); s(2,i)];
-    whisker_y(:,nc+i) = [max(col(col <= s(4,i)+IQR)); s(4,i)];
-%     ## outliers beyond 1 and 2 inter-quartile ranges
-    outliers = col((col < s(2,i)-IQR & col >= s(2,i)-2*IQR) | (col > s(4,i)+IQR & col <= s(4,i)+2*IQR));
-    outliers2 = col(col < s(2,i)-2*IQR | col > s(4,i)+2*IQR);
-    outliers_x = [outliers_x; i*ones(size(outliers))];
-    outliers_y = [outliers_y; outliers];
-    outliers2_x = [outliers2_x; i*ones(size(outliers2))];
-    outliers2_y = [outliers2_y; outliers2];
-  elseif (nd == 1)
-%     ## all statistics collapse to the value of the point
-    s(:,i) = col;
-%     ## single point data sets are plotted as outliers.
-    outliers_x = [outliers_x; i];
-    outliers_y = [outliers_y; col];
-  else
-%     ## no statistics if no points
-    s(:,i) = NaN;
-  end
+        %     ## confidence interval for the median
+        est = 1.57*(s(4,i)-s(2,i))/sqrt(nd);
+        s(6,i) = max([s(3,i)-est, s(2,i)]);
+        s(7,i) = min([s(3,i)+est, s(4,i)]);
+        %     ## whiskers out to the last point within the desired inter-quartile range
+        IQR = maxwhisker*(s(4,i)-s(2,i));
+        whisker_y(:,i) = [min(col(col >= s(2,i)-IQR)); s(2,i)];
+        whisker_y(:,nc+i) = [max(col(col <= s(4,i)+IQR)); s(4,i)];
+        %     ## outliers beyond 1 and 2 inter-quartile ranges
+        outliers = col((col < s(2,i)-IQR & col >= s(2,i)-2*IQR) | (col > s(4,i)+IQR & col <= s(4,i)+2*IQR));
+        outliers2 = col(col < s(2,i)-2*IQR | col > s(4,i)+2*IQR);
+        outliers_x = [outliers_x; i*ones(size(outliers))];
+        outliers_y = [outliers_y; outliers];
+        outliers2_x = [outliers2_x; i*ones(size(outliers2))];
+        outliers2_y = [outliers2_y; outliers2];
+    elseif (nd == 1)
+        %     ## all statistics collapse to the value of the point
+        s(:,i) = col;
+        %     ## single point data sets are plotted as outliers.
+        outliers_x = [outliers_x; i];
+        outliers_y = [outliers_y; col];
+    else
+        %     ## no statistics if no points
+        s(:,i) = NaN;
+    end
 end
 % % % % if isempty(outliers2_y)
 % % % %     outliers2_y=
 % ## Note which boxes don't have enough stats
 chop = find(box <= 1);
-    
+
 % ## Draw a box around the quartiles, with width proportional to the number of
 % ## items in the box. Draw notches if desired.
 box = box*0.23/max(box);
@@ -130,7 +135,7 @@ whisker_x(:,[chop,chop+nc]) = [];
 whisker_y(:,[chop,chop+nc]) = [];
 median_x(:,chop) = [];
 median_y(:,chop) = [];
-% % % % 
+% % % %
 % ## Add caps to the remaining whiskers
 cap_x = whisker_x;
 cap_x(1,:) =cap_x(1,:)- 0.05;
@@ -141,7 +146,7 @@ cap_y = whisker_y([1,1],:);
 % #whisker_x,whisker_y
 % #median_x,median_y
 % #cap_x,cap_y
-% 
+%
 % ## Do the plot
 
 mm=min(min(data));
@@ -149,25 +154,25 @@ MM=max(max(data));
 
 if vertical
     plot (quartile_x, quartile_y, 'b',  ...
-        whisker_x, whisker_y, 'b--',   ...
-        cap_x, cap_y, 'k',   ...
-        median_x, median_y, 'r',  ...
-        outliers_x, outliers_y, [symbol(1),'r'],   ...
-        outliers2_x, outliers2_y, [symbol(2),'r']);
-        set(gca,'XTick',1:nc);
-        set(gca, 'XLim', [0.5, nc+0.5]);
-        set(gca, 'YLim', [mm-(MM-mm)*0.05-eps, MM+(MM-mm)*0.05+eps]);
+          whisker_x, whisker_y, 'b--',   ...
+          cap_x, cap_y, 'k',   ...
+          median_x, median_y, 'r',  ...
+          outliers_x, outliers_y, [symbol(1),'r'],   ...
+          outliers2_x, outliers2_y, [symbol(2),'r']);
+    set(gca,'XTick',1:nc);
+    set(gca, 'XLim', [0.5, nc+0.5]);
+    set(gca, 'YLim', [mm-(MM-mm)*0.05-eps, MM+(MM-mm)*0.05+eps]);
 
 else
-% % % % %     plot (quartile_y, quartile_x, "b;;",
-% % % % %     whisker_y, whisker_x, "b;;",
-% % % % %     cap_y, cap_x, "b;;",
-% % % % %     median_y, median_x, "r;;",
-% % % % %     outliers_y, outliers_x, [symbol(1),"r;;"],
-% % % % %     outliers2_y, outliers2_x, [symbol(2),"r;;"]);
+    % % % % %     plot (quartile_y, quartile_x, "b;;",
+    % % % % %     whisker_y, whisker_x, "b;;",
+    % % % % %     cap_y, cap_x, "b;;",
+    % % % % %     median_y, median_x, "r;;",
+    % % % % %     outliers_y, outliers_x, [symbol(1),"r;;"],
+    % % % % %     outliers2_y, outliers2_x, [symbol(2),"r;;"]);
 end
 
-if nargout,
-  sout=s;
+if nargout
+    sout=s;
 end
 % % % endfunction
\ No newline at end of file
diff --git a/matlab/gsa/myprctilecol.m b/matlab/gsa/myprctilecol.m
index 1037a43e7..15ddcfcd4 100644
--- a/matlab/gsa/myprctilecol.m
+++ b/matlab/gsa/myprctilecol.m
@@ -1,6 +1,11 @@
-function y = myprctilecol(x,p);
+function y = myprctilecol(x,p)
 
-% Copyright (C) 2012 Dynare Team
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -22,10 +27,10 @@ xx = sort(x);
 
 if m==1 | n==1
     m = max(m,n);
-	if m == 1,
-	   y = x*ones(length(p),1);
-	   return;
-	end
+    if m == 1
+        y = x*ones(length(p),1);
+        return
+    end
     n = 1;
     q = 100*(0.5:m - 0.5)./m;
     xx = [min(x); xx(:); max(x)];
diff --git a/matlab/gsa/pick.m b/matlab/gsa/pick.m
new file mode 100644
index 000000000..ed50f60cf
--- /dev/null
+++ b/matlab/gsa/pick.m
@@ -0,0 +1,91 @@
+function pick
+%
+% Copyright (C) 2001-2017 European Commission
+% Copyright (C) 2017 DynareTeam
+    
+% This file is part of GLUEWIN
+% GLUEWIN is a MATLAB code designed for analysing the output
+% of Monte Carlo runs when empirical observations of the model output are available
+% and implements the GSA-GLUE methodology by Ratto et al. [1], based on a combination
+% of GLUE (Generalised Likelihood Uncertainty Estimation) by K. Beven [2] and GSA
+% Global Sensitivity Analysis) [3].']
+% The program has been developed by M. Ratto, European Commission, Joint Research Centre,
+% Institute for the Protection and Security of The Citizen, Technological and Economic Risk Management,
+% Applied Statistics, as a deliverable of the IMPACT project
+% (EC Fifth Framework Programme, SCA Project, IST-1999-11313, DG-INFSO).
+%
+% The graphical layout of the code is inspired by the freeware GLUE package by K. Beven,
+% vailable at the Lancaster University web site on the page [4]:
+% http://www.es.lancs.ac.uk/hfdg/glue.html
+% to which the GLUEWIN code introduces several extensions and additional options.
+% Thanks are due to R. Girardi, A. Rossi, A. Saltelli, S. Tarantola and U. Callies for numerous
+% comments and suggestions.
+% For more information, please contact marco.ratto@ec.europa.eu
+%
+% Disclaimer: This software has been developed at the Joint Research Centre of European Commission
+% by officers in the course of their official duties. This software is not subject to copyright
+% protection and is in the public domain. It is an experimental system. The Joint Research Centre
+% of European Commission assumes no responsibility whatsoever for its use by other parties
+% and makes no guarantees, expressed or implied, about its quality, reliability, or any other
+% characteristic. We would appreciate acknowledgement if the software is used.
+%
+% [1] Ratto, M., Tarantola, S., A. Saltelli, Sensitivity analysis in model calibration: GSA-GLUE approach.
+%                'Computer Physics Communications, 136, 2001, 212-224
+% [2] Beven K.J., Binley A., The Future of Distributed Models: Model Calibration and Uncertainty
+%                'Prediction, Hydrological Processes, 6, 279-298, 1992
+% [3] Saltelli, A., K. Chan, M. Scott, Editors, (2000), Sensitivity analysis, John Wiley & Sons
+%                'publishers, Probability and Statistics series.
+% [4] Beven K., GLUE for Windows User manual, 1998.
+
+
+
+pmenu=findobj(gcf,'type','uicontextmenu','Tag','Run viewer');
+button1=findobj(gcf,'type','uimenu','Tag','save params');
+button2=findobj(gcf,'type','uimenu','Tag','eval params');
+%button=get(pmenu,'children');
+gg=gco;
+ax0=gca;
+set(gg,'buttondownfcn',[]);
+c=get(gca,'currentpoint');
+x=c(1,1);
+y=c(1,2);
+X=get(gco,'xdata');
+Y=get(gco,'ydata');
+dx=get(gca,'xlim');
+dy=get(gca,'ylim');
+pos=get(gca,'position');
+scalex=dx(2)-dx(1);
+scaley=dy(2)-dy(1);
+if length(X)>1
+    K = dsearchn([(Y./scaley)' (X./scalex)'],[y/scaley x/scalex]);
+else
+    az=get(gca,'children');
+    T =get(az(end),'ydata');
+    [dum K]=max(T);
+end
+
+KK=K;
+
+set(button1,'Label',['Save ',num2str(K)],'Callback',['scatter_callback(',num2str(KK),',''save'')']);
+set(button2,'Label',['Eval ',num2str(K)],'Callback',['scatter_callback(',num2str(KK),',''eval'')']);
+hh=findobj(gcf,'type','axes','Tag','scatter');
+for k=1:length(hh)
+    axes(hh(k));
+    dum=get(gca,'children');
+    dumx=get(dum(end),'xdata');
+    dumy=get(dum(end),'ydata');
+    xmid=min(dumx) + 0.5*(max(dumx)-min(dumx));
+    hold on
+    plot(dumx(KK),dumy(KK),'or');
+    if dumx(KK) < xmid
+        text(dumx(KK),dumy(KK),['  ',num2str(K)], ...
+             'FontWeight','Bold',...
+             'Color','r');
+    else
+        text(dumx(KK),dumy(KK),[num2str(K),'  '], ...
+             'HorizontalAlignment','right', ...
+             'FontWeight','Bold',...
+             'Color','r');
+    end
+    hold off
+end
\ No newline at end of file
diff --git a/matlab/gsa/prior_draw_gsa.m b/matlab/gsa/prior_draw_gsa.m
index 1e6672050..c3c92d40d 100644
--- a/matlab/gsa/prior_draw_gsa.m
+++ b/matlab/gsa/prior_draw_gsa.m
@@ -1,28 +1,25 @@
 function pdraw = prior_draw_gsa(init,rdraw)
 % Draws from the prior distributions for use with Sensitivity Toolbox for DYNARE
-% 
+%
 % INPUTS
 %   o init           [integer]  scalar equal to 1 (first call) or 0.
-%   o rdraw          
-%    
-% OUTPUTS 
-%   o pdraw          [double]   draw from the joint prior density. 
+%   o rdraw
 %
-% ALGORITHM 
-%   ...       
+% OUTPUTS
+%   o pdraw          [double]   draw from the joint prior density.
+%
+% ALGORITHM
+%   ...
 %
 % SPECIAL REQUIREMENTS
 %   MATLAB Statistics Toolbox
-%  
+%
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2015 Dynare Team
+% Copyright (C) 2012-2015 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,7 +38,7 @@ function pdraw = prior_draw_gsa(init,rdraw)
 
 global bayestopt_ options_ estim_params_ M_
 persistent npar pshape p6 p7 p3 p4 lbcum ubcum
-  
+
 if init
     pshape = bayestopt_.pshape;
     p6 = bayestopt_.p6;
@@ -59,40 +56,40 @@ if init
         bounds.lb = max(bounds.lb,lb);
         bounds.ub = min(bounds.ub,ub);
     else  % estimated parameters but no declared priors
-        % No priors are declared so Dynare will estimate the model by
-        % maximum likelihood with inequality constraints for the parameters.
+          % No priors are declared so Dynare will estimate the model by
+          % maximum likelihood with inequality constraints for the parameters.
         bounds.lb = lb;
         bounds.ub = ub;
     end
     % set bounds for cumulative probabilities
     for i = 1:npar
-      switch pshape(i)
-        case 5% Uniform prior.
-          p4(i) = min(p4(i),bounds.ub(i));
-          p3(i) = max(p3(i),bounds.lb(i));
-        case 3% Gaussian prior.
-          lbcum(i) = 0.5 * erfc(-(bounds.lb(i)-p6(i))/p7(i) ./ sqrt(2));
-          ubcum(i) = 0.5 * erfc(-(bounds.ub(i)-p6(i))/p7(i) ./ sqrt(2));
-        case 2% Gamma prior.
-          lbcum(i) = gamcdf(bounds.lb(i)-p3(i),p6(i),p7(i));
-          ubcum(i) = gamcdf(bounds.ub(i)-p3(i),p6(i),p7(i));
-        case 1% Beta distribution (TODO: generalized beta distribution)
-          lbcum(i) = betainc((bounds.lb(i)-p3(i))./(p4(i)-p3(i)),p6(i),p7(i));
-          ubcum(i) = betainc((bounds.ub(i)-p3(i))./(p4(i)-p3(i)),p6(i),p7(i));
-        case 4% INV-GAMMA1 distribution
-          % TO BE CHECKED
-          lbcum(i) = gamcdf(1/(bounds.ub(i)-p3(i))^2,p7(i)/2,2/p6(i));
-          ubcum(i) = gamcdf(1/(bounds.lb(i)-p3(i))^2,p7(i)/2,2/p6(i));
-        case 6% INV-GAMMA2 distribution
-          % TO BE CHECKED
-          lbcum(i) = gamcdf(1/(bounds.ub(i)-p3(i)),p7(i)/2,2/p6(i));
-          ubcum(i) = gamcdf(1/(bounds.lb(i)-p3(i)),p7(i)/2,2/p6(i));
-        case 8
-          lbcum(i) = weibcdf(bounds.lb(i)-p3(i),p6(i),p7(i));
-          ubcum(i) = weibcdf(bounds.ub(i)-p3(i),p6(i),p7(i));
-        otherwise
-          % Nothing to do here.
-      end
+        switch pshape(i)
+          case 5% Uniform prior.
+            p4(i) = min(p4(i),bounds.ub(i));
+            p3(i) = max(p3(i),bounds.lb(i));
+          case 3% Gaussian prior.
+            lbcum(i) = 0.5 * erfc(-(bounds.lb(i)-p6(i))/p7(i) ./ sqrt(2));
+            ubcum(i) = 0.5 * erfc(-(bounds.ub(i)-p6(i))/p7(i) ./ sqrt(2));
+          case 2% Gamma prior.
+            lbcum(i) = gamcdf(bounds.lb(i)-p3(i),p6(i),p7(i));
+            ubcum(i) = gamcdf(bounds.ub(i)-p3(i),p6(i),p7(i));
+          case 1% Beta distribution (TODO: generalized beta distribution)
+            lbcum(i) = betainc((bounds.lb(i)-p3(i))./(p4(i)-p3(i)),p6(i),p7(i));
+            ubcum(i) = betainc((bounds.ub(i)-p3(i))./(p4(i)-p3(i)),p6(i),p7(i));
+          case 4% INV-GAMMA1 distribution
+                % TO BE CHECKED
+            lbcum(i) = gamcdf(1/(bounds.ub(i)-p3(i))^2,p7(i)/2,2/p6(i));
+            ubcum(i) = gamcdf(1/(bounds.lb(i)-p3(i))^2,p7(i)/2,2/p6(i));
+          case 6% INV-GAMMA2 distribution
+                % TO BE CHECKED
+            lbcum(i) = gamcdf(1/(bounds.ub(i)-p3(i)),p7(i)/2,2/p6(i));
+            ubcum(i) = gamcdf(1/(bounds.lb(i)-p3(i)),p7(i)/2,2/p6(i));
+          case 8
+            lbcum(i) = weibcdf(bounds.lb(i)-p3(i),p6(i),p7(i));
+            ubcum(i) = weibcdf(bounds.ub(i)-p3(i),p6(i),p7(i));
+          otherwise
+            % Nothing to do here.
+        end
     end
     return
 end
@@ -109,11 +106,11 @@ for i = 1:npar
         pdraw(:,i) = gaminv(rdraw(:,i),p6(i),p7(i))+p3(i);
       case 1% Beta distribution (TODO: generalized beta distribution)
         pdraw(:,i) = betainv(rdraw(:,i),p6(i),p7(i))*(p4(i)-p3(i))+p3(i);
-      case 4% INV-GAMMA1 distribution 
-        % TO BE CHECKED
+      case 4% INV-GAMMA1 distribution
+            % TO BE CHECKED
         pdraw(:,i) =  sqrt(1./gaminv(rdraw(:,i),p7(i)/2,2/p6(i)))+p3(i);
-      case 6% INV-GAMMA2 distribution  
-        % TO BE CHECKED
+      case 6% INV-GAMMA2 distribution
+            % TO BE CHECKED
         pdraw(:,i) =  1./gaminv(rdraw(:,i),p7(i)/2,2/p6(i))+p3(i);
       case 8
         pdraw(:,i) =  wblinv(rdraw(:,i),p6(i),p7(i))+p3(i);
@@ -121,5 +118,3 @@ for i = 1:npar
         % Nothing to do here.
     end
 end
-
-  
diff --git a/matlab/gsa/read_data.m b/matlab/gsa/read_data.m
index 7c7912f7c..bb2c71a61 100644
--- a/matlab/gsa/read_data.m
+++ b/matlab/gsa/read_data.m
@@ -1,13 +1,10 @@
 function [gend, data] = read_data()
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2015 Dynare Team
+% Copyright (C) 2012-2015 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,15 +30,15 @@ gend = options_.nobs;
 
 rawdata = rawdata(options_.first_obs:options_.first_obs+gend-1,:);
 if options_.loglinear == 1 & ~options_.logdata
-  rawdata = log(rawdata);
+    rawdata = log(rawdata);
 end
 if options_.prefilter == 1
-  data = transpose(rawdata-ones(gend,1)* mean(rawdata,1));
+    data = transpose(rawdata-ones(gend,1)* mean(rawdata,1));
 else
-  data = transpose(rawdata);
+    data = transpose(rawdata);
 end
 
 if ~isreal(rawdata)
-  error(['There are complex values in the data. Probably  a wrong' ...
-	 ' transformation'])
+    error(['There are complex values in the data. Probably  a wrong' ...
+           ' transformation'])
 end
diff --git a/matlab/gsa/redform_map.m b/matlab/gsa/redform_map.m
index 8cf74e697..a7ae7f712 100644
--- a/matlab/gsa/redform_map.m
+++ b/matlab/gsa/redform_map.m
@@ -13,13 +13,10 @@ function redform_map(dirname,options_gsa_)
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2016 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,7 +55,7 @@ np = estim_params_.np;
 nshock = estim_params_.nvx + estim_params_.nvn + estim_params_.ncx + estim_params_.ncn;
 pnames=cell(np,1);
 pnames_tex=cell(np,1);
-for jj=1:np        
+for jj=1:np
     if options_.TeX
         [param_name_temp, param_name_tex_temp]= get_the_name(nshock+jj,options_.TeX,M_,estim_params_,options_);
         pnames_tex{jj,1} = strrep(param_name_tex_temp,'$','');
@@ -73,7 +70,7 @@ fname_ = M_.fname;
 
 bounds = prior_bounds(bayestopt_, options_.prior_trunc);
 
-if nargin==0,
+if nargin==0
     dirname='';
 end
 
@@ -103,7 +100,7 @@ if ~exist('T')
     else
         load([dirname,filesep,M_.fname,'_mc'],'T');
     end
-    if ~exist('T'),
+    if ~exist('T')
         disp('The model is too large!')
         disp('Reduced form mapping stopped!')
         return
@@ -117,7 +114,7 @@ adir0=pwd;
 
 nspred=size(T,2)-M_.exo_nbr;
 x0=lpmat(istable,:);
-if isempty(lpmat0),
+if isempty(lpmat0)
     xx0=[];
     nshocks=0;
 else
@@ -126,7 +123,7 @@ else
 end
 [kn, np]=size(x0);
 offset = length(bayestopt_.pshape)-np;
-if options_gsa_.prior_range,
+if options_gsa_.prior_range
     pshape=5*(ones(np,1));
     pd =  [NaN(np,1) NaN(np,1) bounds.lb(offset+1:end) bounds.ub(offset+1:end)];
 else
@@ -161,20 +158,20 @@ for j=1:size(anamendo,1)
         skipline()
         disp(['[', namendo,' vs ',namexo,']'])
 
-        
-        if ~isempty(iexo),
+
+        if ~isempty(iexo)
             %y0=squeeze(T(iendo,iexo+nspred,istable));
             y0=squeeze(T(iendo,iexo+nspred,:));
-            if (max(y0)-min(y0))>1.e-10,
-                if mod(iplo,9)==0 && isempty(threshold) && ~options_.nograph,
+            if (max(y0)-min(y0))>1.e-10
+                if mod(iplo,9)==0 && isempty(threshold) && ~options_.nograph
                     ifig=ifig+1;
-                    hfig = dyn_figure(options_,'name',['Reduced Form Mapping: ', namendo,' vs shocks ',int2str(ifig)]);
+                    hfig = dyn_figure(options_.nodisplay,'name',['Reduced Form Mapping: ', namendo,' vs shocks ',int2str(ifig)]);
                     iplo=0;
                 end
                 iplo=iplo+1;
                 js=js+1;
                 xdir0 = [adir,filesep,namendo,'_vs_', namexo];
-                if ilog==0 || ~isempty(threshold),
+                if ilog==0 || ~isempty(threshold)
                     if isempty(threshold)
                         if isempty(dir(xdir0))
                             mkdir(xdir0)
@@ -195,8 +192,8 @@ for j=1:size(anamendo,1)
                         if isempty(dir(xdir))
                             mkdir(xdir)
                         end
-                        if ~options_.nograph,
-                            hf=dyn_figure(options_,'name',['Reduced Form Mapping (Monte Carlo Filtering): ',namendo,' vs ', namexo]); 
+                        if ~options_.nograph
+                            hf=dyn_figure(options_.nodisplay,'name',['Reduced Form Mapping (Monte Carlo Filtering): ',namendo,' vs ', namexo]);
                             hc = cumplot(y0);
                             a=axis; delete(hc);
                             %     hist(mat_moment{ij}),
@@ -209,12 +206,12 @@ for j=1:size(anamendo,1)
                             set(hc,'color','k','linewidth',2)
                             hold off,
                             title([namendo,' vs ', namexo ' - threshold [' num2str(threshold(1)) ' ' num2str(threshold(2)) ']'],'interpreter','none')
-                            dyn_saveas(hf,[xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namexo],options_);
+                            dyn_saveas(hf,[xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namexo],options_.nodisplay,options_.graph_format);
                             create_TeX_loader(options_,[xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namexo],['Reduced Form Mapping (Monte Carlo Filtering): ',strrep(namendo,'_','\_'),' vs ', strrep(namexo,'_','\_')],[type '_' namendo,'_vs_', namexo])
                         end
                         si(:,js) = NaN(np,1);
                         delete([xdir, '/*threshold*.*'])
-                        
+
                         atitle0=['Reduced Form Mapping (Monte Carlo Filtering) for ',namendo,' vs ', namexo];
                         aname=[type '_' namendo '_vs_' namexo '_threshold'];
                         atitle=[type ' Reduced Form Mapping (Monte Carlo Filtering): Parameter(s) driving ',namendo,' vs ',namexo];
@@ -227,9 +224,9 @@ for j=1:size(anamendo,1)
                         if ~isempty(iy) && ~isempty(iyc)
                             fprintf(['%4.1f%% of the ',type,' support matches ',atitle0,'\n'],length(iy)/length(y0)*100)
                             icheck = mcf_analysis(x0, iy, iyc, options_mcf, options_);
-                            
+
                             lpmat=x0(iy,:);
-                            if nshocks,
+                            if nshocks
                                 lpmat0=xx0(iy,:);
                             end
                             istable=[1:length(iy)];
@@ -238,11 +235,11 @@ for j=1:size(anamendo,1)
                         else
                             icheck=[];
                         end
-                        if isempty(icheck),
+                        if isempty(icheck)
                             atitle0=['Monte Carlo Filtering for ',namendo,' vs ', namexo];
                             options_mcf.title = atitle0;
                             indmcf = redform_mcf(y0, x0, options_mcf, options_);
-                            
+
                         end
                     end
                 else
@@ -257,11 +254,11 @@ for j=1:size(anamendo,1)
                     options_map.OutputDirectoryName = xdir0;
                     silog(:,js) = redform_private(x0, y0, options_map, options_);
                 end
-                
-                if isempty(threshold) && ~options_.nograph,
+
+                if isempty(threshold) && ~options_.nograph
                     figure(hfig)
                     subplot(3,3,iplo),
-                    if ilog,
+                    if ilog
                         [saso, iso] = sort(-silog(:,js));
                         bar([silog(iso(1:min(np,10)),js)])
                         logflag='log';
@@ -273,21 +270,21 @@ for j=1:size(anamendo,1)
                     %set(gca,'xticklabel',pnames(iso(1:min(np,10)),:),'fontsize',8)
                     set(gca,'xticklabel',' ','fontsize',10)
                     set(gca,'xlim',[0.5 10.5])
-                    for ip=1:min(np,10),
+                    for ip=1:min(np,10)
                         text(ip,-0.02,deblank(pnames(iso(ip),:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
                     end
                     title([logflag,' ',namendo,' vs ',namexo],'interpreter','none')
-                    if iplo==9 
-                        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],options_);
+                    if iplo==9
+                        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],options_.nodisplay,options_.graph_format);
                         create_TeX_loader(options_,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],[logflag,' ',strrep(namendo,'_','\_'),' vs ',strrep(namexo,'_','\_')],['redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],1)
                     end
                 end
-                
+
             end
         end
     end
-    if iplo<9 && iplo>0 && ifig && ~options_.nograph,
-        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],options_);
+    if iplo<9 && iplo>0 && ifig && ~options_.nograph
+        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],options_.nodisplay,options_.graph_format);
         create_TeX_loader(options_,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],[logflag,' ',strrep(namendo,'_','\_'),' vs ',strrep(namexo,'_','\_')],['redform_', namendo,'_vs_shocks_',logflag,num2str(ifig)],options_.figures.textwidth*min(iplo/3,1))
     end
     ifig=0;
@@ -297,20 +294,20 @@ for j=1:size(anamendo,1)
         ilagendo=strmatch(namlagendo,M_.endo_names(oo_.dr.order_var(M_.nstatic+1:M_.nstatic+nsok),:),'exact');
         skipline()
         disp(['[', namendo,' vs lagged ',namlagendo,']'])
-        
-        if ~isempty(ilagendo),
+
+        if ~isempty(ilagendo)
             %y0=squeeze(T(iendo,ilagendo,istable));
             y0=squeeze(T(iendo,ilagendo,:));
-            if (max(y0)-min(y0))>1.e-10,
-                if mod(iplo,9)==0 && isempty(threshold) && ~options_.nograph,
+            if (max(y0)-min(y0))>1.e-10
+                if mod(iplo,9)==0 && isempty(threshold) && ~options_.nograph
                     ifig=ifig+1;
-                    hfig = dyn_figure(options_,'name',['Reduced Form Mapping: ' namendo,' vs lags ',int2str(ifig)]);
+                    hfig = dyn_figure(options_.nodisplay,'name',['Reduced Form Mapping: ' namendo,' vs lags ',int2str(ifig)]);
                     iplo=0;
                 end
                 iplo=iplo+1;
                 js=js+1;
                 xdir0 = [adir,filesep,namendo,'_vs_', namlagendo];
-                if ilog==0 || ~isempty(threshold),
+                if ilog==0 || ~isempty(threshold)
                     if isempty(threshold)
                         if isempty(dir(xdir0))
                             mkdir(xdir0)
@@ -331,8 +328,8 @@ for j=1:size(anamendo,1)
                         if isempty(dir(xdir))
                             mkdir(xdir)
                         end
-                        if ~options_.nograph,
-                            hf=dyn_figure(options_,'name',['Reduced Form Mapping (Monte Carlo Filtering): ',namendo,' vs lagged ', namlagendo]); 
+                        if ~options_.nograph
+                            hf=dyn_figure(options_.nodisplay,'name',['Reduced Form Mapping (Monte Carlo Filtering): ',namendo,' vs lagged ', namlagendo]);
                             hc = cumplot(y0);
                             a=axis; delete(hc);
                             %     hist(mat_moment{ij}),
@@ -345,12 +342,12 @@ for j=1:size(anamendo,1)
                             set(hc,'color','k','linewidth',2)
                             hold off,
                             title([namendo,' vs lagged ', namlagendo ' - threshold [' num2str(threshold(1)) ' ' num2str(threshold(2)) ']'],'interpreter','none')
-                            dyn_saveas(hf,[xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namlagendo],options_);
+                            dyn_saveas(hf,[xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namlagendo],options_.nodisplay,options_.graph_format);
                             create_TeX_loader(options_,[xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namlagendo],['Reduced Form Mapping (Monte Carlo Filtering): ',strrep(namendo,'_','\_'),' vs lagged ', strrep(namlagendo,'_','\_')],[type '_' namendo,'_vs_', namlagendo],1)
                         end
-                        
+
                         delete([xdir, '/*threshold*.*'])
-                        
+
                         atitle0=['Reduced Form Mapping (Monte Carlo Filtering) for ',namendo,' vs ', namlagendo];
                         aname=[type '_' namendo '_vs_' namlagendo '_threshold'];
                         atitle=[type ' Reduced Form Mapping (Monte Carlo Filtering): Parameter(s) driving ',namendo,' vs ',namlagendo];
@@ -364,19 +361,19 @@ for j=1:size(anamendo,1)
 
                             fprintf(['%4.1f%% of the ',type,' support matches ',atitle0,'\n'],length(iy)/length(y0)*100)
                             icheck = mcf_analysis(x0, iy, iyc, options_mcf, options_);
-                            
+
                             lpmat=x0(iy,:);
-                            if nshocks,
+                            if nshocks
                                 lpmat0=xx0(iy,:);
                             end
                             istable=[1:length(iy)];
                             save([xdir,filesep, fname_ '_' type '_' namendo,'_vs_', namlagendo '_threshold' ],'lpmat','lpmat0','istable','y0','x0','xx0','iy','iyc')
                             lpmat=[]; lpmat0=[]; istable=[];
-                            
+
                         else
                             icheck = [];
                         end
-                        if isempty(icheck),
+                        if isempty(icheck)
                             atitle0=['Monte Carlo Filtering for ',namendo,' vs ', namlagendo];
                             options_mcf.title = atitle0;
                             indmcf = redform_mcf(y0, x0, options_mcf, options_);
@@ -394,11 +391,11 @@ for j=1:size(anamendo,1)
                     options_map.OutputDirectoryName = xdir0;
                     silog(:,js) = redform_private(x0, y0, options_map, options_);
                 end
-                
+
                 if isempty(threshold) && ~options_.nograph
                     figure(hfig),
                     subplot(3,3,iplo),
-                    if ilog,
+                    if ilog
                         [saso, iso] = sort(-silog(:,js));
                         bar([silog(iso(1:min(np,10)),js)])
                         logflag='log';
@@ -410,58 +407,58 @@ for j=1:size(anamendo,1)
                     %set(gca,'xticklabel',pnames(iso(1:min(np,10)),:),'fontsize',8)
                     set(gca,'xticklabel',' ','fontsize',10)
                     set(gca,'xlim',[0.5 10.5])
-                    for ip=1:min(np,10),
+                    for ip=1:min(np,10)
                         text(ip,-0.02,deblank(pnames(iso(ip),:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
                     end
                     title([logflag,' ',namendo,' vs ',namlagendo,'(-1)'],'interpreter','none')
-                    if iplo==9,
-                        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_lags_',logflag,num2str(ifig)],options_);
+                    if iplo==9
+                        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_lags_',logflag,num2str(ifig)],options_.nodisplay,options_.graph_format);
                         create_TeX_loader(options_,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_lags_',logflag,num2str(ifig)],[logflag,' ',strrep(namendo,'_','\_'),' vs ',strrep(namlagendo,'_','\_'),'(-1)'],['redform_', namendo,'_vs_lags_',logflag,':',num2str(ifig)],1)
                     end
                 end
-                
+
             end
         end
     end
-    if iplo<9 && iplo>0 && ifig && ~options_.nograph,
-        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_lags_',logflag,num2str(ifig)],options_);
+    if iplo<9 && iplo>0 && ifig && ~options_.nograph
+        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_lags_',logflag,num2str(ifig)],options_.nodisplay,options_.graph_format);
         create_TeX_loader(options_,[dirname,filesep,M_.fname,'_redform_', namendo,'_vs_lags_',logflag,num2str(ifig)],[logflag,' ',strrep(namendo,'_','\_'),' vs ',strrep(namlagendo,'_','\_'),'(-1)'],['redform_', namendo,'_vs_lags_',logflag,':',num2str(ifig)],options_.figures.textwidth*min(iplo/3,1));
     end
 end
 
-if isempty(threshold) && ~options_.nograph,
-    if ilog==0,
-        hfig=dyn_figure(options_,'name','Reduced Form GSA'); %bar(si)
-        % boxplot(si','whis',10,'symbol','r.')
+if isempty(threshold) && ~options_.nograph
+    if ilog==0
+        hfig=dyn_figure(options_.nodisplay,'name','Reduced Form GSA'); %bar(si)
+                                                                       % boxplot(si','whis',10,'symbol','r.')
         myboxplot(si',[],'.',[],10)
         xlabel(' ')
         set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
         set(gca,'xlim',[0.5 np+0.5])
         set(gca,'ylim',[0 1])
         set(gca,'position',[0.13 0.2 0.775 0.7])
-        for ip=1:np,
+        for ip=1:np
             text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
         end
         title('Reduced form GSA')
-        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_gsa'],options_);
+        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_gsa'],options_.nodisplay,options_.graph_format);
         create_TeX_loader(options_,[dirname,filesep,M_.fname,'_redform_gsa'],'Reduced Form GSA','redform_gsa')
 
     else
-        hfig=dyn_figure(options_,'name','Reduced Form GSA'); %bar(silog)
-        % boxplot(silog','whis',10,'symbol','r.')
+        hfig=dyn_figure(options_.nodisplay,'name','Reduced Form GSA'); %bar(silog)
+                                                                       % boxplot(silog','whis',10,'symbol','r.')
         myboxplot(silog',[],'.',[],10)
         set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
         xlabel(' ')
         set(gca,'xlim',[0.5 np+0.5])
         set(gca,'ylim',[0 1])
         set(gca,'position',[0.13 0.2 0.775 0.7])
-        for ip=1:np,
+        for ip=1:np
             text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
         end
         title('Reduced form GSA - Log-transformed elements')
-        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_gsa_log'],options_);
+        dyn_saveas(hfig,[dirname,filesep,M_.fname,'_redform_gsa_log'],options_.nodisplay,options_.graph_format);
         create_TeX_loader(options_,[dirname,filesep,M_.fname,'_redform_gsa_log'],'Reduced form GSA - Log-transformed elements','redform_gsa_log')
-        
+
     end
 end
 
@@ -475,20 +472,20 @@ pnames = options_map.param_names;
 pd = options_map.pd;
 pshape = options_map.pshape;
 xdir = options_map.OutputDirectoryName;
-if options_map.prior_range,
-    for j=1:np,
+if options_map.prior_range
+    for j=1:np
         x0(:,j)=(x0(:,j)-pd(j,3))./(pd(j,4)-pd(j,3));
     end
 else
     x0=priorcdf(x0,pshape, pd(:,1), pd(:,2), pd(:,3), pd(:,4));
 end
 
-if ilog,
+if ilog
     fname=[xdir filesep options_map.fname_ '_' options_map.amap_name '_log'];
 else
     fname=[xdir filesep options_map.fname_ '_' options_map.amap_name];
 end
-if iload==0,
+if iload==0
     if isempty(dir(xdir))
         mkdir(xdir)
     end
@@ -497,44 +494,44 @@ if iload==0,
     nest=min(250,nest);
     nfit=min(1000,nrun);
     %   dotheplots = (nfit<=nest);
-%     gsa_ = gsa_sdp(y0(1:nest), x0(1:nest,:), 2, [],[-1 -1 -1 -1 -1 0],[],0,[fname,'_est'], pnames);
+    %     gsa_ = gsa_sdp(y0(1:nest), x0(1:nest,:), 2, [],[-1 -1 -1 -1 -1 0],[],0,[fname,'_est'], pnames);
     [ys,is] = sort(y0);
     istep = ceil(nrun/nest);
-    if istep>1,
-    iest = is(floor(istep/2):istep:end);
-    nest = length(iest);
-    irest = is(setdiff([1:nrun],[floor(istep/2):istep:nrun]));
-    istep = ceil(length(irest)/(nfit-nest));
-    ifit = union(iest, irest(1:istep:end));
+    if istep>1
+        iest = is(floor(istep/2):istep:end);
+        nest = length(iest);
+        irest = is(setdiff([1:nrun],[floor(istep/2):istep:nrun]));
+        istep = ceil(length(irest)/(nfit-nest));
+        ifit = union(iest, irest(1:istep:end));
     else
         warning('the number of samples is too small for ANOVA estimation')
         si=nan(np,1);
         return
     end
-    if ~ismember(irest(end),ifit),
+    if ~ismember(irest(end),ifit)
         ifit = union(ifit, irest(end));
     end
     nfit=length(ifit);
-%     ifit = union(iest, irest(randperm(nrun-nest,nfit-nest)));
-%     ifit = iest;
-%     nfit=nest;
+    %     ifit = union(iest, irest(randperm(nrun-nest,nfit-nest)));
+    %     ifit = iest;
+    %     nfit=nest;
     ipred = setdiff([1:nrun],ifit);
 
-    if ilog,
+    if ilog
         [y1, tmp, isig, lam] = log_trans_(y0(iest));
         y1 = log(y0*isig+lam);
     end
-    if ~options_.nograph,
-        hfig=dyn_figure(options_,'name',options_map.figtitle); 
+    if ~options_.nograph
+        hfig=dyn_figure(options_.nodisplay,'name',options_map.figtitle);
         subplot(221)
-        if ilog,
-            hist(y1,30),
+        if ilog
+            hist(y1,30)
         else
-            hist(y0,30),
+            hist(y0,30)
         end
         title(options_map.title,'interpreter','none')
         subplot(222)
-        if ilog,
+        if ilog
             hc = cumplot(y1);
         else
             hc = cumplot(y0);
@@ -544,88 +541,88 @@ if iload==0,
     end
 
     gsa0 = ss_anova(y0(iest), x0(iest,:), 1);
-    if ilog,
+    if ilog
         [gsa22, gsa1, gsax] = ss_anova_log(y1(iest), x0(iest,:), isig, lam, gsa0);
     end
-%     if (gsa1.out.bic-gsa0.out.bic) < 10,
-%         y00=y0;
-%         gsa00=gsa0;
-%         gsa0=gsa1;
-%         y0=y1;
-%         ilog=1;
-%     end
-if nfit>nest,
-    %         gsa_ = gsa_sdp(y0(1:nfit), x0(1:nfit,:), -2, gsa_.nvr*nest^3/nfit^3,[-1 -1 -1 -1 -1 0],[],0,fname, pnames);
-    nvr =  gsa0.nvr*nest^3/nfit^3;
-    nvr(gsa0.stat<2) = gsa0.nvr(gsa0.stat<2)*nest^5/nfit^5;
-    gsa_ = ss_anova(y0(ifit), x0(ifit,:), 1, 0, 2, nvr);
-    if ilog
-        gsa0 = gsa_;
-        nvr1 =  gsa1.nvr*nest^3/nfit^3;
-        nvr1(gsa1.stat<2) = gsa1.nvr(gsa1.stat<2)*nest^5/nfit^5;
-        nvrx =  gsax.nvr*nest^3/nfit^3;
-        nvrx(gsax.stat<2) = gsax.nvr(gsax.stat<2)*nest^5/nfit^5;
-        [gsa22, gsa1, gsax] = ss_anova_log(y1(ifit), x0(ifit,:), isig, lam, gsa0, [nvr1' nvrx']);
-%         gsa1 = ss_anova(y1(ifit), x0(ifit,:), 1, 0, 2, nvr);
-%         gsa2=gsa1;
-%         gsa2.y = gsa0.y;
-%         gsa2.fit = (exp(gsa1.fit)-lam)*isig;
-%         gsa2.f0 = mean(gsa2.fit);
-%         gsa2.out.SSE = sum((gsa2.fit-gsa2.y).^2);
-%         gsa2.out.bic = gsa2.out.bic-nest*log(gsa1.out.SSE)+nest*log(gsa2.out.SSE);
-%         gsa2.r2 = 1-cov(gsa2.fit-gsa2.y)/cov(gsa2.y);
-%         for j=1:np,
-%             gsa2.fs(:,j) = exp(gsa1.fs(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0;
-%             gsa2.f(:,j) = exp(gsa1.f(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0;
-%             gsa2.si(j) = var(gsa2.f(:,j))/var(gsa2.y);
-%         end
-%         nvr =  gsax.nvr*nest^3/nfit^3;
-%         nvr(gsax.stat<2) = gsax.nvr(gsax.stat<2)*nest^5/nfit^5;
-%         gsax = ss_anova([gsa2.y-gsa2.fit], x0(ifit,:), 1, 0, 2, nvr);
-%         gsa22=gsa2;
-%         gsa22.fit = gsa2.fit+gsax.fit;
-%         gsa22.f0 = mean(gsa22.fit);
-%         gsa22.out.SSE = sum((gsa22.fit-gsa22.y).^2);
-%         gsa22.out.bic = nest*log(gsa22.out.SSE/nest) + (gsax.out.df+gsa2.out.df-1)*log(nest);
-%         gsa22.r2 = 1-sum((gsa22.fit-gsa22.y).^2)/sum((gsa22.y-mean(gsa22.y)).^2);
-%         for j=1:np,
-%             gsa22.fs(:,j) = gsa2.fs(:,j)+gsax.fs(:,j);
-%             gsa22.f(:,j) = gsa2.f(:,j)+gsax.f(:,j);
-%             gsa22.si(j) = var(gsa22.f(:,j))/var(gsa22.y);
-%         end
-        gsa_ = gsa22;
-    end
-else
-    if ilog
-        gsa_ = gsa22;
+    %     if (gsa1.out.bic-gsa0.out.bic) < 10,
+    %         y00=y0;
+    %         gsa00=gsa0;
+    %         gsa0=gsa1;
+    %         y0=y1;
+    %         ilog=1;
+    %     end
+    if nfit>nest
+        %         gsa_ = gsa_sdp(y0(1:nfit), x0(1:nfit,:), -2, gsa_.nvr*nest^3/nfit^3,[-1 -1 -1 -1 -1 0],[],0,fname, pnames);
+        nvr =  gsa0.nvr*nest^3/nfit^3;
+        nvr(gsa0.stat<2) = gsa0.nvr(gsa0.stat<2)*nest^5/nfit^5;
+        gsa_ = ss_anova(y0(ifit), x0(ifit,:), 1, 0, 2, nvr);
+        if ilog
+            gsa0 = gsa_;
+            nvr1 =  gsa1.nvr*nest^3/nfit^3;
+            nvr1(gsa1.stat<2) = gsa1.nvr(gsa1.stat<2)*nest^5/nfit^5;
+            nvrx =  gsax.nvr*nest^3/nfit^3;
+            nvrx(gsax.stat<2) = gsax.nvr(gsax.stat<2)*nest^5/nfit^5;
+            [gsa22, gsa1, gsax] = ss_anova_log(y1(ifit), x0(ifit,:), isig, lam, gsa0, [nvr1' nvrx']);
+            %         gsa1 = ss_anova(y1(ifit), x0(ifit,:), 1, 0, 2, nvr);
+            %         gsa2=gsa1;
+            %         gsa2.y = gsa0.y;
+            %         gsa2.fit = (exp(gsa1.fit)-lam)*isig;
+            %         gsa2.f0 = mean(gsa2.fit);
+            %         gsa2.out.SSE = sum((gsa2.fit-gsa2.y).^2);
+            %         gsa2.out.bic = gsa2.out.bic-nest*log(gsa1.out.SSE)+nest*log(gsa2.out.SSE);
+            %         gsa2.r2 = 1-cov(gsa2.fit-gsa2.y)/cov(gsa2.y);
+            %         for j=1:np,
+            %             gsa2.fs(:,j) = exp(gsa1.fs(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0;
+            %             gsa2.f(:,j) = exp(gsa1.f(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0;
+            %             gsa2.si(j) = var(gsa2.f(:,j))/var(gsa2.y);
+            %         end
+            %         nvr =  gsax.nvr*nest^3/nfit^3;
+            %         nvr(gsax.stat<2) = gsax.nvr(gsax.stat<2)*nest^5/nfit^5;
+            %         gsax = ss_anova([gsa2.y-gsa2.fit], x0(ifit,:), 1, 0, 2, nvr);
+            %         gsa22=gsa2;
+            %         gsa22.fit = gsa2.fit+gsax.fit;
+            %         gsa22.f0 = mean(gsa22.fit);
+            %         gsa22.out.SSE = sum((gsa22.fit-gsa22.y).^2);
+            %         gsa22.out.bic = nest*log(gsa22.out.SSE/nest) + (gsax.out.df+gsa2.out.df-1)*log(nest);
+            %         gsa22.r2 = 1-sum((gsa22.fit-gsa22.y).^2)/sum((gsa22.y-mean(gsa22.y)).^2);
+            %         for j=1:np,
+            %             gsa22.fs(:,j) = gsa2.fs(:,j)+gsax.fs(:,j);
+            %             gsa22.f(:,j) = gsa2.f(:,j)+gsax.f(:,j);
+            %             gsa22.si(j) = var(gsa22.f(:,j))/var(gsa22.y);
+            %         end
+            gsa_ = gsa22;
+        end
     else
-        gsa_ = gsa0;
+        if ilog
+            gsa_ = gsa22;
+        else
+            gsa_ = gsa0;
+        end
     end
-end
     save([fname,'_map.mat'],'gsa_')
     [sidum, iii]=sort(-gsa_.si);
     gsa_.x0=x00(ifit,:);
-    if ~options_.nograph,
+    if ~options_.nograph
         hmap=gsa_sdp_plot(gsa_,[fname '_map'],pnames,iii(1:min(12,np)));
         set(hmap,'name',options_map.amap_title);
     end
     gsa_.x0=x0(ifit,:);
     %   copyfile([fname,'_est.mat'],[fname,'.mat'])
-    if ~options_.nograph,
+    if ~options_.nograph
         figure(hfig);
         subplot(223),
         plot(y0(ifit),[gsa_.fit y0(ifit)],'.'),
         r2 = gsa_.r2;
-%         if ilog,
-%             plot(y00(ifit),[log_trans_(gsa_.fit,'',isig,lam) y00(ifit)],'.'),
-%             r2 = 1 - cov(log_trans_(gsa_.fit,'',isig,lam)-y00(ifit))/cov(y00(ifit));
-%         else               
-%             plot(y0(ifit),[gsa_.fit y0(ifit)],'.'),
-%             r2 = gsa_.r2;
-%         end
+        %         if ilog,
+        %             plot(y00(ifit),[log_trans_(gsa_.fit,'',isig,lam) y00(ifit)],'.'),
+        %             r2 = 1 - cov(log_trans_(gsa_.fit,'',isig,lam)-y00(ifit))/cov(y00(ifit));
+        %         else
+        %             plot(y0(ifit),[gsa_.fit y0(ifit)],'.'),
+        %             r2 = gsa_.r2;
+        %         end
         title(['Learning sample fit - R2=' num2str(r2,2)],'interpreter','none')
-        if nfit<nrun,
-            if ilog,
+        if nfit<nrun
+            if ilog
                 yf = ss_anova_fcast(x0(ipred,:), gsa1);
                 yf = log_trans_(yf,'',isig,lam)+ss_anova_fcast(x0(ipred,:), gsax);
             else
@@ -637,7 +634,7 @@ end
             plot(yn,[yf yn],'.'),
             title(['Out-of-sample prediction - R2=' num2str(r2,2)],'interpreter','none')
         end
-        dyn_saveas(hfig,fname,options_);
+        dyn_saveas(hfig,fname,options_.nodisplay,options_.graph_format);
         create_TeX_loader(options_,fname,['Out-of-sample prediction - R2=' num2str(r2,2)],'redform_gsa_log')
 
         if options_.nodisplay
@@ -646,14 +643,14 @@ end
     end
 else
     %   gsa_ = gsa_sdp_dyn(y0, x0, 0, [],[],[],0,fname, pnames);
-%     gsa_ = gsa_sdp(y0, x0, 0, [],[],[],0,fname, pnames);
+    %     gsa_ = gsa_sdp(y0, x0, 0, [],[],[],0,fname, pnames);
     load([fname,'_map.mat'],'gsa_')
-    if ~options_.nograph,
+    if ~options_.nograph
         yf = ss_anova_fcast(x0, gsa_);
-        hfig=dyn_figure(options_,'name',options_map.title);
+        hfig=dyn_figure(options_.nodisplay,'name',options_map.title);
         plot(y0,[yf y0],'.'),
         title([namy,' vs ', namx,' pred'],'interpreter','none')
-        dyn_saveas(hfig,[fname '_pred'],options_);
+        dyn_saveas(hfig,[fname '_pred'],options_.nodisplay,options_.graph_format);
         create_TeX_loader(options_,[fname '_pred'],options_map.title,[namy,' vs ', namx,' pred'])
 
     end
@@ -674,7 +671,7 @@ gsa2.f0 = mean(gsa2.fit);
 gsa2.out.SSE = sum((gsa2.fit-gsa2.y).^2);
 gsa2.out.bic = gsa2.out.bic-nest*log(gsa1.out.SSE)+nest*log(gsa2.out.SSE);
 gsa2.r2 = 1-cov(gsa2.fit-gsa2.y)/cov(gsa2.y);
-for j=1:np,
+for j=1:np
     gsa2.fs(:,j) = exp(gsa1.fs(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0;
     gsa2.fses(:,j) = exp(gsa1.fs(:,j)+gsa1.fses(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0-gsa2.fs(:,j);
     gsa2.f(:,j) = exp(gsa1.f(:,j)).*mean(exp(gsa1.fit-gsa1.f(:,j)))*isig-lam*isig-gsa2.f0;
@@ -688,14 +685,14 @@ function [gsa22, gsa1, gsax] = ss_anova_log(y,x,isig,lam,gsa0,nvrs)
 
 [nest, np]=size(x);
 
-if nargin==6,
+if nargin==6
     gsa1 = ss_anova(y, x, 1, 0, 2, nvrs(:,1));
 else
     gsa1 = ss_anova(y, x, 1);
 end
 gsa2 = log2level_map(gsa1, isig, lam);
-if nargin >=5 && ~isempty(gsa0),
-    for j=1:np,
+if nargin >=5 && ~isempty(gsa0)
+    for j=1:np
         nvr2(j) = var(diff(gsa2.fs(:,j),2));
         nvr0(j) = var(diff(gsa0.fs(:,j),2));
     end
@@ -705,7 +702,7 @@ if nargin >=5 && ~isempty(gsa0),
     gsa1 = ss_anova(y, x, 1, 0, 2, gsa1.nvr);
     gsa2 = log2level_map(gsa1, isig, lam);
 end
-if nargin==6,
+if nargin==6
     gsax = ss_anova(gsa2.y-gsa2.fit, x, 1, 0, 2, nvrs(:,2));
 else
     gsax = ss_anova(gsa2.y-gsa2.fit, x, 1);
@@ -716,7 +713,7 @@ gsa22.f0 = mean(gsa22.fit);
 gsa22.out.SSE = sum((gsa22.fit-gsa22.y).^2);
 gsa22.out.bic = nest*log(gsa22.out.SSE/nest) + (gsax.out.df+gsa2.out.df-1)*log(nest);
 gsa22.r2 = 1-sum((gsa22.fit-gsa22.y).^2)/sum((gsa22.y-mean(gsa22.y)).^2);
-for j=1:np,
+for j=1:np
     gsa22.fs(:,j) = gsa2.fs(:,j)+gsax.fs(:,j);
     gsa22.fses(:,j) = gsax.fses(:,j);
     gsa22.f(:,j) = gsa2.f(:,j)+gsax.f(:,j);
@@ -727,13 +724,13 @@ return
 
 function indmcf = redform_mcf(y0, x0, options_mcf, options_)
 
-hfig=dyn_figure(options_,'name',options_mcf.amcf_title);
+hfig=dyn_figure(options_.nodisplay,'name',options_mcf.amcf_title);
 
 [post_mean, post_median, post_var, hpd_interval, post_deciles, ...
-    density] = posterior_moments(y0,1,0.9);
+ density] = posterior_moments(y0,1,0.9);
 post_deciles = [-inf; post_deciles; inf];
 
-for jt=1:10,
+for jt=1:10
     indy{jt}=find( (y0>post_deciles(jt)) & (y0<=post_deciles(jt+1)));
     leg{jt}=[int2str(jt) '-dec'];
 end
@@ -744,18 +741,18 @@ indmcf = indmcf(jtmp);
 nbr_par = length(indmcf);
 nrow=ceil(sqrt(nbr_par+1));
 ncol=nrow;
-if nrow*(nrow-1)>nbr_par,
+if nrow*(nrow-1)>nbr_par
     ncol=nrow-1;
 end
 
 cmap = colormap(jet(10));
-for jx=1:nbr_par,
+for jx=1:nbr_par
     subplot(nrow,ncol,jx)
     hold off
-    for jt=1:10,
+    for jt=1:10
         h=cumplot(x0(indy{jt},indmcf(jx)));
         set(h,'color', cmap(jt,:), 'linewidth', 2)
-        hold all,
+        hold all
     end
     title(options_mcf.param_names(indmcf(jx),:),'interpreter','none')
 end
@@ -766,16 +763,16 @@ aa(2)=0.02;
 set(hleg,'Position',aa);
 if ~isoctave
     annotation('textbox', [0.25,0.01,0.5,0.05], ...
-        'String', options_mcf.title, ...
-        'Color','black',...
-        'FontWeight','bold',...
-        'interpreter','none',...
-        'horizontalalignment','center');
+               'String', options_mcf.title, ...
+               'Color','black',...
+               'FontWeight','bold',...
+               'interpreter','none',...
+               'horizontalalignment','center');
 end
 
-dyn_saveas(hfig,[options_mcf.OutputDirectoryName filesep options_mcf.fname_,'_',options_mcf.amcf_name],options_);
+dyn_saveas(hfig,[options_mcf.OutputDirectoryName filesep options_mcf.fname_,'_',options_mcf.amcf_name],options_.nodisplay,options_.graph_format);
 create_TeX_loader(options_,[options_mcf.OutputDirectoryName filesep options_mcf.fname_,'_',options_mcf.amcf_name],strrep(options_mcf.amcf_title,'_','\_'),[options_mcf.fname_,'_',options_mcf.amcf_name])
-        
+
 return
 
 function []=create_TeX_loader(options_,figpath,caption,label_name,scale_factor)
diff --git a/matlab/gsa/redform_screen.m b/matlab/gsa/redform_screen.m
index ab65d846a..d4c007174 100644
--- a/matlab/gsa/redform_screen.m
+++ b/matlab/gsa/redform_screen.m
@@ -8,13 +8,10 @@ function redform_screen(dirname, options_gsa_)
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2016 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,8 +39,8 @@ iload = options_gsa_.load_redform;
 nliv = options_gsa_.morris_nliv;
 
 pnames = M_.param_names(estim_params_.param_vals(:,1),:);
-if nargin==0,
-  dirname='';
+if nargin==0
+    dirname='';
 end
 
 load([dirname,'/',M_.fname,'_prior'],'lpmat','lpmat0','istable','T');
@@ -56,96 +53,96 @@ nshock = length(bayestopt_.pshape)-np;
 nsok = length(find(M_.lead_lag_incidence(M_.maximum_lag,:)));
 
 js=0;
-for j=1:size(anamendo,1),
-  namendo=deblank(anamendo(j,:));
-  iendo=strmatch(namendo,M_.endo_names(oo_.dr.order_var,:),'exact');
+for j=1:size(anamendo,1)
+    namendo=deblank(anamendo(j,:));
+    iendo=strmatch(namendo,M_.endo_names(oo_.dr.order_var,:),'exact');
 
-  iplo=0;
-  ifig=0;
-  for jx=1:size(anamexo,1)
-    namexo=deblank(anamexo(jx,:));
-    iexo=strmatch(namexo,M_.exo_names,'exact');
+    iplo=0;
+    ifig=0;
+    for jx=1:size(anamexo,1)
+        namexo=deblank(anamexo(jx,:));
+        iexo=strmatch(namexo,M_.exo_names,'exact');
 
-    if ~isempty(iexo),
-      y0=teff(T(iendo,iexo+nspred,:),kn,istable);
-      if ~isempty(y0),
-        if mod(iplo,9)==0,
-          ifig=ifig+1;
-          hh=dyn_figure(options_,'name',[namendo,' vs. shocks ',int2str(ifig)]);
-          iplo=0;
-        end
-        iplo=iplo+1;
-        js=js+1;
-        subplot(3,3,iplo),
-        [SAmeas, SAMorris] = Morris_Measure_Groups(np+nshock, [lpmat0 lpmat], y0,nliv);
-        SAM = squeeze(SAMorris(nshock+1:end,1));
-        SA(:,js)=SAM./(max(SAM)+eps);
-        [saso, iso] = sort(-SA(:,js));
-        bar(SA(iso(1:min(np,10)),js))
-        %set(gca,'xticklabel',pnames(iso(1:min(np,10)),:),'fontsize',8)
-        set(gca,'xticklabel',' ','fontsize',10)
-        set(gca,'xlim',[0.5 10.5])
-        for ip=1:min(np,10),
-          text(ip,-0.02,deblank(pnames(iso(ip),:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-        end
-        title([namendo,' vs. ',namexo],'interpreter','none')
-        if iplo==9,
-          dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_shock_',num2str(ifig)],options_); 
-          create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_shock_',num2str(ifig)],ifig,[namendo,' vs. shocks ',int2str(ifig)],[namendo,'_vs_shock'],1)
-        end
+        if ~isempty(iexo)
+            y0=teff(T(iendo,iexo+nspred,:),kn,istable);
+            if ~isempty(y0)
+                if mod(iplo,9)==0
+                    ifig=ifig+1;
+                    hh=dyn_figure(options_.nodisplay,'name',[namendo,' vs. shocks ',int2str(ifig)]);
+                    iplo=0;
+                end
+                iplo=iplo+1;
+                js=js+1;
+                subplot(3,3,iplo),
+                [SAmeas, SAMorris] = Morris_Measure_Groups(np+nshock, [lpmat0 lpmat], y0,nliv);
+                SAM = squeeze(SAMorris(nshock+1:end,1));
+                SA(:,js)=SAM./(max(SAM)+eps);
+                [saso, iso] = sort(-SA(:,js));
+                bar(SA(iso(1:min(np,10)),js))
+                %set(gca,'xticklabel',pnames(iso(1:min(np,10)),:),'fontsize',8)
+                set(gca,'xticklabel',' ','fontsize',10)
+                set(gca,'xlim',[0.5 10.5])
+                for ip=1:min(np,10)
+                    text(ip,-0.02,deblank(pnames(iso(ip),:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+                end
+                title([namendo,' vs. ',namexo],'interpreter','none')
+                if iplo==9
+                    dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_shock_',num2str(ifig)],options_.nodisplay,options_.graph_format);
+                    create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_shock_',num2str(ifig)],ifig,[namendo,' vs. shocks ',int2str(ifig)],[namendo,'_vs_shock'],1)
+                end
 
-      end
+            end
+        end
     end
-  end
-  if iplo<9 && iplo>0 && ifig,
-    dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_shocks_',num2str(ifig)],options_);
-    create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_shock_',num2str(ifig)],ifig,[namendo,' vs. shocks ',int2str(ifig)],[namendo,'_vs_shock'],options_.figures.textwidth*min(iplo/3))
-  end
-
-  iplo=0;
-  ifig=0;
-  for je=1:size(anamlagendo,1)
-    namlagendo=deblank(anamlagendo(je,:));
-    ilagendo=strmatch(namlagendo,M_.endo_names(oo_.dr.order_var(M_.nstatic+1:M_.nstatic+nsok),:),'exact');
-
-    if ~isempty(ilagendo),
-      y0=teff(T(iendo,ilagendo,:),kn,istable);
-      if ~isempty(y0),
-        if mod(iplo,9)==0,
-          ifig=ifig+1;
-          hh=dyn_figure(options_,'name',[namendo,' vs. lagged endogenous ',int2str(ifig)]);
-          iplo=0;
-        end
-        iplo=iplo+1;
-        js=js+1;
-        subplot(3,3,iplo),
-        [SAmeas, SAMorris] = Morris_Measure_Groups(np+nshock, [lpmat0 lpmat], y0,nliv);
-        SAM = squeeze(SAMorris(nshock+1:end,1));
-        SA(:,js)=SAM./(max(SAM)+eps);
-        [saso, iso] = sort(-SA(:,js));
-        bar(SA(iso(1:min(np,10)),js))
-        %set(gca,'xticklabel',pnames(iso(1:min(np,10)),:),'fontsize',8)
-        set(gca,'xticklabel',' ','fontsize',10)
-        set(gca,'xlim',[0.5 10.5])
-        for ip=1:min(np,10),
-          text(ip,-0.02,deblank(pnames(iso(ip),:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
-        end
-
-        title([namendo,' vs. ',namlagendo,'(-1)'],'interpreter','none')
-        if iplo==9,
-          dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],options_);  
-          create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],ifig,[namendo,' vs. lagged endogenous ',int2str(ifig)],[namendo,'_vs_lags'],1)
-        end
-      end
+    if iplo<9 && iplo>0 && ifig
+        dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_shocks_',num2str(ifig)],options_.nodisplay,options_.graph_format);
+        create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_shock_',num2str(ifig)],ifig,[namendo,' vs. shocks ',int2str(ifig)],[namendo,'_vs_shock'],options_.figures.textwidth*min(iplo/3))
+    end
+
+    iplo=0;
+    ifig=0;
+    for je=1:size(anamlagendo,1)
+        namlagendo=deblank(anamlagendo(je,:));
+        ilagendo=strmatch(namlagendo,M_.endo_names(oo_.dr.order_var(M_.nstatic+1:M_.nstatic+nsok),:),'exact');
+
+        if ~isempty(ilagendo)
+            y0=teff(T(iendo,ilagendo,:),kn,istable);
+            if ~isempty(y0)
+                if mod(iplo,9)==0
+                    ifig=ifig+1;
+                    hh=dyn_figure(options_.nodisplay,'name',[namendo,' vs. lagged endogenous ',int2str(ifig)]);
+                    iplo=0;
+                end
+                iplo=iplo+1;
+                js=js+1;
+                subplot(3,3,iplo),
+                [SAmeas, SAMorris] = Morris_Measure_Groups(np+nshock, [lpmat0 lpmat], y0,nliv);
+                SAM = squeeze(SAMorris(nshock+1:end,1));
+                SA(:,js)=SAM./(max(SAM)+eps);
+                [saso, iso] = sort(-SA(:,js));
+                bar(SA(iso(1:min(np,10)),js))
+                %set(gca,'xticklabel',pnames(iso(1:min(np,10)),:),'fontsize',8)
+                set(gca,'xticklabel',' ','fontsize',10)
+                set(gca,'xlim',[0.5 10.5])
+                for ip=1:min(np,10)
+                    text(ip,-0.02,deblank(pnames(iso(ip),:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+                end
+
+                title([namendo,' vs. ',namlagendo,'(-1)'],'interpreter','none')
+                if iplo==9
+                    dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],options_.nodisplay,options_.graph_format);
+                    create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],ifig,[namendo,' vs. lagged endogenous ',int2str(ifig)],[namendo,'_vs_lags'],1)
+                end
+            end
+        end
+    end
+    if iplo<9 && iplo>0 && ifig
+        dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],options_.nodisplay,options_.graph_format);
+        create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],ifig,[namendo,' vs. lagged endogenous ',int2str(ifig)],[namendo,'_vs_lags'],options_.figures.textwidth*min(iplo/3))
     end
-  end
-  if iplo<9 && iplo>0 && ifig,
-    dyn_saveas(hh,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],options_);      
-    create_TeX_loader(options_,[dirname,'/',M_.fname,'_', namendo,'_vs_lags_',num2str(ifig)],ifig,[namendo,' vs. lagged endogenous ',int2str(ifig)],[namendo,'_vs_lags'],options_.figures.textwidth*min(iplo/3))
-  end
 end
 
-hh=dyn_figure(options_,'Name','Reduced form screening'); 
+hh=dyn_figure(options_.nodisplay,'Name','Reduced form screening');
 %bar(SA)
 % boxplot(SA','whis',10,'symbol','r.')
 myboxplot(SA',[],'.',[],10)
@@ -153,13 +150,13 @@ set(gca,'xticklabel',' ','fontsize',10,'xtick',[1:np])
 set(gca,'xlim',[0.5 np+0.5])
 set(gca,'ylim',[0 1])
 set(gca,'position',[0.13 0.2 0.775 0.7])
-for ip=1:np,
-  text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
+for ip=1:np
+    text(ip,-0.02,deblank(pnames(ip,:)),'rotation',90,'HorizontalAlignment','right','interpreter','none')
 end
 xlabel(' ')
 ylabel('Elementary Effects')
 title('Reduced form screening')
-dyn_saveas(hh,[dirname,'/',M_.fname,'_redform_screen'],options_);
+dyn_saveas(hh,[dirname,'/',M_.fname,'_redform_screen'],options_.nodisplay,options_.graph_format);
 create_TeX_loader(options_,[dirname,'/',M_.fname,'_redform_screen'],1,'Reduced form screening','redform_screen',1)
 
 
@@ -180,4 +177,3 @@ if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
     fprintf(fidTeX,'%% End Of TeX file. \n');
     fclose(fidTeX);
 end
-
diff --git a/matlab/gsa/scatter_analysis.m b/matlab/gsa/scatter_analysis.m
new file mode 100644
index 000000000..d526b3f0e
--- /dev/null
+++ b/matlab/gsa/scatter_analysis.m
@@ -0,0 +1,52 @@
+function indmcf = scatter_analysis(lpmat, xdata, options_scatter, DynareOptions)
+%
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+%
+
+% Copyright (C) 2017 European Commission
+% Copyright (C) 2017 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/>.
+
+param_names = options_scatter.param_names;
+
+if DynareOptions.TeX
+    if ~isfield(options_scatter,'param_names_tex')
+        param_names_tex = options_scatter.param_names;
+    else
+        param_names_tex = options_scatter.param_names_tex;
+    end
+end
+amcf_name = options_scatter.amcf_name;
+amcf_title = options_scatter.amcf_title;
+title = options_scatter.title;
+fname_ = options_scatter.fname_;
+xparam1=[];
+if isfield(options_scatter,'xparam1')
+    xparam1=options_scatter.xparam1;
+end
+OutputDirectoryName = options_scatter.OutputDirectoryName;
+
+if ~DynareOptions.nograph
+    skipline()
+    xx=[];
+    if ~isempty(xparam1)
+        xx=xparam1;
+    end
+    scatter_plots(lpmat, xdata, param_names, '.', [fname_, '_', amcf_name], OutputDirectoryName, amcf_title, xx, DynareOptions)
+end
diff --git a/matlab/gsa/scatter_callback.m b/matlab/gsa/scatter_callback.m
new file mode 100644
index 000000000..61345107c
--- /dev/null
+++ b/matlab/gsa/scatter_callback.m
@@ -0,0 +1,42 @@
+function  scatter_callback(K, type)
+%
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+%
+
+% Copyright (C) 2017 European Commission
+% Copyright (C) 2017 Dynare Team
+%
+% This file is part of Dynare.
+%
+% Dynare is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version.
+%
+% Dynare is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+
+global oo_ M_ options_ bayestopt_ estim_params_
+
+x=get(gcf,'userdata');
+r2=x{1};
+x=x{2};
+
+xparam1=x(K,:)';
+
+switch type
+  case 'save'
+    save(['my_params_' int2str(K)],'xparam1')
+
+  case 'eval'
+    disp('Evaluating smoother ...')
+    [oo_, M_]=evaluate_smoother(xparam1,M_.endo_names,M_,oo_,options_,bayestopt_,estim_params_);
+    % [rmse, lnam, r2,vv] = plot_fit(obsname{:});
+end
diff --git a/matlab/gsa/scatter_mcf.m b/matlab/gsa/scatter_mcf.m
index 0c4162990..211b2e74b 100644
--- a/matlab/gsa/scatter_mcf.m
+++ b/matlab/gsa/scatter_mcf.m
@@ -1,182 +1,183 @@
-function  scatter_mcf(X,Y,vnames,plotsymbol, fnam, dirname, figtitle, xparam1, DynareOptions, beha_name, non_beha_name)
-% Frontend to the Sensitivity Analysis Toolbox for DYNARE
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
-
-% Copyright (C) 2014-2016 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/>.
-
-% PURPOSE: Pairwise scatter plots of the columns of x and y after
-% Monte Carlo filtering
-%---------------------------------------------------
-% USAGE:    scatter_mcf(x,y,vnames,pltsym,diagon)
-%        or scatter_mcf(x,y) which relies on defaults
-% where:
-%        x = an nxk matrix with columns containing behavioural sample
-%        y = an mxk matrix with columns containing non-behavioural sample
-%   vnames = a vector of variable names
-%            (default = numeric labels 1,2,3 etc.)
-%   pltsym = a plt symbol
-%            (default = '.' for npts > 100, 'o' for npts < 100
-
-
-Z=[X;Y];
-[n,p] = size(X);
-% X = X - ones(n,1)*min(Z);
-% X = X ./ (ones(n,1)*max(Z));
-[n,p] = size(Y);
-% Y = Y - ones(n,1)*min(Z);
-% Y = Y ./ (ones(n,1)*max(Z));
-[n,p] = size(Z);
-clear Z;
-
-nflag = 0;
-if nargin >=3
-    nflag = 1;
-end;
-
-if nargin<4 || isempty(plotsymbol)
-    if n*p<100, plotsymbol = 'o';
-    else plotsymbol = '.';
-    end
-end
-
-if nargin<5
-    fnam='';
-end
-if nargin<6,
-  dirname='';
-  nograph=1;
-else
-  nograph=0;    
-end
-if nargin<7,
-  figtitle=fnam;
-end
-if nargin<8,
-  xparam1=[];
-end
-if nargin<10,
-  beha_name = 'BEHAVIOUR';
-  non_beha_name = 'NON-BEHAVIOUR';
-end
-if nargin==10,
-  non_beha_name = ['NON-' beha_name];
-end
-
-figtitle_tex=strrep(figtitle,'_','\_');
-
-fig_nam_=[fnam];
-if ~nograph,
-    hh=dyn_figure(DynareOptions,'name',figtitle);
-end
-
-bf = 0.1;
-ffs = 0.05/(p-1);
-ffl = (1-2*bf-0.05)/p;
-if p>1,
-    fL = linspace(bf,1-bf+ffs,p+1);
-else
-    fL = bf;
-end
-for i = 1:p
-    for j = 1:p
-        h = axes('position',[fL(i),fL(p+1-j),ffl,ffl]);
-        if i==j
-            h1=cumplot(X(:,j));
-            %             set(h1,'color',[0 0 1], 'linestyle','--','LineWidth',1.5)
-            set(h1,'color',[0 0 1],'LineWidth',1.5)
-            hold on,
-            h2=cumplot(Y(:,j));
-            set(h2,'color',[1 0 0],'LineWidth',1.5)
-            if ~isempty(xparam1)
-                hold on, plot(xparam1([j j]),[0 1],'k--')
-            end
-            if j<p
-                set(gca,'XTickLabel',[],'XTick',[]);
-            else
-                grid off
-            end
-            set(gca,'YTickLabel',[],'YTick',[]);
-        else
-            if j>i
-                plot(X(:,i),X(:,j),[plotsymbol,'b'])
-                hold on,
-                plot(Y(:,i),Y(:,j),[plotsymbol,'r'])
-            else
-                plot(Y(:,i),Y(:,j),[plotsymbol,'r'])
-                hold on,
-                plot(X(:,i),X(:,j),[plotsymbol,'b'])
-            end
-            if ~isempty(xparam1)
-                hold on, plot(xparam1(i),xparam1(j),'s','MarkerFaceColor',[0 0.75 0],'MarkerEdgeColor',[0 0.75 0])
-            end
-            hold off;
-            %             axis([-0.1 1.1 -0.1 1.1])
-            if i<p,
-                set(gca,'YTickLabel',[],'YTick',[]);
-            else
-                set(gca,'yaxislocation','right');
-            end
-            if j<p
-                set(gca,'XTickLabel',[],'XTick',[]);
-            end
-        end
-        if nflag == 1
-            set(gca,'fontsize',9);
-        end;
-        if i==1
-            if nflag == 1
-                ylabel(vnames(j,:),'Rotation',45,'interpreter','none', ...
-                    'HorizontalAlignment','right','VerticalAlignment','middle');
-            else
-                ylabel([num2str(j),' '],'Rotation',90)
-            end;
-        end
-        if j==1
-            if nflag == 1
-                title(vnames(i,:),'interpreter','none','Rotation',45, ...
-                    'HorizontalAlignment','left','VerticalAlignment','bottom')
-            else
-                title(num2str(i))
-            end;
-        end
-        drawnow
-    end
-end
-if ~isoctave
-    annotation('textbox', [0.1,0,0.35,0.05],'String', beha_name,'Color','Blue','horizontalalignment','center','interpreter','none');
-    annotation('textbox', [0.55,0,0.35,0.05],'String', non_beha_name,'Color','Red','horizontalalignment','center','interpreter','none');
-end
-
-if ~nograph,
-    dyn_saveas(hh,[dirname,filesep,fig_nam_],DynareOptions);
-    if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
-        fidTeX = fopen([dirname,'/',fig_nam_ '.tex'],'w');
-        fprintf(fidTeX,'%% TeX eps-loader file generated by scatter_mcf.m (Dynare).\n');
-        fprintf(fidTeX,['%% ' datestr(now,0) '\n\n']);
-        fprintf(fidTeX,'\\begin{figure}[H]\n');
-        fprintf(fidTeX,'\\centering \n');
-        fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s}\n',strrep([dirname,'/',fig_nam_],'\','/'));
-        fprintf(fidTeX,'\\caption{%s.}',figtitle_tex);
-        fprintf(fidTeX,'\\label{Fig:%s}\n',fig_nam_);
-        fprintf(fidTeX,'\\end{figure}\n\n');
-        fprintf(fidTeX,'%% End Of TeX file. \n');
-        fclose(fidTeX);
-    end
+function  scatter_mcf(X,Y,vnames,plotsymbol, fnam, dirname, figtitle, xparam1, DynareOptions, beha_name, non_beha_name)
+%
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+
+% Copyright (C) 2014-2016 European Commission
+% Copyright (C) 2014-2017 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/>.
+
+% PURPOSE: Pairwise scatter plots of the columns of x and y after
+% Monte Carlo filtering
+%---------------------------------------------------
+% USAGE:    scatter_mcf(x,y,vnames,pltsym,diagon)
+%        or scatter_mcf(x,y) which relies on defaults
+% where:
+%        x = an nxk matrix with columns containing behavioural sample
+%        y = an mxk matrix with columns containing non-behavioural sample
+%   vnames = a vector of variable names
+%            (default = numeric labels 1,2,3 etc.)
+%   pltsym = a plt symbol
+%            (default = '.' for npts > 100, 'o' for npts < 100
+
+
+Z=[X;Y];
+[n,p] = size(X);
+% X = X - ones(n,1)*min(Z);
+% X = X ./ (ones(n,1)*max(Z));
+[n,p] = size(Y);
+% Y = Y - ones(n,1)*min(Z);
+% Y = Y ./ (ones(n,1)*max(Z));
+[n,p] = size(Z);
+clear Z;
+
+nflag = 0;
+if nargin >=3
+    nflag = 1;
+end
+
+if nargin<4 || isempty(plotsymbol)
+    if n*p<100, plotsymbol = 'o';
+    else plotsymbol = '.';
+    end
+end
+
+if nargin<5
+    fnam='';
+end
+if nargin<6
+    dirname='';
+    nograph=1;
+else
+    nograph=0;
+end
+if nargin<7
+    figtitle=fnam;
+end
+if nargin<8
+    xparam1=[];
+end
+if nargin<10
+    beha_name = 'BEHAVIOUR';
+    non_beha_name = 'NON-BEHAVIOUR';
+end
+if nargin==10
+    non_beha_name = ['NON-' beha_name];
+end
+
+figtitle_tex=strrep(figtitle,'_','\_');
+
+fig_nam_=[fnam];
+if ~nograph
+    hh=dyn_figure(DynareOptions.nodisplay,'name',figtitle);
+end
+
+bf = 0.1;
+ffs = 0.05/(p-1);
+ffl = (1-2*bf-0.05)/p;
+if p>1
+    fL = linspace(bf,1-bf+ffs,p+1);
+else
+    fL = bf;
+end
+for i = 1:p
+    for j = 1:p
+        h = axes('position',[fL(i),fL(p+1-j),ffl,ffl]);
+        if i==j
+            h1=cumplot(X(:,j));
+            %             set(h1,'color',[0 0 1], 'linestyle','--','LineWidth',1.5)
+            set(h1,'color',[0 0 1],'LineWidth',1.5)
+            hold on,
+            h2=cumplot(Y(:,j));
+            set(h2,'color',[1 0 0],'LineWidth',1.5)
+            if ~isempty(xparam1)
+                hold on, plot(xparam1([j j]),[0 1],'k--')
+            end
+            if j<p
+                set(gca,'XTickLabel',[],'XTick',[]);
+            else
+                grid off
+            end
+            set(gca,'YTickLabel',[],'YTick',[]);
+        else
+            if j>i
+                plot(X(:,i),X(:,j),[plotsymbol,'b'])
+                hold on,
+                plot(Y(:,i),Y(:,j),[plotsymbol,'r'])
+            else
+                plot(Y(:,i),Y(:,j),[plotsymbol,'r'])
+                hold on,
+                plot(X(:,i),X(:,j),[plotsymbol,'b'])
+            end
+            if ~isempty(xparam1)
+                hold on, plot(xparam1(i),xparam1(j),'s','MarkerFaceColor',[0 0.75 0],'MarkerEdgeColor',[0 0.75 0])
+            end
+            hold off;
+            %             axis([-0.1 1.1 -0.1 1.1])
+            if i<p
+                set(gca,'YTickLabel',[],'YTick',[]);
+            else
+                set(gca,'yaxislocation','right');
+            end
+            if j<p
+                set(gca,'XTickLabel',[],'XTick',[]);
+            end
+        end
+        if nflag == 1
+            set(gca,'fontsize',9);
+        end
+        if i==1
+            if nflag == 1
+                ylabel(vnames(j,:),'Rotation',45,'interpreter','none', ...
+                       'HorizontalAlignment','right','VerticalAlignment','middle');
+            else
+                ylabel([num2str(j),' '],'Rotation',90)
+            end
+        end
+        if j==1
+            if nflag == 1
+                title(vnames(i,:),'interpreter','none','Rotation',45, ...
+                      'HorizontalAlignment','left','VerticalAlignment','bottom')
+            else
+                title(num2str(i))
+            end
+        end
+        drawnow
+    end
+end
+if ~isoctave
+    annotation('textbox', [0.1,0,0.35,0.05],'String', beha_name,'Color','Blue','horizontalalignment','center','interpreter','none');
+    annotation('textbox', [0.55,0,0.35,0.05],'String', non_beha_name,'Color','Red','horizontalalignment','center','interpreter','none');
+end
+
+if ~nograph
+    dyn_saveas(hh,[dirname,filesep,fig_nam_],DynareOptions.nodisplay,DynareOptions.graph_format);
+    if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
+        fidTeX = fopen([dirname,'/',fig_nam_ '.tex'],'w');
+        fprintf(fidTeX,'%% TeX eps-loader file generated by scatter_mcf.m (Dynare).\n');
+        fprintf(fidTeX,['%% ' datestr(now,0) '\n\n']);
+        fprintf(fidTeX,'\\begin{figure}[H]\n');
+        fprintf(fidTeX,'\\centering \n');
+        fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s}\n',strrep([dirname,'/',fig_nam_],'\','/'));
+        fprintf(fidTeX,'\\caption{%s.}',figtitle_tex);
+        fprintf(fidTeX,'\\label{Fig:%s}\n',fig_nam_);
+        fprintf(fidTeX,'\\end{figure}\n\n');
+        fprintf(fidTeX,'%% End Of TeX file. \n');
+        fclose(fidTeX);
+    end
 end
\ No newline at end of file
diff --git a/matlab/gsa/scatter_plots.m b/matlab/gsa/scatter_plots.m
new file mode 100644
index 000000000..f9cf1fa4c
--- /dev/null
+++ b/matlab/gsa/scatter_plots.m
@@ -0,0 +1,189 @@
+function scatter_plots(X,xp,vnames,plotsymbol, fnam, dirname, figtitle, xparam1, DynareOptions)
+%
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
+%
+
+% Copyright (C) 2017 European Commission
+% Copyright (C) 2017 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/>.
+
+% PURPOSE: Pairwise scatter plots of the columns of x and y after
+% Monte Carlo filtering
+%---------------------------------------------------
+% USAGE:    scatter_mcf(x,y,vnames,pltsym,diagon)
+%        or scatter_mcf(x,y) which relies on defaults
+% where:
+%        x = an nxk matrix with columns containing behavioural sample
+%        y = an mxk matrix with columns containing non-behavioural sample
+%   vnames = a vector of variable names
+%            (default = numeric labels 1,2,3 etc.)
+%   pltsym = a plt symbol
+%            (default = '.' for npts > 100, 'o' for npts < 100
+
+
+[n,p] = size(X);
+% X = X - ones(n,1)*min(Z);
+% X = X ./ (ones(n,1)*max(Z));
+
+nflag = 0;
+if nargin >=3
+    nflag = 1;
+end
+
+if nargin<4 || isempty(plotsymbol)
+    if n*p<100, plotsymbol = 'o';
+    else plotsymbol = '.';
+    end
+end
+
+if nargin<5 || isempty(fnam)
+    fnam='scatter_plot';
+end
+if nargin<6 || isempty(dirname)
+    dirname='';
+    nograph=1;
+    DynareOptions.nodisplay=0;
+else
+    nograph=0;
+end
+if nargin<7 || isempty(figtitle)
+    figtitle=fnam;
+end
+if nargin<8
+    xparam1=[];
+end
+
+figtitle_tex=strrep(figtitle,'_','\_');
+
+fig_nam_=[fnam];
+
+hh=dyn_figure(DynareOptions.nodisplay,'name',figtitle);
+set(hh,'userdata',{X,xp})
+
+bf = 0.1;
+ffs = 0.05/(p-1);
+ffl = (1-2*bf-0.05)/p;
+if p>1
+    fL = linspace(bf,1-bf+ffs,p+1);
+else
+    fL = bf;
+end
+for i = 1:p
+    for j = 1:p
+        h = axes('position',[fL(i),fL(p+1-j),ffl,ffl]);
+        if i==j
+            h1=cumplot(X(:,j));
+            set(h,'Tag','cumplot')
+            %             set(h1,'color',[0 0 1], 'linestyle','--','LineWidth',1.5)
+            set(h1,'color',[0 0 1],'LineWidth',1.5)
+            if ~isempty(xparam1)
+                hold on, plot(xparam1([j j]),[0 1],'k--')
+            end
+            if j<p
+                set(gca,'XTickLabel',[],'XTick',[]);
+            else
+                grid off
+            end
+            set(gca,'YTickLabel',[],'YTick',[]);
+        else
+            if j>i
+                plot(X(:,i),X(:,j),[plotsymbol,'b'])
+            else
+                plot(X(:,i),X(:,j),[plotsymbol,'b'])
+            end
+            set(h,'Tag','scatter')
+
+            %%
+            if ~isoctave
+                % Define a context menu; it is not attached to anything
+                hcmenu = uicontextmenu('Callback','pick','Tag','Run viewer');
+                % Define callbacks for context menu
+                % items that change linestyle
+                hcb1 = 'scatter_callback';
+                % hcb2 = ['set(gco,''LineStyle'','':'')'];
+                % hcb3 = ['set(gco,''LineStyle'',''-'')'];
+                % % Define the context menu items and install their callbacks
+                item1 = uimenu(hcmenu,'Label','save','Callback',hcb1,'Tag','save params');
+                item2 = uimenu(hcmenu,'Label','eval','Callback',hcb1,'Tag','eval params');
+                % item3 = uimenu(hcmenu,'Label','solid','Callback',hcb3);
+                % Locate line objects
+                hlines = findall(h,'Type','line');
+                % Attach the context menu to each line
+                for line = 1:length(hlines)
+                    set(hlines(line),'uicontextmenu',hcmenu)
+                end
+            end
+            %%
+            if ~isempty(xparam1)
+                hold on, plot(xparam1(i),xparam1(j),'s','MarkerFaceColor',[0 0.75 0],'MarkerEdgeColor',[0 0.75 0])
+            end
+            hold off;
+            %             axis([-0.1 1.1 -0.1 1.1])
+            if i<p
+                set(gca,'YTickLabel',[],'YTick',[]);
+            else
+                set(gca,'yaxislocation','right');
+            end
+            if j<p
+                set(gca,'XTickLabel',[],'XTick',[]);
+            end
+        end
+        if nflag == 1
+            set(gca,'fontsize',9);
+        end
+        if i==1
+            if nflag == 1
+                ylabel(vnames(j,:),'Rotation',45,'interpreter','none', ...
+                       'HorizontalAlignment','right','VerticalAlignment','middle');
+            else
+                ylabel([num2str(j),' '],'Rotation',90)
+            end
+        end
+        if j==1
+            if nflag == 1
+                title(vnames(i,:),'interpreter','none','Rotation',45, ...
+                      'HorizontalAlignment','left','VerticalAlignment','bottom')
+            else
+                title(num2str(i))
+            end
+        end
+        drawnow
+    end
+end
+% if ~isoctave
+%     annotation('textbox', [0.1,0,0.35,0.05],'String', beha_name,'Color','Blue','horizontalalignment','center','interpreter','none');
+%     annotation('textbox', [0.55,0,0.35,0.05],'String', non_beha_name,'Color','Red','horizontalalignment','center','interpreter','none');
+% end
+
+if ~nograph
+    dyn_saveas(hh,[dirname,filesep,fig_nam_],DynareOptions.nodisplay,DynareOptions.graph_format);
+    if DynareOptions.TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
+        fidTeX = fopen([dirname,'/',fig_nam_ '.tex'],'w');
+        fprintf(fidTeX,'%% TeX eps-loader file generated by scatter_plots.m (Dynare).\n');
+        fprintf(fidTeX,['%% ' datestr(now,0) '\n\n']);
+        fprintf(fidTeX,'\\begin{figure}[H]\n');
+        fprintf(fidTeX,'\\centering \n');
+        fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s}\n',strrep([dirname,'/',fig_nam_],'\','/'));
+        fprintf(fidTeX,'\\caption{%s.}',figtitle_tex);
+        fprintf(fidTeX,'\\label{Fig:%s}\n',fig_nam_);
+        fprintf(fidTeX,'\\end{figure}\n\n');
+        fprintf(fidTeX,'%% End Of TeX file. \n');
+        fclose(fidTeX);
+    end
+end
\ No newline at end of file
diff --git a/matlab/gsa/set_shocks_param.m b/matlab/gsa/set_shocks_param.m
index 8902dfb10..69c12fdbb 100644
--- a/matlab/gsa/set_shocks_param.m
+++ b/matlab/gsa/set_shocks_param.m
@@ -2,7 +2,7 @@ function set_shocks_param(xparam1)
 % function set_shocks_param(xparam1)
 % Set the structural and measurement error variances and covariances
 
-% Copyright (C) 2012-2015 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ if ncx
 end
 %build covariance matrix from correlation matrix and variances already on
 %diagonal
-Sigma_e = diag(sqrt(diag(Sigma_e)))*Correlation_matrix*diag(sqrt(diag(Sigma_e))); 
+Sigma_e = diag(sqrt(diag(Sigma_e)))*Correlation_matrix*diag(sqrt(diag(Sigma_e)));
 %if calibrated covariances, set them now to their stored value
 if isfield(estim_params_,'calibrated_covariances')
     Sigma_e(estim_params_.calibrated_covariances.position)=estim_params_.calibrated_covariances.cov_value;
@@ -93,7 +93,7 @@ if isfield(estim_params_,'calibrated_covariances_ME')
     H(estim_params_.calibrated_covariances_ME.position)=estim_params_.calibrated_covariances_ME.cov_value;
 end
 
-  
+
 % updating matrices in M
 if nvx || ncx
     M_.Sigma_e = Sigma_e;
@@ -101,5 +101,5 @@ if nvx || ncx
 end
 if nvn || ncn
     M_.H = H;
-    M_.Correlation_matrix_ME=Correlation_matrix_ME;    
-end 
\ No newline at end of file
+    M_.Correlation_matrix_ME=Correlation_matrix_ME;
+end
\ No newline at end of file
diff --git a/matlab/gsa/smirnov.m b/matlab/gsa/smirnov.m
index 9568d1e96..11dd4df7d 100644
--- a/matlab/gsa/smirnov.m
+++ b/matlab/gsa/smirnov.m
@@ -4,13 +4,10 @@ function [H,prob,d] = smirnov(x1 , x2 , alpha, iflag )
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +27,7 @@ function [H,prob,d] = smirnov(x1 , x2 , alpha, iflag )
 if nargin<3
     alpha  =  0.05;
 end
-if nargin<4,
+if nargin<4
     iflag=0;
 end
 
@@ -55,7 +52,7 @@ n =  n1*n2 /(n1+n2);
 
 % Compute the d(n1,n2) statistics.
 
-if iflag==0,
+if iflag==0
     d  =  max(abs(cum1 - cum2));
 elseif iflag==-1
     d  =  max(cum2 - cum1);
@@ -67,10 +64,10 @@ end
 %
 
 lam =  max((sqrt(n) + 0.12 + 0.11/sqrt(n)) * d , 0);
-if iflag == 0        
+if iflag == 0
     j       =  [1:101]';
     prob  =  2 * sum((-1).^(j-1).*exp(-2*lam*lam*j.^2));
-    
+
     prob=max(prob,0);
     prob=min(1,prob);
 else
diff --git a/matlab/gsa/stab_map_.m b/matlab/gsa/stab_map_.m
index f6e6d1eeb..52f8d1588 100644
--- a/matlab/gsa/stab_map_.m
+++ b/matlab/gsa/stab_map_.m
@@ -32,13 +32,10 @@ function x0 = stab_map_(OutputDirectoryName,opt_gsa)
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2016 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -62,7 +59,6 @@ global bayestopt_ estim_params_ options_ oo_ M_
 
 Nsam   = opt_gsa.Nsam;
 fload  = opt_gsa.load_stab;
-ksstat = opt_gsa.ksstat;
 alpha2 = opt_gsa.alpha2_stab;
 pvalue_ks = opt_gsa.pvalue_ks;
 pvalue_corr = opt_gsa.pvalue_corr;
@@ -103,8 +99,8 @@ if ~isempty(bayestopt_) && any(bayestopt_.pshape > 0)
     bounds.lb = max(bounds.lb,lb);
     bounds.ub = min(bounds.ub,ub);
 else  % estimated parameters but no declared priors
-    % No priors are declared so Dynare will estimate the model by
-    % maximum likelihood with inequality constraints for the parameters.
+      % No priors are declared so Dynare will estimate the model by
+      % maximum likelihood with inequality constraints for the parameters.
     bounds.lb = lb;
     bounds.ub = ub;
     if opt_gsa.prior_range==0
@@ -113,7 +109,7 @@ else  % estimated parameters but no declared priors
     end
 end
 
-if nargin==0,
+if nargin==0
     OutputDirectoryName='';
 end
 
@@ -123,7 +119,7 @@ options_mcf.alpha2 = alpha2;
 
 name=cell(np,1);
 name_tex=cell(np,1);
-for jj=1:np        
+for jj=1:np
     if options_.TeX
         [param_name_temp, param_name_tex_temp]= get_the_name(nshock+jj,options_.TeX,M_,estim_params_,options_);
         name_tex{jj,1} = strrep(param_name_tex_temp,'$','');
@@ -147,12 +143,12 @@ options_.periods=0;
 options_.nomoments=1;
 options_.irf=0;
 options_.noprint=1;
-if fload==0,
+if fload==0
     %   if prepSA
     %     T=zeros(size(dr_.ghx,1),size(dr_.ghx,2)+size(dr_.ghu,2),Nsam/2);
     %   end
 
-    if isfield(dr_,'ghx'),
+    if isfield(dr_,'ghx')
         egg=zeros(length(dr_.eigval),Nsam);
     end
     yys=zeros(length(dr_.ys),Nsam);
@@ -163,20 +159,20 @@ if fload==0,
         Nsam=size(lpmat,1);
         lpmat0 = lpmat(:,1:nshock);
         lpmat = lpmat(:,nshock+1:end);
-%     elseif opt_gsa.morris==3,
-%         lpmat = prep_ide(Nsam,np,5);
-%         Nsam=size(lpmat,1);
+        %     elseif opt_gsa.morris==3,
+        %         lpmat = prep_ide(Nsam,np,5);
+        %         Nsam=size(lpmat,1);
     else
-        if np<52 && ilptau>0,
+        if np<52 && ilptau>0
             [lpmat] = qmc_sequence(np, int64(1), 0, Nsam)';
-            if np>30 || ilptau==2, % scrambled lptau
-                for j=1:np,
+            if np>30 || ilptau==2 % scrambled lptau
+                for j=1:np
                     lpmat(:,j)=lpmat(randperm(Nsam),j);
                 end
             end
         else %ilptau==0
             [lpmat] = NaN(Nsam,np);
-            for j=1:np,
+            for j=1:np
                 lpmat(:,j) = randperm(Nsam)'./(Nsam+1); %latin hypercube
             end
 
@@ -184,17 +180,17 @@ if fload==0,
     end
     %   try
     dummy=prior_draw_gsa(1); %initialize persistent variables
-    %   catch
-    %     if pprior,
-    %       if opt_gsa.prior_range==0;
-    %         error('Some unknown prior is specified or ML estimation,: use prior_range=1 option!!');
-    %       end
-    %     end
-    %
-    %   end
-    if pprior,
-        for j=1:nshock,
-            if opt_gsa.morris~=1,
+                             %   catch
+                             %     if pprior,
+                             %       if opt_gsa.prior_range==0;
+                             %         error('Some unknown prior is specified or ML estimation,: use prior_range=1 option!!');
+                             %       end
+                             %     end
+                             %
+                             %   end
+    if pprior
+        for j=1:nshock
+            if opt_gsa.morris~=1
                 lpmat0(:,j) = randperm(Nsam)'./(Nsam+1); %latin hypercube
             end
             if opt_gsa.prior_range
@@ -208,7 +204,7 @@ if fload==0,
             %           xdelt(:,:,j)=prior_draw_gsa(0,[lpmat0 lpmat]+deltx);
             %         end
             %       end
-            for j=1:np,
+            for j=1:np
                 lpmat(:,j)=lpmat(:,j).*(bounds.ub(j+nshock)-bounds.lb(j+nshock))+bounds.lb(j+nshock);
             end
         else
@@ -258,24 +254,24 @@ if fload==0,
         %             end
         %         end
         %load([fname_,'_mode'])
-        if neighborhood_width>0 && isempty(options_.mode_file),
+        if neighborhood_width>0 && isempty(options_.mode_file)
             xparam1 = get_all_parameters(estim_params_,M_);
         else
-        eval(['load ' options_.mode_file '.mat;']);
+            eval(['load ' options_.mode_file '.mat;']);
         end
-        if neighborhood_width>0,
-            for j=1:nshock,
+        if neighborhood_width>0
+            for j=1:nshock
                 if opt_gsa.morris ~= 1
-                   lpmat0(:,j) = randperm(Nsam)'./(Nsam+1); %latin hypercube
+                    lpmat0(:,j) = randperm(Nsam)'./(Nsam+1); %latin hypercube
                 end
                 ub=min([bounds.ub(j) xparam1(j)*(1+neighborhood_width)]);
                 lb=max([bounds.lb(j) xparam1(j)*(1-neighborhood_width)]);
                 lpmat0(:,j)=lpmat0(:,j).*(ub-lb)+lb;
             end
-            for j=1:np,
+            for j=1:np
                 ub=xparam1(j+nshock)*(1+sign(xparam1(j+nshock))*neighborhood_width);
                 lb=xparam1(j+nshock)*(1-sign(xparam1(j+nshock))*neighborhood_width);
-                if bounds.ub(j+nshock)>=xparam1(j) && bounds.lb(j)<=xparam1(j+nshock),
+                if bounds.ub(j+nshock)>=xparam1(j) && bounds.lb(j)<=xparam1(j+nshock)
                     ub=min([bounds.ub(j+nshock) ub]);
                     lb=max([bounds.lb(j+nshock) lb]);
                 else
@@ -287,7 +283,7 @@ if fload==0,
             d = chol(inv(hh));
             lp=randn(Nsam*2,nshock+np)*d+kron(ones(Nsam*2,1),xparam1');
             lnprior=zeros(1,Nsam*2);
-            for j=1:Nsam*2,
+            for j=1:Nsam*2
                 lnprior(j) = any(lp(j,:)'<=bounds.lb | lp(j,:)'>=bounds.ub);
             end
             ireal=[1:2*Nsam];
@@ -309,7 +305,7 @@ if fload==0,
     inorestriction=zeros(1,Nsam);
     irestriction=zeros(1,Nsam);
     infox=zeros(Nsam,1);
-    for j=1:Nsam,
+    for j=1:Nsam
         M_ = set_all_parameters([lpmat0(j,:) lpmat(j,:)]',estim_params_,M_);
         %try stoch_simul([]);
         try
@@ -319,14 +315,14 @@ if fload==0,
                 [Tt,Rr,SteadyState,info,M_,options_,oo_] = dynare_resolve(M_,options_,oo_,'restrict');
             end
             infox(j,1)=info(1);
-            if infox(j,1)==0 && ~exist('T','var'),
+            if infox(j,1)==0 && ~exist('T','var')
                 dr_=oo_.dr;
-                if prepSA,
+                if prepSA
                     try
                         T=zeros(size(dr_.ghx,1),size(dr_.ghx,2)+size(dr_.ghu,2),Nsam);
                     catch
                         ME = lasterror();
-                        if strcmp('MATLAB:nomem',ME.identifier),
+                        if strcmp('MATLAB:nomem',ME.identifier)
                             prepSA=0;
                             disp('The model is too large for storing state space matrices ...')
                             disp('for mapping reduced form or for identification')
@@ -338,26 +334,26 @@ if fload==0,
                 end
                 egg=zeros(length(dr_.eigval),Nsam);
             end
-            if infox(j,1),
-%                 disp('no solution'),
-                if isfield(oo_.dr,'ghx'),
+            if infox(j,1)
+                %                 disp('no solution'),
+                if isfield(oo_.dr,'ghx')
                     oo_.dr=rmfield(oo_.dr,'ghx');
                 end
-                if (infox(j,1)<3 || infox(j,1)>5) && isfield(oo_.dr,'eigval'),
+                if (infox(j,1)<3 || infox(j,1)>5) && isfield(oo_.dr,'eigval')
                     oo_.dr=rmfield(oo_.dr,'eigval');
                 end
             end
         catch ME
-            if isfield(oo_.dr,'eigval'),
+            if isfield(oo_.dr,'eigval')
                 oo_.dr=rmfield(oo_.dr,'eigval');
             end
-            if isfield(oo_.dr,'ghx'),
+            if isfield(oo_.dr,'ghx')
                 oo_.dr=rmfield(oo_.dr,'ghx');
             end
-            disp('No solution could be found'),
+            disp('No solution could be found')
         end
         dr_ = oo_.dr;
-        if isfield(dr_,'ghx'),
+        if isfield(dr_,'ghx')
             egg(:,j) = sort(dr_.eigval);
             if prepSA
                 jstab=jstab+1;
@@ -367,14 +363,14 @@ if fload==0,
                 %           bayestopt_.restrict_columns, ...
                 %           bayestopt_.restrict_aux);
             end
-            if ~exist('nspred','var'),
+            if ~exist('nspred','var')
                 nspred = dr_.nspred; %size(dr_.ghx,2);
                 nboth = dr_.nboth;
                 nfwrd = dr_.nfwrd;
             end
             info=endogenous_prior_restrictions(Tt,Rr,M_,options_,oo_);
             infox(j,1)=info(1);
-            if info(1),
+            if info(1)
                 inorestriction(j)=j;
             else
                 iunstable(j)=0;
@@ -388,13 +384,13 @@ if fload==0,
                     if any(isnan(egg(1:nspred,j)))
                         iwrong(j)=j;
                     else
-                        if (nboth || nfwrd) && abs(egg(nspred+1,j))<=options_.qz_criterium,
+                        if (nboth || nfwrd) && abs(egg(nspred+1,j))<=options_.qz_criterium
                             iindeterm(j)=j;
                         end
                     end
                 end
             else
-                if exist('egg','var'),
+                if exist('egg','var')
                     egg(:,j)=ones(size(egg,1),1).*NaN;
                 end
                 iwrong(j)=j;
@@ -406,7 +402,7 @@ if fload==0,
         dyn_waitbar(j/Nsam,h,['MC iteration ',int2str(j),'/',int2str(Nsam)])
     end
     dyn_waitbar_close(h);
-    if prepSA && jstab,
+    if prepSA && jstab
         T=T(:,:,1:jstab);
     else
         T=[];
@@ -458,42 +454,42 @@ if fload==0,
     bkpprior.p2=bayestopt_.p2;
     bkpprior.p3=bayestopt_.p3;
     bkpprior.p4=bayestopt_.p4;
-    if pprior,
+    if pprior
         if ~prepSA
             save([OutputDirectoryName filesep fname_ '_prior.mat'], ...
-                'bkpprior','lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
-                'egg','yys','nspred','nboth','nfwrd','infox')
+                 'bkpprior','lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
+                 'egg','yys','nspred','nboth','nfwrd','infox')
         else
             save([OutputDirectoryName filesep fname_ '_prior.mat'], ...
-                'bkpprior','lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
-                'egg','yys','T','nspred','nboth','nfwrd','infox')
+                 'bkpprior','lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
+                 'egg','yys','T','nspred','nboth','nfwrd','infox')
         end
 
     else
         if ~prepSA
             save([OutputDirectoryName filesep fname_ '_mc.mat'], ...
-                'lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
-                'egg','yys','nspred','nboth','nfwrd','infox')
+                 'lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
+                 'egg','yys','nspred','nboth','nfwrd','infox')
         else
             save([OutputDirectoryName filesep fname_ '_mc.mat'], ...
-                'lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
-                'egg','yys','T','nspred','nboth','nfwrd','infox')
+                 'lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun', ...
+                 'egg','yys','T','nspred','nboth','nfwrd','infox')
         end
     end
 else
-    if pprior,
+    if pprior
         filetoload=[OutputDirectoryName filesep fname_ '_prior.mat'];
     else
         filetoload=[OutputDirectoryName filesep fname_ '_mc.mat'];
     end
     load(filetoload,'lpmat','lpmat0','irestriction','iunstable','istable','iindeterm','iwrong','ixun','egg','yys','nspred','nboth','nfwrd','infox')
     Nsam = size(lpmat,1);
-    if pprior==0 && ~isempty(options_.mode_file),
+    if pprior==0 && ~isempty(options_.mode_file)
         eval(['load ' options_.mode_file '.mat;']);
     end
 
 
-    if prepSA && isempty(strmatch('T',who('-file', filetoload),'exact')),
+    if prepSA && isempty(strmatch('T',who('-file', filetoload),'exact'))
         h = dyn_waitbar(0,'Please wait...');
         options_.periods=0;
         options_.nomoments=1;
@@ -503,7 +499,7 @@ else
         %T=zeros(size(dr_.ghx,1),size(dr_.ghx,2)+size(dr_.ghu,2),length(istable));
         ntrans=length(istable);
         yys=NaN(length(ys_),ntrans);
-        for j=1:ntrans,
+        for j=1:ntrans
             M_.params(estim_params_.param_vals(:,1)) = lpmat(istable(j),:)';
             %stoch_simul([]);
             [Tt,Rr,SteadyState,info,M_,options_,oo_] = dynare_resolve(M_,options_,oo_,'restrict');
@@ -552,51 +548,51 @@ delete([OutputDirectoryName,filesep,fname_,'_',aindname,'.*']);
 delete([OutputDirectoryName,filesep,fname_,'_',aunstname,'.*']);
 delete([OutputDirectoryName,filesep,fname_,'_',awrongname,'.*']);
 
-if length(iunstable)>0 || length(iwrong)>0,
+if length(iunstable)>0 || length(iwrong)>0
     fprintf(['%4.1f%% of the prior support gives unique saddle-path solution.\n'],length(istable)/Nsam*100)
     fprintf(['%4.1f%% of the prior support gives explosive dynamics.\n'],(length(ixun) )/Nsam*100)
-    if ~isempty(iindeterm),
+    if ~isempty(iindeterm)
         fprintf(['%4.1f%% of the prior support gives indeterminacy.\n'],length(iindeterm)/Nsam*100)
     end
     inorestriction = istable(find(~ismember(istable,irestriction))); % violation of prior restrictions
-    if ~isempty(iwrong) || ~isempty(inorestriction),
+    if ~isempty(iwrong) || ~isempty(inorestriction)
         skipline()
-        if any(infox==49),
+        if any(infox==49)
             fprintf(['%4.1f%% of the prior support violates prior restrictions.\n'],(length(inorestriction) )/Nsam*100)
         end
-        if ~isempty(iwrong),
+        if ~isempty(iwrong)
             skipline()
             disp(['For ',num2str(length(iwrong)/Nsam*100,'%4.1f'),'% of the prior support dynare could not find a solution.'])
             skipline()
         end
-        if any(infox==1),
+        if any(infox==1)
             disp(['    For ',num2str(length(find(infox==1))/Nsam*100,'%4.1f'),'% The model doesn''t determine the current variables uniquely.'])
         end
-        if any(infox==2),
+        if any(infox==2)
             disp(['    For ',num2str(length(find(infox==2))/Nsam*100,'%4.1f'),'% MJDGGES returned an error code.'])
         end
-        if any(infox==6),
+        if any(infox==6)
             disp(['    For ',num2str(length(find(infox==6))/Nsam*100,'%4.1f'),'% The jacobian evaluated at the deterministic steady state is complex.'])
         end
-        if any(infox==19),
+        if any(infox==19)
             disp(['    For ',num2str(length(find(infox==19))/Nsam*100,'%4.1f'),'% The steadystate routine thrown an exception (inconsistent deep parameters).'])
         end
-        if any(infox==20),
+        if any(infox==20)
             disp(['    For ',num2str(length(find(infox==20))/Nsam*100,'%4.1f'),'% Cannot find the steady state.'])
         end
-        if any(infox==21),
+        if any(infox==21)
             disp(['    For ',num2str(length(find(infox==21))/Nsam*100,'%4.1f'),'% The steady state is complex.'])
         end
-        if any(infox==22),
+        if any(infox==22)
             disp(['    For ',num2str(length(find(infox==22))/Nsam*100,'%4.1f'),'% The steady has NaNs.'])
         end
-        if any(infox==23),
+        if any(infox==23)
             disp(['    For ',num2str(length(find(infox==23))/Nsam*100,'%4.1f'),'% M_.params has been updated in the steadystate routine and has complex valued scalars.'])
         end
-        if any(infox==24),
+        if any(infox==24)
             disp(['    For ',num2str(length(find(infox==24))/Nsam*100,'%4.1f'),'% M_.params has been updated in the steadystate routine and has some NaNs.'])
         end
-        if any(infox==30),
+        if any(infox==30)
             disp(['    For ',num2str(length(find(infox==30))/Nsam*100,'%4.1f'),'% Ergodic variance can''t be computed.'])
         end
 
@@ -605,8 +601,8 @@ if length(iunstable)>0 || length(iwrong)>0,
     if length(iunstable)<Nsam || length(istable)>1
         itot = [1:Nsam];
         isolve = itot(find(~ismember(itot,iwrong))); % dynare could find a solution
-        % Blanchard Kahn
-        if neighborhood_width,
+                                                     % Blanchard Kahn
+        if neighborhood_width
             options_mcf.xparam1 = xparam1(nshock+1:end);
         end
         itmp = itot(find(~ismember(itot,istable)));
@@ -617,7 +613,7 @@ if length(iunstable)>0 || length(iwrong)>0,
         options_mcf.title = 'unique solution';
         mcf_analysis(lpmat, istable, itmp, options_mcf, options_);
 
-        if ~isempty(iindeterm),
+        if ~isempty(iindeterm)
             itmp = isolve(find(~ismember(isolve,iindeterm)));
             options_mcf.amcf_name = aindname;
             options_mcf.amcf_title = aindtitle;
@@ -626,8 +622,8 @@ if length(iunstable)>0 || length(iwrong)>0,
             options_mcf.title = 'indeterminacy';
             mcf_analysis(lpmat, itmp, iindeterm, options_mcf, options_);
         end
-        
-        if ~isempty(ixun),
+
+        if ~isempty(ixun)
             itmp = isolve(find(~ismember(isolve,ixun)));
             options_mcf.amcf_name = aunstname;
             options_mcf.amcf_title = aunsttitle;
@@ -636,10 +632,10 @@ if length(iunstable)>0 || length(iwrong)>0,
             options_mcf.title = 'instability';
             mcf_analysis(lpmat, itmp, ixun, options_mcf, options_);
         end
-        
+
         inorestriction = istable(find(~ismember(istable,irestriction))); % violation of prior restrictions
         iwrong = iwrong(find(~ismember(iwrong,inorestriction))); % what went wrong beyond prior restrictions
-        if ~isempty(iwrong),
+        if ~isempty(iwrong)
             itmp = itot(find(~ismember(itot,iwrong)));
             options_mcf.amcf_name = awrongname;
             options_mcf.amcf_title = awrongtitle;
@@ -648,9 +644,9 @@ if length(iunstable)>0 || length(iwrong)>0,
             options_mcf.title = 'inability to find a solution';
             mcf_analysis(lpmat, itmp, iwrong, options_mcf, options_);
         end
-        
-        if ~isempty(irestriction),
-            if neighborhood_width,
+
+        if ~isempty(irestriction)
+            if neighborhood_width
                 options_mcf.xparam1 = xparam1;
             end
             np=size(bayestopt_.name,1);
@@ -683,7 +679,7 @@ if length(iunstable)>0 || length(iwrong)>0,
             x0=0.5.*(bounds.ub(1:nshock)-bounds.lb(1:nshock))+bounds.lb(1:nshock);
             x0 = [x0; lpmat(iok,:)'];
         end
-        
+
         M_ = set_all_parameters(x0,estim_params_,M_);
         [oo_.dr,info,M_,options_,oo_] = resol(0,M_,options_,oo_);
         %     stoch_simul([]);
@@ -703,12 +699,8 @@ xparam1=x0;
 save prior_ok.mat xparam1;
 
 options_.periods=opt.periods;
-if isfield(opt,'nomoments'),
+if isfield(opt,'nomoments')
     options_.nomoments=opt.nomoments;
 end
 options_.irf=opt.irf;
 options_.noprint=opt.noprint;
-
-
-
-
diff --git a/matlab/gsa/stab_map_1.m b/matlab/gsa/stab_map_1.m
index a5818dd2c..092b50daa 100644
--- a/matlab/gsa/stab_map_1.m
+++ b/matlab/gsa/stab_map_1.m
@@ -8,7 +8,7 @@ function [proba, dproba] = stab_map_1(lpmat, ibehaviour, inonbehaviour, aname, i
 % iplot = 1 plot cumulative distributions (default)
 % iplot = 0 no plots
 % ipar = index array of parameters to plot
-% dirname = (OPTIONAL) path of the directory where to save 
+% dirname = (OPTIONAL) path of the directory where to save
 %            (default: current directory)
 % pcrit = (OPTIONAL) critical value of the pvalue below which show the plots
 %
@@ -18,13 +18,10 @@ function [proba, dproba] = stab_map_1(lpmat, ibehaviour, inonbehaviour, aname, i
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2016 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,15 +40,15 @@ function [proba, dproba] = stab_map_1(lpmat, ibehaviour, inonbehaviour, aname, i
 
 global estim_params_ bayestopt_ M_ options_
 
-if nargin<5,
-  iplot=1;
+if nargin<5
+    iplot=1;
 end
 fname_ = M_.fname;
-if nargin<7,
-  dirname='';
+if nargin<7
+    dirname='';
 end
 if nargin<9,
-  atitle=aname;
+    atitle=aname;
 end
 
 nshock = estim_params_.nvx;
@@ -62,46 +59,46 @@ nshock = nshock + estim_params_.ncn;
 npar=size(lpmat,2);
 ishock= npar>estim_params_.np;
 
-if nargin<6,
-  ipar=[];
+if nargin<6
+    ipar=[];
 end
-if nargin<8 || isempty(pcrit),
-  pcrit=1;
+if nargin<8 || isempty(pcrit)
+    pcrit=1;
 end
 
-% Smirnov test for Blanchard; 
-for j=1:npar,
-  [H,P,KSSTAT] = smirnov(lpmat(ibehaviour,j),lpmat(inonbehaviour,j));
-  proba(j)=P;
-  dproba(j)=KSSTAT;
+% Smirnov test for Blanchard;
+for j=1:npar
+    [H,P,KSSTAT] = smirnov(lpmat(ibehaviour,j),lpmat(inonbehaviour,j));
+    proba(j)=P;
+    dproba(j)=KSSTAT;
 end
-if isempty(ipar),
-%     ipar=find(dproba>dcrit);
+if isempty(ipar)
+    %     ipar=find(dproba>dcrit);
     ipar=find(proba<pcrit);
 end
 nparplot=length(ipar);
 if iplot && ~options_.nograph
     lpmat=lpmat(:,ipar);
     ftit=bayestopt_.name(ipar+nshock*(1-ishock));
-    
-    for i=1:ceil(nparplot/12),
-        hh=dyn_figure(options_,'name',atitle);
-        for j=1+12*(i-1):min(nparplot,12*i),
+
+    for i=1:ceil(nparplot/12)
+        hh=dyn_figure(options_.nodisplay,'name',atitle);
+        for j=1+12*(i-1):min(nparplot,12*i)
             subplot(3,4,j-12*(i-1))
-            if ~isempty(ibehaviour),
+            if ~isempty(ibehaviour)
                 h=cumplot(lpmat(ibehaviour,j));
                 set(h,'color',[0 0 1], 'linestyle',':','LineWidth',1.5)
             end
-            hold on,
-            if ~isempty(inonbehaviour),
+            hold on
+            if ~isempty(inonbehaviour)
                 h=cumplot(lpmat(inonbehaviour,j));
                 set(h,'color',[0 0 0],'LineWidth',1.5)
             end
             %     title([ftit{j},'. D-stat ', num2str(dproba(ipar(j)),2)],'interpreter','none')
             title([ftit{j},'. p-value ', num2str(proba(ipar(j)),2)],'interpreter','none')
         end
-        if nparplot>12,
-            dyn_saveas(hh,[dirname,filesep,fname_,'_',aname,'_SA_',int2str(i)],options_);
+        if nparplot>12
+            dyn_saveas(hh,[dirname,filesep,fname_,'_',aname,'_SA_',int2str(i)],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fidTeX = fopen([dirname,filesep,fname_,'_',aname,'_SA_',int2str(i) '.tex'],'w');
                 fprintf(fidTeX,'%% TeX eps-loader file generated by stab_map_1.m (Dynare).\n');
@@ -116,7 +113,7 @@ if iplot && ~options_.nograph
                 fclose(fidTeX);
             end
         else
-            dyn_saveas(hh,[dirname,filesep,fname_,'_',aname,'_SA'],options_);
+            dyn_saveas(hh,[dirname,filesep,fname_,'_',aname,'_SA'],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fidTeX = fopen([dirname,filesep,fname_,'_',aname,'_SA.tex'],'w');
                 fprintf(fidTeX,'%% TeX eps-loader file generated by stab_map_1.m (Dynare).\n');
diff --git a/matlab/gsa/stab_map_2.m b/matlab/gsa/stab_map_2.m
index c72e4c0a3..f4b958355 100644
--- a/matlab/gsa/stab_map_2.m
+++ b/matlab/gsa/stab_map_2.m
@@ -3,14 +3,10 @@ function indcorr = stab_map_2(x,alpha2, pvalue_crit, fnam, dirname,xparam1,figti
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
-%
-% Reference:
-% M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012-2016 Dynare Team
-%
+% Copyright (C) 2011-2016 European Commission
+% Copyright (C) 2011-2017 Dynare Team
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
@@ -33,18 +29,18 @@ npar=size(x,2);
 nsam=size(x,1);
 ishock= npar>estim_params_.np;
 nograph = options_.nograph;
-if nargin<4,
-  fnam='';
+if nargin<4
+    fnam='';
 end
-if nargin<5,
-  dirname='';
-  nograph=1;
+if nargin<5
+    dirname='';
+    nograph=1;
 end
-if nargin<6,
-  xparam1=[];
+if nargin<6
+    xparam1=[];
 end
-if nargin<7,
-  figtitle=fnam;
+if nargin<7
+    figtitle=fnam;
 end
 
 ys_ = oo_.dr.ys;
@@ -64,12 +60,12 @@ fig_nam_=strrep(fig_nam_,' ','_');
 ifig=0;
 j2=0;
 if ishock==0
-  npar=estim_params_.np;
-  if ~isempty(xparam1),
-      xparam1=xparam1(nshock+1:end);
-  end
+    npar=estim_params_.np;
+    if ~isempty(xparam1)
+        xparam1=xparam1(nshock+1:end);
+    end
 else
-  npar=estim_params_.np+nshock;
+    npar=estim_params_.np+nshock;
 end
 skipline();
 title_string=['Correlation analysis for ',fnam];
@@ -77,14 +73,14 @@ title_string_tex=['Correlation analysis for ',strrep(fnam,'_','\\_')];
 
 indcorr = [];
 entry_iter=1;
-for j=1:npar,
+for j=1:npar
     i2=find(abs(c00(:,j))>alpha2);
-    if length(i2)>0,
-        for jx=1:length(i2),
-            if pvalue(j,i2(jx))<pvalue_crit,
+    if length(i2)>0
+        for jx=1:length(i2)
+            if pvalue(j,i2(jx))<pvalue_crit
                 indcorr = [indcorr; [j i2(jx)]];
                 j2=j2+1;
-                if ishock,
+                if ishock
                     if options_.TeX
                         [param_name_temp1, param_name_tex_temp1]= get_the_name(j,options_.TeX,M_,estim_params_,options_);
                         param_name_tex_temp1 = strrep(param_name_tex_temp1,'$','');
@@ -116,58 +112,58 @@ for j=1:npar,
                         tmp_name=(['[',param_name_temp1,',',param_name_temp2,']']);
                         name{entry_iter,1}=tmp_name;
                     end
-                end                
+                end
                 data_mat(entry_iter,1)=c0(i2(jx),j);
                 entry_iter=entry_iter+1;
-                
-                if ~nograph,
-                    if mod(j2,12)==1,
-                    ifig=ifig+1;
-                    hh=dyn_figure(options_,'name',[figtitle,' sample bivariate projection ', num2str(ifig)]);
-                end
-                subplot(3,4,j2-(ifig-1)*12)
-                %             bar(c0(i2,j)),
-                %             set(gca,'xticklabel',bayestopt_.name(i2)),
-                %             set(gca,'xtick',[1:length(i2)])
-                %plot(stock_par(ixx(nfilt+1:end,i),j),stock_par(ixx(nfilt+1:end,i),i2(jx)),'.k')
-                %hold on,
-                plot(x(:,j),x(:,i2(jx)),'.')
-                if ~isempty(xparam1)
-                    hold on, plot(xparam1(j),xparam1(i2(jx)),'ro')
-                end
-                %             xlabel(deblank(estim_params_.param_names(j,:)),'interpreter','none'),
-                %             ylabel(deblank(estim_params_.param_names(i2(jx),:)),'interpreter','none'),
-                if ishock,
-                    xlabel(bayestopt_.name{j},'interpreter','none'),
-                    ylabel(bayestopt_.name{i2(jx)},'interpreter','none'),
-                else
-                    xlabel(bayestopt_.name{j+nshock},'interpreter','none'),
-                    ylabel(bayestopt_.name{i2(jx)+nshock},'interpreter','none'),
-                end
-                title(['cc = ',num2str(c0(i2(jx),j))])
-                if (mod(j2,12)==0) && j2>0,
-                    dyn_saveas(hh,[dirname,filesep,fig_nam_,int2str(ifig)],options_);
-                    if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
-                        fidTeX = fopen([dirname,filesep,fig_nam_,int2str(ifig),'.tex'],'w');
-                        fprintf(fidTeX,'%% TeX eps-loader file generated by stab_map_2.m (Dynare).\n');
-                        fprintf(fidTeX,['%% ' datestr(now,0) '\n\n']);
-                        fprintf(fidTeX,'\\begin{figure}[H]\n');
-                        fprintf(fidTeX,'\\centering \n');
-                        fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s}\n',strrep([dirname,'/',fig_nam_,int2str(ifig)],'\','/'));
-                        fprintf(fidTeX,'\\caption{%s.}',[figtitle,' sample bivariate projection ', num2str(ifig)]);
-                        fprintf(fidTeX,'\\label{Fig:%s:%u}\n',fig_nam_,ifig);
-                        fprintf(fidTeX,'\\end{figure}\n\n');
-                        fprintf(fidTeX,'%% End Of TeX file. \n');
-                        fclose(fidTeX);
+
+                if ~nograph
+                    if mod(j2,12)==1
+                        ifig=ifig+1;
+                        hh=dyn_figure(options_.nodisplay,'name',[figtitle,' sample bivariate projection ', num2str(ifig)]);
+                    end
+                    subplot(3,4,j2-(ifig-1)*12)
+                    %             bar(c0(i2,j)),
+                    %             set(gca,'xticklabel',bayestopt_.name(i2)),
+                    %             set(gca,'xtick',[1:length(i2)])
+                    %plot(stock_par(ixx(nfilt+1:end,i),j),stock_par(ixx(nfilt+1:end,i),i2(jx)),'.k')
+                    %hold on,
+                    plot(x(:,j),x(:,i2(jx)),'.')
+                    if ~isempty(xparam1)
+                        hold on, plot(xparam1(j),xparam1(i2(jx)),'ro')
+                    end
+                    %             xlabel(deblank(estim_params_.param_names(j,:)),'interpreter','none'),
+                    %             ylabel(deblank(estim_params_.param_names(i2(jx),:)),'interpreter','none'),
+                    if ishock
+                        xlabel(bayestopt_.name{j},'interpreter','none'),
+                        ylabel(bayestopt_.name{i2(jx)},'interpreter','none'),
+                    else
+                        xlabel(bayestopt_.name{j+nshock},'interpreter','none'),
+                        ylabel(bayestopt_.name{i2(jx)+nshock},'interpreter','none'),
+                    end
+                    title(['cc = ',num2str(c0(i2(jx),j))])
+                    if (mod(j2,12)==0) && j2>0
+                        dyn_saveas(hh,[dirname,filesep,fig_nam_,int2str(ifig)],options_.nodisplay,options_.graph_format);
+                        if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
+                            fidTeX = fopen([dirname,filesep,fig_nam_,int2str(ifig),'.tex'],'w');
+                            fprintf(fidTeX,'%% TeX eps-loader file generated by stab_map_2.m (Dynare).\n');
+                            fprintf(fidTeX,['%% ' datestr(now,0) '\n\n']);
+                            fprintf(fidTeX,'\\begin{figure}[H]\n');
+                            fprintf(fidTeX,'\\centering \n');
+                            fprintf(fidTeX,'\\includegraphics[width=0.8\\textwidth]{%s}\n',strrep([dirname,'/',fig_nam_,int2str(ifig)],'\','/'));
+                            fprintf(fidTeX,'\\caption{%s.}',[figtitle,' sample bivariate projection ', num2str(ifig)]);
+                            fprintf(fidTeX,'\\label{Fig:%s:%u}\n',fig_nam_,ifig);
+                            fprintf(fidTeX,'\\end{figure}\n\n');
+                            fprintf(fidTeX,'%% End Of TeX file. \n');
+                            fclose(fidTeX);
+                        end
                     end
                 end
-                end
             end
-            
+
         end
     end
-    if ~nograph && (j==(npar)) && j2>0 && (mod(j2,12)~=0),
-        dyn_saveas(hh,[dirname,filesep,fig_nam_,int2str(ifig)],options_);
+    if ~nograph && (j==(npar)) && j2>0 && (mod(j2,12)~=0)
+        dyn_saveas(hh,[dirname,filesep,fig_nam_,int2str(ifig)],options_.nodisplay,options_.graph_format);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fidTeX = fopen([dirname,filesep,fig_nam_,int2str(ifig),'.tex'],'w');
             fprintf(fidTeX,'%% TeX eps-loader file generated by stab_map_2.m (Dynare).\n');
@@ -181,10 +177,10 @@ for j=1:npar,
             fprintf(fidTeX,'%% End Of TeX file. \n');
             fclose(fidTeX);
         end
-    end    
+    end
 end
 
-if j2==0,
+if j2==0
     disp(['No correlation term with pvalue <', num2str(pvalue_crit),' and |corr. coef.| >',num2str(alpha2),' found for ',fnam])
 else
     headers=strvcat('Parameters','corrcoef');
diff --git a/matlab/gsa/stand_.m b/matlab/gsa/stand_.m
index 46eb11598..0a53f1a3b 100644
--- a/matlab/gsa/stand_.m
+++ b/matlab/gsa/stand_.m
@@ -9,10 +9,12 @@ function [y, meany, stdy] = stand_(x)
 % my: Vector of mean values for each column of y
 % sy: Vector of standard deviations for each column of y
 %
-% Author : Marco Ratto
+% Written by Marco Ratto
+% Joint Research Centre, The European Commission,
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2012 Dynare Team
-%
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
@@ -28,13 +30,13 @@ function [y, meany, stdy] = stand_(x)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin==0,
-    return;
+if nargin==0
+    return
 end
 
-for j=1:size(x,2);
-meany(j)=mean(x(find(~isnan(x(:,j))),j));
-stdy(j)=std(x(find(~isnan(x(:,j))),j));
+for j=1:size(x,2)
+    meany(j)=mean(x(find(~isnan(x(:,j))),j));
+    stdy(j)=std(x(find(~isnan(x(:,j))),j));
     y(:,j)=(x(:,j)-meany(j))./stdy(j);
 end
 % end of m-file
\ No newline at end of file
diff --git a/matlab/gsa/tcrit.m b/matlab/gsa/tcrit.m
index 2efd947e6..d65b97a39 100644
--- a/matlab/gsa/tcrit.m
+++ b/matlab/gsa/tcrit.m
@@ -1,15 +1,15 @@
 function t_crit = tcrit(n,pval0)
 % function t_crit = tcrit(n,pval0)
 %
-% given the p-value pval0, the function givese the 
-% critical value t_crit of the t-distribution with n degress of freedom 
+% given the p-value pval0, the function givese the
+% critical value t_crit of the t-distribution with n degress of freedom
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
+% marco.ratto@ec.europa.eu
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2012 European Commission
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,126 +27,126 @@ function t_crit = tcrit(n,pval0)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-if nargin==1 || isempty(pval0),
+if nargin==1 || isempty(pval0)
     pval0=0.05;
 end
-if pval0==1,
+if pval0==1
     t_crit=0;
-    return,
+    return
 end
-if pval0==0,
+if pval0==0
     t_crit=inf;
-    return,
+    return
 end
 pval = [  0.10    0.05   0.025    0.01   0.005   0.001];
 pval0=max(pval0,min(pval));
 ncol=min(find(pval<=pval0))+1;
 
 t_crit=[
-  1      3.078   6.314  12.706  31.821  63.657 318.313
-  2      1.886   2.920   4.303   6.965   9.925  22.327
-  3      1.638   2.353   3.182   4.541   5.841  10.215
-  4      1.533   2.132   2.776   3.747   4.604   7.173
-  5      1.476   2.015   2.571   3.365   4.032   5.893
-  6      1.440   1.943   2.447   3.143   3.707   5.208
-  7      1.415   1.895   2.365   2.998   3.499   4.782
-  8      1.397   1.860   2.306   2.896   3.355   4.499
-  9      1.383   1.833   2.262   2.821   3.250   4.296
- 10      1.372   1.812   2.228   2.764   3.169   4.143
- 11      1.363   1.796   2.201   2.718   3.106   4.024
- 12      1.356   1.782   2.179   2.681   3.055   3.929
- 13      1.350   1.771   2.160   2.650   3.012   3.852
- 14      1.345   1.761   2.145   2.624   2.977   3.787
- 15      1.341   1.753   2.131   2.602   2.947   3.733
- 16      1.337   1.746   2.120   2.583   2.921   3.686
- 17      1.333   1.740   2.110   2.567   2.898   3.646
- 18      1.330   1.734   2.101   2.552   2.878   3.610
- 19      1.328   1.729   2.093   2.539   2.861   3.579
- 20      1.325   1.725   2.086   2.528   2.845   3.552
- 21      1.323   1.721   2.080   2.518   2.831   3.527
- 22      1.321   1.717   2.074   2.508   2.819   3.505
- 23      1.319   1.714   2.069   2.500   2.807   3.485
- 24      1.318   1.711   2.064   2.492   2.797   3.467
- 25      1.316   1.708   2.060   2.485   2.787   3.450
- 26      1.315   1.706   2.056   2.479   2.779   3.435
- 27      1.314   1.703   2.052   2.473   2.771   3.421
- 28      1.313   1.701   2.048   2.467   2.763   3.408
- 29      1.311   1.699   2.045   2.462   2.756   3.396
- 30      1.310   1.697   2.042   2.457   2.750   3.385
- 31      1.309   1.696   2.040   2.453   2.744   3.375
- 32      1.309   1.694   2.037   2.449   2.738   3.365
- 33      1.308   1.692   2.035   2.445   2.733   3.356
- 34      1.307   1.691   2.032   2.441   2.728   3.348
- 35      1.306   1.690   2.030   2.438   2.724   3.340
- 36      1.306   1.688   2.028   2.434   2.719   3.333
- 37      1.305   1.687   2.026   2.431   2.715   3.326
- 38      1.304   1.686   2.024   2.429   2.712   3.319
- 39      1.304   1.685   2.023   2.426   2.708   3.313
- 40      1.303   1.684   2.021   2.423   2.704   3.307
- 41      1.303   1.683   2.020   2.421   2.701   3.301
- 42      1.302   1.682   2.018   2.418   2.698   3.296
- 43      1.302   1.681   2.017   2.416   2.695   3.291
- 44      1.301   1.680   2.015   2.414   2.692   3.286
- 45      1.301   1.679   2.014   2.412   2.690   3.281
- 46      1.300   1.679   2.013   2.410   2.687   3.277
- 47      1.300   1.678   2.012   2.408   2.685   3.273
- 48      1.299   1.677   2.011   2.407   2.682   3.269
- 49      1.299   1.677   2.010   2.405   2.680   3.265
- 50      1.299   1.676   2.009   2.403   2.678   3.261
- 51      1.298   1.675   2.008   2.402   2.676   3.258
- 52      1.298   1.675   2.007   2.400   2.674   3.255
- 53      1.298   1.674   2.006   2.399   2.672   3.251
- 54      1.297   1.674   2.005   2.397   2.670   3.248
- 55      1.297   1.673   2.004   2.396   2.668   3.245
- 56      1.297   1.673   2.003   2.395   2.667   3.242
- 57      1.297   1.672   2.002   2.394   2.665   3.239
- 58      1.296   1.672   2.002   2.392   2.663   3.237
- 59      1.296   1.671   2.001   2.391   2.662   3.234
- 60      1.296   1.671   2.000   2.390   2.660   3.232
- 61      1.296   1.670   2.000   2.389   2.659   3.229
- 62      1.295   1.670   1.999   2.388   2.657   3.227
- 63      1.295   1.669   1.998   2.387   2.656   3.225
- 64      1.295   1.669   1.998   2.386   2.655   3.223
- 65      1.295   1.669   1.997   2.385   2.654   3.220
- 66      1.295   1.668   1.997   2.384   2.652   3.218
- 67      1.294   1.668   1.996   2.383   2.651   3.216
- 68      1.294   1.668   1.995   2.382   2.650   3.214
- 69      1.294   1.667   1.995   2.382   2.649   3.213
- 70      1.294   1.667   1.994   2.381   2.648   3.211
- 71      1.294   1.667   1.994   2.380   2.647   3.209
- 72      1.293   1.666   1.993   2.379   2.646   3.207
- 73      1.293   1.666   1.993   2.379   2.645   3.206
- 74      1.293   1.666   1.993   2.378   2.644   3.204
- 75      1.293   1.665   1.992   2.377   2.643   3.202
- 76      1.293   1.665   1.992   2.376   2.642   3.201
- 77      1.293   1.665   1.991   2.376   2.641   3.199
- 78      1.292   1.665   1.991   2.375   2.640   3.198
- 79      1.292   1.664   1.990   2.374   2.640   3.197
- 80      1.292   1.664   1.990   2.374   2.639   3.195
- 81      1.292   1.664   1.990   2.373   2.638   3.194
- 82      1.292   1.664   1.989   2.373   2.637   3.193
- 83      1.292   1.663   1.989   2.372   2.636   3.191
- 84      1.292   1.663   1.989   2.372   2.636   3.190
- 85      1.292   1.663   1.988   2.371   2.635   3.189
- 86      1.291   1.663   1.988   2.370   2.634   3.188
- 87      1.291   1.663   1.988   2.370   2.634   3.187
- 88      1.291   1.662   1.987   2.369   2.633   3.185
- 89      1.291   1.662   1.987   2.369   2.632   3.184
- 90      1.291   1.662   1.987   2.368   2.632   3.183
- 91      1.291   1.662   1.986   2.368   2.631   3.182
- 92      1.291   1.662   1.986   2.368   2.630   3.181
- 93      1.291   1.661   1.986   2.367   2.630   3.180
- 94      1.291   1.661   1.986   2.367   2.629   3.179
- 95      1.291   1.661   1.985   2.366   2.629   3.178
- 96      1.290   1.661   1.985   2.366   2.628   3.177
- 97      1.290   1.661   1.985   2.365   2.627   3.176
- 98      1.290   1.661   1.984   2.365   2.627   3.175
- 99      1.290   1.660   1.984   2.365   2.626   3.175
-100      1.290   1.660   1.984   2.364   2.626   3.174
-inf        1.282   1.645   1.960   2.326   2.576   3.090
-];
+    1      3.078   6.314  12.706  31.821  63.657 318.313
+    2      1.886   2.920   4.303   6.965   9.925  22.327
+    3      1.638   2.353   3.182   4.541   5.841  10.215
+    4      1.533   2.132   2.776   3.747   4.604   7.173
+    5      1.476   2.015   2.571   3.365   4.032   5.893
+    6      1.440   1.943   2.447   3.143   3.707   5.208
+    7      1.415   1.895   2.365   2.998   3.499   4.782
+    8      1.397   1.860   2.306   2.896   3.355   4.499
+    9      1.383   1.833   2.262   2.821   3.250   4.296
+    10      1.372   1.812   2.228   2.764   3.169   4.143
+    11      1.363   1.796   2.201   2.718   3.106   4.024
+    12      1.356   1.782   2.179   2.681   3.055   3.929
+    13      1.350   1.771   2.160   2.650   3.012   3.852
+    14      1.345   1.761   2.145   2.624   2.977   3.787
+    15      1.341   1.753   2.131   2.602   2.947   3.733
+    16      1.337   1.746   2.120   2.583   2.921   3.686
+    17      1.333   1.740   2.110   2.567   2.898   3.646
+    18      1.330   1.734   2.101   2.552   2.878   3.610
+    19      1.328   1.729   2.093   2.539   2.861   3.579
+    20      1.325   1.725   2.086   2.528   2.845   3.552
+    21      1.323   1.721   2.080   2.518   2.831   3.527
+    22      1.321   1.717   2.074   2.508   2.819   3.505
+    23      1.319   1.714   2.069   2.500   2.807   3.485
+    24      1.318   1.711   2.064   2.492   2.797   3.467
+    25      1.316   1.708   2.060   2.485   2.787   3.450
+    26      1.315   1.706   2.056   2.479   2.779   3.435
+    27      1.314   1.703   2.052   2.473   2.771   3.421
+    28      1.313   1.701   2.048   2.467   2.763   3.408
+    29      1.311   1.699   2.045   2.462   2.756   3.396
+    30      1.310   1.697   2.042   2.457   2.750   3.385
+    31      1.309   1.696   2.040   2.453   2.744   3.375
+    32      1.309   1.694   2.037   2.449   2.738   3.365
+    33      1.308   1.692   2.035   2.445   2.733   3.356
+    34      1.307   1.691   2.032   2.441   2.728   3.348
+    35      1.306   1.690   2.030   2.438   2.724   3.340
+    36      1.306   1.688   2.028   2.434   2.719   3.333
+    37      1.305   1.687   2.026   2.431   2.715   3.326
+    38      1.304   1.686   2.024   2.429   2.712   3.319
+    39      1.304   1.685   2.023   2.426   2.708   3.313
+    40      1.303   1.684   2.021   2.423   2.704   3.307
+    41      1.303   1.683   2.020   2.421   2.701   3.301
+    42      1.302   1.682   2.018   2.418   2.698   3.296
+    43      1.302   1.681   2.017   2.416   2.695   3.291
+    44      1.301   1.680   2.015   2.414   2.692   3.286
+    45      1.301   1.679   2.014   2.412   2.690   3.281
+    46      1.300   1.679   2.013   2.410   2.687   3.277
+    47      1.300   1.678   2.012   2.408   2.685   3.273
+    48      1.299   1.677   2.011   2.407   2.682   3.269
+    49      1.299   1.677   2.010   2.405   2.680   3.265
+    50      1.299   1.676   2.009   2.403   2.678   3.261
+    51      1.298   1.675   2.008   2.402   2.676   3.258
+    52      1.298   1.675   2.007   2.400   2.674   3.255
+    53      1.298   1.674   2.006   2.399   2.672   3.251
+    54      1.297   1.674   2.005   2.397   2.670   3.248
+    55      1.297   1.673   2.004   2.396   2.668   3.245
+    56      1.297   1.673   2.003   2.395   2.667   3.242
+    57      1.297   1.672   2.002   2.394   2.665   3.239
+    58      1.296   1.672   2.002   2.392   2.663   3.237
+    59      1.296   1.671   2.001   2.391   2.662   3.234
+    60      1.296   1.671   2.000   2.390   2.660   3.232
+    61      1.296   1.670   2.000   2.389   2.659   3.229
+    62      1.295   1.670   1.999   2.388   2.657   3.227
+    63      1.295   1.669   1.998   2.387   2.656   3.225
+    64      1.295   1.669   1.998   2.386   2.655   3.223
+    65      1.295   1.669   1.997   2.385   2.654   3.220
+    66      1.295   1.668   1.997   2.384   2.652   3.218
+    67      1.294   1.668   1.996   2.383   2.651   3.216
+    68      1.294   1.668   1.995   2.382   2.650   3.214
+    69      1.294   1.667   1.995   2.382   2.649   3.213
+    70      1.294   1.667   1.994   2.381   2.648   3.211
+    71      1.294   1.667   1.994   2.380   2.647   3.209
+    72      1.293   1.666   1.993   2.379   2.646   3.207
+    73      1.293   1.666   1.993   2.379   2.645   3.206
+    74      1.293   1.666   1.993   2.378   2.644   3.204
+    75      1.293   1.665   1.992   2.377   2.643   3.202
+    76      1.293   1.665   1.992   2.376   2.642   3.201
+    77      1.293   1.665   1.991   2.376   2.641   3.199
+    78      1.292   1.665   1.991   2.375   2.640   3.198
+    79      1.292   1.664   1.990   2.374   2.640   3.197
+    80      1.292   1.664   1.990   2.374   2.639   3.195
+    81      1.292   1.664   1.990   2.373   2.638   3.194
+    82      1.292   1.664   1.989   2.373   2.637   3.193
+    83      1.292   1.663   1.989   2.372   2.636   3.191
+    84      1.292   1.663   1.989   2.372   2.636   3.190
+    85      1.292   1.663   1.988   2.371   2.635   3.189
+    86      1.291   1.663   1.988   2.370   2.634   3.188
+    87      1.291   1.663   1.988   2.370   2.634   3.187
+    88      1.291   1.662   1.987   2.369   2.633   3.185
+    89      1.291   1.662   1.987   2.369   2.632   3.184
+    90      1.291   1.662   1.987   2.368   2.632   3.183
+    91      1.291   1.662   1.986   2.368   2.631   3.182
+    92      1.291   1.662   1.986   2.368   2.630   3.181
+    93      1.291   1.661   1.986   2.367   2.630   3.180
+    94      1.291   1.661   1.986   2.367   2.629   3.179
+    95      1.291   1.661   1.985   2.366   2.629   3.178
+    96      1.290   1.661   1.985   2.366   2.628   3.177
+    97      1.290   1.661   1.985   2.365   2.627   3.176
+    98      1.290   1.661   1.984   2.365   2.627   3.175
+    99      1.290   1.660   1.984   2.365   2.626   3.175
+    100      1.290   1.660   1.984   2.364   2.626   3.174
+    inf        1.282   1.645   1.960   2.326   2.576   3.090
+       ];
 
-if n<=100,
+if n<=100
     t_crit=t_crit(n,ncol);
 else
     t_crit=t_crit(end,ncol);
diff --git a/matlab/gsa/teff.m b/matlab/gsa/teff.m
index cd26b5a07..8ebea8d1c 100644
--- a/matlab/gsa/teff.m
+++ b/matlab/gsa/teff.m
@@ -3,13 +3,13 @@ function [yt, j0, ir, ic]=teff(T,Nsam,istable)
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
+% marco.ratto@ec.europa.eu
 %
 % Reference:
 % M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,33 +27,33 @@ function [yt, j0, ir, ic]=teff(T,Nsam,istable)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 ndim = (length(size(T)));
-if ndim==3,
-if nargin==1,
-  Nsam=size(T,3);
-  istable = [1:Nsam]';
-end
-tmax=max(T,[],3);
-tmin=min(T,[],3);
-[ir, ic]=(find( (tmax-tmin)>1.e-8));
-j0 = length(ir);
-yt=zeros(Nsam, j0);
+if ndim==3
+    if nargin==1
+        Nsam=size(T,3);
+        istable = [1:Nsam]';
+    end
+    tmax=max(T,[],3);
+    tmin=min(T,[],3);
+    [ir, ic]=(find( (tmax-tmin)>1.e-8));
+    j0 = length(ir);
+    yt=zeros(Nsam, j0);
 
-for j=1:j0,
-  y0=squeeze(T(ir(j),ic(j),:));
-  %y1=ones(size(lpmat,1),1)*NaN;
-  y1=ones(Nsam,1)*NaN;
-  y1(istable,1)=y0;
-  yt(:,j)=y1;
-end
+    for j=1:j0
+        y0=squeeze(T(ir(j),ic(j),:));
+        %y1=ones(size(lpmat,1),1)*NaN;
+        y1=ones(Nsam,1)*NaN;
+        y1(istable,1)=y0;
+        yt(:,j)=y1;
+    end
 
 else
-tmax=max(T,[],2);
-tmin=min(T,[],2);
-ir=(find( (tmax-tmin)>1.e-8));
-j0 = length(ir);
-yt=NaN(Nsam, j0);
-yt(istable,:)=T(ir,:)';
+    tmax=max(T,[],2);
+    tmin=min(T,[],2);
+    ir=(find( (tmax-tmin)>1.e-8));
+    j0 = length(ir);
+    yt=NaN(Nsam, j0);
+    yt(istable,:)=T(ir,:)';
+
 
-  
 end
 %clear y0 y1;
diff --git a/matlab/gsa/th_moments.m b/matlab/gsa/th_moments.m
index 5616b4045..9b886e851 100644
--- a/matlab/gsa/th_moments.m
+++ b/matlab/gsa/th_moments.m
@@ -1,7 +1,7 @@
 function [vdec, corr, autocorr, z, zz] = th_moments(dr,var_list)
 % [vdec, corr, autocorr, z, zz] = th_moments(dr,var_list)
 
-% Copyright (C) 2012-2016 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -56,13 +56,13 @@ var = gamma_y{1};
 z;
 
 %'VARIANCE DECOMPOSITION (in percent)';
-if M_.exo_nbr>1,
+if M_.exo_nbr>1
     vdec = 100*gamma_y{options_.ar+2}(i1,:);
 else
     vdec = 100*ones(size(gamma_y{1}(i1,1)));
 end
 %'MATRIX OF CORRELATIONS';
-if options_.opt_gsa.useautocorr,
+if options_.opt_gsa.useautocorr
     corr = gamma_y{1}(i1,i1)./(sd(i1)*sd(i1)');
     corr = corr-diag(diag(corr))+diag(diag(gamma_y{1}(i1,i1)));
 else
@@ -71,7 +71,7 @@ end
 if options_.ar > 0
     %'COEFFICIENTS OF AUTOCORRELATION';
     for i=1:options_.ar
-        if options_.opt_gsa.useautocorr,
+        if options_.opt_gsa.useautocorr
             autocorr{i} = gamma_y{i+1}(i1,i1);
         else
             autocorr{i} = gamma_y{i+1}(i1,i1).*(sd(i1)*sd(i1)');
@@ -79,5 +79,3 @@ if options_.ar > 0
         zz(:,i) = diag(gamma_y{i+1}(i1,i1));
     end
 end
-
-
diff --git a/matlab/gsa/trank.m b/matlab/gsa/trank.m
index d788cf085..eb39f1647 100644
--- a/matlab/gsa/trank.m
+++ b/matlab/gsa/trank.m
@@ -1,16 +1,16 @@
-function yr = trank(y);
+function yr = trank(y)
 % yr = trank(y);
 % yr is the rank transformation of y
 %
 % Written by Marco Ratto
 % Joint Research Centre, The European Commission,
-% (http://eemc.jrc.ec.europa.eu/),
-% marco.ratto@jrc.it 
+% marco.ratto@ec.europa.eu
 %
 % Reference:
 % M. Ratto, Global Sensitivity Analysis for Macroeconomic models, MIMEO, 2006.
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012 European Commission
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,7 +28,7 @@ function yr = trank(y);
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 [nr, nc] = size(y);
-for j=1:nc,
-  [dum, is]=sort(y(:,j));
-  yr(is,j)=[1:nr]'./nr;
+for j=1:nc
+    [dum, is]=sort(y(:,j));
+    yr(is,j)=[1:nr]'./nr;
 end
diff --git a/matlab/hessian.m b/matlab/hessian.m
index 4faa4c500..844251f7c 100644
--- a/matlab/hessian.m
+++ b/matlab/hessian.m
@@ -12,19 +12,19 @@ function hessian_mat = hessian(func,x, gstep, varargin) % --*-- Unitary tests --
 %    hessian_mat [double]   Hessian matrix
 %
 % ALGORITHM
-%    Uses Abramowitz and Stegun (1965) formulas 25.3.23 
+%    Uses Abramowitz and Stegun (1965) formulas 25.3.23
 % \[
 %     \frac{\partial^2 f_{0,0}}{\partial {x^2}} = \frac{1}{h^2}\left( f_{1,0} - 2f_{0,0} + f_{ - 1,0} \right)
 % \]
 % and 25.3.27 p. 884
-% 
+%
 % \[
 %     \frac{\partial ^2f_{0,0}}{\partial x\partial y} = \frac{-1}{2h^2}\left(f_{1,0} + f_{-1,0} + f_{0,1} + f_{0,-1} - 2f_{0,0} - f_{1,1} - f_{-1,-1} \right)
 % \]
 %
 % SPECIAL REQUIREMENTS
 %    none
-%  
+%
 
 % Copyright (C) 2001-2017 Dynare Team
 %
@@ -43,7 +43,7 @@ function hessian_mat = hessian(func,x, gstep, varargin) % --*-- Unitary tests --
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if ~isa(func, 'function_handle') 
+if ~isa(func, 'function_handle')
     func = str2func(func);
 end
 
@@ -67,7 +67,7 @@ for i=1:n
     xh1(i)   = x(i)-h_1(i);
     f_1(:,i) = feval(func, xh1, varargin{:});
     %reset parameter
-    xh1(i)   = x(i); 
+    xh1(i)   = x(i);
 end
 
 xh_1 = xh1;
@@ -75,14 +75,14 @@ temp = f1+f_1-f0*ones(1, n); %term f_(1,0)+f_(-1,0)-f_(0,0) used later
 
 hessian_mat = zeros(size(f0,1), n*n);
 
-for i=1:n    
-    if i > 1  
-        %fill symmetric part of Hessian based on previously computed results      
+for i=1:n
+    if i > 1
+        %fill symmetric part of Hessian based on previously computed results
         k = [i:n:n*(i-1)];
         hessian_mat(:,(i-1)*n+1:(i-1)*n+i-1) = hessian_mat(:,k);
-    end     
+    end
     hessian_mat(:,(i-1)*n+i) = (f1(:,i)+f_1(:,i)-2*f0)./(h1(i)*h_1(i)); %formula 25.3.23
-    for j=i+1:n        
+    for j=i+1:n
         %step in up direction
         xh1(i) = x(i)+h1(i);
         xh1(j) = x(j)+h_1(j);
@@ -90,12 +90,12 @@ for i=1:n
         xh_1(i) = x(i)-h1(i);
         xh_1(j) = x(j)-h_1(j);
         hessian_mat(:,(i-1)*n+j) =-(-feval(func, xh1, varargin{:})-feval(func, xh_1, varargin{:})+temp(:,i)+temp(:,j))./(2*h1(i)*h_1(j)); %formula 25.3.27
-        %reset grid points
+                                                                                                                                          %reset grid points
         xh1(i)  = x(i);
         xh1(j)  = x(j);
         xh_1(i) = x(i);
         xh_1(j) = x(j);
-    end    
+    end
 end
 
 
diff --git a/matlab/hessian_sparse.m b/matlab/hessian_sparse.m
index eb447f8d3..1d7a75dbe 100644
--- a/matlab/hessian_sparse.m
+++ b/matlab/hessian_sparse.m
@@ -16,9 +16,9 @@ function hessian_mat = hessian_sparse(func,x,gstep,varargin)
 %
 % SPECIAL REQUIREMENTS
 %    none
-%  
+%
 
-% Copyright (C) 2001-2012 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -35,7 +35,7 @@ function hessian_mat = hessian_sparse(func,x,gstep,varargin)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if ~isa(func, 'function_handle') 
+if ~isa(func, 'function_handle')
     func = str2func(func);
 end
 n=size(x,1);
@@ -49,7 +49,7 @@ xh1=x;
 f0=feval(func,x,varargin{:});
 f1=zeros(size(f0,1),n);
 f_1=f1;
-for i=1:n    
+for i=1:n
     xh1(i)=x(i)+h1(i);
     f1(:,i)=feval(func,xh1,varargin{:});
     xh1(i)=x(i)-h_1(i);
@@ -59,15 +59,15 @@ end
 xh_1=xh1;
 hessian_mat = sparse(size(f0,1),n*n);
 
-for i=1:n    
-%     if i > 1        
-%         k=[i:n:n*(i-1)];
-%         hessian_mat(:,(i-1)*n+1:(i-1)*n+i-1)=hessian_mat(:,k);
-%         hessian_mat(:,k)=0;
-%     end     
+for i=1:n
+    %     if i > 1
+    %         k=[i:n:n*(i-1)];
+    %         hessian_mat(:,(i-1)*n+1:(i-1)*n+i-1)=hessian_mat(:,k);
+    %         hessian_mat(:,k)=0;
+    %     end
     hessian_mat(:,(i-1)*n+i)=(f1(:,i)+f_1(:,i)-2*f0)./(h1(i)*h_1(i));
     temp=f1+f_1-f0*ones(1,n);
-    for j=1:i-1        
+    for j=1:i-1
         xh1(i)=x(i)+h1(i);
         xh1(j)=x(j)+h_1(j);
         xh_1(i)=x(i)-h1(i);
@@ -77,5 +77,5 @@ for i=1:n
         xh1(j)=x(j);
         xh_1(i)=x(i);
         xh_1(j)=x(j);
-    end    
+    end
 end
\ No newline at end of file
diff --git a/matlab/histvalf.m b/matlab/histvalf.m
index e2c144554..580c9be92 100644
--- a/matlab/histvalf.m
+++ b/matlab/histvalf.m
@@ -1,6 +1,6 @@
 function histvalf(fname)
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -86,4 +86,3 @@ for i = 1:length(outvars)
     end
     M_.endo_histval(j, :) = getfield(S, ov_);
 end
-
diff --git a/matlab/homotopy1.m b/matlab/homotopy1.m
index e7de1f16a..e849fceca 100644
--- a/matlab/homotopy1.m
+++ b/matlab/homotopy1.m
@@ -30,7 +30,7 @@ function [M,oo,info,ip,ix,ixd] = homotopy1(values, step_nbr, M, options, oo)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -90,7 +90,7 @@ for i=1:step_nbr+1
         % if homotopy step is not successful, current values of steady
         % state are not modified
         oo.steady_state = steady_state;
-    else 
+    else
         M.params = old_params;
         oo.exo_steady_state = old_exo;
         oo.exo_det_steady_state = old_exo_det;
diff --git a/matlab/homotopy2.m b/matlab/homotopy2.m
index 8e1318a86..7ec87258d 100644
--- a/matlab/homotopy2.m
+++ b/matlab/homotopy2.m
@@ -25,7 +25,7 @@ function homotopy2(values, step_nbr)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -99,7 +99,7 @@ for i = 1:nv
         end
 
         disp([ 'HOMOTOPY mode 2: lauching solver with ' deblank(varname) ' = ' num2str(v) ' ...'])
-        
+
         oo_.steady_state = steady_(M_,options_,oo_);
     end
 end
diff --git a/matlab/homotopy3.m b/matlab/homotopy3.m
index a506bb6b6..b4b46d6f2 100644
--- a/matlab/homotopy3.m
+++ b/matlab/homotopy3.m
@@ -33,7 +33,7 @@ function [M,oo,info,ip,ix,ixd]=homotopy3(values, step_nbr, M, options, oo)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -91,11 +91,11 @@ disp('HOMOTOPY mode 3: launching solver at initial point...')
 
 iter = 1;
 while iter <= step_nbr
-    
+
     M.params(values(ip,2)) = curvalues(ip);
     oo.exo_steady_state(values(ix,2)) = curvalues(ix);
     oo.exo_det_steady_state(values(ixd,2)) = curvalues(ixd);
-    
+
     old_ss = oo.steady_state;
 
     [steady_state,params,info] = steady_(M,options,oo);
@@ -121,8 +121,8 @@ while iter <= step_nbr
         disp('HOMOTOPY mode 3: failed step, now dividing increment by 2...')
         inc = inc/2;
         oo.steady_state = old_ss;
-    end      
-    
+    end
+
     curvalues = last_values + inc;
     kplus = find(curvalues(iplus) >= targetvalues(iplus));
     curvalues(iplus(kplus)) = targetvalues(iplus(kplus));
@@ -136,7 +136,7 @@ while iter <= step_nbr
         oo.exo_det_steady_state = old_exo_det_steady_state;
         return
     end
-    
+
     iter = iter + 1;
 end
 disp('HOMOTOPY mode 3: failed, maximum iterations reached')
diff --git a/matlab/ident_bruteforce.m b/matlab/ident_bruteforce.m
index 41ed952d7..34725ade4 100644
--- a/matlab/ident_bruteforce.m
+++ b/matlab/ident_bruteforce.m
@@ -12,12 +12,12 @@ function [pars, cosnJ] = ident_bruteforce(J,n,TeX, pnames_TeX,tittxt)
 %  pnames_TeX         [char] list of tex names
 %  tittxt             [string]  string indicating the title text for
 %                               graphs and figures
-% 
+%
 % OUTPUTS
 %  pars  : cell array with groupf of params for each column of J for 1 to n
 %  cosnJ : the cosn of each column with the selected group of columns
 
-% Copyright (C) 2009-2016 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -52,7 +52,7 @@ tittxt1=strrep(tittxt1, '.', '');
 
 cosnJ=zeros(k,n);
 pars{k,n}=[];
-for ll = 1:n,
+for ll = 1:n
     h = dyn_waitbar(0,['Brute force collinearity for ' int2str(ll) ' parameters.']);
     for ii = 1:k
         tmp = find([1:k]~=ii);
@@ -63,8 +63,8 @@ for ll = 1:n,
             [cosnJ2(jj,1), b(:,jj)] = cosn([J(:,ii),J(:,tmp2(jj,:))]);
         end
         cosnJ(ii,ll) = max(cosnJ2(:,1));
-        if cosnJ(ii,ll)>1.e-8,
-            if ll>1 && ((cosnJ(ii,ll)-cosnJ(ii,ll-1))<1.e-8),
+        if cosnJ(ii,ll)>1.e-8
+            if ll>1 && ((cosnJ(ii,ll)-cosnJ(ii,ll-1))<1.e-8)
                 pars{ii,ll} = [pars{ii,ll-1} NaN];
                 cosnJ(ii,ll) = cosnJ(ii,ll-1);
             else
@@ -85,7 +85,7 @@ for ll = 1:n,
         fprintf(fidTeX,['%% ' datestr(now,0)]);
         fprintf(fidTeX,' \n');
         fprintf(fidTeX,' \n');
-        
+
         fprintf(fidTeX,'{\\tiny \n');
         fprintf(fidTeX,'\\begin{longtable}{llc} \n');
         fprintf(fidTeX,['\\caption{Collinearity patterns with ',int2str(ll),' parameter(s): ',tittxt,'}\n ']);
@@ -101,19 +101,19 @@ for ll = 1:n,
         fprintf(fidTeX,'\\midrule \\endhead \n');
         fprintf(fidTeX,'\\bottomrule \\multicolumn{3}{r}{(Continued on next page)}\\endfoot \n');
         fprintf(fidTeX,'\\bottomrule\\endlastfoot \n');
-        for i=1:k,
+        for i=1:k
             plist='';
-            for ii=1:ll,
-                if ~isnan(pars{i,ll}(ii)),
+            for ii=1:ll
+                if ~isnan(pars{i,ll}(ii))
                     plist = [plist ' $' pnames_TeX(pars{i,ll}(ii),:) '\;\; $ '];
                 else
                     plist = [plist ' ---- '];
                 end
             end
             fprintf(fidTeX,'$%s$ & [%s] & %7.3f \\\\ \n',...
-                pnames_TeX(i,:),...
-                plist,...
-                cosnJ(i,ll));
+                    pnames_TeX(i,:),...
+                    plist,...
+                    cosnJ(i,ll));
         end
         fprintf(fidTeX,'\\bottomrule \n');
         fprintf(fidTeX,'\\end{longtable}\n');
diff --git a/matlab/identification_analysis.m b/matlab/identification_analysis.m
index 88b60ca4d..c59e08ec6 100644
--- a/matlab/identification_analysis.m
+++ b/matlab/identification_analysis.m
@@ -9,14 +9,14 @@ function [ide_hess, ide_moments, ide_model, ide_lre, derivatives_info, info, opt
 %    o options_ident      [structure] identification options
 %    o dataset_           [structure] the dataset after required transformation
 %    o dataset_info       [structure] Various informations about the dataset (descriptive statistics and missing observations) info for Kalman Filter
-%    o prior_exist        [integer] 
+%    o prior_exist        [integer]
 %                           =1 when prior exists and indentification is checked only for estimated params and shocks
 %                           =0 when prior is not defined and indentification is checked for all params and shocks
 %    o name_tex           [char] list of tex names
 %    o init               [integer] flag  for initialization of persistent vars
 %    o tittxt             [string]  string indicating the title text for
 %                                   graphs and figures
-%    
+%
 % OUTPUTS
 %    o ide_hess           [structure] identification results using Asymptotic Hessian
 %    o ide_moments        [structure] identification results using theoretical moments
@@ -24,11 +24,11 @@ function [ide_hess, ide_moments, ide_model, ide_lre, derivatives_info, info, opt
 %    o ide_lre            [structure] identification results using LRE model
 %    o derivatives_info   [structure] info about analytic derivs
 %    o info               output from dynare resolve
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 
-% Copyright (C) 2008-2016 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,7 +42,7 @@ function [ide_hess, ide_moments, ide_model, ide_lre, derivatives_info, info, opt
 % 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 
+% You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 global oo_ M_ options_ bayestopt_ estim_params_
@@ -51,7 +51,7 @@ persistent indH indJJ indLRE
 nparam=length(params);
 np=length(indx);
 offset=nparam-np;
-if ~isempty(estim_params_),
+if ~isempty(estim_params_)
     M_ = set_all_parameters(params,estim_params_,M_);
 end
 
@@ -63,7 +63,7 @@ periods = options_ident.periods;
 max_dim_cova_group = options_ident.max_dim_cova_group;
 normalize_jacobians = options_ident.normalize_jacobians;
 kron_flag = options_ident.analytic_derivation_mode;
-    
+
 [I,J]=find(M_.lead_lag_incidence');
 
 ide_hess = struct();
@@ -73,29 +73,29 @@ ide_lre = struct();
 derivatives_info = struct();
 
 [A,B,ys,info,M_,options_,oo_] = dynare_resolve(M_,options_,oo_);
-if info(1)==0,
+if info(1)==0
     oo0=oo_;
     tau=[oo_.dr.ys(oo_.dr.order_var); vec(A); dyn_vech(B*M_.Sigma_e*B')];
     yy0=oo_.dr.ys(I);
     [residual, g1 ] = feval([M_.fname,'_dynamic'],yy0, ...
-        repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1]), M_.params, ...
-        oo_.dr.ys, 1);
+                            repmat(oo_.exo_steady_state',[M_.maximum_exo_lag+M_.maximum_exo_lead+1]), M_.params, ...
+                            oo_.dr.ys, 1);
     vg1 = [oo_.dr.ys(oo_.dr.order_var); vec(g1)];
 
     [JJ, H, gam, gp, dA, dOm, dYss] = getJJ(A, B, estim_params_, M_,oo0,options_,kron_flag,indx,indexo,bayestopt_.mf2,nlags,useautocorr);
     derivatives_info.DT=dA;
     derivatives_info.DOm=dOm;
     derivatives_info.DYss=dYss;
-    if init,
+    if init
         indJJ = (find(max(abs(JJ'),[],1)>1.e-8));
         if isempty(indJJ) && any(any(isnan(JJ)))
             error('There are NaN in the JJ matrix. Please check whether your model has units roots and you forgot to set diffuse_filter=1.' )
         elseif any(any(isnan(gam)))
             error('There are NaN''s in the theoretical moments: make sure that for non-stationary models stationary transformations of non-stationary observables are used for checking identification. [TIP: use first differences].')
         end
-        while length(indJJ)<nparam && nlags<10,
+        while length(indJJ)<nparam && nlags<10
             disp('The number of moments with non-zero derivative is smaller than the number of parameters')
-            disp(['Try increasing ar = ', int2str(nlags+1)])           
+            disp(['Try increasing ar = ', int2str(nlags+1)])
             nlags=nlags+1;
             [JJ, H, gam, gp, dA, dOm, dYss] = getJJ(A, B, estim_params_, M_,oo0,options_,kron_flag,indx,indexo,bayestopt_.mf2,nlags,useautocorr);
             derivatives_info.DT=dA;
@@ -104,10 +104,10 @@ if info(1)==0,
             options_.ar=nlags;
             indJJ = (find(max(abs(JJ'),[],1)>1.e-8));
         end
-        if length(indJJ)<nparam,
+        if length(indJJ)<nparam
             disp('The number of moments with non-zero derivative is smaller than the number of parameters')
-            disp('up to 10 lags: check your model')           
-            disp('Either further increase ar or reduce the list of estimated parameters')           
+            disp('up to 10 lags: check your model')
+            disp('Either further increase ar or reduce the list of estimated parameters')
             error('identification_analysis: there are not enough moments and too many parameters'),
         end
         indH = (find(max(abs(H'),[],1)>1.e-8));
@@ -117,58 +117,58 @@ if info(1)==0,
     LRE(:,1)=vg1(indLRE);
     GAM(:,1)=gam(indJJ);
     siJ = (JJ(indJJ,:));
-    siH = (H(indH,:));   
+    siH = (H(indH,:));
     siLRE = (gp(indLRE,:));
     ide_strength_J=NaN(1,nparam);
     ide_strength_J_prior=NaN(1,nparam);
-    if init, %~isempty(indok),
+    if init
         normaliz = NaN(1,nparam);
-        if prior_exist,
-            if ~isempty(estim_params_.var_exo),
+        if prior_exist
+            if ~isempty(estim_params_.var_exo)
                 normaliz1 = estim_params_.var_exo(:,7)'; % normalize with prior standard deviation
             else
                 normaliz1=[];
             end
-            if ~isempty(estim_params_.corrx),
+            if ~isempty(estim_params_.corrx)
                 normaliz1 = [normaliz1 estim_params_.corrx(:,8)']; % normalize with prior standard deviation
             end
-            if ~isempty(estim_params_.param_vals),
+            if ~isempty(estim_params_.param_vals)
                 normaliz1 = [normaliz1 estim_params_.param_vals(:,7)']; % normalize with prior standard deviation
             end
             %                         normaliz = max([normaliz; normaliz1]);
             normaliz1(isinf(normaliz1)) = 1;
-            
+
         else
             normaliz1 = NaN(1,nparam);
         end
-        try,
+        try
             options_.irf = 0;
             options_.noprint = 1;
             options_.order = 1;
             options_.SpectralDensity.trigger = 0;
             options_.periods = periods+100;
-            if options_.kalman_algo > 2,
+            if options_.kalman_algo > 2
                 options_.kalman_algo = 1;
             end
             analytic_derivation = options_.analytic_derivation;
             options_.analytic_derivation = -2;
             info = stoch_simul(char(options_.varobs));
-            dataset_ = dseries(oo_.endo_simul(options_.varobs_id,100+1:end)',dates('1Q1'), options_.varobs);            
+            dataset_ = dseries(oo_.endo_simul(options_.varobs_id,100+1:end)',dates('1Q1'), options_.varobs);
             derivatives_info.no_DLIK=1;
             %bounds = prior_bounds(bayestopt_, options_.prior_trunc);
-            [fval,info,cost_flag,DLIK,AHess,ys,trend_coeff,M_,options_,bayestopt_,oo_] = dsge_likelihood(params',dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_,derivatives_info);             
-%                 fval = DsgeLikelihood(xparam1,data_info,options_,M_,estim_params_,bayestopt_,oo_);
+            [fval,info,cost_flag,DLIK,AHess,ys,trend_coeff,M_,options_,bayestopt_,oo_] = dsge_likelihood(params',dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,bounds,oo_,derivatives_info);
+            %                 fval = DsgeLikelihood(xparam1,data_info,options_,M_,estim_params_,bayestopt_,oo_);
             options_.analytic_derivation = analytic_derivation;
             AHess=-AHess;
-            if min(eig(AHess))<-1.e-10,
+            if min(eig(AHess))<-1.e-10
                 error('identification_analysis: Analytic Hessian is not positive semi-definite!')
             end
-%             chol(AHess);
+            %             chol(AHess);
             ide_hess.AHess= AHess;
             deltaM = sqrt(diag(AHess));
             iflag=any((deltaM.*deltaM)==0);
             tildaM = AHess./((deltaM)*(deltaM'));
-            if iflag || rank(AHess)>rank(tildaM),
+            if iflag || rank(AHess)>rank(tildaM)
                 [ide_hess.cond, ide_hess.ind0, ide_hess.indno, ide_hess.ino, ide_hess.Mco, ide_hess.Pco] = identification_checks(AHess, 1);
             else
                 [ide_hess.cond, ide_hess.ind0, ide_hess.indno, ide_hess.ino, ide_hess.Mco, ide_hess.Pco] = identification_checks(tildaM, 1);
@@ -181,23 +181,23 @@ if info(1)==0,
             cmm = siJ(:,ind1)*((AHess(ind1,ind1))\siJ(:,ind1)');
             temp1=((AHess(ind1,ind1))\siH(:,ind1)');
             diag_chh=sum(siH(:,ind1)'.*temp1)';
-%             chh = siH(:,ind1)*((AHess(ind1,ind1))\siH(:,ind1)');
+            %             chh = siH(:,ind1)*((AHess(ind1,ind1))\siH(:,ind1)');
             ind1=ind1(ind1>offset);
             clre = siLRE(:,ind1-offset)*((AHess(ind1,ind1))\siLRE(:,ind1-offset)');
             rhoM=sqrt(1./diag(inv(tildaM(indok,indok))));
-%             deltaM = deltaM.*abs(params');
+            %             deltaM = deltaM.*abs(params');
             flag_score=1;
-        catch,
-%             replic = max([replic, nparam*(nparam+1)/2*10]);
+        catch
+            %             replic = max([replic, nparam*(nparam+1)/2*10]);
             replic = max([replic, length(indJJ)*3]);
             cmm = simulated_moment_uncertainty(indJJ, periods, replic,options_,M_,oo_);
-%             [V,D,W]=eig(cmm);
+            %             [V,D,W]=eig(cmm);
             sd=sqrt(diag(cmm));
             cc=cmm./(sd*sd');
             if isoctave || matlab_ver_less_than('8.3')
                 [V,D]=eig(cc);
                 %fix for older Matlab versions that do not support computing left eigenvalues, see http://mathworks.com/help/releases/R2012b/matlab/ref/eig.html
-                [W,junk] = eig(cc.'); 
+                [W,junk] = eig(cc.');
                 W = conj(W);
             else
                 [V,D,W]=eig(cc);
@@ -206,40 +206,40 @@ if info(1)==0,
             siTMP=siJ./repmat(sd,[1 nparam]);
             MIM=(siTMP'*V(:,id))*(D(id,id)\(W(:,id)'*siTMP));
             clear siTMP;
-%           MIM=siJ(:,indok)'*(cmm\siJ(:,indok));
-%           look for independent moments!
-% % %             sd=sqrt(diag(cmm));
-% % %             cc=cmm./(sd*sd');
-% % %             ix=[];
-% % %             for jc=1:length(cmm),
-% % %                 jcheck=find(abs(cc(:,jc))>(1-1.e-6));
-% % %                 ix=[ix; jcheck(jcheck>jc)];
-% % %             end
-% % %             iy=find(~ismember([1:length(cmm)],ix));
-% % %             indJJ=indJJ(iy);
-% % %             GAM=GAM(iy);
-% % %             cmm=cmm(iy,iy);
-% % %             siJ = (JJ(indJJ,:));
-% % %             MIM=siJ'*(cmm\siJ);
+            %           MIM=siJ(:,indok)'*(cmm\siJ(:,indok));
+            %           look for independent moments!
+            % % %             sd=sqrt(diag(cmm));
+            % % %             cc=cmm./(sd*sd');
+            % % %             ix=[];
+            % % %             for jc=1:length(cmm),
+            % % %                 jcheck=find(abs(cc(:,jc))>(1-1.e-6));
+            % % %                 ix=[ix; jcheck(jcheck>jc)];
+            % % %             end
+            % % %             iy=find(~ismember([1:length(cmm)],ix));
+            % % %             indJJ=indJJ(iy);
+            % % %             GAM=GAM(iy);
+            % % %             cmm=cmm(iy,iy);
+            % % %             siJ = (JJ(indJJ,:));
+            % % %             MIM=siJ'*(cmm\siJ);
             ide_hess.AHess= MIM;
             deltaM = sqrt(diag(MIM));
             iflag=any((deltaM.*deltaM)==0);
             tildaM = MIM./((deltaM)*(deltaM'));
-            if iflag || rank(MIM)>rank(tildaM),
+            if iflag || rank(MIM)>rank(tildaM)
                 [ide_hess.cond, ide_hess.ind0, ide_hess.indno, ide_hess.ino, ide_hess.Mco, ide_hess.Pco] = identification_checks(MIM, 1);
             else
                 [ide_hess.cond, ide_hess.ind0, ide_hess.indno, ide_hess.ino, ide_hess.Mco, ide_hess.Pco] = identification_checks(tildaM, 1);
             end
             indok = find(max(ide_hess.indno,[],1)==0);
-%             rhoM=sqrt(1-1./diag(inv(tildaM)));
-%             rhoM=(1-1./diag(inv(tildaM)));
+            %             rhoM=sqrt(1-1./diag(inv(tildaM)));
+            %             rhoM=(1-1./diag(inv(tildaM)));
             ind1=find(ide_hess.ind0);
             temp1=((MIM(ind1,ind1))\siH(:,ind1)');
             diag_chh=sum(siH(:,ind1)'.*temp1)';
-%             chh = siH(:,ind1)*((MIM(ind1,ind1))\siH(:,ind1)');
+            %             chh = siH(:,ind1)*((MIM(ind1,ind1))\siH(:,ind1)');
             ind1=ind1(ind1>offset);
             clre = siLRE(:,ind1-offset)*((MIM(ind1,ind1))\siLRE(:,ind1-offset)');
-            if ~isempty(indok),
+            if ~isempty(indok)
                 rhoM(indok)=sqrt(1./diag(inv(tildaM(indok,indok))));
                 normaliz(indok) = (sqrt(diag(inv(tildaM(indok,indok))))./deltaM(indok))'; %sqrt(diag(inv(MIM(indok,indok))))';
             end
@@ -253,24 +253,24 @@ if info(1)==0,
         deltaM = deltaM.*abs(params');
         deltaM(params==0)=deltaM_prior(params==0);
         quant = siJ./repmat(sqrt(diag(cmm)),1,nparam);
-        if size(quant,1)==1,
+        if size(quant,1)==1
             siJnorm = abs(quant).*normaliz1;
         else
             siJnorm = vnorm(quant).*normaliz1;
         end
         %                 siJnorm = vnorm(siJ(inok,:)).*normaliz;
         quant=[];
-%         inok = find((abs(TAU)<1.e-8));
-%         isok = find((abs(TAU)>=1.e-8));
-%         quant(isok,:) = siH(isok,:)./repmat(TAU(isok,1),1,nparam);
-%         quant(inok,:) = siH(inok,:)./repmat(mean(abs(TAU)),length(inok),nparam);
-%         quant = siH./repmat(sqrt(diag(chh)),1,nparam);
+        %         inok = find((abs(TAU)<1.e-8));
+        %         isok = find((abs(TAU)>=1.e-8));
+        %         quant(isok,:) = siH(isok,:)./repmat(TAU(isok,1),1,nparam);
+        %         quant(inok,:) = siH(inok,:)./repmat(mean(abs(TAU)),length(inok),nparam);
+        %         quant = siH./repmat(sqrt(diag(chh)),1,nparam);
         iy = find(diag_chh);
         indH=indH(iy);
         siH=siH(iy,:);
-        if ~isempty(iy),
+        if ~isempty(iy)
             quant = siH./repmat(sqrt(diag_chh(iy)),1,nparam);
-            if size(quant,1)==1,
+            if size(quant,1)==1
                 siHnorm = abs(quant).*normaliz1;
             else
                 siHnorm = vnorm(quant).*normaliz1;
@@ -280,17 +280,17 @@ if info(1)==0,
         end
         %                 siHnorm = vnorm(siH./repmat(TAU,1,nparam)).*normaliz;
         quant=[];
-%         inok = find((abs(LRE)<1.e-8));
-%         isok = find((abs(LRE)>=1.e-8));
-%         quant(isok,:) = siLRE(isok,:)./repmat(LRE(isok,1),1,np);
-%         quant(inok,:) = siLRE(inok,:)./repmat(mean(abs(LRE)),length(inok),np);
+        %         inok = find((abs(LRE)<1.e-8));
+        %         isok = find((abs(LRE)>=1.e-8));
+        %         quant(isok,:) = siLRE(isok,:)./repmat(LRE(isok,1),1,np);
+        %         quant(inok,:) = siLRE(inok,:)./repmat(mean(abs(LRE)),length(inok),np);
         diag_clre = diag(clre);
         iy = find(diag_clre);
         indLRE=indLRE(iy);
         siLRE=siLRE(iy,:);
-        if ~isempty(iy),
+        if ~isempty(iy)
             quant = siLRE./repmat(sqrt(diag_clre(iy)),1,np);
-            if size(quant,1)==1,
+            if size(quant,1)==1
                 siLREnorm = abs(quant).*normaliz1(offset+1:end);
             else
                 siLREnorm = vnorm(quant).*normaliz1(offset+1:end);
@@ -299,16 +299,16 @@ if info(1)==0,
             siLREnorm=[];
         end
         %                 siLREnorm = vnorm(siLRE./repmat(LRE,1,nparam-offset)).*normaliz(offset+1:end);
-        ide_hess.ide_strength_J=ide_strength_J; 
-        ide_hess.ide_strength_J_prior=ide_strength_J_prior; 
-        ide_hess.deltaM=deltaM; 
-        ide_hess.deltaM_prior=deltaM_prior; 
-        ide_moments.siJnorm=siJnorm; 
-        ide_model.siHnorm=siHnorm; 
-        ide_lre.siLREnorm=siLREnorm; 
-        ide_hess.flag_score=flag_score; 
-    end,
-    if normalize_jacobians,
+        ide_hess.ide_strength_J=ide_strength_J;
+        ide_hess.ide_strength_J_prior=ide_strength_J_prior;
+        ide_hess.deltaM=deltaM;
+        ide_hess.deltaM_prior=deltaM_prior;
+        ide_moments.siJnorm=siJnorm;
+        ide_model.siHnorm=siHnorm;
+        ide_lre.siLREnorm=siLREnorm;
+        ide_hess.flag_score=flag_score;
+    end
+    if normalize_jacobians
         normH = max(abs(siH)')';
         normH = normH(:,ones(nparam,1));
         normJ = max(abs(siJ)')';
@@ -329,14 +329,14 @@ if info(1)==0,
     ide_moments.GAM=GAM;
     ide_model.TAU=TAU;
     ide_lre.LRE=LRE;
-%     [ide_checks.idemodel_Mco, ide_checks.idemoments_Mco, ide_checks.idelre_Mco, ...
-%         ide_checks.idemodel_Pco, ide_checks.idemoments_Pco, ide_checks.idelre_Pco, ...
-%         ide_checks.idemodel_cond, ide_checks.idemoments_cond, ide_checks.idelre_cond, ...
-%         ide_checks.idemodel_ee, ide_checks.idemoments_ee, ide_checks.idelre_ee, ...
-%         ide_checks.idemodel_ind, ide_checks.idemoments_ind, ...
-%         ide_checks.idemodel_indno, ide_checks.idemoments_indno, ...
-%         ide_checks.idemodel_ino, ide_checks.idemoments_ino] = ...
-%         identification_checks(H(indH,:)./normH(:,ones(nparam,1)),JJ(indJJ,:)./normJ(:,ones(nparam,1)), gp(indLRE,:)./normLRE(:,ones(size(gp,2),1)));
+    %     [ide_checks.idemodel_Mco, ide_checks.idemoments_Mco, ide_checks.idelre_Mco, ...
+    %         ide_checks.idemodel_Pco, ide_checks.idemoments_Pco, ide_checks.idelre_Pco, ...
+    %         ide_checks.idemodel_cond, ide_checks.idemoments_cond, ide_checks.idelre_cond, ...
+    %         ide_checks.idemodel_ee, ide_checks.idemoments_ee, ide_checks.idelre_ee, ...
+    %         ide_checks.idemodel_ind, ide_checks.idemoments_ind, ...
+    %         ide_checks.idemodel_indno, ide_checks.idemoments_indno, ...
+    %         ide_checks.idemodel_ino, ide_checks.idemoments_ino] = ...
+    %         identification_checks(H(indH,:)./normH(:,ones(nparam,1)),JJ(indJJ,:)./normJ(:,ones(nparam,1)), gp(indLRE,:)./normLRE(:,ones(size(gp,2),1)));
     [ide_moments.cond, ide_moments.ind0, ide_moments.indno, ide_moments.ino, ide_moments.Mco, ide_moments.Pco, ide_moments.jweak, ide_moments.jweak_pair] = ...
         identification_checks(JJ(indJJ,:)./normJ, 0);
     [ide_model.cond, ide_model.ind0, ide_model.indno, ide_model.ino, ide_model.Mco, ide_model.Pco, ide_model.jweak, ide_model.jweak_pair] = ...
@@ -354,9 +354,8 @@ if info(1)==0,
         ide_moments.S = S;
         ide_moments.V = V;
     end
-    
     indok = find(max(ide_moments.indno,[],1)==0);
-    if advanced,
+    if advanced
         [ide_moments.pars, ide_moments.cosnJ] = ident_bruteforce(JJ(indJJ,:)./normJ,max_dim_cova_group,options_.TeX,name_tex,tittxt);
     end
-end    
+end
diff --git a/matlab/identification_checks.m b/matlab/identification_checks.m
index 208d7ecd4..e52fa960d 100644
--- a/matlab/identification_checks.m
+++ b/matlab/identification_checks.m
@@ -7,21 +7,21 @@ function [condJ, ind0, indnoJ, ixnoJ, McoJ, PcoJ, jweak, jweak_pair] = identific
 %                                 derivatives of output w.r.t. parameters and shocks
 %    o JJ               [matrix] [nparams x nparams] IF hess_flag==1
 %                                 information matrix
-%    
+%
 % OUTPUTS
 %    o cond             condition number of JJ
 %    o ind0             [array] binary indicator for non-zero columns of H
-%    o indnoJ           [matrix] index of non-identified params 
+%    o indnoJ           [matrix] index of non-identified params
 %    o ixnoJ            number of rows in indnoJ
 %    o Mco              [array] multicollinearity coefficients
-%    o Pco              [matrix] pairwise correlations 
+%    o Pco              [matrix] pairwise correlations
 %    o jweak            [binary array] gives 1 if the  parameter has Mco=1(with tolerance 1.e-10)
 %    o jweak_pair       [binary matrix] gives 1 if a couple parameters has Pco=1(with tolerance 1.e-10)
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 
-% Copyright (C) 2008-2011 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -45,23 +45,23 @@ function [condJ, ind0, indnoJ, ixnoJ, McoJ, PcoJ, jweak, jweak_pair] = identific
 npar = size(JJ,2);
 indnoJ = zeros(1,npar);
 
-if size(JJ,1)>1,
+if size(JJ,1)>1
     ind1 = find(vnorm(JJ)>=eps); % take non-zero columns
 else
     ind1 = find(abs(JJ)>=eps); % take non-zero columns
-end    
+end
 JJ1 = JJ(:,ind1);
 [eu,ee2,ee1] = svd( JJ1, 0 );
 condJ= cond(JJ1);
 rankJ = rank(JJ);
 rankJJ = rankJ;
 icheck=0;
-if npar>0 && (rankJ<npar), 
+if npar>0 && (rankJ<npar)
     % search for singular values associated to ONE individual parameter
     ee0 = [rankJJ+1:length(ind1)];
     ind11=ones(length(ind1),1);
-    for j=1:length(ee0),
-        if length(find(abs(ee1(:,ee0(j))) > 1.e-3))==1,
+    for j=1:length(ee0)
+        if length(find(abs(ee1(:,ee0(j))) > 1.e-3))==1
             icheck=1;
             ind11 = ind11.*(abs(ee1(:,ee0(j))) <= 1.e-3); % take non-zero columns
         end
@@ -69,26 +69,26 @@ if npar>0 && (rankJ<npar),
     ind1 = ind1(find(ind11)); % take non-zero columns
 end
 
-if icheck,
-JJ1 = JJ(:,ind1);
-[eu,ee2,ee1] = svd( JJ1, 0 );
-condJ= cond(JJ1);
-rankJ = rank(JJ);
-rankJJ = rankJ;
-end    
-    
+if icheck
+    JJ1 = JJ(:,ind1);
+    [eu,ee2,ee1] = svd( JJ1, 0 );
+    condJ= cond(JJ1);
+    rankJ = rank(JJ);
+    rankJJ = rankJ;
+end
+
 
 % if hess_flag==0,
 %     rankJJ = rank(JJ'*JJ);
-% end   
+% end
 
 ind0 = zeros(1,npar);
 ind0(ind1) = 1;
 
-if hess_flag==0,
+if hess_flag==0
     % find near linear dependence problems:
     McoJ = NaN(npar,1);
-    for ii = 1:size(JJ1,2);
+    for ii = 1:size(JJ1,2)
         McoJ(ind1(ii),:) = cosn([JJ1(:,ii),JJ1(:,find([1:1:size(JJ1,2)]~=ii))]);
     end
 else
@@ -96,7 +96,7 @@ else
     tildaJ = JJ(ind1,ind1)./((deltaJ)*(deltaJ'));
     McoJ(ind1,1)=(1-1./diag(inv(tildaJ)));
     rhoM=sqrt(1-McoJ);
-%     PcoJ=inv(tildaJ);
+    %     PcoJ=inv(tildaJ);
     PcoJ=NaN(npar,npar);
     PcoJ(ind1,ind1)=inv(JJ(ind1,ind1));
     sd=sqrt(diag(PcoJ));
@@ -109,19 +109,17 @@ if npar>0 && (rankJ<npar || rankJJ<npar || min(1-McoJ)<1.e-10)
     %         - find out which parameters are involved
     %   disp('Some parameters are NOT identified by the moments included in J')
     %   disp(' ')
-    if length(ind1)<npar,
+    if length(ind1)<npar
         % parameters with zero column in JJ
         ixnoJ = ixnoJ + 1;
         indnoJ(ixnoJ,:) = (~ismember([1:npar],ind1));
     end
     ee0 = [rankJJ+1:length(ind1)];
-    for j=1:length(ee0),
+    for j=1:length(ee0)
         % linearely dependent parameters in JJ
         ixnoJ = ixnoJ + 1;
         indnoJ(ixnoJ,ind1) = (abs(ee1(:,ee0(j))) > 1.e-3)';
     end
-else  %rank(J)==length(theta) =>
-      %         disp('All parameters are identified at theta by the moments included in J')
 end
 
 % here there is no exact linear dependence, but there are several
@@ -132,27 +130,26 @@ jweak=zeros(1,npar);
 jweak_pair=zeros(npar,npar);
 
 if hess_flag==0,
-PcoJ = NaN(npar,npar);
+    PcoJ = NaN(npar,npar);
 
-for ii = 1:size(JJ1,2);
-    PcoJ(ind1(ii),ind1(ii)) = 1;
-    for jj = ii+1:size(JJ1,2);
-        PcoJ(ind1(ii),ind1(jj)) = cosn([JJ1(:,ii),JJ1(:,jj)]);
-        PcoJ(ind1(jj),ind1(ii)) = PcoJ(ind1(ii),ind1(jj));
+    for ii = 1:size(JJ1,2)
+        PcoJ(ind1(ii),ind1(ii)) = 1;
+        for jj = ii+1:size(JJ1,2)
+            PcoJ(ind1(ii),ind1(jj)) = cosn([JJ1(:,ii),JJ1(:,jj)]);
+            PcoJ(ind1(jj),ind1(ii)) = PcoJ(ind1(ii),ind1(jj));
+        end
     end
-end
 
-for j=1:npar,
-    if McoJ(j)>(1-1.e-10), 
-        jweak(j)=1;
-        [ipair, jpair] = find(PcoJ(j,j+1:end)>(1-1.e-10));
-        for jx=1:length(jpair),
-            jweak_pair(j, jpair(jx)+j)=1;
-            jweak_pair(jpair(jx)+j, j)=1;
+    for j=1:npar
+        if McoJ(j)>(1-1.e-10)
+            jweak(j)=1;
+            [ipair, jpair] = find(PcoJ(j,j+1:end)>(1-1.e-10));
+            for jx=1:length(jpair)
+                jweak_pair(j, jpair(jx)+j)=1;
+                jweak_pair(jpair(jx)+j, j)=1;
+            end
         end
     end
 end
-end
 
 jweak_pair=dyn_vech(jweak_pair)';
-
diff --git a/matlab/imcforecast.m b/matlab/imcforecast.m
index f40475e48..66841319a 100644
--- a/matlab/imcforecast.m
+++ b/matlab/imcforecast.m
@@ -2,31 +2,31 @@ function imcforecast(constrained_paths, constrained_vars, options_cond_fcst)
 % Computes conditional forecasts.
 %
 % INPUTS
-%  o constrained_paths    [double]      m*p array, where m is the number of constrained endogenous variables and p is the number of constrained periods. 
-%  o constrained_vars     [char]        m*x array holding the names of the controlled endogenous variables. 
+%  o constrained_paths    [double]      m*p array, where m is the number of constrained endogenous variables and p is the number of constrained periods.
+%  o constrained_vars     [char]        m*x array holding the names of the controlled endogenous variables.
 %  o options_cond_fcst    [structure]   containing the options. The fields are:
 %                                                             + replic              [integer]   scalar, number of monte carlo simulations.
 %                                                             + parameter_set       [char]      values of the estimated parameters:
-%                                                                                               "posterior_mode", 
-%                                                                                               "posterior_mean", 
-%                                                                                               "posterior_median", 
-%                                                                                               "prior_mode" or 
-%                                                                                               "prior mean". 
+%                                                                                               "posterior_mode",
+%                                                                                               "posterior_mean",
+%                                                                                               "posterior_median",
+%                                                                                               "prior_mode" or
+%                                                                                               "prior mean".
 %                                                                                   [double]     np*1 array, values of the estimated parameters.
 %                                                             + controlled_varexo   [char]       m*x array, list of controlled exogenous variables.
-%                                                             + conf_sig            [double]     scalar in [0,1], probability mass covered by the confidence bands. 
+%                                                             + conf_sig            [double]     scalar in [0,1], probability mass covered by the confidence bands.
 %
 % OUTPUTS
 %  None.
-% 
+%
 % SPECIAL REQUIREMENTS
 %  This routine has to be called after an estimation statement or an estimated_params block.
 %
 % REMARKS
 %  [1] Results are stored in a structure which is saved in a mat file called conditional_forecasts.mat.
-%  [2] Use the function plot_icforecast to plot the results. 
+%  [2] Use the function plot_icforecast to plot the results.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -119,7 +119,7 @@ if estimated_model
     data_index = dataset_info.missing.aindex;
     gend = dataset_.nobs;
     missing_value = dataset_info.missing.state;
-    
+
     %store qz_criterium
     qz_criterium_old=options_.qz_criterium;
     options_=select_qz_criterium_value(options_);
@@ -147,7 +147,7 @@ if estimated_model
     % add trend to constant
     for obs_iter=1:length(options_.varobs)
         j = strmatch(options_.varobs{obs_iter},M_.endo_names,'exact');
-        constant(j,:) = constant(j,:)+trend_addition(obs_iter,:);        
+        constant(j,:) = constant(j,:)+trend_addition(obs_iter,:);
     end
     trend = constant(oo_.dr.order_var,:);
     InitState(:,1) = atT(:,end);
@@ -162,8 +162,21 @@ else
     end
 end
 
+if options_.logged_steady_state %if steady state was previously logged, undo this
+    oo_.dr.ys=exp(oo_.dr.ys);
+    oo_.steady_state=exp(oo_.steady_state);
+    options_.logged_steady_state=0;
+end
+
 [T,R,ys,info,M_,options_,oo_] = dynare_resolve(M_,options_,oo_);
 
+if options_.loglinear && isfield(oo_.dr,'ys') && options_.logged_steady_state==0 %log steady state
+    oo_.dr.ys=log_variable(1:M_.endo_nbr,oo_.dr.ys,M_);
+    ys=oo_.dr.ys;
+    oo_.steady_state=log_variable(1:M_.endo_nbr,oo_.steady_state,M_);
+    options_.logged_steady_state=1; %set option for use in stoch_simul
+end
+
 if ~isdiagonal(M_.Sigma_e)
     warning(sprintf('The innovations are correlated (the covariance matrix has non zero off diagonal elements), the results of the conditional forecasts will\ndepend on the ordering of the innovations (as declared after varexo) because a Cholesky decomposition is used to factorize the covariance matrix.\n\n=> It is preferable to declare the correlations in the model block (explicitly imposing the identification restrictions), unless you are satisfied\nwith the implicit identification restrictions implied by the Cholesky decomposition.'))
     sQ = chol(M_.Sigma_e,'lower');
@@ -175,7 +188,14 @@ if ~estimated_model
     if isempty(M_.endo_histval)
         y0 = ys;
     else
-        y0 = M_.endo_histval;
+        if options_.loglinear
+            %make sure that only states are updated (controls have value of 0 in vector)
+            y0=zeros(size(ys));
+            y0_logged = log_variable(1:M_.endo_nbr,M_.endo_histval,M_);
+            y0(M_.endo_histval~=0)=y0_logged(M_.endo_histval~=0);
+        else
+            y0 = M_.endo_histval;
+        end
     end
     InitState(:,1) = y0(oo_.dr.order_var)-ys(oo_.dr.order_var,:); %initial state in deviations from steady state
     trend = repmat(ys(oo_.dr.order_var,:),1,options_cond_fcst.periods+1); %trend needs to contain correct steady state
@@ -205,7 +225,7 @@ jdx = [];
 
 for i = 1:n1
     idx = [idx ; constrained_vars(i,:)];
-%     idx = [idx ; oo_.dr.inv_order_var(constrained_vars(i,:))];
+    %     idx = [idx ; oo_.dr.inv_order_var(constrained_vars(i,:))];
     jdx = [jdx ; strmatch(deblank(options_cond_fcst.controlled_varexo(i,:)),M_.exo_names,'exact')];
 end
 mv = zeros(n1,NumberOfStates);
diff --git a/matlab/indnv.m b/matlab/indnv.m
index 1df707786..0cc88ab5b 100644
--- a/matlab/indnv.m
+++ b/matlab/indnv.m
@@ -13,7 +13,7 @@ function a=indnv(x,y)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,6 +40,3 @@ for i = 1:size(x,1)
         a(i) = j;
     end
 end
-
-
-
diff --git a/matlab/init_plan.m b/matlab/init_plan.m
index 0e9957f48..c82433be3 100644
--- a/matlab/init_plan.m
+++ b/matlab/init_plan.m
@@ -1,4 +1,4 @@
-function plan = init_plan(date) 
+function plan = init_plan(date)
 % Creates and initializes a new forecast scenario
 %
 % INPUTS
@@ -9,7 +9,7 @@ function plan = init_plan(date)
 %  plan                   [structure]       Returns a structure containing a new forecast scenario
 %
 %
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -25,28 +25,27 @@ function plan = init_plan(date)
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
- global M_
-  plan = struct();
-  plan.date = date;
-  plan.date_str = strings(date);
-  endo_names_length = size(M_.endo_names,2);
-  plan.endo_names = deblank(mat2cell(M_.endo_names(1:M_.orig_endo_nbr,:),ones(1,M_.orig_endo_nbr),endo_names_length));
-  exo_names_length = size(M_.exo_names,2);
-  plan.exo_names = deblank(mat2cell(M_.exo_names(1:M_.exo_nbr,:),ones(1,M_.exo_nbr),exo_names_length));
-  plan.constrained_vars_ = [];
-  plan.constrained_paths_ = [];
-  plan.constrained_date_ = [];
-  plan.constrained_int_date_ = []; 
-  plan.constrained_str_date_ = [];
-  plan.constrained_perfect_foresight_ = [];
-  plan.shock_vars_ = [];
-  plan.shock_paths_ = [];
-  plan.shock_date_ = [];
-  plan.shock_int_date_ = []; 
-  plan.shock_str_date_ = [];
-  plan.shock_perfect_foresight_ = [];
-  plan.options_cond_fcst_ = struct();
-  plan.options_cond_fcst_.parameter_set = 'calibration';
-  plan.options_cond_fcst_.simulation_type = 'deterministic';
-  plan.options_cond_fcst_.controlled_varexo = [];
-  
+global M_
+plan = struct();
+plan.date = date;
+plan.date_str = strings(date);
+endo_names_length = size(M_.endo_names,2);
+plan.endo_names = deblank(mat2cell(M_.endo_names(1:M_.orig_endo_nbr,:),ones(1,M_.orig_endo_nbr),endo_names_length));
+exo_names_length = size(M_.exo_names,2);
+plan.exo_names = deblank(mat2cell(M_.exo_names(1:M_.exo_nbr,:),ones(1,M_.exo_nbr),exo_names_length));
+plan.constrained_vars_ = [];
+plan.constrained_paths_ = [];
+plan.constrained_date_ = [];
+plan.constrained_int_date_ = [];
+plan.constrained_str_date_ = [];
+plan.constrained_perfect_foresight_ = [];
+plan.shock_vars_ = [];
+plan.shock_paths_ = [];
+plan.shock_date_ = [];
+plan.shock_int_date_ = [];
+plan.shock_str_date_ = [];
+plan.shock_perfect_foresight_ = [];
+plan.options_cond_fcst_ = struct();
+plan.options_cond_fcst_.parameter_set = 'calibration';
+plan.options_cond_fcst_.simulation_type = 'deterministic';
+plan.options_cond_fcst_.controlled_varexo = [];
diff --git a/matlab/initial_condition_decomposition.m b/matlab/initial_condition_decomposition.m
new file mode 100644
index 000000000..cee5335a8
--- /dev/null
+++ b/matlab/initial_condition_decomposition.m
@@ -0,0 +1,132 @@
+function oo_ = initial_condition_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_params_)
+% function oo_ = initial_condition_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_params_)
+% Computes initial condition contribution to a simulated trajectory. The field set is
+% oo_.initval_decomposition. It is a n_var by n_var+2 by nperiods array. The
+% first n_var columns store the respective endogenous initval contribution, column n+1
+% stores the role of the shocks, while column n+2 stores the
+% value of the smoothed variables.  Variables are stored
+% in the order of declaration, i.e. M_.endo_names.
+%
+% INPUTS
+%    M_:          [structure]  Definition of the model
+%    oo_:         [structure]  Storage of results
+%    options_:    [structure]  Options
+%    varlist:     [char]       List of variables
+%    bayestopt_:  [structure]  describing the priors
+%    estim_params_: [structure] characterizing parameters to be estimated
+%
+% OUTPUTS
+%    oo_:         [structure]  Storage of results
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2017 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/>.
+
+options_.plot_shock_decomp.detail_plot = options_.initial_condition_decomp.detail_plot;
+options_.plot_shock_decomp.steadystate = options_.initial_condition_decomp.steadystate;
+options_.plot_shock_decomp.write_xls = options_.initial_condition_decomp.write_xls;
+options_.plot_shock_decomp.type = options_.initial_condition_decomp.type;
+options_.plot_shock_decomp.plot_init_date = options_.initial_condition_decomp.plot_init_date;
+options_.plot_shock_decomp.plot_end_date = options_.initial_condition_decomp.plot_end_date;
+
+% indices of endogenous variables
+if size(varlist,1) == 0
+    varlist = M_.endo_names(1:M_.orig_endo_nbr,:);
+end
+
+[i_var,nvar,index_uniques] = varlist_indices(varlist,M_.endo_names);
+varlist=varlist(index_uniques,:);
+
+% number of variables
+endo_nbr = M_.endo_nbr;
+
+% parameter set
+parameter_set = options_.parameter_set;
+if isempty(parameter_set)
+    if isfield(oo_,'posterior_mean')
+        parameter_set = 'posterior_mean';
+    elseif isfield(oo_,'mle_mode')
+        parameter_set = 'mle_mode';
+    elseif isfield(oo_,'posterior')
+        parameter_set = 'posterior_mode';
+    else
+        error(['shock_decomposition: option parameter_set is not specified ' ...
+               'and posterior mode is not available'])
+    end
+end
+
+if ~isfield(oo_,'initval_decomposition')
+    options_.selected_variables_only = 0; %make sure all variables are stored
+    options_.plot_priors=0;
+    [oo,junk1,junk2,Smoothed_Variables_deviation_from_mean] = evaluate_smoother(parameter_set,varlist,M_,oo_,options_,bayestopt_,estim_params_);
+
+    % reduced form
+    dr = oo.dr;
+
+    % data reordering
+    order_var = dr.order_var;
+    inv_order_var = dr.inv_order_var;
+
+
+    % coefficients
+    A = dr.ghx;
+    B = dr.ghu;
+
+    % initialization
+    gend = size(oo.SmoothedShocks.(deblank(M_.exo_names(1,:))),1); %+options_.forecast;
+    z = zeros(endo_nbr,endo_nbr+2,gend);
+    z(:,end,:) = Smoothed_Variables_deviation_from_mean;
+
+    for i=1:endo_nbr
+        z(i,i,1) = Smoothed_Variables_deviation_from_mean(i,1);
+    end
+
+    maximum_lag = M_.maximum_lag;
+
+    k2 = dr.kstate(find(dr.kstate(:,2) <= maximum_lag+1),[1 2]);
+    i_state = order_var(k2(:,1))+(min(i,maximum_lag)+1-k2(:,2))*M_.endo_nbr;
+    for i=1:gend
+        if i > 1 && i <= maximum_lag+1
+            lags = min(i-1,maximum_lag):-1:1;
+        end
+
+        if i > 1
+            tempx = permute(z(:,1:endo_nbr,lags),[1 3 2]);
+            m = min(i-1,maximum_lag);
+            tempx = [reshape(tempx,endo_nbr*m,endo_nbr); zeros(endo_nbr*(maximum_lag-i+1),endo_nbr)];
+            z(:,1:endo_nbr,i) = A(inv_order_var,:)*tempx(i_state,:);
+            lags = lags+1;
+        end
+        z(:,endo_nbr+1,i) = z(:,endo_nbr+2,i) - sum(z(:,1:endo_nbr,i),2);
+
+    end
+
+
+    oo_.initval_decomposition = z;
+end
+% if ~options_.no_graph.shock_decomposition
+oo=oo_;
+oo.shock_decomposition = oo_.initval_decomposition;
+M_.exo_names = M_.endo_names;
+M_.exo_nbr = M_.endo_nbr;
+options_.plot_shock_decomp.screen_shocks=1;
+options_.plot_shock_decomp.use_shock_groups = '';
+options_.plot_shock_decomp.fig_names='initval';
+plot_shock_decomposition(M_,oo,options_,varlist);
+% end
\ No newline at end of file
diff --git a/matlab/initial_estimation_checks.m b/matlab/initial_estimation_checks.m
index 03f0eac05..7dfc4d9a2 100644
--- a/matlab/initial_estimation_checks.m
+++ b/matlab/initial_estimation_checks.m
@@ -20,7 +20,7 @@ function DynareResults = initial_estimation_checks(objective_function,xparam1,Dy
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,7 +54,7 @@ if maximum_number_non_missing_observations>length(find(diag(Model.Sigma_e)))+Est
 end
 
 if (any(BayesInfo.pshape  >0 ) && DynareOptions.mh_replic) && DynareOptions.mh_nblck<1
-    error(['initial_estimation_checks:: Bayesian estimation cannot be conducted with mh_nblocks=0.'])    
+    error(['initial_estimation_checks:: Bayesian estimation cannot be conducted with mh_nblocks=0.'])
 end
 
 old_steady_params=Model.params; %save initial parameters for check if steady state changes param values
@@ -69,35 +69,35 @@ if isfield(EstimatedParameters,'param_vals') && ~isempty(EstimatedParameters.par
     [junk, new_steady_params_2] = evaluate_steady_state(DynareResults.steady_state,Model_par_varied,DynareOptions,DynareResults,DynareOptions.diffuse_filter==0);
 
     changed_par_indices=find((old_steady_params(EstimatedParameters.param_vals(:,1))-new_steady_params(EstimatedParameters.param_vals(:,1))) ...
-            | (Model_par_varied.params(EstimatedParameters.param_vals(:,1))-new_steady_params_2(EstimatedParameters.param_vals(:,1))));
+                             | (Model_par_varied.params(EstimatedParameters.param_vals(:,1))-new_steady_params_2(EstimatedParameters.param_vals(:,1))));
 
     if ~isempty(changed_par_indices)
         fprintf('\nThe steady state file internally changed the values of the following estimated parameters:\n')
         disp(Model.param_names(EstimatedParameters.param_vals(changed_par_indices,1),:));
         fprintf('This will override the parameter values drawn from the proposal density and may lead to wrong results.\n')
-        fprintf('Check whether this is really intended.\n')    
+        fprintf('Check whether this is really intended.\n')
         warning('The steady state file internally changes the values of the estimated parameters.')
     end
 end
 
 if any(BayesInfo.pshape) % if Bayesian estimation
     nvx=EstimatedParameters.nvx;
-    if nvx && any(BayesInfo.p3(1:nvx)<0) 
+    if nvx && any(BayesInfo.p3(1:nvx)<0)
         warning('Your prior allows for negative standard deviations for structural shocks. Due to working with variances, Dynare will be able to continue, but it is recommended to change your prior.')
     end
     offset=nvx;
     nvn=EstimatedParameters.nvn;
-    if nvn && any(BayesInfo.p3(1+offset:offset+nvn)<0) 
+    if nvn && any(BayesInfo.p3(1+offset:offset+nvn)<0)
         warning('Your prior allows for negative standard deviations for measurement error. Due to working with variances, Dynare will be able to continue, but it is recommended to change your prior.')
     end
     offset = nvx+nvn;
-    ncx=EstimatedParameters.ncx; 
-    if ncx && (any(BayesInfo.p3(1+offset:offset+ncx)<-1) || any(BayesInfo.p4(1+offset:offset+ncx)>1)) 
+    ncx=EstimatedParameters.ncx;
+    if ncx && (any(BayesInfo.p3(1+offset:offset+ncx)<-1) || any(BayesInfo.p4(1+offset:offset+ncx)>1))
         warning('Your prior allows for correlations between structural shocks larger than +-1 and will not integrate to 1 due to truncation. Please change your prior')
     end
     offset = nvx+nvn+ncx;
-    ncn=EstimatedParameters.ncn; 
-    if ncn && (any(BayesInfo.p3(1+offset:offset+ncn)<-1) || any(BayesInfo.p4(1+offset:offset+ncn)>1)) 
+    ncn=EstimatedParameters.ncn;
+    if ncn && (any(BayesInfo.p3(1+offset:offset+ncn)<-1) || any(BayesInfo.p4(1+offset:offset+ncn)>1))
         warning('Your prior allows for correlations between measurement errors larger than +-1 and will not integrate to 1 due to truncation. Please change your prior')
     end
 end
@@ -142,9 +142,9 @@ if ~isequal(DynareOptions.mode_compute,11) || ...
         fprintf('initial_estimation_checks:: If you think the latter is the case, you should try with different initial values for the estimated parameters.\n')
         error('initial_estimation_checks:: The forecast error variance in the multivariate Kalman filter became singular.')
     end
-    %reset options 
+    %reset options
     DynareOptions.use_univariate_filters_if_singularity_is_detected=use_univariate_filters_if_singularity_is_detected_old;
-else 
+else
     info=0;
     fval = 0;
 end
@@ -165,8 +165,15 @@ elseif imag(fval)
 end
 
 if info(1) > 0
-    disp('Error in computing likelihood for initial parameter values')
-    print_info(info, DynareOptions.noprint, DynareOptions)
+    if DynareOptions.order>1
+        [eigenvalues_] = check(Model,DynareOptions, DynareResults);
+        if any(abs(1-abs(eigenvalues_))<abs(DynareOptions.qz_criterium-1))
+            error('Your model has at least one unit root and you are using a nonlinear filter. Please set nonlinear_filter_initialization=3.')
+        end
+    else
+        disp('Error in computing likelihood for initial parameter values')
+        print_info(info, DynareOptions.noprint, DynareOptions)
+    end
 end
 
 if DynareOptions.prefilter==1
diff --git a/matlab/initialize_from_mode.m b/matlab/initialize_from_mode.m
index d7c11a9d0..4521ec255 100644
--- a/matlab/initialize_from_mode.m
+++ b/matlab/initialize_from_mode.m
@@ -1,20 +1,20 @@
 function estim_params_ = initialize_from_mode(fname,M_,estim_params_)
 % function estim_params_ = initialize_from_mode(fname,M_,estim_params_)
 % initialize parameters and initial value of estimated parameters
-% from a *_mode.mat file    
-%  
+% from a *_mode.mat file
+%
 % INPUTS
 %   fname:  mode file name (*.mat file)
 %   M_:     sructure of model characteristics
 %   estim_params_: structure of estimated parameters
-%  
+%
 % OUTPUTS
 %   estim_params:  modified structure of estimated parameters
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2003-2011 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -99,4 +99,3 @@ for i=1:length(parameter_names)
     end
     error([name 'doesn''t exist in this model'])
 end
-
diff --git a/matlab/initvalf.m b/matlab/initvalf.m
index 0493a2b48..afffede43 100644
--- a/matlab/initvalf.m
+++ b/matlab/initvalf.m
@@ -1,7 +1,7 @@
 function initvalf(fname_)
 % function initvalf(fname_)
 %
-% Reads an initial path from the 'fname_' file for exogenous and endogenous variables   
+% Reads an initial path from the 'fname_' file for exogenous and endogenous variables
 %
 % INPUTS
 %    fname_:         name of the function or file containing the data
@@ -13,7 +13,7 @@ function initvalf(fname_)
 %    All variables local to this function have an underscore appended to
 %    their name, to minimize clashes with model variables loaded by this function.
 
-% Copyright (C) 2003-2012 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,15 +58,15 @@ if ~exist(fullname)
 end
 
 switch (extension)
-    case '.m'
-        eval(basename);
-    case '.mat'
-        load(basename);
-    case { '.xls', '.xlsx' }
-        [data_,names_v_]=xlsread(fullname); % Octave needs the extension explicitly
-        series_=0;
-    otherwise
-        error(['Unsupported extension for datafile: ' extension])
+  case '.m'
+    eval(basename);
+  case '.mat'
+    load(basename);
+  case { '.xls', '.xlsx' }
+    [data_,names_v_]=xlsread(fullname); % Octave needs the extension explicitly
+    series_=0;
+  otherwise
+    error(['Unsupported extension for datafile: ' extension])
 end
 
 options_.initval_file = 1;
@@ -79,7 +79,7 @@ for i_=1:size(M_.endo_names,1)
         if size(x_,2)>size(x_,1) %oo_.endo_simul must be collection of row vectors
             oo_.endo_simul = [oo_.endo_simul; x_];
         else %transpose if column vector
-            oo_.endo_simul = [oo_.endo_simul; x_'];            
+            oo_.endo_simul = [oo_.endo_simul; x_'];
         end
     else
         k_ = strmatch(deblank(M_.endo_names(i_,:)),names_v_,'exact');
@@ -87,7 +87,7 @@ for i_=1:size(M_.endo_names,1)
             error(['INITVAL_FILE: ' deblank(M_.endo_names(i_,:)) ' not found'])
         end
         x_ = data_(:,k_);
-        oo_.endo_simul = [oo_.endo_simul; x_'];            
+        oo_.endo_simul = [oo_.endo_simul; x_'];
     end
 end
 
@@ -97,7 +97,7 @@ for i_=1:size(M_.exo_names,1)
         if size(x_,2)>size(x_,1) %oo_.endo_simul must be collection of row vectors
             oo_.exo_simul = [oo_.exo_simul x_'];
         else %if column vector
-            oo_.exo_simul = [oo_.exo_simul x_];            
+            oo_.exo_simul = [oo_.exo_simul x_];
         end
     else
         k_ = strmatch(deblank(M_.exo_names(i_,:)),names_v_,'exact');
@@ -105,6 +105,6 @@ for i_=1:size(M_.exo_names,1)
             error(['INITVAL_FILE: ' deblank(M_.exo_names(i_,:)) ' not found'])
         end
         x_ = data_(:,k_);
-        oo_.exo_simul = [oo_.exo_simul x_];            
+        oo_.exo_simul = [oo_.exo_simul x_];
     end
 end
\ No newline at end of file
diff --git a/matlab/internals.m b/matlab/internals.m
index 4fc079ec2..a7b96a81f 100644
--- a/matlab/internals.m
+++ b/matlab/internals.m
@@ -56,7 +56,7 @@ function internals(flag, varargin)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/interpret_resol_info.m b/matlab/interpret_resol_info.m
index de16d47e0..45b3993ff 100644
--- a/matlab/interpret_resol_info.m
+++ b/matlab/interpret_resol_info.m
@@ -1,15 +1,15 @@
 function message = interpret_resol_info(info)
-    
+
 % Returns a message describing problem encountered during the resolution of
 % a model.
 %
-% INPUTS 
+% INPUTS
 % - info       [struct]  Second output argument return by the resol routine
 %
-% OUTPUTS 
+% OUTPUTS
 % - message    [string]  Description of the issue preventing model's resolution.
- 
-% Copyright (C) 2001-2016 Dynare Team
+
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/irf.m b/matlab/irf.m
index f4be40503..2355392d7 100644
--- a/matlab/irf.m
+++ b/matlab/irf.m
@@ -2,7 +2,7 @@ function y = irf(dr, e1, long, drop, replic, iorder)
 
 % function y = irf(dr, e1, long, drop, replic, iorder)
 % Computes impulse response functions
-% 
+%
 % INPUTS
 %    dr:     structure of decisions rules for stochastic simulations
 %    e1:     exogenous variables value in time 1 after one shock
@@ -13,11 +13,11 @@ function y = irf(dr, e1, long, drop, replic, iorder)
 %
 % OUTPUTS
 %    y:      impulse response matrix
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2010 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,11 +44,16 @@ else
 end
 y       = 0;
 
-if iorder == 1
+local_order = iorder;
+if M_.hessian_eq_zero && local_order~=1
+    local_order = 1;
+end
+
+if local_order == 1
     y1 = repmat(dr.ys,1,long);
     ex2 = zeros(long,M_.exo_nbr);
     ex2(1,:) = e1';
-    y2 = simult_(temps,dr,ex2,iorder);
+    y2 = simult_(temps,dr,ex2,local_order);
     y = y2(:,M_.maximum_lag+1:end)-y1;
 else
     % eliminate shocks with 0 variance
@@ -60,9 +65,9 @@ else
     for j = 1: replic
         ex1(:,i_exo_var) = randn(long+drop,nxs)*chol_S;
         ex2 = ex1;
-        ex2(drop+1,:) = ex2(drop+1,:)+e1';   
-        y1 = simult_(temps,dr,ex1,iorder);
-        y2 = simult_(temps,dr,ex2,iorder);
+        ex2(drop+1,:) = ex2(drop+1,:)+e1';
+        y1 = simult_(temps,dr,ex1,local_order);
+        y2 = simult_(temps,dr,ex2,local_order);
         y = y+(y2(:,M_.maximum_lag+drop+1:end)-y1(:,M_.maximum_lag+drop+1:end));
     end
     y=y/replic;
diff --git a/matlab/isoctave.m b/matlab/isoctave.m
index 15c6fb38d..22941ce9e 100644
--- a/matlab/isoctave.m
+++ b/matlab/isoctave.m
@@ -1,6 +1,6 @@
 function A = isoctave()
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2016 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/isolder.m b/matlab/isolder.m
index 091455ad0..d364c5c62 100644
--- a/matlab/isolder.m
+++ b/matlab/isolder.m
@@ -2,14 +2,14 @@ function b = isolder(f, F) % --*-- Unitary tests --*--
 
 % Returns true if f is older than any file in folder (and subfolders) F.
 %
-% INPUTS 
+% INPUTS
 % - f   [string]  file name
 % - F   [string]  folder name
 %
-% OUTPUT 
-% - b   [logical] 
+% OUTPUT
+% - b   [logical]
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,9 +29,9 @@ function b = isolder(f, F) % --*-- Unitary tests --*--
 if nargin<2 || isempty(F)
     F = pwd();
 end
- 
+
 b = true;
-    
+
 files = dir(F);
 tfile = dir(f);
 tdate = tfile.datenum;
diff --git a/matlab/k_order_pert.m b/matlab/k_order_pert.m
index db1ef91f4..05c56eb37 100644
--- a/matlab/k_order_pert.m
+++ b/matlab/k_order_pert.m
@@ -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-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,45 +27,45 @@ endo_nbr = M.endo_nbr;
 exo_nbr = M.exo_nbr;
 nspred = M.nspred;
 
-if order>1 && options.loglinear 
-   error('The loglinear-option currently only works at order 1') 
+if order>1 && options.loglinear
+    error('The loglinear-option currently only works at order 1')
 end
 if M.maximum_endo_lead == 0 && order>1
-  error(['2nd and 3rd order approximation not implemented for purely ' ...
-       'backward models'])
+    error(['2nd and 3rd order approximation not implemented for purely ' ...
+           'backward models'])
 end
 
 switch(order)
   case 1
     [err, g_1] = k_order_perturbation(dr,M,options);
     if err
-      info(1)=9;
-      return;
+        info(1)=9;
+        return
     end
     dr.g_1 = g_1;
   case 2
     [err, g_0, g_1, g_2] = k_order_perturbation(dr,M,options);
     if err
-      info(1)=9;
-      return;
+        info(1)=9;
+        return
     end
     dr.g_0 = g_0;
     dr.g_1 = g_1;
     dr.g_2 = g_2;
   case 3
-    if options.pruning 
+    if options.pruning
         [err, g_0, g_1, g_2, g_3, derivs] = k_order_perturbation(dr, ...
                                                           M,options);
         if err
-          info(1)=9;
-          return;
+            info(1)=9;
+            return
         end
     else
         [err, g_0, g_1, g_2, g_3] = k_order_perturbation(dr, ...
                                                          M,options);
         if err
-          info(1)=9;
-          return;
+            info(1)=9;
+            return
         end
     end
     dr.g_0 = g_0;
@@ -119,7 +119,7 @@ else
                 if s1 > s0
                     ghxx(:,s1*nspred+s0+1) = 2*g_2(:,i);
                 end
-            elseif s0 < nspred && s1 < nspred+exo_nbr 
+            elseif s0 < nspred && s1 < nspred+exo_nbr
                 ghxu(:,(s0*exo_nbr+s1-nspred+1)) = 2*g_2(:,i);
             elseif s0 < nspred+exo_nbr && s1 < nspred+exo_nbr
                 ghuu(:,(s0-nspred)*exo_nbr+s1-nspred +1) = 2*g_2(:,i);
@@ -132,7 +132,7 @@ else
             s1 = s1+1;
             if s1 == nspred+exo_nbr
                 s0 = s0+1;
-                s1 = s0; 
+                s1 = s0;
             end
         end % for loop
         dr.ghxx = ghxx;
@@ -186,7 +186,7 @@ for i=1:n1
             m = m + 1;
         end
     end
-end 
+end
 
 function y = unfold12(x,n1,n2)
 y = zeros(size(x,1),n1*n2*n2);
@@ -203,7 +203,3 @@ for i=1:n1
         end
     end
 end
-
-
-            
-            
diff --git a/matlab/kalman/build_selection_matrix.m b/matlab/kalman/build_selection_matrix.m
index f78662ddb..e9899591c 100644
--- a/matlab/kalman/build_selection_matrix.m
+++ b/matlab/kalman/build_selection_matrix.m
@@ -2,7 +2,7 @@ function Z = build_selection_matrix(mf,m,p)
 % Builds the selection matrix of the measurement equation from the vector
 % of indices mf.
 
-% Copyright (C) 2004-2009 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,7 +17,7 @@ function Z = build_selection_matrix(mf,m,p)
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 Z = zeros(p,m);
 for i=1:p
     Z(i,mf(i)) = 1;
diff --git a/matlab/kalman/likelihood/computeDLIK.m b/matlab/kalman/likelihood/computeDLIK.m
index 1acb0796f..0fc417220 100644
--- a/matlab/kalman/likelihood/computeDLIK.m
+++ b/matlab/kalman/likelihood/computeDLIK.m
@@ -1,6 +1,6 @@
 function [Da,DP,DLIK,D2a,D2P,Hesst] = computeDLIK(k,tmp,Z,Zflag,v,T,K,P,iF,Da,DYss,DT,DOm,DP,DH,notsteady,D2a,D2Yss,D2T,D2Om,D2P)
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -22,22 +22,22 @@ function [Da,DP,DLIK,D2a,D2P,Hesst] = computeDLIK(k,tmp,Z,Zflag,v,T,K,P,iF,Da,DY
 persistent DK DF D2K D2F
 
 if notsteady
-if Zflag
-    [DK,DF,DP1] = computeDKalmanZ(T,DT,DOm,P,DP,DH,Z,iF,K);
-    if nargout>4,
-        [D2K,D2F,D2P] = computeD2KalmanZ(T,DT,D2T,D2Om,P,DP,D2P,DH,Z,iF,K,DK);
+    if Zflag
+        [DK,DF,DP1] = computeDKalmanZ(T,DT,DOm,P,DP,DH,Z,iF,K);
+        if nargout>4
+            [D2K,D2F,D2P] = computeD2KalmanZ(T,DT,D2T,D2Om,P,DP,D2P,DH,Z,iF,K,DK);
+        end
+    else
+        [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,Z,iF,K);
+        if nargout>4
+            [D2K,D2F,D2P] = computeD2Kalman(T,DT,D2T,D2Om,P,DP,D2P,DH,Z,iF,K,DK);
+        end
     end
-else
-    [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,Z,iF,K);
-    if nargout>4,
-        [D2K,D2F,D2P] = computeD2Kalman(T,DT,D2T,D2Om,P,DP,D2P,DH,Z,iF,K,DK);
-    end
-end
-DP=DP1;
-clear DP1,
+    DP=DP1;
+    clear DP1
 else
     DP=DP;
-    if nargout>4,
+    if nargout>4
         D2P=D2P;
     end
 end
@@ -47,20 +47,20 @@ Dv=zeros(length(v),k);
 for ii = 1:k
     if Zflag
         Dv(:,ii)   = -Z*Da(:,ii) - Z*DYss(:,ii);
-%         if nargout>4,
-%             for jj = 1:ii
-%                 D2v(:,jj,ii)  = -Z*D2Yss(:,jj,ii)  - Z*D2a(:,jj,ii);
-%                 D2v(:,ii,jj) = D2v(:,jj,ii);
-%             end
-%         end
+        %         if nargout>4,
+        %             for jj = 1:ii
+        %                 D2v(:,jj,ii)  = -Z*D2Yss(:,jj,ii)  - Z*D2a(:,jj,ii);
+        %                 D2v(:,ii,jj) = D2v(:,jj,ii);
+        %             end
+        %         end
     else
         Dv(:,ii)   = -Da(Z,ii) - DYss(Z,ii);
-%         if nargout>4,
-%             for jj = 1:ii
-%                 D2v(:,jj,ii)  = -D2Yss(Z,jj,ii)  - D2a(Z,jj,ii);
-%                 D2v(:,ii,jj) = D2v(:,jj,ii);
-%             end
-%         end
+        %         if nargout>4,
+        %             for jj = 1:ii
+        %                 D2v(:,jj,ii)  = -D2Yss(Z,jj,ii)  - D2a(Z,jj,ii);
+        %                 D2v(:,ii,jj) = D2v(:,jj,ii);
+        %             end
+        %         end
     end
 end
 
@@ -71,8 +71,8 @@ for ii = 1:k
     %  dai = da(:,:,ii);
     dKi  = DK(:,:,ii);
     dtmp(:,ii) = Da(:,ii)+dKi*v+K*Dv(:,ii);
-    
-    if nargout>4,
+
+    if nargout>4
         diFi = -iF*DF(:,:,ii)*iF;
         for jj = 1:ii
             jcount=jcount+1;
@@ -82,9 +82,9 @@ for ii = 1:k
             d2Kij  = D2K(:,:,jj,ii);
             d2Fij  = D2F(:,:,jj,ii);
             d2iFij = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
-%             dtmpj = Da(:,jj)+dKj*v+K*Dv(:,jj);
-            
-%             d2vij  = D2v(:,ii,jj);
+            %             dtmpj = Da(:,jj)+dKj*v+K*Dv(:,jj);
+
+            %             d2vij  = D2v(:,ii,jj);
             if Zflag
                 d2vij  = -Z*D2Yss(:,jj,ii)  - Z*D2a(:,jj,ii);
             else
@@ -93,36 +93,36 @@ for ii = 1:k
             d2tmpij = D2a(:,jj,ii) + d2Kij*v + dKj*Dv(:,ii) + dKi*Dv(:,jj) + K*d2vij;
             D2a(:,jj,ii) = reshape(D2T(:,jcount),size(T))*tmp + DT(:,:,jj)*dtmp(:,ii) + DT(:,:,ii)*dtmp(:,jj) + T*d2tmpij;
             D2a(:,ii,jj) = D2a(:,jj,ii);
-            
-            if nargout==6,
+
+            if nargout==6
                 Hesst(ii,jj) = getHesst_ij(v,Dv(:,ii),Dv(:,jj),d2vij,iF,diFi,diFj,d2iFij,dFj,d2Fij);
             end
         end
     end
-        
+
     Da(:,ii)   = DT(:,:,ii)*tmp + T*dtmp(:,ii);
     DLIK(ii,1)  = trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
 end
 
-if nargout==4,
+if nargout==4
     %         Hesst(ii,jj) = getHesst_ij(v,Dv(:,ii),Dv(:,jj),0,iF,diFi,diFj,0,dFj,0);
     vecDPmf = reshape(DF,[],k);
     D2a = 2*Dv'*iF*Dv + (vecDPmf' * kron(iF,iF) * vecDPmf);
-%     for ii = 1:k
-%         
-%         diFi = -iF*DF(:,:,ii)*iF;
-%         for jj = 1:ii
-%             dFj    = DF(:,:,jj);
-%             diFj   = -iF*DF(:,:,jj)*iF;
-%             
-%             Hesst(ii,jj) = getHesst_ij(v*0,Dv(:,ii),Dv(:,jj),v*0,iF,diFi,diFj,0,-dFj,0);
-%         end
-%     end
+    %     for ii = 1:k
+    %
+    %         diFi = -iF*DF(:,:,ii)*iF;
+    %         for jj = 1:ii
+    %             dFj    = DF(:,:,jj);
+    %             diFj   = -iF*DF(:,:,jj)*iF;
+    %
+    %             Hesst(ii,jj) = getHesst_ij(v*0,Dv(:,ii),Dv(:,jj),v*0,iF,diFi,diFj,0,-dFj,0);
+    %         end
+    %     end
 end
 
 % end of computeDLIK
 
-function Hesst_ij = getHesst_ij(e,dei,dej,d2eij,iS,diSi,diSj,d2iSij,dSj,d2Sij);
+function Hesst_ij = getHesst_ij(e,dei,dej,d2eij,iS,diSi,diSj,d2iSij,dSj,d2Sij)
 % computes (i,j) term in the Hessian
 
 Hesst_ij = trace(diSi*dSj + iS*d2Sij) + e'*d2iSij*e + 2*(dei'*diSj*e + dei'*iS*dej + e'*diSi*dej + e'*iS*d2eij);
@@ -165,12 +165,12 @@ end
 
 % end of computeDKalmanZ
 
-function [d2K,d2S,d2P1] = computeD2Kalman(A,dA,d2A,d2Om,P0,dP0,d2P1,DH,Z,iF,K0,dK0);
+function [d2K,d2S,d2P1] = computeD2Kalman(A,dA,d2A,d2Om,P0,dP0,d2P1,DH,Z,iF,K0,dK0)
 % computes the second derivatives of the Kalman matrices
 % note: A=T in main func.
-        
-            k      = size(dA,3);
-            tmp    = P0-K0*P0(Z,:);
+
+k      = size(dA,3);
+tmp    = P0-K0*P0(Z,:);
 [ns,no] = size(K0);
 
 % CPC = C*P0*C'; CPC = .5*(CPC+CPC');iF = inv(CPC);
@@ -186,14 +186,14 @@ jcount=0;
 for ii = 1:k
     dAi = dA(:,:,ii);
     dFi = dP0(Z,Z,ii);
-%     d2Omi = d2Om(:,:,ii);
+    %     d2Omi = d2Om(:,:,ii);
     diFi = -iF*dFi*iF;
     dKi = dK0(:,:,ii);
-    for jj = 1:ii,
+    for jj = 1:ii
         jcount=jcount+1;
         dAj = dA(:,:,jj);
         dFj = dP0(Z,Z,jj);
-%         d2Omj = d2Om(:,:,jj);
+        %         d2Omj = d2Om(:,:,jj);
         dFj = dP0(Z,Z,jj);
         diFj = -iF*dFj*iF;
         dKj = dK0(:,:,jj);
@@ -201,44 +201,44 @@ for ii = 1:k
         d2Aij = reshape(d2A(:,jcount),[ns ns]);
         d2Pij = dyn_unvech(d2P1(:,jcount));
         d2Omij = dyn_unvech(d2Om(:,jcount));
-       
-    % second order
-    
-    d2Fij = d2Pij(Z,Z) ;
-    
-%     d2APC = d2Aij*P0*C' + A*d2Pij*C' + A*P0*d2Cij' + dAi*dPj*C' + dAj*dPi*C' + A*dPj*dCi' + A*dPi*dCj' + dAi*P0*dCj' + dAj*P0*dCi';
-    d2APC = d2Pij(:,Z);
-    
-    d2iF = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
-    
-    d2Kij= d2Pij(:,Z)*iF + P0(:,Z)*d2iF + dP0(:,Z,jj)*diFi + dP0(:,Z,ii)*diFj;
-        
-    d2KCP = d2Kij*P0(Z,:) + K0*d2Pij(Z,:) + dKi*dP0(Z,:,jj) + dKj*dP0(Z,:,ii) ;
-    
-    dtmpi        = dP0(:,:,ii) - dK0(:,:,ii)*P0(Z,:) - K0*dP0(Z,:,ii);
-    dtmpj        = dP0(:,:,jj) - dK0(:,:,jj)*P0(Z,:) - K0*dP0(Z,:,jj);
-    d2tmp = d2Pij - d2KCP;
 
-    d2AtmpA = d2Aij*tmp*A' + A*d2tmp*A' + A*tmp*d2Aij' + dAi*dtmpj*A' + dAj*dtmpi*A' + A*dtmpj*dAi' + A*dtmpi*dAj' + dAi*tmp*dAj' + dAj*tmp*dAi';
+        % second order
 
-    d2K(:,:,ii,jj)  = d2Kij; %#ok<NASGU>
-    d2P1(:,jcount) = dyn_vech(d2AtmpA  + d2Omij);  %#ok<*NASGU>
-    d2S(:,:,ii,jj)  = d2Fij;
-    d2K(:,:,jj,ii)  = d2Kij; %#ok<NASGU>
-%     d2P1(:,:,jj,ii) = d2AtmpA  + d2Omij;  %#ok<*NASGU>
-    d2S(:,:,jj,ii)  = d2Fij;
-%     d2iS(:,:,ii,jj) = d2iF;
+        d2Fij = d2Pij(Z,Z) ;
+
+        %     d2APC = d2Aij*P0*C' + A*d2Pij*C' + A*P0*d2Cij' + dAi*dPj*C' + dAj*dPi*C' + A*dPj*dCi' + A*dPi*dCj' + dAi*P0*dCj' + dAj*P0*dCi';
+        d2APC = d2Pij(:,Z);
+
+        d2iF = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
+
+        d2Kij= d2Pij(:,Z)*iF + P0(:,Z)*d2iF + dP0(:,Z,jj)*diFi + dP0(:,Z,ii)*diFj;
+
+        d2KCP = d2Kij*P0(Z,:) + K0*d2Pij(Z,:) + dKi*dP0(Z,:,jj) + dKj*dP0(Z,:,ii) ;
+
+        dtmpi        = dP0(:,:,ii) - dK0(:,:,ii)*P0(Z,:) - K0*dP0(Z,:,ii);
+        dtmpj        = dP0(:,:,jj) - dK0(:,:,jj)*P0(Z,:) - K0*dP0(Z,:,jj);
+        d2tmp = d2Pij - d2KCP;
+
+        d2AtmpA = d2Aij*tmp*A' + A*d2tmp*A' + A*tmp*d2Aij' + dAi*dtmpj*A' + dAj*dtmpi*A' + A*dtmpj*dAi' + A*dtmpi*dAj' + dAi*tmp*dAj' + dAj*tmp*dAi';
+
+        d2K(:,:,ii,jj)  = d2Kij; %#ok<NASGU>
+        d2P1(:,jcount) = dyn_vech(d2AtmpA  + d2Omij);  %#ok<*NASGU>
+        d2S(:,:,ii,jj)  = d2Fij;
+        d2K(:,:,jj,ii)  = d2Kij; %#ok<NASGU>
+                                 %     d2P1(:,:,jj,ii) = d2AtmpA  + d2Omij;  %#ok<*NASGU>
+        d2S(:,:,jj,ii)  = d2Fij;
+        %     d2iS(:,:,ii,jj) = d2iF;
     end
 end
 
 % end of computeD2Kalman
 
-function [d2K,d2S,d2P1] = computeD2KalmanZ(A,dA,d2A,d2Om,P0,dP0,d2P1,DH,Z,iF,K0,dK0);
+function [d2K,d2S,d2P1] = computeD2KalmanZ(A,dA,d2A,d2Om,P0,dP0,d2P1,DH,Z,iF,K0,dK0)
 % computes the second derivatives of the Kalman matrices
 % note: A=T in main func.
-        
-            k      = size(dA,3);
-            tmp    = P0-K0*Z*P0(:,:);
+
+k      = size(dA,3);
+tmp    = P0-K0*Z*P0(:,:);
 [ns,no] = size(K0);
 
 % CPC = C*P0*C'; CPC = .5*(CPC+CPC');iF = inv(CPC);
@@ -251,17 +251,17 @@ d2S  = zeros(no,no,k,k);
 % d2P1 = zeros(ns,ns,k,k);
 
 jcount=0;
-for ii = 1:k,
+for ii = 1:k
     dAi = dA(:,:,ii);
     dFi = Z*dP0(:,:,ii)*Z;
-%     d2Omi = d2Om(:,:,ii);
+    %     d2Omi = d2Om(:,:,ii);
     diFi = -iF*dFi*iF;
     dKi = dK0(:,:,ii);
-    for jj = 1:ii,
+    for jj = 1:ii
         jcount=jcount+1;
         dAj = dA(:,:,jj);
         dFj = Z*dP0(:,:,jj)*Z;
-%         d2Omj = d2Om(:,:,jj);
+        %         d2Omj = d2Om(:,:,jj);
         dFj = Z*dP0(:,:,jj)*Z;
         diFj = -iF*dFj*iF;
         dKj = dK0(:,:,jj);
@@ -269,36 +269,34 @@ for ii = 1:k,
         d2Aij = reshape(d2A(:,jcount),[ns ns]);
         d2Pij = dyn_unvech(d2P1(:,jcount));
         d2Omij = dyn_unvech(d2Om(:,jcount));
-       
-    % second order
-    
-    d2Fij = Z*d2Pij(:,:)*Z ;
-    
-%     d2APC = d2Aij*P0*C' + A*d2Pij*C' + A*P0*d2Cij' + dAi*dPj*C' + dAj*dPi*C' + A*dPj*dCi' + A*dPi*dCj' + dAi*P0*dCj' + dAj*P0*dCi';
-    d2APC = d2Pij(:,:)*Z;
-    
-    d2iF = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
-    
-    d2Kij= d2Pij(:,:)*Z*iF + P0(:,:)*Z*d2iF + dP0(:,:,jj)*Z*diFi + dP0(:,:,ii)*Z*diFj;
-        
-    d2KCP = d2Kij*Z*P0(:,:) + K0*Z*d2Pij(:,:) + dKi*Z*dP0(:,:,jj) + dKj*Z*dP0(:,:,ii) ;
-    
-    dtmpi        = dP0(:,:,ii) - dK0(:,:,ii)*Z*P0(:,:) - K0*Z*dP0(:,:,ii);
-    dtmpj        = dP0(:,:,jj) - dK0(:,:,jj)*Z*P0(:,:) - K0*Z*dP0(:,:,jj);
-    d2tmp = d2Pij - d2KCP;
 
-    d2AtmpA = d2Aij*tmp*A' + A*d2tmp*A' + A*tmp*d2Aij' + dAi*dtmpj*A' + dAj*dtmpi*A' + A*dtmpj*dAi' + A*dtmpi*dAj' + dAi*tmp*dAj' + dAj*tmp*dAi';
+        % second order
 
-    d2K(:,:,ii,jj)  = d2Kij; %#ok<NASGU>
-    d2P1(:,jcount) = dyn_vech(d2AtmpA  + d2Omij);  %#ok<*NASGU>
-    d2S(:,:,ii,jj)  = d2Fij;
-%     d2iS(:,:,ii,jj) = d2iF;
-    d2K(:,:,jj,ii)  = d2Kij; %#ok<NASGU>
-%     d2P1(:,:,jj,ii) = d2AtmpA  + d2Omij;  %#ok<*NASGU>
-    d2S(:,:,jj,ii)  = d2Fij;
+        d2Fij = Z*d2Pij(:,:)*Z ;
+
+        %     d2APC = d2Aij*P0*C' + A*d2Pij*C' + A*P0*d2Cij' + dAi*dPj*C' + dAj*dPi*C' + A*dPj*dCi' + A*dPi*dCj' + dAi*P0*dCj' + dAj*P0*dCi';
+        d2APC = d2Pij(:,:)*Z;
+
+        d2iF = -diFi*dFj*iF -iF*d2Fij*iF -iF*dFj*diFi;
+
+        d2Kij= d2Pij(:,:)*Z*iF + P0(:,:)*Z*d2iF + dP0(:,:,jj)*Z*diFi + dP0(:,:,ii)*Z*diFj;
+
+        d2KCP = d2Kij*Z*P0(:,:) + K0*Z*d2Pij(:,:) + dKi*Z*dP0(:,:,jj) + dKj*Z*dP0(:,:,ii) ;
+
+        dtmpi        = dP0(:,:,ii) - dK0(:,:,ii)*Z*P0(:,:) - K0*Z*dP0(:,:,ii);
+        dtmpj        = dP0(:,:,jj) - dK0(:,:,jj)*Z*P0(:,:) - K0*Z*dP0(:,:,jj);
+        d2tmp = d2Pij - d2KCP;
+
+        d2AtmpA = d2Aij*tmp*A' + A*d2tmp*A' + A*tmp*d2Aij' + dAi*dtmpj*A' + dAj*dtmpi*A' + A*dtmpj*dAi' + A*dtmpi*dAj' + dAi*tmp*dAj' + dAj*tmp*dAi';
+
+        d2K(:,:,ii,jj)  = d2Kij; %#ok<NASGU>
+        d2P1(:,jcount) = dyn_vech(d2AtmpA  + d2Omij);  %#ok<*NASGU>
+        d2S(:,:,ii,jj)  = d2Fij;
+        %     d2iS(:,:,ii,jj) = d2iF;
+        d2K(:,:,jj,ii)  = d2Kij; %#ok<NASGU>
+                                 %     d2P1(:,:,jj,ii) = d2AtmpA  + d2Omij;  %#ok<*NASGU>
+        d2S(:,:,jj,ii)  = d2Fij;
     end
 end
 
 % end of computeD2KalmanZ
-
-
diff --git a/matlab/kalman/likelihood/kalman_filter.m b/matlab/kalman/likelihood/kalman_filter.m
index 5c375a241..441ee8525 100644
--- a/matlab/kalman/likelihood/kalman_filter.m
+++ b/matlab/kalman/likelihood/kalman_filter.m
@@ -1,4 +1,4 @@
-function [LIK, LIKK, a, P] = kalman_filter(Y,start,last,a,P,kalman_tol,riccati_tol,presample,T,Q,R,H,Z,mm,pp,rr,Zflag,diffuse_periods,analytic_derivation,DT,DYss,DOm,DH,DP,D2T,D2Yss,D2Om,D2H,D2P)
+function [LIK, LIKK, a, P] = kalman_filter(Y,start,last,a,P,kalman_tol,riccati_tol,rescale_prediction_error_covariance,presample,T,Q,R,H,Z,mm,pp,rr,Zflag,diffuse_periods,analytic_derivation,DT,DYss,DOm,DH,DP,D2T,D2Yss,D2Om,D2H,D2P)
 % Computes the likelihood of a stationary state space model.
 
 %@info:
@@ -71,7 +71,7 @@ function [LIK, LIKK, a, P] = kalman_filter(Y,start,last,a,P,kalman_tol,riccati_t
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2004-2013 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -88,8 +88,6 @@ function [LIK, LIKK, a, P] = kalman_filter(Y,start,last,a,P,kalman_tol,riccati_t
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-% AUTHOR(S) stephane DOT adjemian AT univ DASH lemans DOT fr
-
 % Set defaults.
 if nargin<17
     Zflag = 0;
@@ -122,10 +120,10 @@ likk = zeros(smpl,1);      % Initialization of the vector gathering the densitie
 LIK  = Inf;                % Default value of the log likelihood.
 oldK = Inf;
 notsteady   = 1;
-F_singular  = 1;
+F_singular  = true;
 asy_hess=0;
 
-if  analytic_derivation == 0,
+if  analytic_derivation == 0
     DLIK=[];
     Hess=[];
     LIKK=[];
@@ -134,15 +132,15 @@ else
     DLIK  = zeros(k,1);                             % Initialization of the score.
     Da    = zeros(mm,k);                            % Derivative State vector.
     dlikk = zeros(smpl,k);
-    
-    if Zflag==0,
+
+    if Zflag==0
         C = zeros(pp,mm);
-        for ii=1:pp; C(ii,Z(ii))=1;end         % SELECTION MATRIX IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
+        for ii=1:pp, C(ii,Z(ii))=1; end         % SELECTION MATRIX IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
     else
         C=Z;
     end
     dC = zeros(pp,mm,k);   % either selection matrix or schur have zero derivatives
-    if analytic_derivation==2,
+    if analytic_derivation==2
         Hess  = zeros(k,k);                             % Initialization of the Hessian
         D2a    = zeros(mm,k,k);                             % State vector.
         d2C = zeros(pp,mm,k,k);
@@ -153,7 +151,7 @@ else
         D2T=[];
         D2Yss=[];
     end
-    if asy_hess,
+    if asy_hess
         Hess  = zeros(k,k);                             % Initialization of the Hessian
     end
     LIK={inf,DLIK,Hess};
@@ -169,19 +167,34 @@ while notsteady && t<=last
         v  = Y(:,t)-a(Z);
         F  = P(Z,Z) + H;
     end
-    sig=sqrt(diag(F));
-    if any(diag(F)<kalman_tol) || rcond(F./(sig*sig')) < kalman_tol
+    badly_conditioned_F = false;
+    if rescale_prediction_error_covariance
+        sig=sqrt(diag(F));
+        if any(diag(F)<kalman_tol) || rcond(F./(sig*sig'))<kalman_tol
+            badly_conditioned_F = true;
+        end
+    else
+        if rcond(F)<kalman_tol
+            badly_conditioned_F = true;
+        end
+    end
+    if badly_conditioned_F
         if ~all(abs(F(:))<kalman_tol)
-            %use diffuse filter
+            % Use univariate filter (will remove observations with zero variance prediction error)
             return
         else
-            %pathological case, discard draw
+            % Pathological case, discard draw.
             return
         end
     else
-        F_singular = 0;
-        log_dF      = log(det(F./(sig*sig')))+2*sum(log(sig));
-        iF      = inv(F./(sig*sig'))./(sig*sig');
+        F_singular = false;
+        if rescale_prediction_error_covariance
+            log_dF = log(det(F./(sig*sig')))+2*sum(log(sig));
+            iF = inv(F./(sig*sig'))./(sig*sig');
+        else
+            log_dF = log(det(F));
+            iF = inv(F);
+        end
         likk(s) = log_dF+transpose(v)*iF*v;
         if Zflag
             K = P*Z'*iF;
@@ -191,22 +204,22 @@ while notsteady && t<=last
             Ptmp = T*(P-K*P(Z,:))*transpose(T)+QQ;
         end
         tmp = (a+K*v);
-        if analytic_derivation,
-            if analytic_derivation==2,
+        if analytic_derivation
+            if analytic_derivation==2
                 [Da,DP,DLIKt,D2a,D2P, Hesst] = computeDLIK(k,tmp,Z,Zflag,v,T,K,P,iF,Da,DYss,DT,DOm,DP,DH,notsteady,D2a,D2Yss,D2T,D2Om,D2P);
             else
                 [Da,DP,DLIKt,Hesst] = computeDLIK(k,tmp,Z,Zflag,v,T,K,P,iF,Da,DYss,DT,DOm,DP,DH,notsteady);
             end
             if t>presample
                 DLIK = DLIK + DLIKt;
-                if analytic_derivation==2 || asy_hess,
+                if analytic_derivation==2 || asy_hess
                     Hess = Hess + Hesst;
                 end
             end
             dlikk(s,:)=DLIKt;
         end
         a = T*tmp;
-        P=Ptmp;
+        P = Ptmp;
         notsteady = max(abs(K(:)-oldK))>riccati_tol;
         oldK = K(:);
     end
@@ -219,12 +232,12 @@ end
 
 % Add observation's densities constants and divide by two.
 likk(1:s) = .5*(likk(1:s) + pp*log(2*pi));
-if analytic_derivation,
+if analytic_derivation
     DLIK = DLIK/2;
     dlikk = dlikk/2;
-    if analytic_derivation==2 || asy_hess,
-        if asy_hess==0,
-        Hess = Hess + tril(Hess,-1)';
+    if analytic_derivation==2 || asy_hess
+        if asy_hess==0
+            Hess = Hess + tril(Hess,-1)';
         end
         Hess = -Hess/2;
     end
@@ -232,34 +245,32 @@ end
 
 % Call steady state Kalman filter if needed.
 if t <= last
-    if analytic_derivation,
-        if analytic_derivation==2,
-            [tmp, tmp2] = kalman_filter_ss(Y,t,last,a,T,K,iF,dF,Z,pp,Zflag, ...
-                analytic_derivation,Da,DT,DYss,D2a,D2T,D2Yss);
+    if analytic_derivation
+        if analytic_derivation==2
+            [tmp, tmp2] = kalman_filter_ss(Y, t, last, a, T, K, iF, dF, Z, pp, Zflag, analytic_derivation, Da, DT, DYss, D2a, D2T, D2Yss);
         else
-            [tmp, tmp2] = kalman_filter_ss(Y,t,last,a,T,K,iF,dF,Z,pp,Zflag, ...
-                analytic_derivation,Da,DT,DYss,asy_hess);
+            [tmp, tmp2] = kalman_filter_ss(Y, t, last, a, T, K, iF, dF, Z, pp, Zflag, analytic_derivation, Da, DT, DYss, asy_hess);
         end
-        likk(s+1:end)=tmp2{1};
-        dlikk(s+1:end,:)=tmp2{2};
+        likk(s+1:end) = tmp2{1};
+        dlikk(s+1:end,:) = tmp2{2};
         DLIK = DLIK + tmp{2};
-        if analytic_derivation==2 || asy_hess,
+        if analytic_derivation==2 || asy_hess
             Hess = Hess + tmp{3};
         end
     else
-        [tmp, likk(s+1:end)] = kalman_filter_ss(Y,t,last,a,T,K,iF,log_dF,Z,pp,Zflag);
+        [tmp, likk(s+1:end)] = kalman_filter_ss(Y, t, last, a, T, K, iF, log_dF, Z, pp, Zflag);
     end
 end
 
 % Compute minus the log-likelihood.
-if presample>diffuse_periods,
+if presample>diffuse_periods
     LIK = sum(likk(1+(presample-diffuse_periods):end));
 else
     LIK = sum(likk);
 end
 
-if analytic_derivation,
-    if analytic_derivation==2 || asy_hess,
+if analytic_derivation
+    if analytic_derivation==2 || asy_hess
         LIK={LIK, DLIK, Hess};
     else
         LIK={LIK, DLIK};
diff --git a/matlab/kalman/likelihood/kalman_filter_d.m b/matlab/kalman/likelihood/kalman_filter_d.m
index a10cf6f4d..79b3607fb 100644
--- a/matlab/kalman/likelihood/kalman_filter_d.m
+++ b/matlab/kalman/likelihood/kalman_filter_d.m
@@ -1,7 +1,7 @@
 function [dLIK,dlik,a,Pstar] = kalman_filter_d(Y, start, last, a, Pinf, Pstar, kalman_tol, diffuse_kalman_tol, riccati_tol, presample, T, R, Q, H, Z, mm, pp, rr)
 % Computes the diffuse likelihood of a state space model.
 %
-% INPUTS 
+% INPUTS
 %    Y           [double]      pp*smpl matrix of (detrended) data, where pp is the number of observed variables.
 %    start       [integer]     scalar, first observation.
 %    last        [integer]     scalar, last observation.
@@ -10,33 +10,33 @@ function [dLIK,dlik,a,Pstar] = kalman_filter_d(Y, start, last, a, Pinf, Pstar, k
 %    Pstar       [double]      mm*mm matrix used to initialize the covariance matrix of the state vector.
 %    kalman_tol  [double]      scalar, tolerance parameter (rcond) of F_star.
 %    diffuse_kalman_tol [double]      scalar, tolerance parameter (rcond) of Pinf to signify end of diffuse filtering and Finf.
-%    riccati_tol [double]      scalar, tolerance parameter (riccati iteration); 
+%    riccati_tol [double]      scalar, tolerance parameter (riccati iteration);
 %                              not used in this filter as usually diffuse phase will be left before convergence of filter to steady state.
-%    presample   [integer]     scalar, presampling if strictly positive.    
+%    presample   [integer]     scalar, presampling if strictly positive.
 %    T           [double]      mm*mm matrix, transition matrix in  the state equations.
 %    R           [double]      mm*rr matrix relating the structural innovations to the state vector.
 %    Q           [double]      rr*rr covariance matrix of the structural innovations.
-%    H           [double]      pp*pp covariance matrix of the measurement errors (if H is equal to zero (scalar) there is no measurement error). 
+%    H           [double]      pp*pp covariance matrix of the measurement errors (if H is equal to zero (scalar) there is no measurement error).
 %    Z           [double]      pp*mm matrix, selection matrix or pp linear independent combinations of the state vector.
 %    mm          [integer]     scalar, number of state variables.
 %    pp          [integer]     scalar, number of observed variables.
-%    rr          [integer]     scalar, number of structural innovations.    
-%             
-% OUTPUTS 
+%    rr          [integer]     scalar, number of structural innovations.
+%
+% OUTPUTS
 %    LIK         [double]      scalar, minus loglikelihood
 %    lik         [double]      smpl*1 vector, log density of each vector of observations.
 %    a           [double]      mm*1 vector, current estimate of the state vector.
-%    Pstar       [double]      mm*mm matrix, covariance matrix of the state vector.    
-%        
-% REFERENCES 
+%    Pstar       [double]      mm*mm matrix, covariance matrix of the state vector.
+%
+% REFERENCES
 %   See "Filtering and Smoothing of State Vector for Diffuse State Space
-%   Models", S.J. Koopman and J. Durbin (2003), in Journal of Time Series 
-%   Analysis, vol. 24(1), pp. 85-98. 
+%   Models", S.J. Koopman and J. Durbin (2003), in Journal of Time Series
+%   Analysis, vol. 24(1), pp. 85-98.
 %   and
 %   Durbin/Koopman (2012): "Time Series Analysis by State Space Methods", Oxford University Press,
 %   Second Edition, Ch. 5 and 7.2
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -69,10 +69,10 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
     s = t-start+1;
     v = Y(:,t)-Z*a;                                                     %get prediction error v^(0) in (5.13) DK (2012)
     Finf  = Z*Pinf*Z';                                                  % (5.7) in DK (2012)
-    %do case distinction based on whether F_{\infty,t} has full rank or 0 rank
-    if rcond(Finf) < diffuse_kalman_tol                                 %F_{\infty,t} = 0 
+                                                                        %do case distinction based on whether F_{\infty,t} has full rank or 0 rank
+    if rcond(Finf) < diffuse_kalman_tol                                 %F_{\infty,t} = 0
         if ~all(abs(Finf(:)) < diffuse_kalman_tol)                      %rank-deficient but not rank 0
-            % The univariate diffuse kalman filter should be used instead.
+                                                                        % The univariate diffuse kalman filter should be used instead.
             return
         else                                                            %rank of F_{\infty,t} is 0
             Fstar  = Z*Pstar*Z' + H;                                    % (5.7) in DK (2012)
@@ -81,8 +81,8 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
                     % The univariate diffuse kalman filter should be used.
                     return
                 else                                                    %rank 0
-                   %pathological case, discard draw
-                   return
+                                                                        %pathological case, discard draw
+                    return
                 end
             else
                 iFstar = inv(Fstar);
@@ -95,15 +95,15 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
             end
         end
     else                                                                %F_{\infty,t} positive definite
-        %To compare to DK (2012), this block makes use of the following transformation
-        %Kstar=T^{-1}*K^{(1)}=M_{*}*F^{(1)}+M_{\infty}*F^{(2)}
-        %     =P_{*}*Z'*F^{(1)}+P_{\infty}*Z'*((-1)*(-F_{\infty}^{-1})*F_{*}*(F_{\infty}^{-1}))
-        %     =[P_{*}*Z'-Kinf*F_{*})]*F^{(1)}
-        %Make use of L^{0}'=(T-K^{(0)}*Z)'=(T-T*M_{\infty}*F^{(1)}*Z)'
-        %                  =(T-T*P_{\infty*Z'*F^{(1)}*Z)'=(T-T*Kinf*Z)'
-        %                  = (T*(I-*Kinf*Z))'=(I-Z'*Kinf')*T'
-        %P_{*}=T*P_{\infty}*L^{(1)}+T*P_{*}*L^{(0)}+RQR
-        %     =T*[(P_{\infty}*(-K^{(1)*Z}))+P_{*}*(I-Z'*Kinf')*T'+RQR]
+                                                                        %To compare to DK (2012), this block makes use of the following transformation
+                                                                        %Kstar=T^{-1}*K^{(1)}=M_{*}*F^{(1)}+M_{\infty}*F^{(2)}
+                                                                        %     =P_{*}*Z'*F^{(1)}+P_{\infty}*Z'*((-1)*(-F_{\infty}^{-1})*F_{*}*(F_{\infty}^{-1}))
+                                                                        %     =[P_{*}*Z'-Kinf*F_{*})]*F^{(1)}
+                                                                        %Make use of L^{0}'=(T-K^{(0)}*Z)'=(T-T*M_{\infty}*F^{(1)}*Z)'
+                                                                        %                  =(T-T*P_{\infty*Z'*F^{(1)}*Z)'=(T-T*Kinf*Z)'
+                                                                        %                  = (T*(I-*Kinf*Z))'=(I-Z'*Kinf')*T'
+                                                                        %P_{*}=T*P_{\infty}*L^{(1)}+T*P_{*}*L^{(0)}+RQR
+                                                                        %     =T*[(P_{\infty}*(-K^{(1)*Z}))+P_{*}*(I-Z'*Kinf')*T'+RQR]
         dlik(s)= log(det(Finf));                                        %set w_t to top case in bottom equation page 172, DK (2012)
         iFinf  = inv(Finf);
         Kinf   = Pinf*Z'*iFinf;                                         %define Kinf=T^{-1}*K_0 with M_{\infty}=Pinf*Z'
@@ -117,7 +117,7 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
 end
 
 if t>last
-    warning(['kalman_filter_d: There isn''t enough information to estimate the initial conditions of the nonstationary variables. The diffuse Kalman filter never left the diffuse stage.']);                   
+    warning(['kalman_filter_d: There isn''t enough information to estimate the initial conditions of the nonstationary variables. The diffuse Kalman filter never left the diffuse stage.']);
     dLIK = NaN;
     return
 end
diff --git a/matlab/kalman/likelihood/kalman_filter_fast.m b/matlab/kalman/likelihood/kalman_filter_fast.m
index a60011ade..db3dec3b7 100644
--- a/matlab/kalman/likelihood/kalman_filter_fast.m
+++ b/matlab/kalman/likelihood/kalman_filter_fast.m
@@ -74,7 +74,7 @@ function [LIK, LIKK, a, P] = kalman_filter_fast(Y,start,last,a,P,kalman_tol,ricc
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2004-2013 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -152,7 +152,7 @@ while notsteady && t<=last
     end
     if rcond(F) < kalman_tol
         if ~all(abs(F(:))<kalman_tol)
-            % The univariate diffuse kalman filter should be used.            
+            % The univariate diffuse kalman filter should be used.
             return
         else
             %pathological case, discard draw
@@ -194,12 +194,12 @@ end
 
 % Add observation's densities constants and divide by two.
 likk(1:s) = .5*(likk(1:s) + pp*log(2*pi));
-if analytic_derivation,
+if analytic_derivation
     DLIK = DLIK/2;
     dlikk = dlikk/2;
-    if analytic_derivation==2 || asy_hess,
-        if asy_hess==0,
-        Hess = Hess + tril(Hess,-1)';
+    if analytic_derivation==2 || asy_hess
+        if asy_hess==0
+            Hess = Hess + tril(Hess,-1)';
         end
         Hess = -Hess/2;
     end
@@ -207,34 +207,34 @@ end
 
 % Call steady state Kalman filter if needed.
 if t <= last
-    if analytic_derivation,
-        if analytic_derivation==2,
+    if analytic_derivation
+        if analytic_derivation==2
             [tmp, tmp2] = kalman_filter_ss(Y,t,last,a,T,K,iF,dF,Z,pp,Zflag, ...
-                analytic_derivation,Da,DT,DYss,D2a,D2T,D2Yss);
+                                           analytic_derivation,Da,DT,DYss,D2a,D2T,D2Yss);
         else
             [tmp, tmp2] = kalman_filter_ss(Y,t,last,a,T,K,iF,dF,Z,pp,Zflag, ...
-                analytic_derivation,Da,DT,DYss,asy_hess);
+                                           analytic_derivation,Da,DT,DYss,asy_hess);
         end
         likk(s+1:end)=tmp2{1};
         dlikk(s+1:end,:)=tmp2{2};
         DLIK = DLIK + tmp{2};
-        if analytic_derivation==2 || asy_hess,
+        if analytic_derivation==2 || asy_hess
             Hess = Hess + tmp{3};
         end
     else
-        [tmp, likk(s+1:end)] = kalman_filter_ss(Y,t,last,a,T,K,iF,log(dF),Z,pp,Zflag);
+        [tmp, likk(s+1:end)] = kalman_filter_ss(Y, t, last, a, T, K, iF, log(dF), Z, pp, Zflag);
     end
 end
 
 % Compute minus the log-likelihood.
-if presample>diffuse_periods,
+if presample>diffuse_periods
     LIK = sum(likk(1+(presample-diffuse_periods):end));
 else
     LIK = sum(likk);
 end
 
-if analytic_derivation,
-    if analytic_derivation==2 || asy_hess,
+if analytic_derivation
+    if analytic_derivation==2 || asy_hess
         LIK={LIK, DLIK, Hess};
     else
         LIK={LIK, DLIK};
diff --git a/matlab/kalman/likelihood/kalman_filter_ss.m b/matlab/kalman/likelihood/kalman_filter_ss.m
index 8e5f92733..5510de9f3 100644
--- a/matlab/kalman/likelihood/kalman_filter_ss.m
+++ b/matlab/kalman/likelihood/kalman_filter_ss.m
@@ -54,7 +54,7 @@ function [LIK, likk, a] = kalman_filter_ss(Y,start,last,a,T,K,iF,log_dF,Z,pp,Zfl
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -86,18 +86,18 @@ if nargin<12
     analytic_derivation = 0;
 end
 
-if  analytic_derivation == 0,
+if  analytic_derivation == 0
     DLIK=[];
     Hess=[];
 else
     k = size(DT,3);                                 % number of structural parameters
     DLIK  = zeros(k,1);                             % Initialization of the score.
     dlikk = zeros(smpl,k);
-    if analytic_derivation==2,
+    if analytic_derivation==2
         Hess  = zeros(k,k);                             % Initialization of the Hessian
     else
         asy_hess=D2a;
-        if asy_hess,
+        if asy_hess
             Hess  = zeros(k,k);                             % Initialization of the Hessian
         else
             Hess=[];
@@ -112,14 +112,14 @@ while t <= last
         v = Y(:,t)-a(Z);
     end
     tmp = (a+K*v);
-    if analytic_derivation,
-        if analytic_derivation==2,
+    if analytic_derivation
+        if analytic_derivation==2
             [Da,junk,DLIKt,D2a,junk2, Hesst] = computeDLIK(k,tmp,Z,Zflag,v,T,K,[],iF,Da,DYss,DT,[],[],[],notsteady,D2a,D2Yss,D2T,[],[]);
         else
             [Da,junk,DLIKt,Hesst] = computeDLIK(k,tmp,Z,Zflag,v,T,K,[],iF,Da,DYss,DT,[],[],[],notsteady);
         end
         DLIK = DLIK + DLIKt;
-        if analytic_derivation==2 || asy_hess,
+        if analytic_derivation==2 || asy_hess
             Hess = Hess + Hesst;
         end
         dlikk(t-start+1,:)=DLIKt;
@@ -137,17 +137,17 @@ likk = .5*(likk + pp*log(2*pi));
 
 % Sum the observation's densities (minus the likelihood)
 LIK = sum(likk);
-if analytic_derivation,
+if analytic_derivation
     dlikk = dlikk/2;
     DLIK = DLIK/2;
     likk = {likk, dlikk};
 end
-if analytic_derivation==2 || asy_hess,
-    if asy_hess==0,
+if analytic_derivation==2 || asy_hess
+    if asy_hess==0
         Hess = Hess + tril(Hess,-1)';
     end
     Hess = -Hess/2;
     LIK={LIK,DLIK,Hess};
-elseif analytic_derivation==1,
+elseif analytic_derivation==1
     LIK={LIK,DLIK};
 end
diff --git a/matlab/kalman/likelihood/missing_observations_kalman_filter.m b/matlab/kalman/likelihood/missing_observations_kalman_filter.m
index 6b70a59af..f1bd40cb5 100644
--- a/matlab/kalman/likelihood/missing_observations_kalman_filter.m
+++ b/matlab/kalman/likelihood/missing_observations_kalman_filter.m
@@ -1,38 +1,38 @@
-function  [LIK, lik, a, P] = missing_observations_kalman_filter(data_index,number_of_observations,no_more_missing_observations,Y,start,last,a,P,kalman_tol,riccati_tol,presample,T,Q,R,H,Z,mm,pp,rr,Zflag,diffuse_periods)
+function  [LIK, lik, a, P] = missing_observations_kalman_filter(data_index,number_of_observations,no_more_missing_observations,Y,start,last,a,P,kalman_tol,riccati_tol,rescale_prediction_error_covariance,presample,T,Q,R,H,Z,mm,pp,rr,Zflag,diffuse_periods)
 % Computes the likelihood of a state space model in the case with missing observations.
 %
 % INPUTS
 %    data_index                   [cell]      1*smpl cell of column vectors of indices.
 %    number_of_observations       [integer]   scalar.
 %    no_more_missing_observations [integer]   scalar.
-%    Y                            [double]    pp*smpl matrix of data.    
+%    Y                            [double]    pp*smpl matrix of data.
 %    start                        [integer]   scalar, index of the first observation.
 %    last                         [integer]   scalar, index of the last observation.
 %    a                            [double]    pp*1 vector, initial level of the state vector.
 %    P                            [double]    pp*pp matrix, covariance matrix of the initial state vector.
 %    kalman_tol                   [double]    scalar, tolerance parameter (rcond).
-%    riccati_tol                  [double]    scalar, tolerance parameter (riccati iteration).    
+%    riccati_tol                  [double]    scalar, tolerance parameter (riccati iteration).
 %    presample                    [integer]   scalar, presampling if strictly positive.
 %    T                            [double]    mm*mm transition matrix of the state equation.
-%    Q                            [double]    rr*rr covariance matrix of the structural innovations.    
+%    Q                            [double]    rr*rr covariance matrix of the structural innovations.
 %    R                            [double]    mm*rr matrix, mapping structural innovations to state variables.
-%    H                            [double]    pp*pp (or 1*1 =0 if no measurement error) covariance matrix of the measurement errors. 
-%    Z                            [integer]   pp*1 vector of indices for the observed variables.    
+%    H                            [double]    pp*pp (or 1*1 =0 if no measurement error) covariance matrix of the measurement errors.
+%    Z                            [integer]   pp*1 vector of indices for the observed variables.
 %    mm                           [integer]   scalar, dimension of the state vector.
 %    pp                           [integer]   scalar, number of observed variables.
-%    rr                           [integer]   scalar, number of structural innovations.    
-%    
-% OUTPUTS 
+%    rr                           [integer]   scalar, number of structural innovations.
+%
+% OUTPUTS
 %    LIK        [double]    scalar, MINUS loglikelihood
 %    lik        [double]    vector, density of observations in each period.
 %    a          [double]    mm*1 vector, estimated level of the states.
-%    P          [double]    mm*mm matrix, covariance matrix of the states.        
-%        
+%    P          [double]    mm*mm matrix, covariance matrix of the states.
+%
 %
 % NOTES
-%   The vector "lik" is used to evaluate the jacobian of the likelihood.   
+%   The vector "lik" is used to evaluate the jacobian of the likelihood.
 
-% Copyright (C) 2004-2012 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -82,7 +82,7 @@ lik  = zeros(smpl,1);      % Initialization of the vector gathering the densitie
 LIK  = Inf;                % Default value of the log likelihood.
 oldK = Inf;
 notsteady   = 1;
-F_singular  = 1;
+F_singular  = true;
 s = 0;
 
 while notsteady && t<=last
@@ -102,19 +102,34 @@ while notsteady && t<=last
             v = Y(d_index,t) - a(z);
             F = P(z,z) + H(d_index,d_index);
         end
-        sig=sqrt(diag(F));
-        if any(diag(F)<kalman_tol) || rcond(F./(sig*sig')) < kalman_tol
+        badly_conditioned_F = false;
+        if rescale_prediction_error_covariance
+            sig=sqrt(diag(F));
+            if any(diag(F)<kalman_tol) || rcond(F./(sig*sig'))<kalman_tol
+                badly_conditioned_F = true;
+            end
+        else
+            if rcond(F)<kalman_tol
+                badly_conditioned_F = true;
+            end
+        end
+        if badly_conditioned_F
             if ~all(abs(F(:))<kalman_tol)
-                %use diffuse filter
+                % Use univariate filter.
                 return
             else
-                %pathological case, discard draw
+                % Pathological case, discard draw
                 return
             end
         else
-            F_singular = 0;
-            log_dF      = log(det(F./(sig*sig')))+2*sum(log(sig));
-            iF      = inv(F./(sig*sig'))./(sig*sig');
+            F_singular = false;
+            if rescale_prediction_error_covariance
+                log_dF = log(det(F./(sig*sig')))+2*sum(log(sig));
+                iF = inv(F./(sig*sig'))./(sig*sig');
+            else
+                log_dF = log(det(F));
+                iF = inv(F);
+            end
             lik(s) = log_dF + transpose(v)*iF*v + length(d_index)*log(2*pi);
             if Zflag
                 K = P*z'*iF;
@@ -142,7 +157,7 @@ lik(1:s) = .5*lik(1:s);
 
 % Call steady state Kalman filter if needed.
 if t<=last
-    [tmp, lik(s+1:end)] = kalman_filter_ss(Y,t,last,a,T,K,iF,log_dF,Z,pp,Zflag);
+    [tmp, lik(s+1:end)] = kalman_filter_ss(Y, t, last, a, T, K, iF, log_dF, Z, pp, Zflag);
 end
 
 % Compute minus the log-likelihood.
diff --git a/matlab/kalman/likelihood/missing_observations_kalman_filter_d.m b/matlab/kalman/likelihood/missing_observations_kalman_filter_d.m
index a497d6e53..ec8c286a4 100644
--- a/matlab/kalman/likelihood/missing_observations_kalman_filter_d.m
+++ b/matlab/kalman/likelihood/missing_observations_kalman_filter_d.m
@@ -1,11 +1,11 @@
 function [dLIK,dlik,a,Pstar] = missing_observations_kalman_filter_d(data_index,number_of_observations,no_more_missing_observations, ...
-                                                      Y, start, last, ...
-                                                      a, Pinf, Pstar, ...
-                                                      kalman_tol, diffuse_kalman_tol, riccati_tol, presample, ...
-                                                      T, R, Q, H, Z, mm, pp, rr)
+                                                  Y, start, last, ...
+                                                  a, Pinf, Pstar, ...
+                                                  kalman_tol, diffuse_kalman_tol, riccati_tol, presample, ...
+                                                  T, R, Q, H, Z, mm, pp, rr)
 % Computes the diffuse likelihood of a state space model when some observations are missing.
 %
-% INPUTS 
+% INPUTS
 %    data_index                   [cell]      1*smpl cell of column vectors of indices.
 %    number_of_observations       [integer]   scalar.
 %    no_more_missing_observations [integer]   scalar.
@@ -17,32 +17,32 @@ function [dLIK,dlik,a,Pstar] = missing_observations_kalman_filter_d(data_index,n
 %    Pstar                        [double]      mm*mm matrix used to initialize the covariance matrix of the state vector.
 %    kalman_tol                   [double]      scalar, tolerance parameter (rcond).
 %    riccati_tol                  [double]      scalar, tolerance parameter (riccati iteration).
-%    presample                    [integer]     scalar, presampling if strictly positive.    
+%    presample                    [integer]     scalar, presampling if strictly positive.
 %    T                            [double]      mm*mm matrix, transition matrix in  the state equations.
 %    R                            [double]      mm*rr matrix relating the structural innovations to the state vector.
 %    Q                            [double]      rr*rr covariance matrix of the structural innovations.
-%    H                            [double]      pp*pp covariance matrix of the measurement errors (if H is equal to zero (scalar) there is no measurement error). 
+%    H                            [double]      pp*pp covariance matrix of the measurement errors (if H is equal to zero (scalar) there is no measurement error).
 %    Z                            [double]      pp*mm matrix, selection matrix or pp linear independant combinations of the state vector.
 %    mm                           [integer]     scalar, number of state variables.
 %    pp                           [integer]     scalar, number of observed variables.
-%    rr                           [integer]     scalar, number of structural innovations.    
-%             
-% OUTPUTS 
+%    rr                           [integer]     scalar, number of structural innovations.
+%
+% OUTPUTS
 %    dLIK        [double]    scalar, MINUS loglikelihood
 %    dlik        [double]    vector, density of observations in each period.
 %    a           [double]    mm*1 vector, estimated level of the states.
-%    Pstar       [double]    mm*mm matrix, covariance matrix of the states.        
-%        
+%    Pstar       [double]    mm*mm matrix, covariance matrix of the states.
+%
 % REFERENCES
 %   See "Filtering and Smoothing of State Vector for Diffuse State Space
-%   Models", S.J. Koopman and J. Durbin (2003), in Journal of Time Series 
-%   Analysis, vol. 24(1), pp. 85-98. 
+%   Models", S.J. Koopman and J. Durbin (2003), in Journal of Time Series
+%   Analysis, vol. 24(1), pp. 85-98.
 %   and
 %   Durbin/Koopman (2012): "Time Series Analysis by State Space Methods", Oxford University Press,
 %   Second Edition, Ch. 5 and 7.2
 
-% 
-% Copyright (C) 2004-2016 Dynare Team
+%
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -87,11 +87,11 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
         Pinf  = T*Pinf*transpose(T);
     else
         ZZ = Z(d_index,:);                                                  %span selector matrix
-        v  = Y(d_index,t)-ZZ*a;                                             %get prediction error v^(0) in (5.13) DK (2012)         
+        v  = Y(d_index,t)-ZZ*a;                                             %get prediction error v^(0) in (5.13) DK (2012)
         Finf  = ZZ*Pinf*ZZ';                                                % (5.7) in DK (2012)
-        if rcond(Finf) < diffuse_kalman_tol                                 %F_{\infty,t} = 0 
+        if rcond(Finf) < diffuse_kalman_tol                                 %F_{\infty,t} = 0
             if ~all(abs(Finf(:)) < diffuse_kalman_tol)                      %rank-deficient but not rank 0
-                % The univariate diffuse kalman filter should be used.
+                                                                            % The univariate diffuse kalman filter should be used.
                 return
             else                                                            %rank of F_{\infty,t} is 0
                 Fstar = ZZ*Pstar*ZZ' + H(d_index,d_index);                  % (5.7) in DK (2012)
@@ -100,7 +100,7 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
                         % The univariate diffuse kalman filter should be used.
                         return
                     else %rank 0
-                        %pathological case, discard draw
+                         %pathological case, discard draw
                         return
                     end
                 else
@@ -129,7 +129,7 @@ while rank(Pinf,diffuse_kalman_tol) && (t<=last)
 end
 
 if t==(last+1)
-    warning(['kalman_filter_d: There isn''t enough information to estimate the initial conditions of the nonstationary variables. The diffuse Kalman filter never left the diffuse stage.']);                   
+    warning(['kalman_filter_d: There isn''t enough information to estimate the initial conditions of the nonstationary variables. The diffuse Kalman filter never left the diffuse stage.']);
     dLIK = NaN;
     return
 end
diff --git a/matlab/kalman/likelihood/univariate_computeDLIK.m b/matlab/kalman/likelihood/univariate_computeDLIK.m
index 1338a84a6..083fb12db 100644
--- a/matlab/kalman/likelihood/univariate_computeDLIK.m
+++ b/matlab/kalman/likelihood/univariate_computeDLIK.m
@@ -1,6 +1,6 @@
 function [Da,DP1,DLIK,D2a,D2P,Hesst] = univariate_computeDLIK(k,indx,Z,Zflag,v,K,PZ,F,Da,DYss,DP,DH,notsteady,D2a,D2Yss,D2P)
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -21,12 +21,12 @@ function [Da,DP1,DLIK,D2a,D2P,Hesst] = univariate_computeDLIK(k,indx,Z,Zflag,v,K
 
 persistent DDK DDF DD2K DD2F
 
-if notsteady,
+if notsteady
     if Zflag
         Dv   = -Z*Da(:,:) - Z*DYss(:,:);
         DF = zeros(k,1);
         DK = zeros([rows(K),k]);
-        for j=1:k,
+        for j=1:k
             DF(j)=Z*DP(:,:,j)*Z'+DH;
             DK(:,j) = (DP(:,:,j)*Z')/F-PZ*DF(j)/F^2;
         end
@@ -35,9 +35,9 @@ if notsteady,
             D2v = zeros(k,k);
             D2K = zeros(rows(K),k,k);
             jcount=0;
-            for j=1:k,
+            for j=1:k
                 D2v(:,j)   = -Z*D2a(:,:,j) - Z*D2Yss(:,:,j);
-                for i=1:j,
+                for i=1:j
                     jcount=jcount+1;
                     D2F(j,i)=Z*dyn_unvech(D2P(:,jcount))*Z';
                     D2F(i,j)=D2F(j,i);
@@ -47,7 +47,7 @@ if notsteady,
                 end
             end
         end
-        
+
     else
         Dv   = -Da(Z,:) - DYss(Z,:);
         DF = squeeze(DP(Z,Z,:))+DH';
@@ -57,8 +57,8 @@ if notsteady,
             D2K = zeros(rows(K),k,k);
             D2v   = squeeze(-D2a(Z,:,:) - D2Yss(Z,:,:));
             jcount=0;
-            for j=1:k,
-                for i=1:j,
+            for j=1:k
+                for i=1:j
                     jcount=jcount+1;
                     tmp = dyn_unvech(D2P(:,jcount));
                     D2F(j,i) = tmp(Z,Z);
@@ -67,7 +67,7 @@ if notsteady,
                     D2K(:,i,j) = D2K(:,i,j) -PZ*D2F(j,i)/F^2 - squeeze(DP(:,Z,i))*DF(j)/F^2 - ...
                         squeeze(DP(:,Z,j))*DF(i)'/F^2 + 2/F^3*PZ*DF(i)'*DF(j);
                     D2K(:,j,i) = D2K(:,i,j);
-%                     D2K = squeeze(D2P(:,Z,:,:))/F;
+                    %                     D2K = squeeze(D2P(:,Z,:,:))/F;
                 end
             end
         end
@@ -89,7 +89,7 @@ else
         Dv   = -Z*Da(:,:) - Z*DYss(:,:);
         if nargout>4
             D2v = zeros(k,k);
-            for j=1:k,
+            for j=1:k
                 D2v(:,j)   = -Z*D2a(:,:,j) - Z*D2Yss(:,:,j);
             end
         end
@@ -104,70 +104,68 @@ end
 DLIK = DF/F + 2*Dv'/F*v - v^2/F^2*DF;
 if nargout==6
     Hesst = D2F/F-1/F^2*(DF*DF') + 2*D2v/F*v + 2*(Dv'*Dv)/F - 2*(DF*Dv)*v/F^2 ...
-        - v^2/F^2*D2F - 2*v/F^2*(Dv'*DF') + 2*v^2/F^3*(DF*DF');
-elseif nargout==4,
+            - v^2/F^2*D2F - 2*v/F^2*(Dv'*DF') + 2*v^2/F^3*(DF*DF');
+elseif nargout==4
     D2a = 1/F^2*(DF*DF') + 2*(Dv'*Dv)/F ;
-%     D2a = -1/F^2*(DF*DF') + 2*(Dv'*Dv)/F  + 2*v^2/F^3*(DF*DF') ...
-%         - 2*(DF*Dv)*v/F^2 - 2*v/F^2*(Dv'*DF');
-%     D2a = +2*(Dv'*Dv)/F + (DF' * DF)/F^2;
+    %     D2a = -1/F^2*(DF*DF') + 2*(Dv'*Dv)/F  + 2*v^2/F^3*(DF*DF') ...
+    %         - 2*(DF*Dv)*v/F^2 - 2*v/F^2*(Dv'*DF');
+    %     D2a = +2*(Dv'*Dv)/F + (DF' * DF)/F^2;
 end
 
 Da = Da + DK*v+K*Dv;
 if nargout>4
-    
+
     D2a = D2a + D2K*v;
-    for j=1:k,
+    for j=1:k
         %         D2a(:,:,j) = D2a(:,:,j) + DK*Dv(j) + DK(:,j)*Dv + K*D2v(j,:);
-        for i=1:j,
+        for i=1:j
             D2a(:,j,i) = D2a(:,j,i) + DK(:,i)*Dv(j) + DK(:,j)*Dv(i) + K*D2v(j,i);
             D2a(:,i,j) = D2a(:,j,i);
         end
     end
-    
-    
+
+
 end
 
-if notsteady,
+if notsteady
     DP1 = DP*0;
-    if Zflag,
-        for j=1:k,
+    if Zflag
+        for j=1:k
             DP1(:,:,j)=DP(:,:,j) - (DP(:,:,j)*Z')*K'-PZ*DK(:,j)';
         end
     else
-        for j=1:k,
+        for j=1:k
             DP1(:,:,j)=DP(:,:,j) - (DP(:,Z,j))*K'-PZ*DK(:,j)';
         end
     end
-    if nargout>4,
-        if Zflag,
-            for j=1:k,
-                for i=1:j,
+    if nargout>4
+        if Zflag
+            for j=1:k
+                for i=1:j
                     jcount = jcount+1;
                     tmp = dyn_unvech(D2P(:,jcount));
                     tmp = tmp - (tmp*Z')*K' - (DP(:,:,j)*Z')*DK(:,i)' ...
-                        - (DP(:,:,i)*Z')*DK(:,j)' -PZ*D2K(:,j,i)';
+                          - (DP(:,:,i)*Z')*DK(:,j)' -PZ*D2K(:,j,i)';
                     D2P(:,jcount) = dyn_vech(tmp);
-%                     D2P(:,:,i,j) = D2P(:,:,j,i);
+                    %                     D2P(:,:,i,j) = D2P(:,:,j,i);
                 end
             end
         else
             DPZ = squeeze(DP(:,Z,:));
             jcount = 0;
-            for j=1:k,
-                for i=1:j,
+            for j=1:k
+                for i=1:j
                     jcount = jcount+1;
                     tmp = dyn_unvech(D2P(:,jcount));
                     D2PZ = tmp(:,Z);
                     tmp = tmp - D2PZ*K' - DPZ(:,j)*DK(:,i)'- DPZ(:,i)*DK(:,j)' - PZ*squeeze(D2K(:,j,i))';
                     D2P(:,jcount) = dyn_vech(tmp);
-%                     D2P(:,:,i,j) = D2P(:,:,j,i);
+                    %                     D2P(:,:,i,j) = D2P(:,:,j,i);
                 end
             end
-            
+
         end
     end
 else
     DP1=DP;
 end
-
-
diff --git a/matlab/kalman/likelihood/univariate_computeDstate.m b/matlab/kalman/likelihood/univariate_computeDstate.m
index a535a0a51..eecee428e 100644
--- a/matlab/kalman/likelihood/univariate_computeDstate.m
+++ b/matlab/kalman/likelihood/univariate_computeDstate.m
@@ -1,6 +1,6 @@
 function [Da1,DP1,D2a,D2P] = univariate_computeDstate(k,a,P,T,Da,DP,DT,DOm,notsteady,D2a,D2P,D2T,D2Om)
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -22,35 +22,35 @@ function [Da1,DP1,D2a,D2P] = univariate_computeDstate(k,a,P,T,Da,DP,DT,DOm,notst
 
 DP1=DP*0;
 Da1=Da*0;
-for j=1:k,
+for j=1:k
     Da1(:,j) = T*Da(:,j) + DT(:,:,j)*a;
-    if notsteady,
+    if notsteady
         DP1(:,:,j) = T*DP(:,:,j)*T'+DT(:,:,j)*P*T'+T*P*DT(:,:,j)';
     else
         DP1=DP;
     end
 end
-if notsteady,
+if notsteady
     DP1 = DP1 + DOm;
 end
-if nargout>2,
+if nargout>2
     jcount=0;
-    for j=1:k,
-        for i=1:j,
+    for j=1:k
+        for i=1:j
             jcount=jcount+1;
             D2a(:,j,i) = DT(:,:,i)*Da(:,j) + DT(:,:,j)*Da(:,i) + T*D2a(:,j,i)+ reshape(D2T(:,jcount),size(T))*a;
             D2a(:,i,j) = D2a(:,j,i);
-            if notsteady,
+            if notsteady
                 tmp = dyn_unvech(D2P(:,jcount));
                 tmp = T*tmp*T' +DT(:,:,i)*DP(:,:,j)*T'+T*DP(:,:,j)*DT(:,:,i)' + ...
-                    DT(:,:,j)*DP(:,:,i)*T'+T*DP(:,:,i)*DT(:,:,j)' + ...
-                    DT(:,:,j)*P*DT(:,:,i)'+DT(:,:,i)*P*DT(:,:,j)'+ ...
-                    reshape(D2T(:,jcount),size(T))*P*T'+T*P*reshape(D2T(:,jcount),size(T))' + ...
-                    dyn_unvech(D2Om(:,jcount));
+                      DT(:,:,j)*DP(:,:,i)*T'+T*DP(:,:,i)*DT(:,:,j)' + ...
+                      DT(:,:,j)*P*DT(:,:,i)'+DT(:,:,i)*P*DT(:,:,j)'+ ...
+                      reshape(D2T(:,jcount),size(T))*P*T'+T*P*reshape(D2T(:,jcount),size(T))' + ...
+                      dyn_unvech(D2Om(:,jcount));
                 D2P(:,jcount) = dyn_vech(tmp);
-%                 D2P(:,:,i,j) = D2P(:,:,j,i);
+                %                 D2P(:,:,i,j) = D2P(:,:,j,i);
             end
         end
     end
-    
+
 end
diff --git a/matlab/kalman/likelihood/univariate_kalman_filter.m b/matlab/kalman/likelihood/univariate_kalman_filter.m
index dd4559cd5..add638a54 100644
--- a/matlab/kalman/likelihood/univariate_kalman_filter.m
+++ b/matlab/kalman/likelihood/univariate_kalman_filter.m
@@ -37,7 +37,7 @@ function [LIK, lik,a,P] = univariate_kalman_filter(data_index,number_of_observat
 %! @item Q
 %! Matrix (@var{rr}*@var{rr}) of doubles, covariance matrix of the structural innovations (noise in the state equation).
 %! @item R
-%! Matrix (@var{mm}*@var{rr}) of doubles, 
+%! Matrix (@var{mm}*@var{rr}) of doubles,
 %! @item H
 %! Vector (@var{pp}) of doubles, diagonal of covariance matrix of the measurement errors (corelation among measurement errors is handled by a model transformation).
 %! @item Z
@@ -76,15 +76,15 @@ function [LIK, lik,a,P] = univariate_kalman_filter(data_index,number_of_observat
 %! @ref{univariate_kalman_filter_ss}
 %! @end deftypefn
 %@eod:
-% 
+%
 % Algorithm:
-% 
+%
 %   Uses the univariate filter as described in Durbin/Koopman (2012): "Time
 %   Series Analysis by State Space Methods", Oxford University Press,
 %   Second Edition, Ch. 6.4 + 7.2.5
 
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -128,7 +128,7 @@ oldK = Inf;
 K = NaN(mm,pp);
 asy_hess=0;
 
-if  analytic_derivation == 0,
+if  analytic_derivation == 0
     DLIK=[];
     Hess=[];
 else
@@ -136,15 +136,15 @@ else
     DLIK  = zeros(k,1);                             % Initialization of the score.
     Da    = zeros(mm,k);                            % Derivative State vector.
     dlik  = zeros(smpl,k);
-    
-    if Zflag==0,
+
+    if Zflag==0
         C = zeros(pp,mm);
-        for ii=1:pp; C(ii,Z(ii))=1;end         % SELECTION MATRIX IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
+        for ii=1:pp, C(ii,Z(ii))=1; end         % SELECTION MATRIX IN MEASUREMENT EQ. (FOR WHEN IT IS NOT CONSTANT)
     else
         C=Z;
     end
     dC = zeros(pp,mm,k);   % either selection matrix or schur have zero derivatives
-    if analytic_derivation==2,
+    if analytic_derivation==2
         Hess  = zeros(k,k);                             % Initialization of the Hessian
         D2a    = zeros(mm,k,k);                             % State vector.
         d2C = zeros(pp,mm,k,k);
@@ -155,7 +155,7 @@ else
         D2T=[];
         D2Yss=[];
     end
-    if asy_hess,
+    if asy_hess
         Hess  = zeros(k,k);                             % Initialization of the Hessian
     end
     LIK={inf,DLIK,Hess};
@@ -172,13 +172,13 @@ while notsteady && t<=last %loop over t
     oldP = P(:);
     for i=1:rows(z) %loop over i
         if Zflag
-            prediction_error = Y(d_index(i),t) - z(i,:)*a;  % nu_{t,i} in 6.13 in DK (2012) 
+            prediction_error = Y(d_index(i),t) - z(i,:)*a;  % nu_{t,i} in 6.13 in DK (2012)
             PZ = P*z(i,:)';                                 % Z_{t,i}*P_{t,i}*Z_{t,i}'
-            Fi = z(i,:)*PZ + H(d_index(i));                 % F_{t,i} in 6.13 in DK (2012), relies on H being diagonal 
+            Fi = z(i,:)*PZ + H(d_index(i));                 % F_{t,i} in 6.13 in DK (2012), relies on H being diagonal
         else
-            prediction_error = Y(d_index(i),t) - a(z(i));   % nu_{t,i} in 6.13 in DK (2012) 
+            prediction_error = Y(d_index(i),t) - a(z(i));   % nu_{t,i} in 6.13 in DK (2012)
             PZ = P(:,z(i));                                 % Z_{t,i}*P_{t,i}*Z_{t,i}'
-            Fi = PZ(z(i)) + H(d_index(i));                  % F_{t,i} in 6.13 in DK (2012), relies on H being diagonal 
+            Fi = PZ(z(i)) + H(d_index(i));                  % F_{t,i} in 6.13 in DK (2012), relies on H being diagonal
         end
         if Fi>kalman_tol
             Ki =  PZ/Fi; %K_{t,i} in 6.13 in DK (2012)
@@ -186,15 +186,15 @@ while notsteady && t<=last %loop over t
                 K(:,i) = Ki;
             end
             lik(s,i) = log(Fi) + (prediction_error*prediction_error)/Fi + l2pi; %Top equation p. 175 in DK (2012)
-            if analytic_derivation,
-                if analytic_derivation==2,
+            if analytic_derivation
+                if analytic_derivation==2
                     [Da,DP,DLIKt,D2a,D2P, Hesst] = univariate_computeDLIK(k,i,z(i,:),Zflag,prediction_error,Ki,PZ,Fi,Da,DYss,DP,DH(d_index(i),:),notsteady,D2a,D2Yss,D2P);
                 else
                     [Da,DP,DLIKt,Hesst] = univariate_computeDLIK(k,i,z(i,:),Zflag,prediction_error,Ki,PZ,Fi,Da,DYss,DP,DH(d_index(i),:),notsteady);
                 end
                 if t>presample
                     DLIK = DLIK + DLIKt;
-                    if analytic_derivation==2 || asy_hess,
+                    if analytic_derivation==2 || asy_hess
                         Hess = Hess + Hesst;
                     end
                 end
@@ -207,14 +207,14 @@ while notsteady && t<=last %loop over t
             % p. 157, DK (2012)
         end
     end
-    if analytic_derivation,        
-        if analytic_derivation==2,
+    if analytic_derivation
+        if analytic_derivation==2
             [Da,DP,D2a,D2P] = univariate_computeDstate(k,a,P,T,Da,DP,DT,DOm,notsteady,D2a,D2P,D2T,D2Om);
         else
             [Da,DP] = univariate_computeDstate(k,a,P,T,Da,DP,DT,DOm,notsteady);
         end
     end
-    a = T*a;            %transition according to (6.14) in DK (2012) 
+    a = T*a;            %transition according to (6.14) in DK (2012)
     P = T*P*T' + QQ;    %transition according to (6.14) in DK (2012)
     if t>=no_more_missing_observations
         notsteady = max(abs(K(:)-oldK))>riccati_tol;
@@ -225,29 +225,29 @@ end
 
 % Divide by two.
 lik(1:s,:) = .5*lik(1:s,:);
-if analytic_derivation,
+if analytic_derivation
     DLIK = DLIK/2;
     dlik = dlik/2;
-    if analytic_derivation==2 || asy_hess,
-%         Hess = (Hess + Hess')/2;
+    if analytic_derivation==2 || asy_hess
+        %         Hess = (Hess + Hess')/2;
         Hess = -Hess/2;
     end
 end
 
 % Call steady state univariate kalman filter if needed.
 if t <= last
-    if analytic_derivation,
-        if analytic_derivation==2,
+    if analytic_derivation
+        if analytic_derivation==2
             [tmp, tmp2] = univariate_kalman_filter_ss(Y,t,last,a,P,kalman_tol,T,H,Z,pp,Zflag, ...
-                analytic_derivation,Da,DT,DYss,DP,DH,D2a,D2T,D2Yss,D2P);
+                                                      analytic_derivation,Da,DT,DYss,DP,DH,D2a,D2T,D2Yss,D2P);
         else
             [tmp, tmp2] = univariate_kalman_filter_ss(Y,t,last,a,P,kalman_tol,T,H,Z,pp,Zflag, ...
-                analytic_derivation,Da,DT,DYss,DP,DH,asy_hess);
+                                                      analytic_derivation,Da,DT,DYss,DP,DH,asy_hess);
         end
         lik(s+1:end,:)=tmp2{1};
         dlik(s+1:end,:)=tmp2{2};
         DLIK = DLIK + tmp{2};
-        if analytic_derivation==2 || asy_hess,
+        if analytic_derivation==2 || asy_hess
             Hess = Hess + tmp{3};
         end
     else
@@ -262,8 +262,8 @@ else
     LIK = sum(sum(lik));
 end
 
-if analytic_derivation,
-    if analytic_derivation==2 || asy_hess,
+if analytic_derivation
+    if analytic_derivation==2 || asy_hess
         LIK={LIK, DLIK, Hess};
     else
         LIK={LIK, DLIK};
diff --git a/matlab/kalman/likelihood/univariate_kalman_filter_d.m b/matlab/kalman/likelihood/univariate_kalman_filter_d.m
index ac121ee33..ce78d2421 100644
--- a/matlab/kalman/likelihood/univariate_kalman_filter_d.m
+++ b/matlab/kalman/likelihood/univariate_kalman_filter_d.m
@@ -80,14 +80,14 @@ function [dLIK, dlikk, a, Pstar, llik] = univariate_kalman_filter_d(data_index,
 %! @ref{univariate_kalman_filter_ss}
 %! @end deftypefn
 %@eod:
-% 
+%
 % Algorithm:
-% 
+%
 %   Uses the diffuse univariate filter as described in Durbin/Koopman (2012): "Time
 %   Series Analysis by State Space Methods", Oxford University Press,
 %   Second Edition, Ch. 5, 6.4 + 7.2.5
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -125,15 +125,15 @@ while newRank && (t<=last)
     d_index = data_index{t};
     for i=1:length(d_index)
         Zi = Z(d_index(i),:);
-        prediction_error = Y(d_index(i),t) - Zi*a;      % nu_{t,i} in 6.13 in DK (2012) 
+        prediction_error = Y(d_index(i),t) - Zi*a;      % nu_{t,i} in 6.13 in DK (2012)
         Fstar = Zi*Pstar*Zi' + H(d_index(i));           % F_{*,t} in 5.7 in DK (2012), relies on H being diagonal
-        Finf  = Zi*Pinf*Zi';                            % F_{\infty,t} in 5.7 in DK (2012), relies on H being diagonal 
+        Finf  = Zi*Pinf*Zi';                            % F_{\infty,t} in 5.7 in DK (2012), relies on H being diagonal
         Kstar = Pstar*Zi';
         % Conduct check of rank
-        % Pinf and Finf are always scaled such that their norm=1: Fstar/Pstar, instead, 
+        % Pinf and Finf are always scaled such that their norm=1: Fstar/Pstar, instead,
         % depends on the actual values of std errors in the model and can be badly scaled.
-        % experience is that diffuse_kalman_tol has to be bigger than kalman_tol, to ensure 
-        % exiting the diffuse filter properly, avoiding tests that provide false non-zero rank for Pinf. 
+        % experience is that diffuse_kalman_tol has to be bigger than kalman_tol, to ensure
+        % exiting the diffuse filter properly, avoiding tests that provide false non-zero rank for Pinf.
         % Also the test for singularity is better set coarser for Finf than for Fstar for the same reason
         if Finf>diffuse_kalman_tol && newRank           % F_{\infty,t,i} = 0, use upper part of bracket on p. 175 DK (2012) for w_{t,i}
             Kinf   = Pinf*Zi';
@@ -141,7 +141,7 @@ while newRank && (t<=last)
             a         = a + Kinf_Finf*prediction_error;
             Pstar     = Pstar + Kinf*(Kinf_Finf'*(Fstar/Finf)) - Kstar*Kinf_Finf' - Kinf_Finf*Kstar';
             Pinf      = Pinf - Kinf*Kinf_Finf';
-            llik(s,d_index(i)) = log(Finf) + l2pi;      
+            llik(s,d_index(i)) = log(Finf) + l2pi;
             dlikk(s) = dlikk(s) + llik(s,d_index(i));
         elseif Fstar>kalman_tol
             llik(s,d_index(i)) = log(Fstar) + (prediction_error*prediction_error/Fstar) + l2pi;
diff --git a/matlab/kalman/likelihood/univariate_kalman_filter_ss.m b/matlab/kalman/likelihood/univariate_kalman_filter_ss.m
index cbc1d5775..9d8cbff06 100644
--- a/matlab/kalman/likelihood/univariate_kalman_filter_ss.m
+++ b/matlab/kalman/likelihood/univariate_kalman_filter_ss.m
@@ -54,10 +54,10 @@ function [LIK,likk,a] = univariate_kalman_filter_ss(Y,start,last,a,P,kalman_tol,
 %! @sp 1
 %! @end deftypefn
 %@eod:
-% 
+%
 % Algorithm: See univariate_kalman_filter.m
 
-% Copyright (C) 2011-2016 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -90,18 +90,18 @@ if nargin<12
     analytic_derivation = 0;
 end
 
-if  analytic_derivation == 0,
+if  analytic_derivation == 0
     DLIK=[];
     Hess=[];
 else
     k = size(DT,3);                                 % number of structural parameters
     DLIK  = zeros(k,1);                             % Initialization of the score.
     dlikk = zeros(smpl,k);
-    if analytic_derivation==2,
+    if analytic_derivation==2
         Hess  = zeros(k,k);                             % Initialization of the Hessian
     else
         asy_hess=D2a;
-        if asy_hess,
+        if asy_hess
             Hess  = zeros(k,k);                             % Initialization of the Hessian
         else
             Hess=[];
@@ -113,9 +113,9 @@ end
 while t<=last
     s  = t-start+1;
     PP = P;
-    if analytic_derivation,
+    if analytic_derivation
         DPP = DP;
-        if analytic_derivation==2,
+        if analytic_derivation==2
             D2PP = D2P;
         end
     end
@@ -134,14 +134,14 @@ while t<=last
             a  = a + Ki*prediction_error;
             PP = PP - PPZ*Ki';
             likk(s,i) = log(Fi) + prediction_error*prediction_error/Fi + l2pi;
-            if analytic_derivation,
-                if analytic_derivation==2,
+            if analytic_derivation
+                if analytic_derivation==2
                     [Da,DPP,DLIKt,D2a,D2PP, Hesst] = univariate_computeDLIK(k,i,Z(i,:),Zflag,prediction_error,Ki,PPZ,Fi,Da,DYss,DPP,DH(i,:),0,D2a,D2Yss,D2PP);
                 else
                     [Da,DPP,DLIKt,Hesst] = univariate_computeDLIK(k,i,Z(i,:),Zflag,prediction_error,Ki,PPZ,Fi,Da,DYss,DPP,DH(i,:),0);
                 end
                 DLIK = DLIK + DLIKt;
-                if analytic_derivation==2 || asy_hess,
+                if analytic_derivation==2 || asy_hess
                     Hess = Hess + Hesst;
                 end
                 dlikk(s,:)=dlikk(s,:)+DLIKt';
@@ -151,8 +151,8 @@ while t<=last
             % p. 157, DK (2012)
         end
     end
-    if analytic_derivation,        
-        if analytic_derivation==2,
+    if analytic_derivation
+        if analytic_derivation==2
             [Da,junk,D2a] = univariate_computeDstate(k,a,P,T,Da,DP,DT,[],0,D2a,D2P,D2T);
         else
             Da = univariate_computeDstate(k,a,P,T,Da,DP,DT,[],0);
@@ -165,15 +165,15 @@ end
 likk = .5*likk;
 
 LIK = sum(sum(likk));
-if analytic_derivation,
+if analytic_derivation
     dlikk = dlikk/2;
     DLIK = DLIK/2;
     likk = {likk, dlikk};
 end
-if analytic_derivation==2 || asy_hess,
-%     Hess = (Hess + Hess')/2;
+if analytic_derivation==2 || asy_hess
+    %     Hess = (Hess + Hess')/2;
     Hess = -Hess/2;
     LIK={LIK,DLIK,Hess};
-elseif analytic_derivation==1,
+elseif analytic_derivation==1
     LIK={LIK,DLIK};
 end
\ No newline at end of file
diff --git a/matlab/kalman/steady_state_kalman_gain.m b/matlab/kalman/steady_state_kalman_gain.m
index 460534e1b..c40761d4a 100644
--- a/matlab/kalman/steady_state_kalman_gain.m
+++ b/matlab/kalman/steady_state_kalman_gain.m
@@ -1,23 +1,23 @@
 function [K,iF,P] = steady_state_kalman_gain(T,R,Q,H,mf)
 % Given the invariant state space representation of a model, this
 % function computes the gain matrix and the covariance matrix of the
-% state vector at the steady state of the kalman filter. 
-% 
-% INPUTS 
-%   T   [double]    m*m transition matrix of the state vector.  
+% state vector at the steady state of the kalman filter.
+%
+% INPUTS
+%   T   [double]    m*m transition matrix of the state vector.
 %   R   [double]    m*q matrix (q is the number of structural innovations).
 %   Q   [double]    q*q covariance matrix of the structural innovations.
 %   H   [double]    p*p covariance matrix of the measurement error.
 %   mf  [integer]   p*1 vector, indices for the observed variables
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   K   [double]    kalman gain matrix.
 %   P   [double]    covariance matrix of the state vector.
-%               
+%
 % SPECIAL REQUIREMENTS
 %   Needs a solver for Riccati equations (dare.m)
 
-% Copyright (C) 2004-2009 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/kalman_transition_matrix.m b/matlab/kalman_transition_matrix.m
index 77b3a4d3a..f79b436cd 100644
--- a/matlab/kalman_transition_matrix.m
+++ b/matlab/kalman_transition_matrix.m
@@ -1,21 +1,21 @@
 function [A,B] = kalman_transition_matrix(dr,iv,ic,exo_nbr)
 %function [A,B] = kalman_transition_matrix(dr,iv,ic,exo_nbr)
 % Builds the transition equation of the state space representation out of ghx and ghu for Kalman filter
-% 
+%
 % INPUTS
 %    dr:      structure of decisions rules for stochastic simulations
 %    iv:      selected variables
 %    ic:      state variables position in the transition matrix columns
 %    exo_nbr: number of exogenous variables
-%    
+%
 % OUTPUTS
 %    A:       matrix of predetermined variables effects in linear solution (ghx)
 %    B:       matrix of shocks effects in linear solution (ghu)
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,4 +41,3 @@ A(:,ic) = dr.ghx(iv,:);
 if nargout>1
     B = dr.ghu(iv,:);
 end
-
diff --git a/matlab/kernel_density_estimate.m b/matlab/kernel_density_estimate.m
index 172097c87..c04927681 100644
--- a/matlab/kernel_density_estimate.m
+++ b/matlab/kernel_density_estimate.m
@@ -1,30 +1,30 @@
-function [abscissa,f] = kernel_density_estimate(data,number_of_grid_points,number_of_draws,bandwidth,kernel_function) 
-% Estimates a continuous density. 
-% 
+function [abscissa,f] = kernel_density_estimate(data,number_of_grid_points,number_of_draws,bandwidth,kernel_function)
+% Estimates a continuous density.
+%
 % INPUTS
 %   data                  [double]  Vector (number_of_draws*1) of draws.
 %   number_of_grid_points [integer] Scalar, number of points where the density is estimated.
-%                                   This (positive) integer must be a power of two.  
+%                                   This (positive) integer must be a power of two.
 %   number_of_draws       [integer] Scalar, number of draws.
-%   bandwidth             [double]  Real positive scalar.                                  
+%   bandwidth             [double]  Real positive scalar.
 %   kernel_function       [string]  Name of the kernel function: 'gaussian', 'triweight',
-%                                   'uniform', 'triangle', 'epanechnikov', 'quartic', 
+%                                   'uniform', 'triangle', 'epanechnikov', 'quartic',
 %                                   'triweight' and 'cosinus'
 %
 % OUTPUTS
 %    abscissa             [double] Vector (number_of_grid_points*1) of values on the abscissa axis.
-%    f:                   [double] Vector (number_of_grid_points*1) of values on the ordinate axis, 
+%    f:                   [double] Vector (number_of_grid_points*1) of values on the ordinate axis,
 %                                  (density estimates).
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none.
 %
 % REFERENCES
 %    A kernel density estimator is used (see Silverman [1986], "Density estimation for statistics and data analysis")
-%    The code is adapted from Anders Holtsberg's matlab toolbox (stixbox). 
+%    The code is adapted from Anders Holtsberg's matlab toolbox (stixbox).
 %
 
-% Copyright (C) 2004-2008 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -53,19 +53,19 @@ if (abs(test-round(test)) > 1e-12)
 end
 
 %% Kernel specification.
-if strcmpi(kernel_function,'gaussian') 
+if strcmpi(kernel_function,'gaussian')
     kernel = @(x) inv(sqrt(2*pi))*exp(-0.5*x.^2);
-elseif strcmpi(kernel_function,'uniform') 
-    kernel = @(x) 0.5*(abs(x) <= 1); 
-elseif strcmpi(kernel_function,'triangle') 
+elseif strcmpi(kernel_function,'uniform')
+    kernel = @(x) 0.5*(abs(x) <= 1);
+elseif strcmpi(kernel_function,'triangle')
     kernel = @(x) (1-abs(x)).*(abs(x) <= 1);
-elseif strcmpi(kernel_function,'epanechnikov') 
+elseif strcmpi(kernel_function,'epanechnikov')
     kernel = @(x) 0.75*(1-x.^2).*(abs(x) <= 1);
-elseif strcmpi(kernel_function,'quartic') 
+elseif strcmpi(kernel_function,'quartic')
     kernel = @(x) 0.9375*((1-x.^2).^2).*(abs(x) <= 1);
-elseif strcmpi(kernel_function,'triweight') 
+elseif strcmpi(kernel_function,'triweight')
     kernel = @(x) 1.09375*((1-x.^2).^3).*(abs(x) <= 1);
-elseif strcmpi(kernel_function,'cosinus') 
+elseif strcmpi(kernel_function,'cosinus')
     kernel = @(x) (pi/4)*cos((pi/2)*x).*(abs(x) <= 1);
 end
 
@@ -73,9 +73,9 @@ end
 lower_bound  = min(data) - (max(data)-min(data))/3;
 upper_bound  = max(data) + (max(data)-min(data))/3;
 abscissa = linspace(lower_bound,upper_bound,number_of_grid_points)';
-inc = abscissa(2)-abscissa(1); 
+inc = abscissa(2)-abscissa(1);
 xi  = zeros(number_of_grid_points,1);
-xa  = (data-lower_bound)/(upper_bound-lower_bound)*number_of_grid_points; 
+xa  = (data-lower_bound)/(upper_bound-lower_bound)*number_of_grid_points;
 for i = 1:number_of_draws
     indx = floor(xa(i));
     temp = xa(i)-indx;
diff --git a/matlab/list_of_functions_to_be_cleared.m b/matlab/list_of_functions_to_be_cleared.m
index e482add52..a9d182dae 100644
--- a/matlab/list_of_functions_to_be_cleared.m
+++ b/matlab/list_of_functions_to_be_cleared.m
@@ -1 +1 @@
-list_of_functions = {'discretionary_policy_1', 'dsge_var_likelihood', 'dyn_first_order_solver', 'dyn_waitbar', 'ep_residuals', 'evaluate_likelihood', 'evaluate_smoother', 'prior_draw_gsa', 'identification_analysis', 'computeDLIK', 'univariate_computeDLIK', 'metropolis_draw', 'flag_implicit_skip_nan', 'moment_function', 'non_linear_dsge_likelihood', 'mr_hessian', 'masterParallel', 'auxiliary_initialization', 'auxiliary_particle_filter', 'conditional_filter_proposal', 'conditional_particle_filter', 'gaussian_filter', 'gaussian_filter_bank', 'gaussian_mixture_filter', 'gaussian_mixture_filter_bank', 'Kalman_filter', 'online_auxiliary_filter', 'sequential_importance_particle_filter', 'solve_model_for_online_filter', 'perfect_foresight_simulation', 'prior_draw', 'priordens', 'smm_objective'};
\ No newline at end of file
+list_of_functions = {'discretionary_policy_1', 'dsge_var_likelihood', 'dyn_first_order_solver', 'dyn_waitbar', 'ep_residuals', 'evaluate_likelihood', 'prior_draw_gsa', 'identification_analysis', 'computeDLIK', 'univariate_computeDLIK', 'metropolis_draw', 'flag_implicit_skip_nan', 'moment_function', 'non_linear_dsge_likelihood', 'mr_hessian', 'masterParallel', 'auxiliary_initialization', 'auxiliary_particle_filter', 'conditional_filter_proposal', 'conditional_particle_filter', 'gaussian_filter', 'gaussian_filter_bank', 'gaussian_mixture_filter', 'gaussian_mixture_filter_bank', 'Kalman_filter', 'online_auxiliary_filter', 'sequential_importance_particle_filter', 'solve_model_for_online_filter', 'perfect_foresight_simulation', 'prior_draw', 'priordens', 'smm_objective'};
\ No newline at end of file
diff --git a/matlab/list_of_parameters_calibrated_as_NaN.m b/matlab/list_of_parameters_calibrated_as_NaN.m
index 603a9f2e1..01964a89a 100644
--- a/matlab/list_of_parameters_calibrated_as_NaN.m
+++ b/matlab/list_of_parameters_calibrated_as_NaN.m
@@ -1,19 +1,19 @@
 function list = list_of_parameters_calibrated_as_NaN(M_)
 % The name of the function is explicit enough...
-%  
+%
 % INPUTS
 %   M_    [structure]   Description of the (simulated or estimated) model.
-%  
+%
 % OUTPUTS
 %   list  [char]        n*p array of characters, each line is the name of parameter without value.
-%    
+%
 % ALGORITHM
 %   none
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/lmmcp/catstruct.m b/matlab/lmmcp/catstruct.m
index 540bc99d7..df4a9c05b 100644
--- a/matlab/lmmcp/catstruct.m
+++ b/matlab/lmmcp/catstruct.m
@@ -1,174 +1,171 @@
-function A = catstruct(varargin)
-% CATSTRUCT   Concatenate or merge structures with different fieldnames
-%   X = CATSTRUCT(S1,S2,S3,...) merges the structures S1, S2, S3 ...
-%   into one new structure X. X contains all fields present in the various
-%   structures. An example:
-%
-%     A.name = 'Me' ;
-%     B.income = 99999 ;
-%     X = catstruct(A,B) 
-%     % -> X.name = 'Me' ;
-%     %    X.income = 99999 ;
-%
-%   If a fieldname is not unique among structures (i.e., a fieldname is
-%   present in more than one structure), only the value from the last
-%   structure with this field is used. In this case, the fields are 
-%   alphabetically sorted. A warning is issued as well. An axample:
-%
-%     S1.name = 'Me' ;
-%     S2.age  = 20 ; S3.age  = 30 ; S4.age  = 40 ;
-%     S5.honest = false ;
-%     Y = catstruct(S1,S2,S3,S4,S5) % use value from S4
-%
-%   The inputs can be array of structures. All structures should have the
-%   same size. An example:
-%
-%     C(1).bb = 1 ; C(2).bb = 2 ;
-%     D(1).aa = 3 ; D(2).aa = 4 ;
-%     CD = catstruct(C,D) % CD is a 1x2 structure array with fields bb and aa
-%
-%   The last input can be the string 'sorted'. In this case,
-%   CATSTRUCT(S1,S2, ..., 'sorted') will sort the fieldnames alphabetically. 
-%   To sort the fieldnames of a structure A, you could use
-%   CATSTRUCT(A,'sorted') but I recommend ORDERFIELDS for doing that.
-%
-%   When there is nothing to concatenate, the result will be an empty
-%   struct (0x0 struct array with no fields).
-%
-%   NOTE: To concatenate similar arrays of structs, you can use simple
-%   concatenation: 
-%     A = dir('*.mat') ; B = dir('*.m') ; C = [A ; B] ;
-%
-%   See also CAT, STRUCT, FIELDNAMES, STRUCT2CELL, ORDERFIELDS
-
-% for Matlab R13 and up
-% version 3.0 (mar 2013)
-% Originally downloaded from MATLAB central:
-% http://www.mathworks.com/matlabcentral/fileexchange/7842-catstruct
-
-% Copyright (C) 2005 Jos van der Geest <jos@jasen.nl>
-% Copyright (C) 2013 Christophe Gouel
-% Copyright (C) 2016 Dynare Team
-%
-% Redistribution and use in source and binary forms, with or without
-% modification, are permitted provided that the following conditions are
-% met:
-% 
-%     * Redistributions of source code must retain the above copyright
-%       notice, this list of conditions and the following disclaimer.
-%     * Redistributions in binary form must reproduce the above copyright
-%       notice, this list of conditions and the following disclaimer in
-%       the documentation and/or other materials provided with the distribution
-% 
-% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-% POSSIBILITY OF SUCH DAMAGE.
-
-% History
-% Created in 2005
-% Revisions
-%   2.0 (sep 2007) removed bug when dealing with fields containing cell
-%                  arrays (Thanks to Rene Willemink)
-%   2.1 (sep 2008) added warning and error identifiers
-%   2.2 (oct 2008) fixed error when dealing with empty structs (Thanks to
-%                  Lars Barring)
-%   3.0 (mar 2013) fixed problem when the inputs were array of structures
-%                  (thanks to Tor Inge Birkenes for pointing this out).
-%                  Rephrased the help section as well.
-
-narginchk(1, Inf);
-N = nargin ;
-
-if ~isstruct(varargin{end}),
-    if isequal(varargin{end},'sorted'),
-        sorted = 1 ;
-        N = N-1 ;
-        if N<1
-            error('catstruct: wrong number of input arguments') ;
-        end
-    else
-        error('catstruct:InvalidArgument','Last argument should be a structure, or the string "sorted".') ;
-    end
-else
-    sorted = 0 ;
-end
-
-sz0 = [] ; % used to check that all inputs have the same size
-
-% used to check for a few trivial cases
-NonEmptyInputs = false(N,1) ; 
-NonEmptyInputsN = 0 ;
-
-% used to collect the fieldnames and the inputs
-FN = cell(N,1) ;
-VAL = cell(N,1) ;
-
-% parse the inputs
-for ii=1:N,
-    X = varargin{ii} ;
-    if ~isstruct(X),
-        error('catstruct:InvalidArgument',['Argument #' num2str(ii) ' is not a structure.']) ;
-    end
-    
-    if ~isempty(X),
-        % empty structs are ignored
-        if ii > 1 && ~isempty(sz0)
-            if ~isequal(size(X), sz0)
-                error('catstruct:UnequalSizes','All structures should have the same size.') ;
-            end
-        else
-            sz0 = size(X) ;
-        end
-        NonEmptyInputsN = NonEmptyInputsN + 1 ;
-        NonEmptyInputs(ii) = true ;
-        FN{ii} = fieldnames(X) ;
-        VAL{ii} = struct2cell(X) ;
-    end
-end
-
-if NonEmptyInputsN == 0
-    % all structures were empty
-    A = struct([]) ;
-elseif NonEmptyInputsN == 1,
-    % there was only one non-empty structure
-    A = varargin{NonEmptyInputs} ;
-    if sorted,
-        A = orderfields(A) ;
-    end
-else
-    % there is actually something to concatenate
-    FN = cat(1,FN{:}) ;    
-    VAL = cat(1,VAL{:}) ;    
-    FN = squeeze(FN) ;
-    VAL = squeeze(VAL) ;
-    MatlabVersion = version;
-    if isoctave || str2double(MatlabVersion(end-5:end-2))<2013 % Equivalent to, but faster than if verLessThan('matlab','8.1')
-      [UFN,ind] = unique(FN) ;          
-    else
-      [UFN,ind] = unique(FN,'legacy') ;
-    end
-    
-    if numel(UFN) ~= numel(FN),
-        warning('catstruct:DuplicatesFound','Fieldnames are not unique between structures.') ;
-        sorted = 1 ;
-    end
-    
-    if sorted,
-        VAL = VAL(ind,:) ;
-        FN = FN(ind,:) ;
-    end
-    
-    A = cell2struct(VAL, FN);
-    A = reshape(A, sz0) ; % reshape into original format
-end
-
-
-
+function A = catstruct(varargin)
+% CATSTRUCT   Concatenate or merge structures with different fieldnames
+%   X = CATSTRUCT(S1,S2,S3,...) merges the structures S1, S2, S3 ...
+%   into one new structure X. X contains all fields present in the various
+%   structures. An example:
+%
+%     A.name = 'Me' ;
+%     B.income = 99999 ;
+%     X = catstruct(A,B)
+%     % -> X.name = 'Me' ;
+%     %    X.income = 99999 ;
+%
+%   If a fieldname is not unique among structures (i.e., a fieldname is
+%   present in more than one structure), only the value from the last
+%   structure with this field is used. In this case, the fields are
+%   alphabetically sorted. A warning is issued as well. An axample:
+%
+%     S1.name = 'Me' ;
+%     S2.age  = 20 ; S3.age  = 30 ; S4.age  = 40 ;
+%     S5.honest = false ;
+%     Y = catstruct(S1,S2,S3,S4,S5) % use value from S4
+%
+%   The inputs can be array of structures. All structures should have the
+%   same size. An example:
+%
+%     C(1).bb = 1 ; C(2).bb = 2 ;
+%     D(1).aa = 3 ; D(2).aa = 4 ;
+%     CD = catstruct(C,D) % CD is a 1x2 structure array with fields bb and aa
+%
+%   The last input can be the string 'sorted'. In this case,
+%   CATSTRUCT(S1,S2, ..., 'sorted') will sort the fieldnames alphabetically.
+%   To sort the fieldnames of a structure A, you could use
+%   CATSTRUCT(A,'sorted') but I recommend ORDERFIELDS for doing that.
+%
+%   When there is nothing to concatenate, the result will be an empty
+%   struct (0x0 struct array with no fields).
+%
+%   NOTE: To concatenate similar arrays of structs, you can use simple
+%   concatenation:
+%     A = dir('*.mat') ; B = dir('*.m') ; C = [A ; B] ;
+%
+%   See also CAT, STRUCT, FIELDNAMES, STRUCT2CELL, ORDERFIELDS
+
+% for Matlab R13 and up
+% version 3.0 (mar 2013)
+% Originally downloaded from MATLAB central:
+% http://www.mathworks.com/matlabcentral/fileexchange/7842-catstruct
+
+% Copyright (C) 2005 Jos van der Geest <jos@jasen.nl>
+% Copyright (C) 2013 Christophe Gouel
+% Copyright (C) 2016-2017 Dynare Team
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted provided that the following conditions are
+% met:
+%
+%     * Redistributions of source code must retain the above copyright
+%       notice, this list of conditions and the following disclaimer.
+%     * Redistributions in binary form must reproduce the above copyright
+%       notice, this list of conditions and the following disclaimer in
+%       the documentation and/or other materials provided with the distribution
+%
+% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+% POSSIBILITY OF SUCH DAMAGE.
+
+% History
+% Created in 2005
+% Revisions
+%   2.0 (sep 2007) removed bug when dealing with fields containing cell
+%                  arrays (Thanks to Rene Willemink)
+%   2.1 (sep 2008) added warning and error identifiers
+%   2.2 (oct 2008) fixed error when dealing with empty structs (Thanks to
+%                  Lars Barring)
+%   3.0 (mar 2013) fixed problem when the inputs were array of structures
+%                  (thanks to Tor Inge Birkenes for pointing this out).
+%                  Rephrased the help section as well.
+
+narginchk(1, Inf);
+N = nargin ;
+
+if ~isstruct(varargin{end})
+    if isequal(varargin{end},'sorted')
+        sorted = 1 ;
+        N = N-1 ;
+        if N<1
+            error('catstruct: wrong number of input arguments') ;
+        end
+    else
+        error('catstruct:InvalidArgument','Last argument should be a structure, or the string "sorted".') ;
+    end
+else
+    sorted = 0 ;
+end
+
+sz0 = [] ; % used to check that all inputs have the same size
+
+% used to check for a few trivial cases
+NonEmptyInputs = false(N,1) ;
+NonEmptyInputsN = 0 ;
+
+% used to collect the fieldnames and the inputs
+FN = cell(N,1) ;
+VAL = cell(N,1) ;
+
+% parse the inputs
+for ii=1:N
+    X = varargin{ii} ;
+    if ~isstruct(X)
+        error('catstruct:InvalidArgument',['Argument #' num2str(ii) ' is not a structure.']) ;
+    end
+
+    if ~isempty(X)
+        % empty structs are ignored
+        if ii > 1 && ~isempty(sz0)
+            if ~isequal(size(X), sz0)
+                error('catstruct:UnequalSizes','All structures should have the same size.') ;
+            end
+        else
+            sz0 = size(X) ;
+        end
+        NonEmptyInputsN = NonEmptyInputsN + 1 ;
+        NonEmptyInputs(ii) = true ;
+        FN{ii} = fieldnames(X) ;
+        VAL{ii} = struct2cell(X) ;
+    end
+end
+
+if NonEmptyInputsN == 0
+    % all structures were empty
+    A = struct([]) ;
+elseif NonEmptyInputsN == 1
+    % there was only one non-empty structure
+    A = varargin{NonEmptyInputs} ;
+    if sorted
+        A = orderfields(A) ;
+    end
+else
+    % there is actually something to concatenate
+    FN = cat(1,FN{:}) ;
+    VAL = cat(1,VAL{:}) ;
+    FN = squeeze(FN) ;
+    VAL = squeeze(VAL) ;
+    MatlabVersion = version;
+    if isoctave || str2double(MatlabVersion(end-5:end-2))<2013 % Equivalent to, but faster than if verLessThan('matlab','8.1')
+        [UFN,ind] = unique(FN) ;
+    else
+        [UFN,ind] = unique(FN,'legacy') ;
+    end
+
+    if numel(UFN) ~= numel(FN)
+        warning('catstruct:DuplicatesFound','Fieldnames are not unique between structures.') ;
+        sorted = 1 ;
+    end
+
+    if sorted
+        VAL = VAL(ind,:) ;
+        FN = FN(ind,:) ;
+    end
+
+    A = cell2struct(VAL, FN);
+    A = reshape(A, sz0) ; % reshape into original format
+end
diff --git a/matlab/lmmcp/dyn_lmmcp_func.m b/matlab/lmmcp/dyn_lmmcp_func.m
index 936f98306..0da1f7565 100644
--- a/matlab/lmmcp/dyn_lmmcp_func.m
+++ b/matlab/lmmcp/dyn_lmmcp_func.m
@@ -3,7 +3,7 @@ function [F,A] = dyn_lmmcp_func(x, model_dynamic, Y0, YT, exo_simul, params, ...
                                 i_cols_A1, i_cols_1, i_cols_T, i_cols_j, ...
                                 nnzA,eq_index)
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -20,37 +20,36 @@ function [F,A] = dyn_lmmcp_func(x, model_dynamic, Y0, YT, exo_simul, params, ...
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    Y = [Y0; x; YT];
-    
-    F = zeros(periods*ny,1);
+Y = [Y0; x; YT];
+
+F = zeros(periods*ny,1);
+if nargout == 2
+    A = sparse([],[],[],periods*ny,periods*ny,periods*nnzA);
+end
+
+i_rows = 1:ny;
+i_cols = find(lead_lag_incidence');
+i_cols_A = i_cols;
+
+for it = 2:(periods+1)
+
+    [res,jacobian] = model_dynamic(Y(i_cols),exo_simul, params, ...
+                                   steady_state,it);
+    F(i_rows) = res(eq_index);
+
     if nargout == 2
-        A = sparse([],[],[],periods*ny,periods*ny,periods*nnzA);
-    end
-
-    i_rows = 1:ny;
-    i_cols = find(lead_lag_incidence');
-    i_cols_A = i_cols;
-
-    for it = 2:(periods+1)
-        
-        [res,jacobian] = model_dynamic(Y(i_cols),exo_simul, params, ...
-                                       steady_state,it);
-        F(i_rows) = res(eq_index);
-        
-        if nargout == 2
-            if it == 2
-                A(i_rows,i_cols_A1) = jacobian(eq_index,i_cols_1);
-            elseif it == periods+1
-                A(i_rows,i_cols_A(i_cols_T)) = jacobian(eq_index,i_cols_T);
-            else
-                A(i_rows,i_cols_A) = jacobian(eq_index,i_cols_j);
-            end
-        end
-        
-        i_rows = i_rows + ny;
-        i_cols = i_cols + ny;
-        if nargout == 2 && it > 2
-            i_cols_A = i_cols_A + ny;
+        if it == 2
+            A(i_rows,i_cols_A1) = jacobian(eq_index,i_cols_1);
+        elseif it == periods+1
+            A(i_rows,i_cols_A(i_cols_T)) = jacobian(eq_index,i_cols_T);
+        else
+            A(i_rows,i_cols_A) = jacobian(eq_index,i_cols_j);
         end
     end
 
+    i_rows = i_rows + ny;
+    i_cols = i_cols + ny;
+    if nargout == 2 && it > 2
+        i_cols_A = i_cols_A + ny;
+    end
+end
diff --git a/matlab/lmmcp/get_complementarity_conditions.m b/matlab/lmmcp/get_complementarity_conditions.m
index d1ea1771f..fb48ece9a 100644
--- a/matlab/lmmcp/get_complementarity_conditions.m
+++ b/matlab/lmmcp/get_complementarity_conditions.m
@@ -2,17 +2,17 @@ function [lb,ub,eq_index] = get_complementarity_conditions(M,ramsey_policy)
 % [lb,ub,eq_index] = get_complementarity_conditions(M,ramsey_policy)
 % INPUTS
 %   - M                   [struct] contains a description of the model.
-%   - ramsey_policy       [boolean] indicator whether a Ramsey problem is considered 
+%   - ramsey_policy       [boolean] indicator whether a Ramsey problem is considered
 % OUTPUTS
 %   - lb                  [double] endo_nbr*1 array of lower bounds for
 %                                   endogenous variables
 %   - ub                  [double] endo_nbr*1 array of upper bounds for
 %                                   endogenous variables
-%   - eq_index            [struct] endo_nbr*1 index vector describing residual mapping resulting 
+%   - eq_index            [struct] endo_nbr*1 index vector describing residual mapping resulting
 %                                from complementarity setup used in
 %                                perfect_foresight_mcp_problem.m
 
-% Copyright (C) 2014-16 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,14 +55,14 @@ for i=1:size(etags,1)
         str = etags{i,3};
         kop = strfind(etags{i,3},'<');
         if ~isempty(kop)
-                k = find(strcmp(strtrim(str(1:kop-1)),cellstr(M.endo_names))); %get variable index with restriction
-                if isempty(k)
-                    error(sprintf(['Complementarity condition %s: variable %s is ' ...
-                                   'not recognized'],etags{i,3},strtrim(str(1:kop-1))))
-                end
-                ub(k) = str2num(str(kop+1:end));
-                eq_index(etags{i,1}) = k;
-                eq_index(k) = etags{i,1};
+            k = find(strcmp(strtrim(str(1:kop-1)),cellstr(M.endo_names))); %get variable index with restriction
+            if isempty(k)
+                error(sprintf(['Complementarity condition %s: variable %s is ' ...
+                               'not recognized'],etags{i,3},strtrim(str(1:kop-1))))
+            end
+            ub(k) = str2num(str(kop+1:end));
+            eq_index(etags{i,1}) = k;
+            eq_index(k) = etags{i,1};
         else
             kop = strfind(etags{i,3},'>');
             if ~isempty(kop)
@@ -81,4 +81,3 @@ for i=1:size(etags,1)
         end
     end
 end
-
diff --git a/matlab/lmmcp/lmmcp.m b/matlab/lmmcp/lmmcp.m
index 1ac1c5e0a..50404ac7c 100644
--- a/matlab/lmmcp/lmmcp.m
+++ b/matlab/lmmcp/lmmcp.m
@@ -1,625 +1,625 @@
-function [x,FVAL,EXITFLAG,OUTPUT,JACOB] = lmmcp(FUN,x,lb,ub,options,varargin)
-% LMMCP solves a mixed complementarity problem.
-%
-% LMMCP uses a semismooth least squares formulation. The method applies a
-% Levenberg-Marquardt/Gauss-Newton algorithm to a least-squares formulation.
-%
-% X = LMMCP(FUN,X0) tries to solve the system of nonlinear equations F(X)=0 and
-% starts at the vector X0. FUN accepts a vector X and return a vector F of equation
-% values F evaluated at X and, as second output if required, a matrix J, the
-% Jacobian evaluated at X.
-%
-% X = LMMCP(FUN,X0,LB,UB) solves the mixed complementarity problem of the form:
-% LB =X     =>   F(X)>0,
-% LB<=X<=UB =>   F(X)=0,
-%     X =UB =>   F(X)<0.
-%
-% X = LMMCP(FUN,X0,LB,UB,OPTIONS) solves the MCP problem using the options
-% defined in the structure OPTIONS. Main fields are
-%      Display    : control the display of iterations, 'none' (default),
-%                   'iter-detailed' or 'final-detailed'
-%  Switch from phase I to phase II
-%      preprocess : activate preprocessor for phase I (default = 1)
-%      presteps   : number of iterations in phase I (default = 20)
-%  Termination parameters
-%      MaxIter    : Maximum number of iterations (default = 500)
-%      tmin       : safeguard stepsize (default = 1E-12)
-%      TolFun     : Termination tolerance on the function value, a positive 
-%                   scalar (default = sqrt(eps))
-%  Stepsize parameters
-%      m          : number of previous function values to use in the nonmonotone
-%                   line search rule (default = 10)
-%      kwatch     : maximum number of steps (default = 20 and should not be
-%                   smaller than m)
-%      watchdog   : activate the watchdog strategy (default = 1)
-%  Ther are other minor parameters. Please see the code for their default values
-%  and interpretation.
-%
-% [X,FVAL] = LMMCP(FUN,X0,...) returns the value of the equations FUN at X.
-%
-% [X,FVAL,EXITFLAG] = LMMCP(FUN,X0,...) returns EXITFLAG that describes the exit
-% conditions. Possible values are
-%      1         : LMMCP converged to a root
-%      0         : Too many iterations
-%     -1         :
-%
-% [X,FVAL,EXITFLAG,OUTPUT] = LMMCP(FUN,X0,...) returns the structure OUTPUT that
-% contains the number of iterations (OUTPUT.iterations), the value of the merit
-% function (OUTPUT.Psix), and the norm of the derivative of the merit function
-% (OUTPUT.normDPsix).
-%
-% [X,FVAL,EXITFLAG,OUTPUT,JACOB] = LMMCP(FUN,X0,...) returns JACOB the Jacobian
-% of FUN evaluated at X.
-%
-% More details of the main program may be found in the following paper:
-%
-% Christian Kanzow and Stefania Petra: On a semismooth least squares formulation of
-% complementarity problems with gap reduction. Optimization Methods and Software
-% 19, 2004, pp. 507-525.
-%
-% In addition, the current implementation uses a preprocessor which is the
-% projected Levenberg-Marquardt step from the following preprint:
-%
-% Christian Kanzow and Stefania Petra: Projected filter trust region methods for a
-% semismooth least squares formulation of mixed complementarity
-% problems. Optimization Methods and Software
-% 22, 2007, pp. 713-735.
-%
-% A user's guide is also available:
-%
-% Christian Kanzow and Stefania Petra (2005).
-% LMMCP --- A Levenberg-Marquardt-type MATLAB Solver for Mixed Complementarity Problems.
-% University of Wuerzburg.
-% http://www.mathematik.uni-wuerzburg.de/~kanzow/software/UserGuide.pdf
-%
-% This is a modification by Christophe Gouel of the original files, which can be
-% downloaded from:
-% http://www.mathematik.uni-wuerzburg.de/~kanzow/software/LMMCP.zip
-%
-% Written by Christian Kanzow and Stefania Petra
-%            Institute of Applied Mathematics and Statistics
-%            University of Wuerzburg
-%            Am Hubland
-%            97074 Wuerzburg
-%            GERMANY
-%
-%            e-mail: kanzow@mathematik.uni-wuerzburg.de
-%                    petra@mathematik.uni-wuerzburg.de
-%
-% Christian Kanzow sent a private message to Dynare Team on July 8, 2014,
-% confirming the free software status of lmmcp and granting unlimited
-% permission to use, copy, modifiy or redistribute the file.
-
-% Copyright (C) 2005 Christian Kanzow and Stefania Petra
-% Copyright (C) 2013 Christophe Gouel
-% Copyright (C) 2014 Dynare Team
-%
-% Unlimited permission is granted to everyone to use, copy, modify or
-% distribute this software.
-
-%% Initialization
-defaultopt = struct(...
-    'beta',       0.55,...
-    'Big',        1e10,...
-    'delta',      5,...
-    'deltamin',   1,...
-    'Display',    'none',...
-    'epsilon1',   1e-6,...
-    'eta',        0.95,...
-    'kwatch',     20,...
-    'lambda1',    0.1,...
-    'm',          10,...
-    'MaxIter',    500,...
-    'null',       1e-10,...
-    'preprocess', 1,...
-    'presteps',   20,...
-    'sigma',      1e-4,...
-    'sigma1',     0.5,...
-    'sigma2',     2,...
-    'tmin',       1e-12,...
-    'TolFun',     sqrt(eps),...
-    'watchdog',   1);
-
-if nargin < 4
-  ub = inf(size(x));
-  if nargin < 3
-    lb = -inf(size(x));
-  end
-end
-
-if nargin < 5 || isempty(options) || ~isstruct(options)
-  options = defaultopt;
-else
-  warning('off','catstruct:DuplicatesFound')
-  options = catstruct(defaultopt,options);
-end
-
-warning('off','MATLAB:rankDeficientMatrix')
-
-switch options.Display
-  case {'off','none'}
-    verbosity = 0;
-  case {'iter','iter-detailed'}
-    verbosity = 2;
-  case {'final','final-detailed'}
-    verbosity = 1;
-  otherwise
-    verbosity = 0;
-end
-
-% parameter settings
-eps1 = options.epsilon1;
-eps2 = 0.5*options.TolFun^2;
-null = options.null;
-Big  = options.Big;
-
-% maximal number of iterations
-kmax     = options.MaxIter;
-
-% choice of lambda
-lambda1  = options.lambda1;
-lambda2  = 1-lambda1;
-
-% steplength parameters
-beta     = options.beta;
-sigma    = options.sigma;
-tmin     = options.tmin;
-
-% parameters watchdog and nonmonotone line search; redefined later
-m        = options.m;
-kwatch   = options.kwatch;
-watchdog = options.watchdog; % 1=watchdog strategy active, otherwise not
-
-% parameters for preprocessor
-preprocess = options.preprocess; % 1=preprocessor used, otherwise not
-presteps   = options.presteps; % maximum number of preprocessing steps
-
-% trust-region parameters for preprocessor
-delta    = options.delta;
-deltamin = options.deltamin;
-sigma1   = options.sigma1;
-sigma2   = options.sigma2;
-eta      = options.eta;
-
-% initializations
-k        = 0;
-k_main   = 0;
-
-% compute a feasible starting point by projection
-x = max(lb,min(x,ub));
-
-n = length(x);
-OUTPUT.Dim = n;
-
-% definition of index sets I_l, I_u and I_lu
-Indexset       = zeros(n,1);
-I_l            = lb>-Big & ub>Big;
-I_u            = lb<-Big & ub<Big;
-I_lu           = lb>-Big & ub<Big;
-Indexset(I_l)  = 1;
-Indexset(I_u)  = 2;
-Indexset(I_lu) = 3;
-
-% function evaluations
-[Fx,DFx] = feval(FUN,x,varargin{:});
-
-% choice of NCP-function and corresponding evaluations
-Phix      = Phi(x,Fx,lb,ub,lambda1,lambda2,n,Indexset);
-normPhix  = norm(Phix);
-Psix      = 0.5*(Phix'*Phix);
-DPhix     = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset);
-DPsix     = DPhix'*Phix;
-normDPsix = norm(DPsix);
-
-% save initial values
-x0         = x;
-Phix0      = Phix;
-Psix0      = Psix;
-DPhix0     = DPhix;
-DPsix0     = DPsix;
-normDPsix0 = normDPsix;
-
-% watchdog strategy
-aux    = zeros(m,1);
-aux(1) = Psix;
-MaxPsi = Psix;
-
-if watchdog==1
-  kbest        = k;
-  xbest        = x;
-  Phibest      = Phix;
-  Psibest      = Psix;
-  DPhibest     = DPhix;
-  DPsibest     = DPsix;
-  normDPsibest = normDPsix;
-end
-
-% initial output
-if verbosity > 1
-  fprintf('   k               Psi(x)                || DPsi(x) ||    stepsize\n');
-  disp('====================================================================')
-  disp('********************* Output at starting point *********************')
-  fprintf('%4.0f %24.5e %24.5e\n',k,Psix,normDPsix);
-end
-
-%% Preprocessor using local method
-
-if preprocess==1
-
-  if verbosity > 1
-    disp('************************** Preprocessor ****************************')
-  end
-  
-  normpLM=1;
-  while (k < presteps) && (Psix > eps2) && (normpLM>null)
-    k = k+1;
-    
-    % choice of Levenberg-Marquardt parameter, note that we do not use
-    % the condition estimator for large-scale problems, although this
-    % may cause numerical problems in some examples
-
-    i  = false;
-    mu = 0;
-    if n<100
-      i = true;
-      mu = 1e-16;
-      if condest(DPhix'*DPhix)>1e25
-        mu = 1e-6/(k+1);
-      end
-    end
-    if i
-      pLM =  [DPhix; sqrt(mu)*speye(n)]\[-Phix; zeros(n,1)];
-    else
-      pLM = -DPhix\Phix;
-    end
-    normpLM = norm(pLM);
-    
-    % compute the projected Levenberg-Marquard step onto box Xk
-    lbnew = max(min(lb-x,0),-delta);
-    ubnew = min(max(ub-x,0),delta);
-    d     = max(lbnew,min(pLM,ubnew));
-    xnew  = x+d;
-
-    % function evaluations etc.
-    [Fxnew,DFxnew] = feval(FUN,xnew,varargin{:});
-    Phixnew        = Phi(xnew,Fxnew,lb,ub,lambda1,lambda2,n,Indexset);
-    Psixnew        = 0.5*(Phixnew'*Phixnew);
-    normPhixnew    = norm(Phixnew);
-    
-    % update of delta
-    if normPhixnew<=eta*normPhix
-      delta = max(deltamin,sigma2*delta);
-    elseif normPhixnew>5*eta*normPhix
-      delta = max(deltamin,sigma1*delta);
-    end
-
-    % update
-    x         = xnew;
-    Fx        = Fxnew;
-    DFx       = DFxnew;
-    Phix      = Phixnew;
-    Psix      = Psixnew;
-    normPhix  = normPhixnew;
-    DPhix     = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset);
-    DPsix     = DPhix'*Phix;
-    normDPsix = norm(DPsix,inf);
-    
-    % output at each iteration
-    t=1;
-    if verbosity > 1
-      fprintf('%4.0f %24.5e %24.5e %11.7g\n',k,Psix,normDPsix,t);
-    end
-  end
-end
-
-% terminate program or redefine current iterate as original initial point
-if preprocess==1 && Psix<eps2
-  if verbosity > 0
-    fprintf('Psix = %1.4e\nnormDPsix = %1.4e\n',Psix,normDPsix);
-    disp('Approximate solution found.')
-  end
-  EXITFLAG          = 1;
-  FVAL              = Fx;
-  OUTPUT.iterations = k;
-  OUTPUT.Psix       = Psix;
-  OUTPUT.normDPsix  = normDPsix;
-  JACOB             = DFx;
-  return
-elseif preprocess==1 && Psix>=eps2
-  x=x0;
-  Phix=Phix0;
-  Psix=Psix0;
-  DPhix=DPhix0;
-  DPsix=DPsix0;
-  if verbosity > 1
-    disp('******************** Restart with initial point ********************')
-    fprintf('%4.0f %24.5e %24.5e\n',k_main,Psix0,normDPsix0);
-  end
-end
-
-%%   Main algorithm
-
-if verbosity > 1
-  disp('************************** Main program ****************************')
-end
-
-while (k < kmax) && (Psix > eps2)
-
-  % choice of Levenberg-Marquardt parameter, note that we do not use
-  % the condition estimator for large-scale problems, although this
-  % may cause numerical problems in some examples
-
-  i = false;
-  if n<100
-    i  = true;
-    mu = 1e-16;
-    if condest(DPhix'*DPhix)>1e25
-      mu = 1e-1/(k+1);
-    end
-  end
-  
-  % compute a Levenberg-Marquard direction
-
-  if i
-    d = [DPhix; sqrt(mu)*speye(n)]\[-Phix; zeros(n,1)];
-  else
-    d = -DPhix\Phix;
-  end
-
-  % computation of steplength t using the nonmonotone Armijo-rule
-  % starting with the 6-th iteration
-
-  % computation of steplength t using the monotone Armijo-rule if
-  % d is a 'good' descent direction or k<=5
-
-  t       = 1;
-  xnew    = x+d;
-  Fxnew   = feval(FUN,xnew,varargin{:});
-  Phixnew = Phi(xnew,Fxnew,lb,ub,lambda1,lambda2,n,Indexset);
-  Psixnew = 0.5*(Phixnew'*Phixnew);
-  const   = sigma*DPsix'*d;
-  
-  while (Psixnew > MaxPsi + const*t)  && (t > tmin)
-    t       = t*beta;
-    xnew    = x+t*d;
-    Fxnew   = feval(FUN,xnew,varargin{:});
-    Phixnew = Phi(xnew,Fxnew,lb,ub,lambda1,lambda2,n,Indexset);
-    Psixnew = 0.5*(Phixnew'*Phixnew);
-  end
-
-  % updatings
-  x         = xnew;
-  Fx        = Fxnew;
-  Phix      = Phixnew;
-  Psix      = Psixnew;
-  [junk,DFx]   = feval(FUN,x,varargin{:});
-  DPhix     = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset);
-  DPsix     = DPhix'*Phix;
-  normDPsix = norm(DPsix);
-  k         = k+1;
-  k_main    = k_main+1;
-  
-  if k_main<=5
-    aux(mod(k_main,m)+1) = Psix;
-    MaxPsi               = Psix;
-  else
-    aux(mod(k_main,m)+1) = Psix;
-    MaxPsi               = max(aux);
-  end
-  
-  % updatings for the watchdog strategy
-  if watchdog ==1
-    if Psix<Psibest
-      kbest        = k;
-      xbest        = x;
-      Phibest      = Phix;
-      Psibest      = Psix;
-      DPhibest     = DPhix;
-      DPsibest     = DPsix;
-      normDPsibest = normDPsix;
-    elseif k-kbest>kwatch
-      x=xbest;
-      Phix=Phibest;
-      Psix=Psibest;
-      DPhix=DPhibest;
-      DPsix=DPsibest;
-      normDPsix=normDPsibest;
-      MaxPsi=Psix;
-    end
-  end
-
-  if verbosity > 1
-    % output at each iteration
-    fprintf('%4.0f %24.5e %24.5e %11.7g\n',k,Psix,normDPsix,t);
-  end
-end
-
-%% Final output
-if Psix<=eps2
-  EXITFLAG = 1;
-  if verbosity > 0, disp('Approximate solution found.'); end
-elseif k>=kmax
-  EXITFLAG = 0;
-  if verbosity > 0, disp('Maximum iteration number reached.'); end
-elseif normDPsix<=eps1
-  EXITFLAG          = -1; % Provisoire
-  if verbosity > 0, disp('Approximate stationary point found.'); end
-else
-  EXITFLAG          = -1; % Provisoire
-  if verbosity > 0, disp('No solution found.'); end
-end
-
-FVAL              = Fx;
-OUTPUT.iterations = k;
-OUTPUT.Psix       = Psix;
-OUTPUT.normDPsix  = normDPsix;
-JACOB             = DFx;
-
-%% Subfunctions
-
-function y = Phi(x,Fx,lb,ub,lambda1,lambda2,n,Indexset)
-%% PHI
-
-y           = zeros(2*n,1);
-phi_u       = sqrt((ub-x).^2+Fx.^2)-ub+x+Fx;
-LZ          = false(n,1); % logical zero
-
-I0          = Indexset==0;
-y(I0)       = -lambda1*Fx(I0);
-y([LZ; I0]) = -lambda2*Fx(I0);
-
-I1          = Indexset==1;
-y(I1)       = lambda1*(-x(I1)+lb(I1)-Fx(I1)+sqrt((x(I1)-lb(I1)).^2+Fx(I1).^2));
-y([LZ; I1]) = lambda2*max(0,x(I1)-lb(I1)).*max(0,Fx(I1));
-
-I2          = Indexset==2;
-y(I2)       = -lambda1*phi_u(I2);
-y([LZ; I2]) = lambda2*max(0,ub(I2)-x(I2)).*max(0,-Fx(I2));
-
-I3          = Indexset==3;
-y(I3)       = lambda1*(sqrt((x(I3)-lb(I3)).^2+phi_u(I3).^2)-x(I3)+lb(I3)-phi_u(I3));
-y([LZ; I3]) = lambda2*(max(0,x(I3)-lb(I3)).*max(0,Fx(I3))+max(0,ub(I3)-x(I3)).*max(0,-Fx(I3)));
-
-
-function H = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset)
-%% DPHI evaluates an element of the C-subdifferential of operator Phi
-
-null       = 1e-8;
-beta_l     = zeros(n,1);
-beta_u     = zeros(n,1);
-alpha_l    = zeros(n,1);
-alpha_u    = zeros(n,1);
-
-
-z          = zeros(n,1);
-H2         = sparse(n,n);
-
-I          = abs(x-lb)<=null & abs(Fx)<=null;
-beta_l(I)  = 1;
-z(I)       = 1;
-
-I          = abs(ub-x)<=null & abs(Fx)<=null;
-beta_u(I)  = 1;
-z(I)       = 1;
-
-I          = x-lb>=-null & Fx>=-null;
-alpha_l(I) = 1;
-
-I          = ub-x>=-null & Fx<=null;
-alpha_u(I) = 1;
-
-Da         = zeros(n,1);
-Db         = zeros(n,1);
-
-I          = 1:n;
-
-I0         = Indexset==0;
-Da(I0)     = 0;
-Db(I0)     = -1;
-H2(I0,:)   = -DFx(I0,:);
-
-I1         = Indexset==1;
-denom1     = zeros(n,1);
-denom2     = zeros(n,1);
-if any(I1)
-  denom1(I1) = max(null,sqrt((x(I1)-lb(I1)).^2+Fx(I1).^2));
-  denom2(I1) = max(null,sqrt(z(I1).^2+(DFx(I1,:)*z).^2));
-end
-
-I1b        = Indexset==1 & beta_l==0;
-Da(I1b)    = (x(I1b)-lb(I1b))./denom1(I1b)-1;
-Db(I1b)    = Fx(I1b)./denom1(I1b)-1;
-I1b        = Indexset==1 & beta_l~=0;
-if any(I1b)
-  Da(I1b)  = z(I1b)./denom2(I1b)-1;
-  Db(I1b)  = (DFx(I1b,:)*z)./denom2(I1b)-1;
-end
-
-I1a         = I(Indexset==1 & alpha_l==1);
-if any(I1a)
-    H2(I1a,:) = spdiags(x(I1a)-lb(I1a), 0, length(I1a), length(I1a))*DFx(I1a,:) +...
-              sparse(1:length(I1a),I1a,Fx(I1a),length(I1a),n,length(I1a));
-end
-
-I2         = Indexset==2;
-denom1     = zeros(n,1);
-denom2     = zeros(n,1);
-if any(I2)
-  denom1(I2) = max(null,sqrt((ub(I2)-x(I2)).^2+Fx(I2).^2));
-  denom2(I2) = max(null,sqrt(z(I2).^2+(DFx(I2,:)*z).^2));
-end
-
-I2b        = Indexset==2 & beta_u==0;
-Da(I2b)    = (ub(I2b)-x(I2b))./denom1(I2b)-1;
-Db(I2b)    = -Fx(I2b)./denom1(I2b)-1;
-I2b        = Indexset==2 & beta_u~=0;
-if any(I2b)
-  Da(I2b)  = -z(I2b)./denom2(I2b)-1;
-  Db(I2b)  = -(DFx(I2b,:)*z)./denom2(I2b)-1;
-end
-
-I2a         = I(Indexset==2 & alpha_u==1);
-if any(I2a)
-  H2(I2a,:) = bsxfun(@times,x(I2a)-ub(I2a),DFx(I2a,:))+...
-              sparse(1:length(I2a),I2a,Fx(I2a),length(I2a),n,length(I2a));
-end
-
-I3         = Indexset==3;
-phi        = zeros(n,1);
-ai         = zeros(n,1);
-bi         = zeros(n,1);
-ci         = zeros(n,1);
-di         = zeros(n,1);
-denom1     = zeros(n,1);
-denom2     = zeros(n,1);
-denom3     = zeros(n,1);
-denom4     = zeros(n,1);
-if any(I3)
-  phi(I3)    = -ub(I3)+x(I3)+Fx(I3)+sqrt((ub(I3)-x(I3)).^2+Fx(I3).^2);
-  denom1(I3) = max(null,sqrt((x(I3)-lb(I3)).^2+phi(I3).^2));
-  denom2(I3) = max(null,sqrt(z(I3).^2+(DFx(I3,:)*z).^2));
-  denom3(I3) = max(null,sqrt((ub(I3)-x(I3)).^2+Fx(I3).^2));
-  denom4(I3) = max(null,sqrt(z(I3).^2));
-end
-
-I3bu       = Indexset==3 & beta_u==0;
-ci(I3bu)   = (x(I3bu)-ub(I3bu))./denom3(I3bu)+1;
-di(I3bu)   = Fx(I3bu)./denom3(I3bu)+1;
-I3bu       = Indexset==3 & beta_u~=0;
-if any(I3bu)
-  ci(I3bu)   = 1+z(I3bu)./denom2(I3bu);
-  di(I3bu)   = 1+(DFx(I3bu,:)*z)./denom2(I3bu);
-end
-
-I3bl       = Indexset==3 & beta_l==0;
-ai(I3bl)   = (x(I3bl)-lb(I3bl))./denom1(I3bl)-1;
-bi(I3bl)   = phi(I3bl)./denom1(I3bl)-1;
-I3bl       = Indexset==3 & beta_l~=0;
-if any(I3bl)
-  ai(I3bl)   = z(I3bl)./denom4(I3bl)-1;
-  bi(I3bl)   = (ci(I3bl).*z(I3bl)+(di(I3bl,ones(1,n)).*DFx(I3bl,:))*z)./denom4(I3bl)-1;
-end
-
-Da(I3)     = ai(I3)+bi(I3).*ci(I3);
-Db(I3)     = bi(I3).*di(I3);
-
-I3a         = I(Indexset==3 & alpha_l==1 & alpha_u==1);
-if any(I3a)
-  H2(I3a,:) = bsxfun(@times,-lb(I3a)-ub(I3a)+2*x(I3a),DFx(I3a,:))+...
-              2*sparse(1:length(I3a),I3a,Fx(I3a),length(I3a),n,length(I3a));
-end
-I3a         = I(Indexset==3 & alpha_l==1 & alpha_u~=1);
-if any(I3a)
-  H2(I3a,:) = bsxfun(@times,x(I3a)-lb(I3a),DFx(I3a,:))+...
-              sparse(1:length(I3a),I3a,Fx(I3a),length(I3a),n,length(I3a));
-end
-I3a         = I(Indexset==3 & alpha_l~=1 & alpha_u==1);
-if any(I3a)
-  H2(I3a,:) = bsxfun(@times,x(I3a)-ub(I3a),DFx(I3a,:))+...
-              sparse(1:length(I3a),I3a,Fx(I3a),length(I3a),n,length(I3a));
-end
-
-H1 = spdiags(Db,0,length(Db),length(Db))*DFx;
-H1 = H1 + spdiags(Da, 0, length(Da), length(Da));
-
-H  = [lambda1*H1; lambda2*H2];
+function [x,FVAL,EXITFLAG,OUTPUT,JACOB] = lmmcp(FUN,x,lb,ub,options,varargin)
+% LMMCP solves a mixed complementarity problem.
+%
+% LMMCP uses a semismooth least squares formulation. The method applies a
+% Levenberg-Marquardt/Gauss-Newton algorithm to a least-squares formulation.
+%
+% X = LMMCP(FUN,X0) tries to solve the system of nonlinear equations F(X)=0 and
+% starts at the vector X0. FUN accepts a vector X and return a vector F of equation
+% values F evaluated at X and, as second output if required, a matrix J, the
+% Jacobian evaluated at X.
+%
+% X = LMMCP(FUN,X0,LB,UB) solves the mixed complementarity problem of the form:
+% LB =X     =>   F(X)>0,
+% LB<=X<=UB =>   F(X)=0,
+%     X =UB =>   F(X)<0.
+%
+% X = LMMCP(FUN,X0,LB,UB,OPTIONS) solves the MCP problem using the options
+% defined in the structure OPTIONS. Main fields are
+%      Display    : control the display of iterations, 'none' (default),
+%                   'iter-detailed' or 'final-detailed'
+%  Switch from phase I to phase II
+%      preprocess : activate preprocessor for phase I (default = 1)
+%      presteps   : number of iterations in phase I (default = 20)
+%  Termination parameters
+%      MaxIter    : Maximum number of iterations (default = 500)
+%      tmin       : safeguard stepsize (default = 1E-12)
+%      TolFun     : Termination tolerance on the function value, a positive
+%                   scalar (default = sqrt(eps))
+%  Stepsize parameters
+%      m          : number of previous function values to use in the nonmonotone
+%                   line search rule (default = 10)
+%      kwatch     : maximum number of steps (default = 20 and should not be
+%                   smaller than m)
+%      watchdog   : activate the watchdog strategy (default = 1)
+%  Ther are other minor parameters. Please see the code for their default values
+%  and interpretation.
+%
+% [X,FVAL] = LMMCP(FUN,X0,...) returns the value of the equations FUN at X.
+%
+% [X,FVAL,EXITFLAG] = LMMCP(FUN,X0,...) returns EXITFLAG that describes the exit
+% conditions. Possible values are
+%      1         : LMMCP converged to a root
+%      0         : Too many iterations
+%     -1         :
+%
+% [X,FVAL,EXITFLAG,OUTPUT] = LMMCP(FUN,X0,...) returns the structure OUTPUT that
+% contains the number of iterations (OUTPUT.iterations), the value of the merit
+% function (OUTPUT.Psix), and the norm of the derivative of the merit function
+% (OUTPUT.normDPsix).
+%
+% [X,FVAL,EXITFLAG,OUTPUT,JACOB] = LMMCP(FUN,X0,...) returns JACOB the Jacobian
+% of FUN evaluated at X.
+%
+% More details of the main program may be found in the following paper:
+%
+% Christian Kanzow and Stefania Petra: On a semismooth least squares formulation of
+% complementarity problems with gap reduction. Optimization Methods and Software
+% 19, 2004, pp. 507-525.
+%
+% In addition, the current implementation uses a preprocessor which is the
+% projected Levenberg-Marquardt step from the following preprint:
+%
+% Christian Kanzow and Stefania Petra: Projected filter trust region methods for a
+% semismooth least squares formulation of mixed complementarity
+% problems. Optimization Methods and Software
+% 22, 2007, pp. 713-735.
+%
+% A user's guide is also available:
+%
+% Christian Kanzow and Stefania Petra (2005).
+% LMMCP --- A Levenberg-Marquardt-type MATLAB Solver for Mixed Complementarity Problems.
+% University of Wuerzburg.
+% http://www.mathematik.uni-wuerzburg.de/~kanzow/software/UserGuide.pdf
+%
+% This is a modification by Christophe Gouel of the original files, which can be
+% downloaded from:
+% http://www.mathematik.uni-wuerzburg.de/~kanzow/software/LMMCP.zip
+%
+% Written by Christian Kanzow and Stefania Petra
+%            Institute of Applied Mathematics and Statistics
+%            University of Wuerzburg
+%            Am Hubland
+%            97074 Wuerzburg
+%            GERMANY
+%
+%            e-mail: kanzow@mathematik.uni-wuerzburg.de
+%                    petra@mathematik.uni-wuerzburg.de
+%
+% Christian Kanzow sent a private message to Dynare Team on July 8, 2014,
+% confirming the free software status of lmmcp and granting unlimited
+% permission to use, copy, modifiy or redistribute the file.
+
+% Copyright (C) 2005 Christian Kanzow and Stefania Petra
+% Copyright (C) 2013 Christophe Gouel
+% Copyright (C) 2014-2017 Dynare Team
+%
+% Unlimited permission is granted to everyone to use, copy, modify or
+% distribute this software.
+
+%% Initialization
+defaultopt = struct(...
+    'beta',       0.55,...
+    'Big',        1e10,...
+    'delta',      5,...
+    'deltamin',   1,...
+    'Display',    'none',...
+    'epsilon1',   1e-6,...
+    'eta',        0.95,...
+    'kwatch',     20,...
+    'lambda1',    0.1,...
+    'm',          10,...
+    'MaxIter',    500,...
+    'null',       1e-10,...
+    'preprocess', 1,...
+    'presteps',   20,...
+    'sigma',      1e-4,...
+    'sigma1',     0.5,...
+    'sigma2',     2,...
+    'tmin',       1e-12,...
+    'TolFun',     sqrt(eps),...
+    'watchdog',   1);
+
+if nargin < 4
+    ub = inf(size(x));
+    if nargin < 3
+        lb = -inf(size(x));
+    end
+end
+
+if nargin < 5 || isempty(options) || ~isstruct(options)
+    options = defaultopt;
+else
+    warning('off','catstruct:DuplicatesFound')
+    options = catstruct(defaultopt,options);
+end
+
+warning('off','MATLAB:rankDeficientMatrix')
+
+switch options.Display
+  case {'off','none'}
+    verbosity = 0;
+  case {'iter','iter-detailed'}
+    verbosity = 2;
+  case {'final','final-detailed'}
+    verbosity = 1;
+  otherwise
+    verbosity = 0;
+end
+
+% parameter settings
+eps1 = options.epsilon1;
+eps2 = 0.5*options.TolFun^2;
+null = options.null;
+Big  = options.Big;
+
+% maximal number of iterations
+kmax     = options.MaxIter;
+
+% choice of lambda
+lambda1  = options.lambda1;
+lambda2  = 1-lambda1;
+
+% steplength parameters
+beta     = options.beta;
+sigma    = options.sigma;
+tmin     = options.tmin;
+
+% parameters watchdog and nonmonotone line search; redefined later
+m        = options.m;
+kwatch   = options.kwatch;
+watchdog = options.watchdog; % 1=watchdog strategy active, otherwise not
+
+% parameters for preprocessor
+preprocess = options.preprocess; % 1=preprocessor used, otherwise not
+presteps   = options.presteps; % maximum number of preprocessing steps
+
+% trust-region parameters for preprocessor
+delta    = options.delta;
+deltamin = options.deltamin;
+sigma1   = options.sigma1;
+sigma2   = options.sigma2;
+eta      = options.eta;
+
+% initializations
+k        = 0;
+k_main   = 0;
+
+% compute a feasible starting point by projection
+x = max(lb,min(x,ub));
+
+n = length(x);
+OUTPUT.Dim = n;
+
+% definition of index sets I_l, I_u and I_lu
+Indexset       = zeros(n,1);
+I_l            = lb>-Big & ub>Big;
+I_u            = lb<-Big & ub<Big;
+I_lu           = lb>-Big & ub<Big;
+Indexset(I_l)  = 1;
+Indexset(I_u)  = 2;
+Indexset(I_lu) = 3;
+
+% function evaluations
+[Fx,DFx] = feval(FUN,x,varargin{:});
+
+% choice of NCP-function and corresponding evaluations
+Phix      = Phi(x,Fx,lb,ub,lambda1,lambda2,n,Indexset);
+normPhix  = norm(Phix);
+Psix      = 0.5*(Phix'*Phix);
+DPhix     = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset);
+DPsix     = DPhix'*Phix;
+normDPsix = norm(DPsix);
+
+% save initial values
+x0         = x;
+Phix0      = Phix;
+Psix0      = Psix;
+DPhix0     = DPhix;
+DPsix0     = DPsix;
+normDPsix0 = normDPsix;
+
+% watchdog strategy
+aux    = zeros(m,1);
+aux(1) = Psix;
+MaxPsi = Psix;
+
+if watchdog==1
+    kbest        = k;
+    xbest        = x;
+    Phibest      = Phix;
+    Psibest      = Psix;
+    DPhibest     = DPhix;
+    DPsibest     = DPsix;
+    normDPsibest = normDPsix;
+end
+
+% initial output
+if verbosity > 1
+    fprintf('   k               Psi(x)                || DPsi(x) ||    stepsize\n');
+    disp('====================================================================')
+    disp('********************* Output at starting point *********************')
+    fprintf('%4.0f %24.5e %24.5e\n',k,Psix,normDPsix);
+end
+
+%% Preprocessor using local method
+
+if preprocess==1
+
+    if verbosity > 1
+        disp('************************** Preprocessor ****************************')
+    end
+
+    normpLM=1;
+    while (k < presteps) && (Psix > eps2) && (normpLM>null)
+        k = k+1;
+
+        % choice of Levenberg-Marquardt parameter, note that we do not use
+        % the condition estimator for large-scale problems, although this
+        % may cause numerical problems in some examples
+
+        i  = false;
+        mu = 0;
+        if n<100
+            i = true;
+            mu = 1e-16;
+            if condest(DPhix'*DPhix)>1e25
+                mu = 1e-6/(k+1);
+            end
+        end
+        if i
+            pLM =  [DPhix; sqrt(mu)*speye(n)]\[-Phix; zeros(n,1)];
+        else
+            pLM = -DPhix\Phix;
+        end
+        normpLM = norm(pLM);
+
+        % compute the projected Levenberg-Marquard step onto box Xk
+        lbnew = max(min(lb-x,0),-delta);
+        ubnew = min(max(ub-x,0),delta);
+        d     = max(lbnew,min(pLM,ubnew));
+        xnew  = x+d;
+
+        % function evaluations etc.
+        [Fxnew,DFxnew] = feval(FUN,xnew,varargin{:});
+        Phixnew        = Phi(xnew,Fxnew,lb,ub,lambda1,lambda2,n,Indexset);
+        Psixnew        = 0.5*(Phixnew'*Phixnew);
+        normPhixnew    = norm(Phixnew);
+
+        % update of delta
+        if normPhixnew<=eta*normPhix
+            delta = max(deltamin,sigma2*delta);
+        elseif normPhixnew>5*eta*normPhix
+            delta = max(deltamin,sigma1*delta);
+        end
+
+        % update
+        x         = xnew;
+        Fx        = Fxnew;
+        DFx       = DFxnew;
+        Phix      = Phixnew;
+        Psix      = Psixnew;
+        normPhix  = normPhixnew;
+        DPhix     = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset);
+        DPsix     = DPhix'*Phix;
+        normDPsix = norm(DPsix,inf);
+
+        % output at each iteration
+        t=1;
+        if verbosity > 1
+            fprintf('%4.0f %24.5e %24.5e %11.7g\n',k,Psix,normDPsix,t);
+        end
+    end
+end
+
+% terminate program or redefine current iterate as original initial point
+if preprocess==1 && Psix<eps2
+    if verbosity > 0
+        fprintf('Psix = %1.4e\nnormDPsix = %1.4e\n',Psix,normDPsix);
+        disp('Approximate solution found.')
+    end
+    EXITFLAG          = 1;
+    FVAL              = Fx;
+    OUTPUT.iterations = k;
+    OUTPUT.Psix       = Psix;
+    OUTPUT.normDPsix  = normDPsix;
+    JACOB             = DFx;
+    return
+elseif preprocess==1 && Psix>=eps2
+    x=x0;
+    Phix=Phix0;
+    Psix=Psix0;
+    DPhix=DPhix0;
+    DPsix=DPsix0;
+    if verbosity > 1
+        disp('******************** Restart with initial point ********************')
+        fprintf('%4.0f %24.5e %24.5e\n',k_main,Psix0,normDPsix0);
+    end
+end
+
+%%   Main algorithm
+
+if verbosity > 1
+    disp('************************** Main program ****************************')
+end
+
+while (k < kmax) && (Psix > eps2)
+
+    % choice of Levenberg-Marquardt parameter, note that we do not use
+    % the condition estimator for large-scale problems, although this
+    % may cause numerical problems in some examples
+
+    i = false;
+    if n<100
+        i  = true;
+        mu = 1e-16;
+        if condest(DPhix'*DPhix)>1e25
+            mu = 1e-1/(k+1);
+        end
+    end
+
+    % compute a Levenberg-Marquard direction
+
+    if i
+        d = [DPhix; sqrt(mu)*speye(n)]\[-Phix; zeros(n,1)];
+    else
+        d = -DPhix\Phix;
+    end
+
+    % computation of steplength t using the nonmonotone Armijo-rule
+    % starting with the 6-th iteration
+
+    % computation of steplength t using the monotone Armijo-rule if
+    % d is a 'good' descent direction or k<=5
+
+    t       = 1;
+    xnew    = x+d;
+    Fxnew   = feval(FUN,xnew,varargin{:});
+    Phixnew = Phi(xnew,Fxnew,lb,ub,lambda1,lambda2,n,Indexset);
+    Psixnew = 0.5*(Phixnew'*Phixnew);
+    const   = sigma*DPsix'*d;
+
+    while (Psixnew > MaxPsi + const*t)  && (t > tmin)
+        t       = t*beta;
+        xnew    = x+t*d;
+        Fxnew   = feval(FUN,xnew,varargin{:});
+        Phixnew = Phi(xnew,Fxnew,lb,ub,lambda1,lambda2,n,Indexset);
+        Psixnew = 0.5*(Phixnew'*Phixnew);
+    end
+
+    % updatings
+    x         = xnew;
+    Fx        = Fxnew;
+    Phix      = Phixnew;
+    Psix      = Psixnew;
+    [junk,DFx]   = feval(FUN,x,varargin{:});
+    DPhix     = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset);
+    DPsix     = DPhix'*Phix;
+    normDPsix = norm(DPsix);
+    k         = k+1;
+    k_main    = k_main+1;
+
+    if k_main<=5
+        aux(mod(k_main,m)+1) = Psix;
+        MaxPsi               = Psix;
+    else
+        aux(mod(k_main,m)+1) = Psix;
+        MaxPsi               = max(aux);
+    end
+
+    % updatings for the watchdog strategy
+    if watchdog ==1
+        if Psix<Psibest
+            kbest        = k;
+            xbest        = x;
+            Phibest      = Phix;
+            Psibest      = Psix;
+            DPhibest     = DPhix;
+            DPsibest     = DPsix;
+            normDPsibest = normDPsix;
+        elseif k-kbest>kwatch
+            x=xbest;
+            Phix=Phibest;
+            Psix=Psibest;
+            DPhix=DPhibest;
+            DPsix=DPsibest;
+            normDPsix=normDPsibest;
+            MaxPsi=Psix;
+        end
+    end
+
+    if verbosity > 1
+        % output at each iteration
+        fprintf('%4.0f %24.5e %24.5e %11.7g\n',k,Psix,normDPsix,t);
+    end
+end
+
+%% Final output
+if Psix<=eps2
+    EXITFLAG = 1;
+    if verbosity > 0, disp('Approximate solution found.'); end
+elseif k>=kmax
+    EXITFLAG = 0;
+    if verbosity > 0, disp('Maximum iteration number reached.'); end
+elseif normDPsix<=eps1
+    EXITFLAG          = -1; % Provisoire
+    if verbosity > 0, disp('Approximate stationary point found.'); end
+else
+    EXITFLAG          = -1; % Provisoire
+    if verbosity > 0, disp('No solution found.'); end
+end
+
+FVAL              = Fx;
+OUTPUT.iterations = k;
+OUTPUT.Psix       = Psix;
+OUTPUT.normDPsix  = normDPsix;
+JACOB             = DFx;
+
+%% Subfunctions
+
+function y = Phi(x,Fx,lb,ub,lambda1,lambda2,n,Indexset)
+%% PHI
+
+y           = zeros(2*n,1);
+phi_u       = sqrt((ub-x).^2+Fx.^2)-ub+x+Fx;
+LZ          = false(n,1); % logical zero
+
+I0          = Indexset==0;
+y(I0)       = -lambda1*Fx(I0);
+y([LZ; I0]) = -lambda2*Fx(I0);
+
+I1          = Indexset==1;
+y(I1)       = lambda1*(-x(I1)+lb(I1)-Fx(I1)+sqrt((x(I1)-lb(I1)).^2+Fx(I1).^2));
+y([LZ; I1]) = lambda2*max(0,x(I1)-lb(I1)).*max(0,Fx(I1));
+
+I2          = Indexset==2;
+y(I2)       = -lambda1*phi_u(I2);
+y([LZ; I2]) = lambda2*max(0,ub(I2)-x(I2)).*max(0,-Fx(I2));
+
+I3          = Indexset==3;
+y(I3)       = lambda1*(sqrt((x(I3)-lb(I3)).^2+phi_u(I3).^2)-x(I3)+lb(I3)-phi_u(I3));
+y([LZ; I3]) = lambda2*(max(0,x(I3)-lb(I3)).*max(0,Fx(I3))+max(0,ub(I3)-x(I3)).*max(0,-Fx(I3)));
+
+
+function H = DPhi(x,Fx,DFx,lb,ub,lambda1,lambda2,n,Indexset)
+%% DPHI evaluates an element of the C-subdifferential of operator Phi
+
+null       = 1e-8;
+beta_l     = zeros(n,1);
+beta_u     = zeros(n,1);
+alpha_l    = zeros(n,1);
+alpha_u    = zeros(n,1);
+
+
+z          = zeros(n,1);
+H2         = sparse(n,n);
+
+I          = abs(x-lb)<=null & abs(Fx)<=null;
+beta_l(I)  = 1;
+z(I)       = 1;
+
+I          = abs(ub-x)<=null & abs(Fx)<=null;
+beta_u(I)  = 1;
+z(I)       = 1;
+
+I          = x-lb>=-null & Fx>=-null;
+alpha_l(I) = 1;
+
+I          = ub-x>=-null & Fx<=null;
+alpha_u(I) = 1;
+
+Da         = zeros(n,1);
+Db         = zeros(n,1);
+
+I          = 1:n;
+
+I0         = Indexset==0;
+Da(I0)     = 0;
+Db(I0)     = -1;
+H2(I0,:)   = -DFx(I0,:);
+
+I1         = Indexset==1;
+denom1     = zeros(n,1);
+denom2     = zeros(n,1);
+if any(I1)
+    denom1(I1) = max(null,sqrt((x(I1)-lb(I1)).^2+Fx(I1).^2));
+    denom2(I1) = max(null,sqrt(z(I1).^2+(DFx(I1,:)*z).^2));
+end
+
+I1b        = Indexset==1 & beta_l==0;
+Da(I1b)    = (x(I1b)-lb(I1b))./denom1(I1b)-1;
+Db(I1b)    = Fx(I1b)./denom1(I1b)-1;
+I1b        = Indexset==1 & beta_l~=0;
+if any(I1b)
+    Da(I1b)  = z(I1b)./denom2(I1b)-1;
+    Db(I1b)  = (DFx(I1b,:)*z)./denom2(I1b)-1;
+end
+
+I1a         = I(Indexset==1 & alpha_l==1);
+if any(I1a)
+    H2(I1a,:) = spdiags(x(I1a)-lb(I1a), 0, length(I1a), length(I1a))*DFx(I1a,:) +...
+        sparse(1:length(I1a),I1a,Fx(I1a),length(I1a),n,length(I1a));
+end
+
+I2         = Indexset==2;
+denom1     = zeros(n,1);
+denom2     = zeros(n,1);
+if any(I2)
+    denom1(I2) = max(null,sqrt((ub(I2)-x(I2)).^2+Fx(I2).^2));
+    denom2(I2) = max(null,sqrt(z(I2).^2+(DFx(I2,:)*z).^2));
+end
+
+I2b        = Indexset==2 & beta_u==0;
+Da(I2b)    = (ub(I2b)-x(I2b))./denom1(I2b)-1;
+Db(I2b)    = -Fx(I2b)./denom1(I2b)-1;
+I2b        = Indexset==2 & beta_u~=0;
+if any(I2b)
+    Da(I2b)  = -z(I2b)./denom2(I2b)-1;
+    Db(I2b)  = -(DFx(I2b,:)*z)./denom2(I2b)-1;
+end
+
+I2a         = I(Indexset==2 & alpha_u==1);
+if any(I2a)
+    H2(I2a,:) = bsxfun(@times,x(I2a)-ub(I2a),DFx(I2a,:))+...
+        sparse(1:length(I2a),I2a,Fx(I2a),length(I2a),n,length(I2a));
+end
+
+I3         = Indexset==3;
+phi        = zeros(n,1);
+ai         = zeros(n,1);
+bi         = zeros(n,1);
+ci         = zeros(n,1);
+di         = zeros(n,1);
+denom1     = zeros(n,1);
+denom2     = zeros(n,1);
+denom3     = zeros(n,1);
+denom4     = zeros(n,1);
+if any(I3)
+    phi(I3)    = -ub(I3)+x(I3)+Fx(I3)+sqrt((ub(I3)-x(I3)).^2+Fx(I3).^2);
+    denom1(I3) = max(null,sqrt((x(I3)-lb(I3)).^2+phi(I3).^2));
+    denom2(I3) = max(null,sqrt(z(I3).^2+(DFx(I3,:)*z).^2));
+    denom3(I3) = max(null,sqrt((ub(I3)-x(I3)).^2+Fx(I3).^2));
+    denom4(I3) = max(null,sqrt(z(I3).^2));
+end
+
+I3bu       = Indexset==3 & beta_u==0;
+ci(I3bu)   = (x(I3bu)-ub(I3bu))./denom3(I3bu)+1;
+di(I3bu)   = Fx(I3bu)./denom3(I3bu)+1;
+I3bu       = Indexset==3 & beta_u~=0;
+if any(I3bu)
+    ci(I3bu)   = 1+z(I3bu)./denom2(I3bu);
+    di(I3bu)   = 1+(DFx(I3bu,:)*z)./denom2(I3bu);
+end
+
+I3bl       = Indexset==3 & beta_l==0;
+ai(I3bl)   = (x(I3bl)-lb(I3bl))./denom1(I3bl)-1;
+bi(I3bl)   = phi(I3bl)./denom1(I3bl)-1;
+I3bl       = Indexset==3 & beta_l~=0;
+if any(I3bl)
+    ai(I3bl)   = z(I3bl)./denom4(I3bl)-1;
+    bi(I3bl)   = (ci(I3bl).*z(I3bl)+(di(I3bl,ones(1,n)).*DFx(I3bl,:))*z)./denom4(I3bl)-1;
+end
+
+Da(I3)     = ai(I3)+bi(I3).*ci(I3);
+Db(I3)     = bi(I3).*di(I3);
+
+I3a         = I(Indexset==3 & alpha_l==1 & alpha_u==1);
+if any(I3a)
+    H2(I3a,:) = bsxfun(@times,-lb(I3a)-ub(I3a)+2*x(I3a),DFx(I3a,:))+...
+        2*sparse(1:length(I3a),I3a,Fx(I3a),length(I3a),n,length(I3a));
+end
+I3a         = I(Indexset==3 & alpha_l==1 & alpha_u~=1);
+if any(I3a)
+    H2(I3a,:) = bsxfun(@times,x(I3a)-lb(I3a),DFx(I3a,:))+...
+        sparse(1:length(I3a),I3a,Fx(I3a),length(I3a),n,length(I3a));
+end
+I3a         = I(Indexset==3 & alpha_l~=1 & alpha_u==1);
+if any(I3a)
+    H2(I3a,:) = bsxfun(@times,x(I3a)-ub(I3a),DFx(I3a,:))+...
+        sparse(1:length(I3a),I3a,Fx(I3a),length(I3a),n,length(I3a));
+end
+
+H1 = spdiags(Db,0,length(Db),length(Db))*DFx;
+H1 = H1 + spdiags(Da, 0, length(Da), length(Da));
+
+H  = [lambda1*H1; lambda2*H2];
diff --git a/matlab/lnsrch1.m b/matlab/lnsrch1.m
index 6457793c7..09b128b91 100644
--- a/matlab/lnsrch1.m
+++ b/matlab/lnsrch1.m
@@ -20,11 +20,11 @@ function [x,f,fvec,check]=lnsrch1(xold, fold, g, p, stpmax, func, j1, j2, tolx,
 %   fvec:     residuals vector
 %   check=1:  problem of the looping which continues indefinitely
 %
-% 
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -48,7 +48,7 @@ x = xold;
 nn = length(j2);
 summ = sqrt(p'*p);
 
-if ~isfinite(summ) 
+if ~isfinite(summ)
     if ~isequal(func,@perfect_foresight_problem)
         eq_number_string=[];
         for ii=1:length(j1)-1
@@ -61,13 +61,13 @@ if ~isfinite(summ)
             var_string=[var_string, deblank(Model.endo_names(j2(ii),:)), ', '];
         end
         var_string=[var_string, deblank(Model.endo_names(j2(end),:))];
-        fprintf('\nAn infinite element was encountered when trying to solve equation(s) %s \n',eq_number_string) 
+        fprintf('\nAn infinite element was encountered when trying to solve equation(s) %s \n',eq_number_string)
         fprintf('with respect to the variable(s): %s.\n',var_string)
         fprintf('The values of the endogenous variables when the problem was encountered were:\n')
         for ii=1:length(xold)
             fprintf('%-s % 8.4g \n',Model.endo_names(ii,:),xold(ii));
         end
-        skipline();    
+        skipline();
     end
     error(['Some element of Newton direction isn''t finite. Jacobian maybe' ...
            ' singular or there is a problem with initial values'])
@@ -103,7 +103,7 @@ while 1
     else
         if f <= fold+alf*alam*slope
             check = 0;
-            break ;
+            break
         else
             if alam == 1
                 tmplam = -slope/(2*(f-fold-slope)) ;
diff --git a/matlab/lnsrch1_wrapper_one_boundary.m b/matlab/lnsrch1_wrapper_one_boundary.m
index 224851046..8ac9c14d0 100644
--- a/matlab/lnsrch1_wrapper_one_boundary.m
+++ b/matlab/lnsrch1_wrapper_one_boundary.m
@@ -12,16 +12,16 @@ function r = lnsrch1_wrapper_one_boundary(ya, y_index, fname, y, x, params, stea
 %   x                   [matrix]        All the exogenous variables of the model
 %   params              [vector]        All the parameters of the model
 % OUTPUTS
-%   r                   [vector]        The residuals of the current block      
-%  
+%   r                   [vector]        The residuals of the current block
+%
 % ALGORITHM
 %   none.
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/lnsrch1_wrapper_two_boundaries.m b/matlab/lnsrch1_wrapper_two_boundaries.m
index 3b55ca703..05c396c77 100644
--- a/matlab/lnsrch1_wrapper_two_boundaries.m
+++ b/matlab/lnsrch1_wrapper_two_boundaries.m
@@ -17,16 +17,16 @@ function ra = lnsrch1_wrapper_two_boundaries(ya, fname, y, y_index, x, ...
 %   y_size              [int]           The number of endogenous variables
 %                                       in the current block
 % OUTPUTS
-%   ra                  [vector]        The residuals of the current block      
-%  
+%   ra                  [vector]        The residuals of the current block
+%
 % ALGORITHM
 %   none.
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 2009-2015 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/load_first_mh_history_file.m b/matlab/load_first_mh_history_file.m
index 3177fafe4..b99c8ccbf 100644
--- a/matlab/load_first_mh_history_file.m
+++ b/matlab/load_first_mh_history_file.m
@@ -1,8 +1,8 @@
 function info = load_first_mh_history_file(MetropolisFolder, ModelName)
 
 % This routine requires that the MCMC draws were obtained with a dynare version greater than 4.3.3.
- 
-% Copyright (C) 2013 Dynare Team
+
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/load_last_mh_history_file.m b/matlab/load_last_mh_history_file.m
index 92bf059db..2874dbffd 100644
--- a/matlab/load_last_mh_history_file.m
+++ b/matlab/load_last_mh_history_file.m
@@ -4,13 +4,13 @@ function info = load_last_mh_history_file(MetropolisFolder, ModelName)
 % Inputs:
 %   MetropolisFolder    [char]      Name of the metropolis subfolder
 %   ModelName           [char]      Name of the mod-file
-% Outputs:  
+% Outputs:
 %   info                [struct]    structure storing the MH history
-% 
+%
 % Notes: The record structure is written to the caller workspace via an
 % assignin statement.
 
-% Copyright (C) 2013-2016 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -37,7 +37,7 @@ mh_history_files = dir([BaseName '_mh_history_*.mat']);
 % Consistency with older versions of Dynare.
 if isequal(length(mh_history_files),0)
     if exist([BaseName '_mh_history.mat'])
-        format_mh_history_file = 1; % old Dynare format 
+        format_mh_history_file = 1; % old Dynare format
     else
         error(['Estimation::load_mh_file: I cannot find any mh-history file in ' MetropolisFolder '!'])
     end
@@ -63,7 +63,7 @@ else
     load([BaseName '_mh_history_' num2str(length(mh_history_files)-1) '.mat']);
     % add fields that have later been introduced
     if ~isfield(record,'MCMCConcludedSuccessfully')
-        record.MCMCConcludedSuccessfully = NaN; % This information is forever lost...    
+        record.MCMCConcludedSuccessfully = NaN; % This information is forever lost...
     end
     if ~isfield(record,'MAX_nruns')
         record.MAX_nruns=NaN(size(record.MhDraws,1),1); % This information is forever lost...
diff --git a/matlab/load_m_file_data_legacy.m b/matlab/load_m_file_data_legacy.m
index 9442abfac..9d4b8e34c 100644
--- a/matlab/load_m_file_data_legacy.m
+++ b/matlab/load_m_file_data_legacy.m
@@ -1,6 +1,6 @@
-function data  = load_m_file_data_legacy(datafile, varobs)
+function o2WysrOISH  = load_m_file_data_legacy(datafile, U7ORsJ0vy3) % --*-- Unitary tests --*--
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -21,27 +21,142 @@ cXDHdrXnqo5KwwVpTRuc6OprAW = datafile(1:end-2);
 [pathtocXDHdrXnqo5KwwVpTRuc6OprAW,cXDHdrXnqo5KwwVpTRuc6OprAW,junk] = fileparts(cXDHdrXnqo5KwwVpTRuc6OprAW);
 
 if ~isempty(pathtocXDHdrXnqo5KwwVpTRuc6OprAW)
+    % We need to change directory, first we keep the current directory in memory...
     OvMuQsJgjwzYG5Pni0TzU8Acb2YBJva = pwd();
+    % Then we move in the directory where the data file is saved.
     cd(pathtocXDHdrXnqo5KwwVpTRuc6OprAW);
 end
 
+% We evaluate the matlab script defining the data. All the variables in the
+% variables defined in this script are loaded in the current workspace.
 eval(cXDHdrXnqo5KwwVpTRuc6OprAW);
 
 if ~isempty(pathtocXDHdrXnqo5KwwVpTRuc6OprAW)
+    % If we previously changed directory, we go back to the initial directory.
     cd(OvMuQsJgjwzYG5Pni0TzU8Acb2YBJva);
+    clear OvMuQsJgjwzYG5Pni0TzU8Acb2YBJva;
 end
 
-try
-    data = dseries(eval(cellofstring4eval(varobs)),[],varobs);
-catch
-    errmsg = sprintf('makedataset: Check that all the variables listed in varobs exist in %s and have the same number of observations.',datafile);
-    error(errmsg)
+% Clear all the variables except the ones defined in the script.
+clear('pathtocXDHdrXnqo5KwwVpTRuc6OprAW', 'cXDHdrXnqo5KwwVpTRuc6OprAW', 'junk');
+
+% Get the list of variables in the script.
+mj6F4eU1BN = whos();
+Z3s1ZFBffw = {mj6F4eU1BN(:).name};
+
+% Check that the variables in varobs are available.
+if ~isequal(sort(intersect(Z3s1ZFBffw, U7ORsJ0vy3)), sort(U7ORsJ0vy3))
+    qtvUkxKk6b = setdiff(U7ORsJ0vy3, intersect(Z3s1ZFBffw, U7ORsJ0vy3));
+    qtvUkxKk6b = sprintf('%s ', qtvUkxKk6b{:});
+    qtvUkxKk6b = qtvUkxKk6b(1:end-1);
+    error('Some variables are missing (%s)!', qtvUkxKk6b)
 end
 
-function str = cellofstring4eval(A)
-    n = length(A);
-    str = '[';
-    for i=1:n-1
-        str = [str, A{i}, ','];
+% Check that the variables are provided as vectors.
+N5L9sgRHIu = {};
+for uAiwEPcc3Q=1:length(U7ORsJ0vy3)
+    if ~isvector(eval(U7ORsJ0vy3{uAiwEPcc3Q}))
+        N5L9sgRHIu(end+1) = {U7ORsJ0vy3{uAiwEPcc3Q}};
     end
-    str = [str, A{n}, ']'];
\ No newline at end of file
+end
+if ~isempty(N5L9sgRHIu)
+    N5L9sgRHIu = sprintf('%s ', N5L9sgRHIu{:});
+    N5L9sgRHIu = N5L9sgRHIu(1:end-1);
+    error('Observed variables should be provided as vectors (%s are not vectors)!')
+end
+
+% Check that all the vectors have the same number of elements.
+RXZzmKFPFK = numel(eval(U7ORsJ0vy3{1}));
+for uAiwEPcc3Q=2:length(U7ORsJ0vy3)
+    if ~isequal(numel(eval(U7ORsJ0vy3{1})), RXZzmKFPFK)
+        error('All vectors must have the same number of elements (%s has %i elements while %s has %i elements)!', U7ORsJ0vy3{1}, numel(eval(U7ORsJ0vy3{1})), U7ORsJ0vy3{uAiwEPcc3Q}, numel(eval(U7ORsJ0vy3{uAiwEPcc3Q})));
+    end
+end
+
+% Put the observed variables in data
+JSmvfqTSXT = repmat(' vec(%s) ', 1, length(U7ORsJ0vy3));
+VbO4y7zOlh = sprintf('[%s]', JSmvfqTSXT);
+o2WysrOISH = dseries(eval(sprintf(VbO4y7zOlh, U7ORsJ0vy3{:})), [], U7ORsJ0vy3);
+
+return
+
+%@test:1
+% Write a data file
+fid = fopen('example.m','w');
+fwriten(fid, 'a = randn(100,1);');
+fwriten(fid, 'b = randn(100,1);');
+fwriten(fid, 'c = transpose(randn(100,1));');
+fwriten(fid, 'd = randn(100,1);');
+fwriten(fid, 'e = randn(100,2);');
+fwriten(fid, ' ');
+fwriten(fid, 'f = NaN(100,1);');
+fwriten(fid, 'for i=1:100');
+fwriten(fid, '  f(i) = log(rand());')
+fwriten(fid, 'end');
+fclose(fid);
+% Define a set of variables to be loaded.
+listofvariablestobeloaded = {'b', 'a'};
+% Test if we can load the data.
+try
+    data = load_m_file_data_legacy('example.m', listofvariablestobeloaded);
+    delete example.m
+    t(1) = 1;
+catch
+    t(1) = 0;
+end
+T = all(t);
+%@eof:1
+
+%@test:2
+% Write a data file
+fid = fopen('example.m','w');
+fwriten(fid, 'a = randn(100,1);');
+fwriten(fid, 'b = randn(100,1);');
+fwriten(fid, 'c = transpose(randn(100,1));');
+fwriten(fid, 'd = randn(100,1);');
+fwriten(fid, 'e = randn(100,2);');
+fwriten(fid, ' ');
+fwriten(fid, 'f = NaN(100,1);');
+fwriten(fid, 'for i=1:100');
+fwriten(fid, '  f(i) = log(rand());')
+fwriten(fid, 'end');
+fclose(fid);
+% Define a set of variables to be loaded.
+listofvariablestobeloaded = {'e', 'a'};
+% Test if we can load the data.
+try
+    data = load_m_file_data_legacy('example.m', listofvariablestobeloaded);
+    delete example.m
+    t(1) = 0;
+catch
+    t(1) = 1;
+end
+T = all(t);
+%@eof:2
+
+%@test:3
+% Write a data file
+fid = fopen('example.m','w');
+fwriten(fid, 'a = randn(100,1);');
+fwriten(fid, 'b = randn(100,1);');
+fwriten(fid, 'c = transpose(randn(100,1));');
+fwriten(fid, 'd = randn(100,1);');
+fwriten(fid, 'e = randn(100,2);');
+fwriten(fid, ' ');
+fwriten(fid, 'f = NaN(100,1);');
+fwriten(fid, 'for i=1:100');
+fwriten(fid, '  f(i) = log(rand());')
+fwriten(fid, 'end');
+fclose(fid);
+% Define a set of variables to be loaded.
+listofvariablestobeloaded = {'c', 'a'};
+% Test if we can load the data.
+try
+    data = load_m_file_data_legacy('example.m', listofvariablestobeloaded);
+    delete example.m
+    t(1) = 1;
+catch
+    t(1) = 0;
+end
+T = all(t);
+%@eof:3
diff --git a/matlab/load_mat_file_data_legacy.m b/matlab/load_mat_file_data_legacy.m
new file mode 100644
index 000000000..356c57237
--- /dev/null
+++ b/matlab/load_mat_file_data_legacy.m
@@ -0,0 +1,42 @@
+function data  = load_mat_file_data_legacy(datafile, varobs)
+
+% Copyright (C) 2017 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/>.
+
+data_file=load(datafile);
+
+names=fieldnames(data_file);
+
+if ~all(ismember(varobs',names))
+    missing_variables=varobs(~ismember(varobs',names))';
+    disp_string=[missing_variables{1,:}];
+    for ii=2:size(missing_variables,1)
+        disp_string=[disp_string,', ',missing_variables{ii,:}];
+    end
+    error('makedataset: The variable(s) %s listed in varobs are not contained in the dataset %s',disp_string);
+else
+    data_mat=[];
+    for var_iter=1:length(varobs)
+        try
+            data_mat=[data_mat vec(data_file.(varobs{1,var_iter}))];
+        catch
+            error('makedataset: The variable %s does not have dimensions conformable with the previous one',varobs{1,var_iter});
+        end
+    end
+end
+
+data = dseries(data_mat,[],varobs);
\ No newline at end of file
diff --git a/matlab/lpdfgam.m b/matlab/lpdfgam.m
index b82e43234..7dbcf2579 100644
--- a/matlab/lpdfgam.m
+++ b/matlab/lpdfgam.m
@@ -1,19 +1,19 @@
-function  [ldens,Dldens,D2ldens] = lpdfgam(x,a,b);
+function  [ldens,Dldens,D2ldens] = lpdfgam(x,a,b)
 % Evaluates the logged GAMMA PDF at x.
 %
-% INPUTS     
+% INPUTS
 %    x     [double]  m*n matrix of locations,
 %    a     [double]  m*n matrix or scalar, First GAMMA distribution parameters (shape),
 %    b     [double]  m*n matrix or scalar, Second GAMMA distribution parameters (scale),
 %
 % OUTPUTS
 %    ldens [double]  m*n matrix of logged GAMMA densities evaluated at x.
-%     
-%        
+%
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,7 +41,7 @@ end
 
 
 
-if nargout >1 
+if nargout >1
     if length(a)==1
         Dldens(idx) = (a-1)./(x(idx)) - ones(length(idx),1)/b ;
     else
diff --git a/matlab/lpdfgbeta.m b/matlab/lpdfgbeta.m
index e8d8af521..6f0dd0fd8 100644
--- a/matlab/lpdfgbeta.m
+++ b/matlab/lpdfgbeta.m
@@ -1,20 +1,20 @@
-function [ldens,Dldens,D2ldens] = lpdfgbeta(x,a,b,aa,bb);
-% Evaluates the logged BETA PDF at x. 
+function [ldens,Dldens,D2ldens] = lpdfgbeta(x,a,b,aa,bb)
+% Evaluates the logged BETA PDF at x.
 %
-% INPUTS 
+% INPUTS
 %    x     [double]  m*n matrix of loactions,
-%    a     [double]  m*n matrix of First BETA distribution parameters, 
-%    b     [double]  m*n matrix of Second BETA distribution parameters, 
-%    aa    [double]  m*n matrix of lower bounds for (generalized) distribution, 
+%    a     [double]  m*n matrix of First BETA distribution parameters,
+%    b     [double]  m*n matrix of Second BETA distribution parameters,
+%    aa    [double]  m*n matrix of lower bounds for (generalized) distribution,
 %    bb    [double]  m*n matrix of upper bounds for (generalized) distribution
 %
-% OUTPUTS 
+% OUTPUTS
 %    ldens [double]  m*n matrix of logged (generalized) BETA densities.
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2011 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,7 +41,7 @@ else
 end
 
 
-if nargout >1 
+if nargout >1
     if length(a)==1
         Dldens(idx) = (a-1)./(x(idx)-aa) - (b-1)./(bb-x(idx)) ;
     else
@@ -50,7 +50,7 @@ if nargout >1
 end
 
 
-if nargout == 3 
+if nargout == 3
     if length(a)==1
         D2ldens(idx) = -(a-1)./(x(idx)-aa).^2 - (b-1)./(bb-x(idx)).^2 ;
     else
diff --git a/matlab/lpdfig1.m b/matlab/lpdfig1.m
index 5aeb05f90..2b14c8fab 100644
--- a/matlab/lpdfig1.m
+++ b/matlab/lpdfig1.m
@@ -1,15 +1,15 @@
 function [ldens,Dldens,D2ldens] = lpdfig1(x,s,nu)
 % Evaluates the logged INVERSE-GAMMA-1 PDF at x.
 %
-% X ~ IG1(s,nu) if X = sqrt(Y) where Y ~ IG2(s,nu) and Y = inv(Z) with Z ~ G(nu/2,2/s) (Gamma distribution) 
+% X ~ IG1(s,nu) if X = sqrt(Y) where Y ~ IG2(s,nu) and Y = inv(Z) with Z ~ G(nu/2,2/s) (Gamma distribution)
 %
 % See L. Bauwens, M. Lubrano and J-F. Richard [1999, appendix A] for more details.
 %
 %
-% INPUTS     
+% INPUTS
 %    x     [double]  m*n matrix of locations,
-%    s     [double]  m*n matrix or scalar, First INVERSE-GAMMA-1 distribution parameters, 
-%    nu    [double]  m*n matrix or scalar, Second INVERSE-GAMMA-1 distribution parameters. 
+%    s     [double]  m*n matrix or scalar, First INVERSE-GAMMA-1 distribution parameters,
+%    nu    [double]  m*n matrix or scalar, Second INVERSE-GAMMA-1 distribution parameters.
 %
 % OUTPUTS
 %    ldens [double]  m*n matrix of logged INVERSE-GAMMA-1 densities evaluated at x.
@@ -17,7 +17,7 @@ function [ldens,Dldens,D2ldens] = lpdfig1(x,s,nu)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2004-2011 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -35,7 +35,7 @@ function [ldens,Dldens,D2ldens] = lpdfig1(x,s,nu)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 ldens = -Inf( size(x) ) ;
-idx = find( x>0 ) ;    
+idx = find( x>0 ) ;
 
 if length(s)==1
     ldens(idx) = log(2) - gammaln(.5*nu) - .5*nu*(log(2)-log(s)) - (nu+1)*log(x(idx)) - .5*s./(x(idx).*x(idx)) ;
@@ -43,7 +43,7 @@ else
     ldens(idx) = log(2) - gammaln(.5*nu(idx)) - .5*nu(idx).*(log(2)-log(s(idx))) - (nu(idx)+1).*log(x(idx)) - .5*s(idx)./(x(idx).*x(idx)) ;
 end
 
-if nargout >1 
+if nargout >1
     if length(s)==1
         Dldens(idx) = - (nu+1)./(x(idx)) + s./(x(idx).^3) ;
     else
@@ -51,11 +51,10 @@ if nargout >1
     end
 end
 
-if nargout == 3 
+if nargout == 3
     if length(s)==1
         D2ldens(idx) =  (nu+1)./(x(idx).^2) - 3*s(idx)./(x(idx).^4) ;
     else
         D2ldens(idx) =  (nu(idx)+1)./(x(idx).^2) - 3*s(idx)./(x(idx).^4) ;
     end
 end
-
diff --git a/matlab/lpdfig2.m b/matlab/lpdfig2.m
index 00de3abb1..e1b3ca2a1 100644
--- a/matlab/lpdfig2.m
+++ b/matlab/lpdfig2.m
@@ -1,15 +1,15 @@
 function [ldens,Dldens,D2ldens] = lpdfig2(x,s,nu)
 % Evaluates the logged INVERSE-GAMMA-2 PDF at x.
 %
-% X ~ IG2(s,nu) if X = inv(Z) where Z ~ G(nu/2,2/s) (Gamma distribution) 
+% X ~ IG2(s,nu) if X = inv(Z) where Z ~ G(nu/2,2/s) (Gamma distribution)
 %
 % See L. Bauwens, M. Lubrano and J-F. Richard [1999, appendix A] for more details.
 %
 %
-% INPUTS     
+% INPUTS
 %    x     [double]  m*n matrix of locations,
-%    s     [double]  m*n matrix or scalar, First INVERSE-GAMMA-2 distribution parameters, 
-%    nu    [double]  m*n matrix or scalar, Second INVERSE-GAMMA-2 distribution parameters. 
+%    s     [double]  m*n matrix or scalar, First INVERSE-GAMMA-2 distribution parameters,
+%    nu    [double]  m*n matrix or scalar, Second INVERSE-GAMMA-2 distribution parameters.
 %
 % OUTPUTS
 %    ldens [double]  m*n matrix of logged INVERSE-GAMMA-2 densities evaluated at x.
@@ -17,7 +17,7 @@ function [ldens,Dldens,D2ldens] = lpdfig2(x,s,nu)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2004-2011 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -35,7 +35,7 @@ function [ldens,Dldens,D2ldens] = lpdfig2(x,s,nu)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 ldens = -Inf( size(x) ) ;
-idx = find( x>0 ) ;    
+idx = find( x>0 ) ;
 
 if length(s)==1
     ldens(idx) = -gammaln(.5*nu) - (.5*nu)*(log(2)-log(s)) - .5*(nu+2)*log(x(idx)) -.5*s./x(idx);
@@ -43,7 +43,7 @@ else
     ldens(idx) = -gammaln(.5*nu(idx)) - (.5*nu(idx)).*(log(2)-log(s(idx))) - .5*(nu(idx)+2).*log(x(idx)) -.5*s(idx)./x(idx);
 end
 
-if nargout >1 
+if nargout >1
     if length(s)==1
         Dldens(idx) = - .5*(nu+2)./(x(idx)) + .5*s./x(idx).^2;
     else
@@ -51,7 +51,7 @@ if nargout >1
     end
 end
 
-if nargout == 3 
+if nargout == 3
     if length(s)==1
         D2ldens(idx) = .5*(nu+2)./(x(idx)).^2 - s./x(idx).^3;
     else
diff --git a/matlab/lpdfnorm.m b/matlab/lpdfnorm.m
index bb9da98d8..2c1249996 100644
--- a/matlab/lpdfnorm.m
+++ b/matlab/lpdfnorm.m
@@ -1,19 +1,19 @@
 function  [ldens,Dldens,D2ldens] = lpdfnorm(x,a,b)
 % Evaluates the logged UNIVARIATE GAUSSIAN PDF at x.
 %
-% INPUTS 
+% INPUTS
 %    x     [double]  m*n matrix of locations,
-%    a     [double]  m*n matrix or scalar, First GAUSSIAN distribution parameters (expectation) 
-%    b     [double]  m*n matrix or scalar, Second GAUSSIAN distribution parameters (standard deviation). 
+%    a     [double]  m*n matrix or scalar, First GAUSSIAN distribution parameters (expectation)
+%    b     [double]  m*n matrix or scalar, Second GAUSSIAN distribution parameters (standard deviation).
 %
-% OUTPUTS 
+% OUTPUTS
 %    ldens [double]  m*n matrix of logged GAUSSIAN densities evaluated at x.
-%     
-%        
+%
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2012 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,10 +34,10 @@ if nargin<3, b=1; end
 if nargin<2, a=0; end
 ldens = -log(b) -.5*log(2*pi) - .5*((x-a)./b).*((x-a)./b) ;
 
-if nargout >1 
+if nargout >1
     Dldens =  - (1./b).*((x-a)./b) ;
 end
 
-if nargout == 3 
+if nargout == 3
     D2ldens =  - (1./b).^2 ;
 end
\ No newline at end of file
diff --git a/matlab/lyapunov_solver.m b/matlab/lyapunov_solver.m
index a7b96c997..98d782cdf 100644
--- a/matlab/lyapunov_solver.m
+++ b/matlab/lyapunov_solver.m
@@ -1,14 +1,14 @@
 function P=lyapunov_solver(T,R,Q,DynareOptions) % --*-- Unitary tests --*--
 % function P=lyapunov_solver(T,R,Q,DynareOptions)
 % Solves the Lyapunov equation P-T*P*T' = R*Q*R' arising in a state-space
-% system, where P is the variance of the states 
+% system, where P is the variance of the states
 %
 % Inputs
 %   T               [double]    n*n matrix.
 %   R               [double]    n*m matrix.
 %   Q               [double]    m*m matrix.
 %   DynareOptions   [structure] Dynare options
-% 
+%
 % Outputs
 %   P               [double]    n*n matrix.
 %
@@ -20,10 +20,10 @@ function P=lyapunov_solver(T,R,Q,DynareOptions) % --*-- Unitary tests --*--
 %   DynareOptions.lyapunov_db == 1
 %       doubling algorithm
 %   DynareOptions.lyapunov_srs == 1
-%       Square-root solver for discrete-time Lyapunov equations (requires Matlab System Control toolbox 
+%       Square-root solver for discrete-time Lyapunov equations (requires Matlab System Control toolbox
 %       or Octave control package)
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -60,10 +60,10 @@ elseif DynareOptions.lyapunov_srs == 1
     end
     chol_Q = R*chol(Q,'lower');
     R_P = dlyapchol(T,chol_Q);
-    P = R_P' * R_P;    
+    P = R_P' * R_P;
 else
     P = lyapunov_symm(T,R*Q*R',DynareOptions.lyapunov_fixed_point_tol,DynareOptions.qz_criterium,DynareOptions.lyapunov_complex_threshold, [], DynareOptions.debug);
-end;
+end
 
 %@test:1
 %$ t = NaN(10,1);
@@ -81,7 +81,7 @@ end;
 %$ tmp2=randn(m_small,m_small);
 %$ Q_small=tmp2*tmp2';
 %$ R_small=randn(n_small,m_small);
-%$ 
+%$
 %$ n_large=9;
 %$ m_large=11;
 %$ T_large=randn(n_large,n_large);
@@ -89,7 +89,7 @@ end;
 %$ tmp2=randn(m_large,m_large);
 %$ Q_large=tmp2*tmp2';
 %$ R_large=randn(n_large,m_large);
-%$ 
+%$
 %$ % DynareOptions.lyapunov_fp == 1
 %$ options_.lyapunov_fp = 1;
 %$ try
diff --git a/matlab/lyapunov_symm.m b/matlab/lyapunov_symm.m
index 694415d71..53eaf9e4c 100644
--- a/matlab/lyapunov_symm.m
+++ b/matlab/lyapunov_symm.m
@@ -1,22 +1,22 @@
 function [x,u] = lyapunov_symm(a,b,lyapunov_fixed_point_tol,qz_criterium,lyapunov_complex_threshold,method,debug)  % --*-- Unitary tests --*--
 % Solves the Lyapunov equation x-a*x*a' = b, for b and x symmetric matrices.
 % If a has some unit roots, the function computes only the solution of the stable subsystem.
-%  
+%
 % INPUTS:
 %   a                           [double]    n*n matrix.
 %   b                           [double]    n*n matrix.
 %   qz_criterium                [double]    unit root threshold for eigenvalues
 %   lyapunov_fixed_point_tol    [double]    convergence criteria for fixed_point algorithm.
 %   lyapunov_complex_threshold  [double]    scalar, complex block threshold for the upper triangular matrix T.
-%   method                      [integer]   Scalar, if method=0 [default] then U, T, n and k are not persistent.  
-%                                                      method=1 then U, T, n and k are declared as persistent 
-%                                                               variables and the Schur decomposition is triggered.    
-%                                                      method=2 then U, T, n and k are declared as persistent 
+%   method                      [integer]   Scalar, if method=0 [default] then U, T, n and k are not persistent.
+%                                                      method=1 then U, T, n and k are declared as persistent
+%                                                               variables and the Schur decomposition is triggered.
+%                                                      method=2 then U, T, n and k are declared as persistent
 %                                                               variables and the Schur decomposition is not performed.
 %                                                      method=3 fixed point method
 % OUTPUTS
 %   x:      [double]    m*m solution matrix of the lyapunov equation, where m is the dimension of the stable subsystem.
-%   u:      [double]    Schur vectors associated with unit roots  
+%   u:      [double]    Schur vectors associated with unit roots
 %
 % ALGORITHM
 %   Uses reordered Schur decomposition (Bartels-Stewart algorithm)
@@ -25,7 +25,7 @@ function [x,u] = lyapunov_symm(a,b,lyapunov_fixed_point_tol,qz_criterium,lyapuno
 % SPECIAL REQUIREMENTS
 %   None
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,7 +54,7 @@ if method == 3
     persistent X method1;
     if ~isempty(method1)
         method = method1;
-    end;
+    end
     if debug
         fprintf('lyapunov_symm:: [method=%d] \n',method);
     end
@@ -67,16 +67,16 @@ if method == 3
             max_it_fp = 2000;
         else
             max_it_fp = 300;
-        end;
+        end
         at = a';
         %fixed point iterations
-        while evol >  lyapunov_fixed_point_tol && it_fp < max_it_fp;
+        while evol >  lyapunov_fixed_point_tol && it_fp < max_it_fp
             X_old = X;
             X = a * X * at + b;
             evol = max(sum(abs(X - X_old))); %norm_1
-            %evol = max(sum(abs(X - X_old)')); %norm_inf
+                                             %evol = max(sum(abs(X - X_old)')); %norm_inf
             it_fp = it_fp + 1;
-        end;
+        end
         if debug
             fprintf('lyapunov_symm:: lyapunov fixed_point iterations=%d norm=%g\n',it_fp,evol);
         end
@@ -87,9 +87,9 @@ if method == 3
         else
             method1 = 3;
             x = X;
-            return;
-        end;
-    end;
+            return
+        end
+    end
 end
 
 if method
@@ -110,7 +110,7 @@ end
 if method<2
     [U,T] = schur(a);
     e1 = abs(ordeig(T)) > 2-qz_criterium;
-    k = sum(e1);       % Number of unit roots. 
+    k = sum(e1);       % Number of unit roots.
     n = length(e1)-k;  % Number of stationary variables.
     if k > 0
         % Selects stable roots
diff --git a/matlab/marginal_density.m b/matlab/marginal_density.m
index 32880f34a..e5683da2c 100644
--- a/matlab/marginal_density.m
+++ b/matlab/marginal_density.m
@@ -15,7 +15,7 @@ function [marginal,oo_] = marginal_density(M_, options_, estim_params_, oo_, bay
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2011 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,14 +58,15 @@ lpost_mode = posterior_kernel_at_the_mode;
 xparam1 = posterior_mean;
 hh = inv(SIGMA);
 fprintf(' Done!\n');
-if ~isfield(oo_,'posterior_mode')
+if ~isfield(oo_,'posterior_mode') || (options_.mh_replic && isequal(options_.posterior_sampler_options.posterior_sampling_method,'slice'))
     oo_=fill_mh_mode(posterior_mode',NaN(npar,1),M_,options_,estim_params_,bayestopt_,oo_,'posterior');
 end
 
 % save the posterior mean and the inverse of the covariance matrix
 % (usefull if the user wants to perform some computations using
-% the posterior mean instead of the posterior mode ==> ). 
-save([M_.fname '_mean.mat'],'xparam1','hh','SIGMA');
+% the posterior mean instead of the posterior mode ==> ).
+parameter_names = bayestopt_.name;
+save([M_.fname '_mean.mat'],'xparam1','hh','parameter_names','SIGMA');
 
 fprintf('Estimation::marginal density: I''m computing the posterior log marginal density (modified harmonic mean)... ');
 logdetSIGMA = log(det(SIGMA));
@@ -75,7 +76,7 @@ linee = 0;
 check_coverage = 1;
 increase = 1;
 while check_coverage
-    for p = 0.1:0.1:0.9;
+    for p = 0.1:0.1:0.9
         critval = chi2inv(p,npar);
         ifil = FirstLine;
         tmp = 0;
@@ -105,7 +106,7 @@ while check_coverage
             disp('Estimation::marginal density: The support of the weighting density function is not large enough...')
             disp('Estimation::marginal density: I increase the variance of this distribution.')
             increase = 1.2*increase;
-            linee    = 0;   
+            linee    = 0;
         else
             disp('Estimation::marginal density: Let me try again.')
             increase = 1.2*increase;
@@ -113,9 +114,9 @@ while check_coverage
             if increase > 20
                 check_coverage = 0;
                 clear invSIGMA detSIGMA increase;
-                disp('Estimation::marginal density: There''s probably a problem with the modified harmonic mean estimator.')    
+                disp('Estimation::marginal density: There''s probably a problem with the modified harmonic mean estimator.')
             end
-        end  
+        end
     else
         check_coverage = 0;
         clear invSIGMA detSIGMA increase;
@@ -129,17 +130,17 @@ return
 
 function oo_=fill_mh_mode(xparam1,stdh,M_,options_,estim_params_,bayestopt_,oo_, field_name)
 %function oo_=fill_mh_mode(xparam1,stdh,M_,options_,estim_params_,bayestopt_,oo_, field_name)
-% 
-% INPUTS 
+%
+% INPUTS
 %   o xparam1       [double]   (p*1) vector of estimate parameters.
 %   o stdh          [double]   (p*1) vector of estimate parameters.
-%   o M_                        Matlab's structure describing the Model (initialized by dynare, see @ref{M_}).          
+%   o M_                        Matlab's structure describing the Model (initialized by dynare, see @ref{M_}).
 %   o estim_params_             Matlab's structure describing the estimated_parameters (initialized by dynare, see @ref{estim_params_}).
 %   o options_                  Matlab's structure describing the options (initialized by dynare, see @ref{options_}).
 %   o bayestopt_                Matlab's structure describing the priors (initialized by dynare, see @ref{bayesopt_}).
 %   o oo_                       Matlab's structure gathering the results (initialized by dynare, see @ref{oo_}).
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   o oo_                       Matlab's structure gathering the results
 %
 % SPECIAL REQUIREMENTS
@@ -171,8 +172,8 @@ if nvx
         eval(['oo_.' field_name '_std_at_mode.shocks_std.' name ' = stdh(ip);']);
         ip = ip+1;
     end
- end
- if nvn
+end
+if nvn
     ip = nvx+1;
     for i=1:nvn
         name = options_.varobs{estim_params_.nvn_observable_correspondence(i,1)};
@@ -180,7 +181,7 @@ if nvx
         eval(['oo_.' field_name '_std_at_mode.measurement_errors_std.' name ' = stdh(ip);']);
         ip = ip+1;
     end
- end
+end
 
 if ncx
     ip = nvx+nvn+1;
diff --git a/matlab/matlab_ver_less_than.m b/matlab/matlab_ver_less_than.m
index 53dd8d7ef..10cd640d2 100644
--- a/matlab/matlab_ver_less_than.m
+++ b/matlab/matlab_ver_less_than.m
@@ -8,14 +8,14 @@ function r = matlab_ver_less_than(verstr)
 %
 % INPUTS
 %    verstr: a string of the format 'x.y' or 'x.y.z'
-%    
+%
 % OUTPUTS
 %    r: 0 or 1
 %
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2014 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/maximize_prior_density.m b/matlab/maximize_prior_density.m
index 72df861a4..9f79e44a4 100644
--- a/matlab/maximize_prior_density.m
+++ b/matlab/maximize_prior_density.m
@@ -1,21 +1,21 @@
 function [xparams,lpd,hessian_mat] = ...
     maximize_prior_density(iparams, prior_shape, prior_hyperparameter_1, prior_hyperparameter_2, prior_inf_bound, prior_sup_bound,DynareOptions,DynareModel,BayesInfo,EstimatedParams,DynareResults)
 % Maximizes the logged prior density using Chris Sims' optimization routine.
-% 
-% INPUTS 
+%
+% INPUTS
 %   iparams                        [double]   vector of initial parameters.
 %   prior_shape                    [integer]  vector specifying prior densities shapes.
 %   prior_hyperparameter_1         [double]   vector, first hyperparameter.
 %   prior_hyperparameter_2         [double]   vector, second hyperparameter.
 %   prior_inf_bound                [double]   vector, prior's lower bound.
-%   prior_sup_bound                [double]   vector, prior's upper bound. 
+%   prior_sup_bound                [double]   vector, prior's upper bound.
 %
-% OUTPUTS 
+% OUTPUTS
 %   xparams       [double]  vector, prior mode.
 %   lpd           [double]  scalar, value of the logged prior density at the mode.
 %   hessian_mat   [double]  matrix, Hessian matrix at the prior mode.
 
-% Copyright (C) 2009-2015 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/mcforecast3.m b/matlab/mcforecast3.m
index 3e1de2888..b318d46f4 100644
--- a/matlab/mcforecast3.m
+++ b/matlab/mcforecast3.m
@@ -2,7 +2,7 @@ function [forcs, e]= mcforecast3(cL,H,mcValue,shocks,forcs,T,R,mv,mu)
 % forcs = mcforecast3(cL,H,mcValue,shocks,forcs,T,R,mv,mu)
 % Computes the shock values for constrained forecasts necessary to keep
 % endogenous variables at their constrained paths
-% 
+%
 % INPUTS
 %  o cL             [scalar]                            number of controlled periods
 %  o H              [scalar]                            number of forecast periods
@@ -14,7 +14,7 @@ function [forcs, e]= mcforecast3(cL,H,mcValue,shocks,forcs,T,R,mv,mu)
 %  o mv             [n_controlled_exo by n_endovars boolean]        indicator vector  selecting constrained endogenous variables
 %  o mu             [n_controlled_vars by nexo boolean]             indicator vector
 %                                                   selecting controlled exogenous variables
-% 
+%
 % Algorithm:
 %   Relies on state-space form:
 %       y_t=T*y_{t-1}+R*shocks(:,t)
@@ -30,8 +30,8 @@ function [forcs, e]= mcforecast3(cL,H,mcValue,shocks,forcs,T,R,mv,mu)
 %   After obtaining the shocks, and for uncontrolled periods, the state-space representation
 %       y_t=T*y_{t-1}+R*shocks(:,t)
 %   is used for forecasting
-%  
-% Copyright (C) 2006-2013 Dynare Team
+%
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/mcompare.m b/matlab/mcompare.m
index 9bf0f1713..f3f052f68 100644
--- a/matlab/mcompare.m
+++ b/matlab/mcompare.m
@@ -1,7 +1,7 @@
 function mcompare(s1,s2)
-% MCOMPARE :    MCOMPARE ( [ 'file1' ; 'file2' ] , [ 'var1' ; 'var2' ...] )     
+% MCOMPARE :    MCOMPARE ( [ 'file1' ; 'file2' ] , [ 'var1' ; 'var2' ...] )
 %               This optional command plots the relative differences between
-%               two different simulations for a list of variables. One plot 
+%               two different simulations for a list of variables. One plot
 %               is drawn for each variable. The trajectories must have been
 %               previously saved by the instruction DYNASAVE. The simulation
 %               in file1 serves as the base simulation and the ploted quantity
@@ -10,7 +10,7 @@ function mcompare(s1,s2)
 %               value of the base simulation, the absolute difference is ploted
 %               instead of the relative one.
 
-% Copyright (C) 2001-2011 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/mcp_func.m b/matlab/mcp_func.m
index 424b9203f..30494b95a 100644
--- a/matlab/mcp_func.m
+++ b/matlab/mcp_func.m
@@ -1,17 +1,17 @@
 function [res,fjac,domer] = mcp_func(x,jacflag)
 % function [res,fjac,domer] = mcp_func(x,jacflag)
 % wrapper function for mixed complementarity problem when using PATH
-% 
-% INPUTS 
+%
+% INPUTS
 % - x                   [double] N*T array, paths for the endogenous variables (initial guess).
 % - jacflag             [scalar] indicator whether Jacobian is requested
 %
-% OUTPUTS 
+% OUTPUTS
 %  - res                [double] (N*T)*1 array, residuals of the stacked problem
 %  - fjac               [double] (N*T)*(N*T) array, Jacobian of the stacked problem
 %  - domer              [scalar] errorflag that is 1 if solution is not real
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/metropolis_draw.m b/matlab/metropolis_draw.m
index f0fcf49bd..94c421278 100644
--- a/matlab/metropolis_draw.m
+++ b/matlab/metropolis_draw.m
@@ -1,12 +1,12 @@
 function [xparams, logpost, options_]=metropolis_draw(init,options_,estim_params_,M_)
-% function [xparams, logpost]=metropolis_draw(init) 
+% function [xparams, logpost]=metropolis_draw(init)
 % Builds draws from metropolis
 %
 % INPUTS:
-%   init:              scalar equal to 
-%                      1: first call to store the required information 
-%                           on files, lines, and chains to be read 
-%                           in persistent variables to make them available 
+%   init:              scalar equal to
+%                      1: first call to store the required information
+%                           on files, lines, and chains to be read
+%                           in persistent variables to make them available
 %                           for future calls
 %                      0: load a parameter draw
 % Additional Inputs required for initialization
@@ -19,12 +19,12 @@ function [xparams, logpost, options_]=metropolis_draw(init,options_,estim_params
 %                      if init==1: error flaog
 %   logpost:           log of posterior density
 %   options_:          [structure]     Matlab's structure describing the options (initialized by dynare, see @ref{options_}).
-%   
+%
 % SPECIAL REQUIREMENTS
 %
 %   Requires CutSample to be run before in order to set up mh_history-file
 
-% Copyright (C) 2003-2015 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -61,20 +61,20 @@ if init
     %load mh_history-file with info on what to load
     load_last_mh_history_file(MetropolisFolder, FileName);
     FirstMhFile = record.KeepedDraws.FirstMhFile;
-    FirstLine = record.KeepedDraws.FirstLine; 
-    TotalNumberOfMhFiles = sum(record.MhDraws(:,2)); 
-    LastMhFile = TotalNumberOfMhFiles; 
+    FirstLine = record.KeepedDraws.FirstLine;
+    TotalNumberOfMhFiles = sum(record.MhDraws(:,2));
+    LastMhFile = TotalNumberOfMhFiles;
     TotalNumberOfMhDraws = sum(record.MhDraws(:,1));
     NumberOfDraws = TotalNumberOfMhDraws-floor(options_.mh_drop*TotalNumberOfMhDraws);
     MAX_nruns = ceil(options_.MaxNumberOfBytes/(npar+2)/8); %number of parameters plus posterior plus ?
     mh_nblck = options_.mh_nblck;
     % set sub_draws option if empty
     if isempty(options_.sub_draws)
-        options_.sub_draws = min(options_.posterior_max_subsample_draws, round(.25*NumberOfDraws));
+        options_.sub_draws = min(options_.posterior_max_subsample_draws, ceil(.25*NumberOfDraws));
     else
-        if options_.sub_draws>NumberOfDraws
+        if options_.sub_draws>NumberOfDraws*mh_nblck
             skipline()
-            disp(['Estimation::mcmc: The value of option sub_draws (' num2str(options_.sub_draws) ') is greater than the number of available draws in the MCMC (' num2str(NumberOfDraws) ')!'])
+            disp(['Estimation::mcmc: The value of option sub_draws (' num2str(options_.sub_draws) ') is greater than the number of available draws in the MCMC (' num2str(NumberOfDraws*mh_nblck) ')!'])
             disp('Estimation::mcmc: You can either change the value of sub_draws, reduce the value of mh_drop, or run another mcmc (with the load_mh_file option).')
             skipline()
             xparams = 1; % xparams is interpreted as an error flag
@@ -82,16 +82,16 @@ if init
     end
     return
 else %not initialization, return one draw
-    %get random draw from random chain
+     %get random draw from random chain
     ChainNumber = ceil(rand*mh_nblck);
     DrawNumber  = ceil(rand*NumberOfDraws);
 
     if DrawNumber <= MAX_nruns-FirstLine+1 %draw in first file, needs to account for first line
         MhFilNumber = FirstMhFile;
         MhLine = FirstLine+DrawNumber-1;
-    else %draw in other file 
+    else %draw in other file
         DrawNumber  = DrawNumber-(MAX_nruns-FirstLine+1);
-        MhFilNumber = FirstMhFile+ceil(DrawNumber/MAX_nruns); 
+        MhFilNumber = FirstMhFile+ceil(DrawNumber/MAX_nruns);
         MhLine = DrawNumber-(MhFilNumber-FirstMhFile-1)*MAX_nruns;
     end
     %load parameters and posterior
diff --git a/matlab/metropolis_hastings_initialization.m b/matlab/metropolis_hastings_initialization.m
index e18ea098a..e9d97a0ea 100644
--- a/matlab/metropolis_hastings_initialization.m
+++ b/matlab/metropolis_hastings_initialization.m
@@ -3,13 +3,13 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 % function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npar, NumberOfBlocks, nruns, NewFile, MAX_nruns, d ] = ...
 %     metropolis_hastings_initialization(TargetFun, xparam1, vv, mh_bounds,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,oo_)
 % Metropolis-Hastings initialization.
-% 
-% INPUTS 
+%
+% INPUTS
 %   o TargetFun  [char]     string specifying the name of the objective
 %                           function (posterior kernel).
 %   o xparam1    [double]   (p*1) vector of parameters to be estimated (initial values).
 %   o vv         [double]   (p*p) matrix, posterior covariance matrix (at the mode).
-%   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters. 
+%   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters.
 %   o dataset_              data structure
 %   o dataset_info          dataset info structure
 %   o options_              options structure
@@ -17,17 +17,17 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 %   o estim_params_         estimated parameters structure
 %   o bayestopt_            estimation options structure
 %   o oo_                   outputs structure
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   o ix2                   [double]   (NumberOfBlocks*npar) vector of starting points for different chains
 %   o ilogpo2               [double]   (NumberOfBlocks*1) vector of initial posterior values for different chains
 %   o ModelName             [string]    name of the mod-file
 %   o MetropolisFolder      [string]    path to the Metropolis subfolder
-%   o FirstBlock            [scalar]    number of the first MH chain to be run (not equal to 1 in case of recovery)   
-%   o FirstLine             [double]   (NumberOfBlocks*1) vector of first draw in each chain (not equal to 1 in case of recovery)   
+%   o FirstBlock            [scalar]    number of the first MH chain to be run (not equal to 1 in case of recovery)
+%   o FirstLine             [double]   (NumberOfBlocks*1) vector of first draw in each chain (not equal to 1 in case of recovery)
 %   o npar                  [scalar]    number of parameters estimated
-%   o NumberOfBlocks        [scalar]    Number of MCM chains requested   
-%   o nruns                 [double]   (NumberOfBlocks*1) number of draws in each chain 
+%   o NumberOfBlocks        [scalar]    Number of MCM chains requested
+%   o nruns                 [double]   (NumberOfBlocks*1) number of draws in each chain
 %   o NewFile               [scalar]    (NumberOfBlocks*1) vector storing the number
 %                                       of the first MH-file to created for each chain when saving additional
 %                                       draws
@@ -37,7 +37,7 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -57,7 +57,7 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 %Initialize outputs
 ix2 = [];
 ilogpo2 = [];
-ModelName = []; 
+ModelName = [];
 MetropolisFolder = [];
 FirstBlock = [];
 FirstLine = [];
@@ -124,7 +124,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
             trial = 1;
             while validate == 0 && trial <= 10
                 candidate = rand_multivariate_normal( transpose(xparam1), d * options_.mh_init_scale, npar);
-                if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub) 
+                if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub)
                     ix2(j,:) = candidate;
                     ilogpo2(j) = - feval(TargetFun,ix2(j,:)',dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_);
                     if ~isfinite(ilogpo2(j)) % if returned log-density is
@@ -167,7 +167,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
     else% Case 2: one chain (we start from the posterior mode)
         fprintf(fidlog,['  Initial values of the parameters:\n']);
         candidate = transpose(xparam1(:));%
-        if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub) 
+        if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub)
             ix2 = candidate;
             ilogpo2 = - feval(TargetFun,ix2',dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_);
             disp('Estimation::mcmc: Initialization at the posterior mode.')
@@ -223,7 +223,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
     fprintf(fidlog,['    Expected number of files per block.......: ' int2str(AnticipatedNumberOfFiles) '.\n']);
     fprintf(fidlog,['    Expected number of lines in the last file: ' int2str(AnticipatedNumberOfLinesInTheLastFile) '.\n']);
     fprintf(fidlog,['\n']);
-    for j = 1:NumberOfBlocks,
+    for j = 1:NumberOfBlocks
         fprintf(fidlog,['    Initial state of the Gaussian random number generator for chain number ',int2str(j),':\n']);
         for i=1:length(record.InitialSeeds(j).Normal)
             fprintf(fidlog,['      ' num2str(record.InitialSeeds(j).Normal(i)') '\n']);
@@ -232,7 +232,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
         for i=1:length(record.InitialSeeds(j).Unifor)
             fprintf(fidlog,['      ' num2str(record.InitialSeeds(j).Unifor(i)') '\n']);
         end
-    end,
+    end
     fprintf(fidlog,' \n');
     fclose(fidlog);
 elseif options_.load_mh_file && ~options_.mh_recover
@@ -281,7 +281,7 @@ elseif options_.load_mh_file && ~options_.mh_recover
     NumberOfDrawsWrittenInThePastLastFile = MAX_nruns - LastLineNumber;
     NumberOfDrawsToBeSaved = nruns(1) - NumberOfDrawsWrittenInThePastLastFile;
     AnticipatedNumberOfFiles = ceil(NumberOfDrawsToBeSaved/MAX_nruns);
-    AnticipatedNumberOfLinesInTheLastFile = NumberOfDrawsToBeSaved - (AnticipatedNumberOfFiles-1)*MAX_nruns;  
+    AnticipatedNumberOfLinesInTheLastFile = NumberOfDrawsToBeSaved - (AnticipatedNumberOfFiles-1)*MAX_nruns;
     record.LastFileNumber = LastFileNumber + AnticipatedNumberOfFiles;
     record.LastLineNumber = AnticipatedNumberOfLinesInTheLastFile;
     record.MhDraws(end,1) = nruns(1);
@@ -300,15 +300,15 @@ elseif options_.mh_recover
     load_last_mh_history_file(MetropolisFolder, ModelName);
     NumberOfBlocks = record.Nblck;% Number of "parallel" mcmc chains.
     options_.mh_nblck = NumberOfBlocks;
-    
+
     %% check consistency of options
     if record.MhDraws(end,1)~=options_.mh_replic
         fprintf('\nEstimation::mcmc: You cannot specify a different mh_replic than in the chain you are trying to recover\n')
         fprintf('Estimation::mcmc: I am resetting mh_replic to %u\n',record.MhDraws(end,1))
         options_.mh_replic=record.MhDraws(end,1);
         nruns = ones(NumberOfBlocks,1)*options_.mh_replic;
-    end    
-    
+    end
+
     if ~isnan(record.MAX_nruns(end,1)) %field exists
         if record.MAX_nruns(end,1)~=MAX_nruns
             fprintf('\nEstimation::mcmc: You cannot specify a different MaxNumberOfBytes than in the chain you are trying to recover\n')
@@ -335,9 +335,9 @@ elseif options_.mh_recover
     if OldMhExists
         LastLineNumberInThePreviousMh = record.MhDraws(end-1,3);% Number of lines in the last mh files of the previous session.
         LastFileNumberInThePreviousMh = sum(record.MhDraws(1:end-1,2),1);% Number of mh files in the the previous sessions.
-        %Test if the last mh files of the previous session were not full yet 
-        if LastLineNumberInThePreviousMh < MAX_nruns%not full 
-            %store starting point if whole chain needs to be redone
+                                                                         %Test if the last mh files of the previous session were not full yet
+        if LastLineNumberInThePreviousMh < MAX_nruns%not full
+                                                    %store starting point if whole chain needs to be redone
             NewFile = ones(NumberOfBlocks,1)*LastFileNumberInThePreviousMh;
             FirstLine = ones(NumberOfBlocks,1)*(LastLineNumberInThePreviousMh+1);
             LastFileFullIndicator=0;
@@ -354,9 +354,9 @@ elseif options_.mh_recover
         FirstLine = ones(NumberOfBlocks,1);
         LastFileFullIndicator=1;
     end
-    
+
     %% Now find out what exactly needs to be redone
-    % 1. Check if really something needs to be done 
+    % 1. Check if really something needs to be done
     % How many mh files should we have ?
     ExpectedNumberOfMhFilesPerBlock = sum(record.MhDraws(:,2),1);
     ExpectedNumberOfMhFiles = ExpectedNumberOfMhFilesPerBlock*NumberOfBlocks;
@@ -366,7 +366,7 @@ elseif options_.mh_recover
     % Quit if no crashed mcmc chain can be found as there are as many files as expected
     if (TotalNumberOfMhFiles==ExpectedNumberOfMhFiles)
         disp('Estimation::mcmc: It appears that you don''t need to use the mh_recover option!')
-        disp('                  You have to edit the mod file and remove the mh_recover option') 
+        disp('                  You have to edit the mod file and remove the mh_recover option')
         disp('                  in the estimation command')
         error('Estimation::mcmc: mh_recover option not required!')
     end
@@ -389,15 +389,15 @@ elseif options_.mh_recover
         end
         FirstBlock = FirstBlock+1;
     end
-    
-    %% 3. Overwrite default settings for 
+
+    %% 3. Overwrite default settings for
     % How many mh-files are saved in this block?
     NumberOfSavedMhFilesInTheCrashedBlck = NumberOfMhFilesPerBlock(FirstBlock);
     ExistingDrawsInLastMCFile=0; %initialize: no MCMC draws of current MCMC are in file from last run
-    % Check whether last present file is a file included in the last MCMC run
-    if ~LastFileFullIndicator 
+                                 % Check whether last present file is a file included in the last MCMC run
+    if ~LastFileFullIndicator
         if NumberOfSavedMhFilesInTheCrashedBlck==NewFile(FirstBlock) %only that last file exists, but no files from current MCMC
-            loaded_results=load([BaseName '_mh' int2str(NewFile(FirstBlock)) '_blck' int2str(FirstBlock) '.mat']);    
+            loaded_results=load([BaseName '_mh' int2str(NewFile(FirstBlock)) '_blck' int2str(FirstBlock) '.mat']);
             %check whether that last file was filled
             if size(loaded_results.x2,1)==MAX_nruns %file is full
                 NewFile(FirstBlock)=NewFile(FirstBlock)+1; %set first file to be created to next one
@@ -407,20 +407,20 @@ elseif options_.mh_recover
                 ExistingDrawsInLastMCFile=0;
             end
         end
-    elseif LastFileFullIndicator 
+    elseif LastFileFullIndicator
         ExistingDrawsInLastMCFile=0;
         if NumberOfSavedMhFilesInTheCrashedBlck==NewFile(FirstBlock) %only the last file exists, but no files from current MCMC
             NewFile(FirstBlock)=NewFile(FirstBlock)+1; %set first file to be created to next one
         end
     end
-%     % Correct the number of saved mh files if the crashed Metropolis was not the first session (so
-%     % that NumberOfSavedMhFilesInTheCrashedBlck is the number of saved mh files in the crashed chain 
-%     % of the current session).  
-%     if OldMhExists
-%         NumberOfSavedMhFilesInTheCrashedBlck = NumberOfSavedMhFilesInTheCrashedBlck - LastFileNumberInThePreviousMh;
-%     end
-%     NumberOfSavedMhFiles = NumberOfSavedMhFilesInTheCrashedBlck+LastFileNumberInThePreviousMh;
-    
+    %     % Correct the number of saved mh files if the crashed Metropolis was not the first session (so
+    %     % that NumberOfSavedMhFilesInTheCrashedBlck is the number of saved mh files in the crashed chain
+    %     % of the current session).
+    %     if OldMhExists
+    %         NumberOfSavedMhFilesInTheCrashedBlck = NumberOfSavedMhFilesInTheCrashedBlck - LastFileNumberInThePreviousMh;
+    %     end
+    %     NumberOfSavedMhFiles = NumberOfSavedMhFilesInTheCrashedBlck+LastFileNumberInThePreviousMh;
+
     % Correct initial conditions.
     if NumberOfSavedMhFilesInTheCrashedBlck<ExpectedNumberOfMhFilesPerBlock
         loaded_results=load([BaseName '_mh' int2str(NumberOfSavedMhFilesInTheCrashedBlck) '_blck' int2str(FirstBlock) '.mat']);
diff --git a/matlab/metropolis_run_analysis.m b/matlab/metropolis_run_analysis.m
index 99b589c82..acdfe3b33 100644
--- a/matlab/metropolis_run_analysis.m
+++ b/matlab/metropolis_run_analysis.m
@@ -1,19 +1,19 @@
 function metropolis_run_analysis(M,basetopt,j)
 %function metropolis_run_analysis(M)
 % analizes Metropolis runs
-%  
+%
 % INPUTS
 %   M:         (struct)  Model structure
 %   basetopt:  (struct)  Estimated parameters structure
 %   j:         (int)     Index of estimated paramter
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2003-2011 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,7 +39,7 @@ params = [];
 blck = 1;
 for i=1:record.LastFileNumber
     fname = [M.fname '/metropolis/' M.fname '_mh' int2str(i) '_blck' ...
-            int2str(blck) '.mat'];
+             int2str(blck) '.mat'];
     if exist(fname,'file')
         o=load(fname);
         logPost = [logPost; o.logpo2];
diff --git a/matlab/mex/k_order_perturbation.m b/matlab/mex/k_order_perturbation.m
index 96b7ba5f6..7c10d0efd 100644
--- a/matlab/mex/k_order_perturbation.m
+++ b/matlab/mex/k_order_perturbation.m
@@ -37,7 +37,7 @@
 %                         The Taylor coefficient (1/6) is
 %                         included. Inside the tensor, the variables are in
 %                         dr.order_var order of state endogenous variables
-%                         and shocks 
+%                         and shocks
 % derivs        struct    contains the original derivatives of the
 %                         decision function (ghx, ghu, ghxx, ghxu, ghuu,
 %                         ghs2, ghxxx, ghxxu, ghxuu,ghuuu, ghxss, ghuss),
@@ -52,7 +52,7 @@
 % dynare/mex/sources/k_order_perturbation.cc and it uses code provided by
 % dynare++
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/mex/qmc_sequence.m b/matlab/mex/qmc_sequence.m
index aa26ae2d3..1b9349273 100644
--- a/matlab/mex/qmc_sequence.m
+++ b/matlab/mex/qmc_sequence.m
@@ -16,7 +16,7 @@
 %!  @sp 1
 %!  @table @ @samp
 %!  @item @var{t}=0
-%!  Uniform numbers in a n-dimensional (unit by default) hypercube 
+%!  Uniform numbers in a n-dimensional (unit by default) hypercube
 %!  @item @var{t}=1
 %!  Gaussian numbers
 %!  @item @var{t}=2
@@ -55,7 +55,7 @@
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -125,7 +125,7 @@
 %$
 %$ [draws1, S] = qmc_sequence(d,s,0,n,[0 , 2; -1, 2]);
 %$ [draws2, Q] = qmc_sequence(d,s,0,n);
-%$ 
+%$
 %$ draws3 = draws2;
 %$ draws3(1,:) = 2*draws2(1,:);
 %$ draws3(2,:) = 3*draws2(2,:)-1;
diff --git a/matlab/mh_autocorrelation_function.m b/matlab/mh_autocorrelation_function.m
index 96b4c5875..377de1978 100644
--- a/matlab/mh_autocorrelation_function.m
+++ b/matlab/mh_autocorrelation_function.m
@@ -1,9 +1,9 @@
 function mh_autocorrelation_function(options_,M_,estim_params_,type,blck,name1,name2)
 % This function plots the autocorrelation of the sampled draws in the
 % posterior distribution.
-% 
 %
-% INPUTS 
+%
+% INPUTS
 %
 %   options_        [structure]    Dynare structure.
 %   M_              [structure]    Dynare structure (related to model definition).
@@ -11,14 +11,14 @@ function mh_autocorrelation_function(options_,M_,estim_params_,type,blck,name1,n
 %   type            [string]       'DeepParameter', 'MeasurementError' (for measurement equation error) or 'StructuralShock' (for structural shock).
 %   blck            [integer]      Number of the mh chain.
 %   name1           [string]       Object name.
-%   name2           [string]       Object name. 
-%    
-% OUTPUTS 
+%   name2           [string]       Object name.
+%
+% OUTPUTS
 %   None
-%        
+%
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2013 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,7 +36,7 @@ function mh_autocorrelation_function(options_,M_,estim_params_,type,blck,name1,n
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 % Cet the column index:
-if nargin<7    
+if nargin<7
     column = name2index(options_, M_, estim_params_, type, name1);
 else
     column = name2index(options_, M_, estim_params_, type, name1, name2);
@@ -88,10 +88,10 @@ else
 end
 
 if options_.mh_nblck>1
-    FigureName = [ FigureName , ' (block number' int2str(blck)  ').']; 
+    FigureName = [ FigureName , ' (block number' int2str(blck)  ').'];
 end
 
-hh=dyn_figure(options_,'Name',FigureName);
+hh=dyn_figure(options_.nodisplay,'Name',FigureName);
 
 bar(0:options_.mh_autocorrelation_function_size,autocor,'k');
 axis tight
@@ -104,4 +104,4 @@ if ~exist([M_.fname filesep 'graphs'])
 end
 
 plot_name=get_the_name(column,0,M_,estim_params_,options_);
-dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'MH_Autocorrelation_' plot_name],options_)
+dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'MH_Autocorrelation_' plot_name],options_.nodisplay,options_.graph_format)
diff --git a/matlab/mh_optimal_bandwidth.m b/matlab/mh_optimal_bandwidth.m
index 7355fddbd..0a827c5ac 100644
--- a/matlab/mh_optimal_bandwidth.m
+++ b/matlab/mh_optimal_bandwidth.m
@@ -1,30 +1,30 @@
-function optimal_bandwidth = mh_optimal_bandwidth(data,number_of_draws,bandwidth,kernel_function) 
+function optimal_bandwidth = mh_optimal_bandwidth(data,number_of_draws,bandwidth,kernel_function)
 % This function gives the optimal bandwidth parameter of a kernel estimator
-% used to estimate a posterior univariate density from realisations of a 
-% Metropolis-Hastings algorithm. 
+% used to estimate a posterior univariate density from realisations of a
+% Metropolis-Hastings algorithm.
 %
 % INPUTS:
 %   data               [double]  Vector (number_of_draws*1) of draws.
 %   number_of_draws    [integer] Scalar, number of draws.
-%   bandwidth          [integer] Scalar equal to 0,-1 or -2.    
+%   bandwidth          [integer] Scalar equal to 0,-1 or -2.
 %                                bandwidth =  0 => Silverman [1986] rule of thumb.
 %                                bandwidth = -1 => Sheather and Jones [1991].
-%                                bandwidth = -2 => Local bandwith parameters.                              
+%                                bandwidth = -2 => Local bandwith parameters.
 %   kernel_function    [string]  Name of the kernel function: 'gaussian', 'triweight',
-%                                'uniform', 'triangle', 'epanechnikov', 'quartic', 
+%                                'uniform', 'triangle', 'epanechnikov', 'quartic',
 %                                'triweight' and 'cosinus'
 %
 % OUTPUTS:
 %   optimal_bandwidth: [double]  Scalar or vector, optimal window width.
-%   
+%
 % SPECIAL REQUIREMENTS:
 %   none.
 %
 % REFERENCES:
-%   [1] M. Skoeld and G.O. Roberts [2003], "Density estimation for the Metropolis-Hastings algorithm". 
-%   [2] Silverman [1986], "Density estimation for statistics and data analysis". 
+%   [1] M. Skoeld and G.O. Roberts [2003], "Density estimation for the Metropolis-Hastings algorithm".
+%   [2] Silverman [1986], "Density estimation for statistics and data analysis".
 
-% Copyright (C) 2004-2015 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,7 +41,7 @@ function optimal_bandwidth = mh_optimal_bandwidth(data,number_of_draws,bandwidth
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-%% Kernel specifications.
+% Kernel specifications.
 if strcmpi(kernel_function,'gaussian')
     % Kernel definition
     k    = @(x)inv(sqrt(2*pi))*exp(-0.5*x.^2);
@@ -53,30 +53,30 @@ if strcmpi(kernel_function,'gaussian')
     k6   = @(x)inv(sqrt(2*pi))*(-15*exp(-0.5*x.^2)+45*(x.^2).*exp(-0.5*x.^2)-15*(x.^4).*exp(-0.5*x.^2)+(x.^6).*exp(-0.5*x.^2));
     mu02 = inv(2*sqrt(pi));
     mu21 = 1;
-elseif strcmpi(kernel_function,'uniform') 
+elseif strcmpi(kernel_function,'uniform')
     k    = @(x)0.5*(abs(x) <= 1);
     mu02 = 0.5;
     mu21 = 1/3;
-elseif strcmpi(kernel_function,'triangle') 
+elseif strcmpi(kernel_function,'triangle')
     k    = @(x)(1-abs(x)).*(abs(x) <= 1);
     mu02 = 2/3;
     mu21 = 1/6;
-elseif strcmpi(kernel_function,'epanechnikov') 
+elseif strcmpi(kernel_function,'epanechnikov')
     k    = @(x)0.75*(1-x.^2).*(abs(x) <= 1);
     mu02 = 3/5;
     mu21 = 1/5;
-elseif strcmpi(kernel_function,'quartic') 
+elseif strcmpi(kernel_function,'quartic')
     k    = @(x)0.9375*((1-x.^2).^2).*(abs(x) <= 1);
     mu02 = 15/21;
     mu21 = 1/7;
-elseif strcmpi(kernel_function,'triweight') 
+elseif strcmpi(kernel_function,'triweight')
     k    = @(x)1.09375*((1-x.^2).^3).*(abs(x) <= 1);
     k2   = @(x)(105/4*(1-x.^2).*x.^2-105/16*(1-x.^2).^2).*(abs(x) <= 1);
     k4   = @(x)(-1575/4*x.^2+315/4).*(abs(x) <= 1);
     k6   = @(x)(-1575/2).*(abs(x) <= 1);
     mu02 = 350/429;
     mu21 = 1/9;
-elseif strcmpi(kernel_function,'cosinus') 
+elseif strcmpi(kernel_function,'cosinus')
     k    = @(x)(pi/4)*cos((pi/2)*x).*(abs(x) <= 1);
     k2   = @(x)(-1/16*cos(pi*x/2)*pi^3).*(abs(x) <= 1);
     k4   = @(x)(1/64*cos(pi*x/2)*pi^5).*(abs(x) <= 1);
@@ -89,32 +89,34 @@ else
 end
 
 
-%% Get the Skold and Roberts' correction.
+% Get the Skold and Roberts' correction.
 if bandwidth==0 || bandwidth==-1
     correction = correction_for_repeated_draws(data,number_of_draws);
 else
     correction = 0;
 end
-%% Compute the standard deviation of the draws.
+
+% Compute the standard deviation of the draws.
 sigma = std(data);
-%% Optimal bandwidth parameter.
-if bandwidth == 0;  % Rule of thumb bandwidth parameter (Silverman [1986].
+
+% Optimal bandwidth parameter.
+if bandwidth == 0  % Rule of thumb bandwidth parameter (Silverman [1986].
     h = 2*sigma*(sqrt(pi)*mu02/(12*(mu21^2)*number_of_draws))^(1/5);
     h = h*correction^(1/5);
-elseif bandwidth == -1; % Sheather and Jones [1991] plug-in estimation of the optimal bandwidth parameter. 
-    if strcmp(kernel_function,'uniform')      || ... 
-            strcmp(kernel_function,'triangle')     || ... 
-            strcmp(kernel_function,'epanechnikov') || ... 
+elseif bandwidth == -1 % Sheather and Jones [1991] plug-in estimation of the optimal bandwidth parameter.
+    if strcmp(kernel_function,'uniform')      || ...
+            strcmp(kernel_function,'triangle')     || ...
+            strcmp(kernel_function,'epanechnikov') || ...
             strcmp(kernel_function,'quartic')
         error(['I can''t compute the optimal bandwidth with this kernel...' ...
                'Try the gaussian, triweight or cosinus kernels.']);
-    end 
+    end
     Itilda4 = 8*7*6*5/(((2*sigma)^9)*sqrt(pi));
     g3      = abs(2*correction*k6(0)/(mu21*Itilda4*number_of_draws))^(1/9);
     Ihat3   = 0;
     for i=1:number_of_draws
         Ihat3 = Ihat3 + sum(k6((data(i,1)-data)/g3));
-    end     
+    end
     Ihat3 = - Ihat3/((number_of_draws^2)*g3^7);
     g2    = abs(2*correction*k4(0)/(mu21*Ihat3*number_of_draws))^(1/7);
     Ihat2 = 0;
@@ -122,40 +124,40 @@ elseif bandwidth == -1; % Sheather and Jones [1991] plug-in estimation of the op
         Ihat2 = Ihat2 + sum(k4((data(i)-data)/g2));
     end
     Ihat2 = Ihat2/((number_of_draws^2)*g2^5);
-    h     = (correction*mu02/(number_of_draws*Ihat2*mu21^2))^(1/5); % equation (22) in Skold and Roberts [2003]. 
-elseif bandwidth == -2;     % Bump killing... I compute local bandwith parameters in order to remove 
-                            % spurious bumps introduced by long rejecting periods.   
-    if strcmp(kernel_function,'uniform')      || ... 
-            strcmp(kernel_function,'triangle')     || ... 
-            strcmp(kernel_function,'epanechnikov') || ... 
+    h     = (correction*mu02/(number_of_draws*Ihat2*mu21^2))^(1/5); % equation (22) in Skold and Roberts [2003].
+elseif bandwidth == -2     % Bump killing... I compute local bandwith parameters in order to remove
+                           % spurious bumps introduced by long rejecting periods.
+    if strcmp(kernel_function,'uniform')      || ...
+            strcmp(kernel_function,'triangle')     || ...
+            strcmp(kernel_function,'epanechnikov') || ...
             strcmp(kernel_function,'quartic')
         error(['I can''t compute the optimal bandwidth with this kernel...' ...
                'Try the gaussian, triweight or cosinus kernels.']);
     end
-    T = zeros(n,1);
-    for i=1:n
+    T = zeros(number_of_draws, 1);
+    for i=1:number_of_draws
         j = i;
-        while j<= n && (data(j,1)-data(i,1))<2*eps;
+        while j<=number_of_draws && (data(j,1)-data(i,1))<2*eps
             j = j+1;
-        end     
+        end
         T(i) = (j-i);
         correction = correction + 2*T(i) - 1;
     end
     correction = correction/number_of_draws;
     Itilda4 = 8*7*6*5/(((2*sigma)^9)*sqrt(pi));
-    g3      = abs(2*correction*k6(0)/(mu21*Itilda4*correction))^(1/9);
+    g3      = abs(2*correction*k6(0)/(mu21*Itilda4*number_of_draws))^(1/9);
     Ihat3   = 0;
     for i=1:number_of_draws
         Ihat3 = Ihat3 + sum(k6((data(i,1)-data)/g3));
     end
     Ihat3 = -Ihat3/((n^2)*g3^7);
-    g2    = abs(2*correction*k4(0)/(mu21*Ihat3*n))^(1/7);
+    g2    = abs(2*correction*k4(0)/(mu21*Ihat3*number_of_draws))^(1/7);
     Ihat2 = 0;
-    for i=1:number_of_draws;
+    for i=1:number_of_draws
         Ihat2 = Ihat2 + sum(k4((data(i)-data)/g2));
-    end     
+    end
     Ihat2 = Ihat2/((number_of_draws^2)*g2^5);
-    h = ((2*T-1)*mu02/(number_of_draws*Ihat2*mu21^2)).^(1/5); % h is a column vector (local banwidth parameters). 
+    h = ((2*T-1)*mu02/(number_of_draws*Ihat2*mu21^2)).^(1/5); % h is a column vector (local banwidth parameters).
 else
     disp('mh_optimal_bandwidth:: ');
     error('Parameter bandwidth must be equal to 0, -1 or -2.');
@@ -169,7 +171,7 @@ function correction = correction_for_repeated_draws(draws,n)
 correction = 0;
 for i=1:n
     j = i;
-    while j<=n && ( draws(j,1) - draws(i,1) )<2*eps; 
+    while j<=n && ( draws(j,1) - draws(i,1) )<2*eps
         j = j+1;
     end
     correction = correction + 2*(j-i) - 1;
diff --git a/matlab/minus_logged_prior_density.m b/matlab/minus_logged_prior_density.m
index 38662541e..0b5b1e815 100644
--- a/matlab/minus_logged_prior_density.m
+++ b/matlab/minus_logged_prior_density.m
@@ -1,19 +1,19 @@
 function [fval,info,exit_flag,fake_1,fake_2] = minus_logged_prior_density(xparams,pshape,p6,p7,p3,p4,DynareOptions,DynareModel,EstimatedParams,DynareResults)
 % Evaluates minus the logged prior density.
-% 
-% INPUTS 
+%
+% INPUTS
 %   xparams    [double]   vector of parameters.
 %   pshape     [integer]  vector specifying prior densities shapes.
 %   p6         [double]   vector, first hyperparameter.
 %   p7         [double]   vector, second hyperparameter.
 %   p3         [double]   vector, prior's lower bound.
-%   p4         [double]   vector, prior's upper bound. 
+%   p4         [double]   vector, prior's upper bound.
 %
-% OUTPUTS 
+% OUTPUTS
 %   f          [double]  value of minus the logged prior density.
 %   info       [double]  vector: second entry stores penalty, first entry the error code.
 %
-% Copyright (C) 2009-2016 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -128,8 +128,8 @@ M_ = set_all_parameters(xparams,EstimatedParams,DynareModel);
 % Return, with endogenous penalty when possible, if dynare_resolve issues an error code (defined in resol).
 if info(1)
     if info(1) == 3 || info(1) == 4 || info(1) == 5 || info(1)==6 ||info(1) == 19 ...
-            info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
-            info(1) == 81 || info(1) == 84 ||  info(1) == 85
+                info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
+                info(1) == 81 || info(1) == 84 ||  info(1) == 85
         %meaningful second entry of output that can be used
         fval = Inf;
         info(4) = info(2);
@@ -138,7 +138,7 @@ if info(1)
     else
         fval = Inf;
         info(4) = 0.1;
-        exit_flag = 0;        
+        exit_flag = 0;
         return
     end
 end
diff --git a/matlab/missing/corrcoef/corrcoef.m b/matlab/missing/corrcoef/corrcoef.m
index c918c6104..893fd7c57 100644
--- a/matlab/missing/corrcoef/corrcoef.m
+++ b/matlab/missing/corrcoef/corrcoef.m
@@ -25,28 +25,28 @@ function [R,sig,ci1,ci2,nan_sig] = corrcoef(X,Y,varargin)
 %               This replaces RANKCORR.M
 %
 % [...] = CORRCOEF(..., param1, value1, param2, value2, ... );
-%	param       value
-%	'Mode'		type of correlation
-%		'Pearson','parametric'
-%		'Spearman'
-%		'rank'
-%	'rows'		how do deal with missing values encoded as NaN's.
-%		'complete': remove all rows with at least one NaN
-%		'pairwise': [default]
-%	'alpha'		0.01	: significance level to compute confidence interval
+%       param       value
+%       'Mode'          type of correlation
+%               'Pearson','parametric'
+%               'Spearman'
+%               'rank'
+%       'rows'          how do deal with missing values encoded as NaN's.
+%               'complete': remove all rows with at least one NaN
+%               'pairwise': [default]
+%       'alpha'         0.01    : significance level to compute confidence interval
 %
 % [R,p,ci1,ci2,nansig] = CORRCOEF(...);
 %   R is the correlation matrix
-%	R(i,j) is the correlation coefficient r between X(:,i) and Y(:,j)
+%       R(i,j) is the correlation coefficient r between X(:,i) and Y(:,j)
 %  p    gives the significance of R
-%	It tests the null hypothesis that the product moment correlation coefficient is zero
+%       It tests the null hypothesis that the product moment correlation coefficient is zero
 %       using Student's t-test on the statistic t = r*sqrt(N-2)/sqrt(1-r^2)
 %       where N is the number of samples (Statistics, M. Spiegel, Schaum series).
 %  p > alpha: do not reject the Null hypothesis: 'R is zero'.
 %  p < alpha: The alternative hypothesis 'R is larger than zero' is true with probability (1-alpha).
-%  ci1	lower (1-alpha) confidence interval
-%  ci2	upper (1-alpha) confidence interval
-%	If no alpha is provided, the default alpha is 0.01. This can be changed with function flag_implicit_significance.
+%  ci1  lower (1-alpha) confidence interval
+%  ci2  upper (1-alpha) confidence interval
+%       If no alpha is provided, the default alpha is 0.01. This can be changed with function flag_implicit_significance.
 %  nan_sig  p-value whether H0: 'NaN''s are not correlated' could be correct
 %       if nan_sig < alpha, H1 ('NaNs are correlated') is very likely.
 %
@@ -65,7 +65,7 @@ function [R,sig,ci1,ci2,nan_sig] = corrcoef(X,Y,varargin)
 % Further recommandation related to the correlation coefficient:
 % + LOOK AT THE SCATTERPLOTS to make sure that the relationship is linear
 % + Correlation is not causation because
-%	it is not clear which parameter is 'cause' and which is 'effect' and
+%       it is not clear which parameter is 'cause' and which is 'effect' and
 %       the observed correlation between two variables might be due to the action of other, unobserved variables.
 %
 % see also: SUMSKIPNAN, COVM, COV, COR, SPEARMAN, RANKCORR, RANKS,
@@ -91,7 +91,7 @@ function [R,sig,ci1,ci2,nan_sig] = corrcoef(X,Y,varargin)
 
 %       $Id: corrcoef.m 9387 2011-12-15 10:42:14Z schloegl $
 %       Copyright (C) 2000-2004,2008,2009,2011 by Alois Schloegl <alois.schloegl@gmail.com>
-%       Copyright (C) 2014 Dynare Team
+%       Copyright (C) 2014-2017 Dynare Team
 %       This function is part of the NaN-toolbox
 %       http://pub.ist.ac.at/~schloegl/matlab/NaN/
 
@@ -124,59 +124,59 @@ function [R,sig,ci1,ci2,nan_sig] = corrcoef(X,Y,varargin)
 
 global FLAG_NANS_OCCURED;
 
-NARG = nargout;	% needed because nargout is not reentrant in Octave, and corrcoef is recursive
+NARG = nargout; % needed because nargout is not reentrant in Octave, and corrcoef is recursive
 mode = [];
 
 if nargin==1
-        Y = [];
-        Mode='Pearson';
+    Y = [];
+    Mode='Pearson';
 elseif nargin==0
-        fprintf(2,'Error CORRCOEF: Missing argument(s)\n');
+    fprintf(2,'Error CORRCOEF: Missing argument(s)\n');
 elseif nargin>1
-        if ischar(Y)
-                varg = [Y,varargin];
-                Y=[];
-        else
-                varg = varargin;
-        end;
+    if ischar(Y)
+        varg = [Y,varargin];
+        Y=[];
+    else
+        varg = varargin;
+    end
 
-        if length(varg)<1,
-                Mode = 'Pearson';
-        elseif length(varg)==1,
-                Mode = varg{1};
-        else
-                for k = 2:2:length(varg),
-                        mode = setfield(mode,lower(varg{k-1}),varg{k});
-                end;
-                if isfield(mode,'mode')
-                        Mode = mode.mode;
-                end;
-        end;
-end;
-if isempty(Mode) Mode='pearson'; end;
+    if length(varg)<1
+        Mode = 'Pearson';
+    elseif length(varg)==1
+        Mode = varg{1};
+    else
+        for k = 2:2:length(varg)
+            mode = setfield(mode,lower(varg{k-1}),varg{k});
+        end
+        if isfield(mode,'mode')
+            Mode = mode.mode;
+        end
+    end
+end
+if isempty(Mode), Mode='pearson'; end
 Mode=[Mode,'        '];
 
 
 
-FLAG_WARNING = warning;		% save warning status
+FLAG_WARNING = warning;         % save warning status
 warning('off');
 
 [r1,c1]=size(X);
 if ~isempty(Y)
-        [r2,c2]=size(Y);
-        if r1~=r2,
-                fprintf(2,'Error CORRCOEF: X and Y must have the same number of observations (rows).\n');
-                return;
-        end;
-        NN = real(~isnan(X)')*real(~isnan(Y));
+    [r2,c2]=size(Y);
+    if r1~=r2
+        fprintf(2,'Error CORRCOEF: X and Y must have the same number of observations (rows).\n');
+        return
+    end
+    NN = real(~isnan(X)')*real(~isnan(Y));
 else
-        [r2,c2]=size(X);
-        NN = real(~isnan(X)')*real(~isnan(X));
-end;
+    [r2,c2]=size(X);
+    NN = real(~isnan(X)')*real(~isnan(X));
+end
 
 %%%%% generate combinations using indices for pairwise calculation of the correlation
 YESNAN = any(isnan(X(:))) | any(isnan(Y(:)));
-if YESNAN,
+if YESNAN
     FLAG_NANS_OCCURED=(1==1);
     if isfield(mode,'rows')
         if strcmp(mode.rows,'complete')
@@ -184,7 +184,7 @@ if YESNAN,
             X = X(ix,:);
             if ~isempty(Y)
                 Y = Y(ix,:);
-            end;
+            end
             YESNAN = 0;
             NN = size(X,1);
         elseif strcmp(mode.rows,'all')
@@ -192,175 +192,175 @@ if YESNAN,
             %%NN(NN < size(X,1)) = NaN;
         elseif strcmp(mode.rows,'pairwise')
             %%% default
-        end;
-    end;
-end;
-if isempty(Y),
-        IX = ones(c1)-diag(ones(c1,1));
-        [jx, jy ] = find(IX);
-        [jxo,jyo] = find(IX);
+        end
+    end
+end
+if isempty(Y)
+    IX = ones(c1)-diag(ones(c1,1));
+    [jx, jy ] = find(IX);
+    [jxo,jyo] = find(IX);
     R = eye(c1);
 else
-        IX = sparse([],[],[],c1+c2,c1+c2,c1*c2);
-        IX(1:c1,c1+(1:c2)) = 1;
-        [jx,jy] = find(IX);
+    IX = sparse([],[],[],c1+c2,c1+c2,c1*c2);
+    IX(1:c1,c1+(1:c2)) = 1;
+    [jx,jy] = find(IX);
 
-        IX = ones(c1,c2);
-        [jxo,jyo] = find(IX);
+    IX = ones(c1,c2);
+    [jxo,jyo] = find(IX);
     R = zeros(c1,c2);
-end;
+end
 
-if strcmp(lower(Mode(1:7)),'pearson');
-        % see http://mathworld.wolfram.com/CorrelationCoefficient.html
-    if ~YESNAN,
-                [S,N,SSQ] = sumskipnan(X,1);
-                if ~isempty(Y),
-                    [S2,N2,SSQ2] = sumskipnan(Y,1);
-                        CC = X'*Y;
-                        M1 = S./N;
-                        M2 = S2./N2;
-                        cc = CC./NN - M1'*M2;
-                        R  = cc./sqrt((SSQ./N-M1.*M1)'*(SSQ2./N2-M2.*M2));
-                else
-                        CC = X'*X;
-                        M  = S./N;
-                        cc = CC./NN - M'*M;
-                        v  = SSQ./N - M.*M; %max(N-1,0);
-                        R  = cc./sqrt(v'*v);
-                end;
+if strcmp(lower(Mode(1:7)),'pearson')
+    % see http://mathworld.wolfram.com/CorrelationCoefficient.html
+    if ~YESNAN
+        [S,N,SSQ] = sumskipnan(X,1);
+        if ~isempty(Y)
+            [S2,N2,SSQ2] = sumskipnan(Y,1);
+            CC = X'*Y;
+            M1 = S./N;
+            M2 = S2./N2;
+            cc = CC./NN - M1'*M2;
+            R  = cc./sqrt((SSQ./N-M1.*M1)'*(SSQ2./N2-M2.*M2));
         else
-                if ~isempty(Y),
-                        X  = [X,Y];
-                end;
-                for k = 1:length(jx),
-                        %ik = ~any(isnan(X(:,[jx(k),jy(k)])),2);
-                        ik = ~isnan(X(:,jx(k))) & ~isnan(X(:,jy(k)));
-                        [s,n,s2] = sumskipnan(X(ik,[jx(k),jy(k)]),1);
-                        v  = (s2-s.*s./n)./n;
-                        cc = X(ik,jx(k))'*X(ik,jy(k));
-                        cc = cc/n(1) - prod(s./n);
-                        %r(k) = cc./sqrt(prod(v));
-                        R(jxo(k),jyo(k)) = cc./sqrt(prod(v));
-                end;
+            CC = X'*X;
+            M  = S./N;
+            cc = CC./NN - M'*M;
+            v  = SSQ./N - M.*M; %max(N-1,0);
+            R  = cc./sqrt(v'*v);
+        end
+    else
+        if ~isempty(Y)
+            X  = [X,Y];
+        end
+        for k = 1:length(jx)
+            %ik = ~any(isnan(X(:,[jx(k),jy(k)])),2);
+            ik = ~isnan(X(:,jx(k))) & ~isnan(X(:,jy(k)));
+            [s,n,s2] = sumskipnan(X(ik,[jx(k),jy(k)]),1);
+            v  = (s2-s.*s./n)./n;
+            cc = X(ik,jx(k))'*X(ik,jy(k));
+            cc = cc/n(1) - prod(s./n);
+            %r(k) = cc./sqrt(prod(v));
+            R(jxo(k),jyo(k)) = cc./sqrt(prod(v));
+        end
     end
 
-elseif strcmp(lower(Mode(1:4)),'rank');
-        % see [ 6] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
-    if ~YESNAN,
-                if isempty(Y)
-                    R = corrcoef(ranks(X));
-                else
-                        R = corrcoef(ranks(X),ranks(Y));
-                end;
+elseif strcmp(lower(Mode(1:4)),'rank')
+    % see [ 6] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
+    if ~YESNAN
+        if isempty(Y)
+            R = corrcoef(ranks(X));
         else
-                if ~isempty(Y),
-                        X = [X,Y];
-                end;
-                for k = 1:length(jx),
-                        %ik = ~any(isnan(X(:,[jx(k),jy(k)])),2);
-                        ik = ~isnan(X(:,jx(k))) & ~isnan(X(:,jy(k)));
-                        il = ranks(X(ik,[jx(k),jy(k)]));
-                        R(jxo(k),jyo(k)) = corrcoef(il(:,1),il(:,2));
-                end;
+            R = corrcoef(ranks(X),ranks(Y));
+        end
+    else
+        if ~isempty(Y)
+            X = [X,Y];
+        end
+        for k = 1:length(jx)
+            %ik = ~any(isnan(X(:,[jx(k),jy(k)])),2);
+            ik = ~isnan(X(:,jx(k))) & ~isnan(X(:,jy(k)));
+            il = ranks(X(ik,[jx(k),jy(k)]));
+            R(jxo(k),jyo(k)) = corrcoef(il(:,1),il(:,2));
+        end
         X = ranks(X);
-    end;
+    end
 
-elseif strcmp(lower(Mode(1:8)),'spearman');
-        % see [ 6] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
-        if ~isempty(Y),
-                X = [X,Y];
-        end;
+elseif strcmp(lower(Mode(1:8)),'spearman')
+    % see [ 6] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
+    if ~isempty(Y)
+        X = [X,Y];
+    end
 
-        n = repmat(nan,c1,c2);
+    n = repmat(nan,c1,c2);
 
-        if ~YESNAN,
-                iy = ranks(X);	%  calculates ranks;
+    if ~YESNAN
+        iy = ranks(X);  %  calculates ranks;
 
-                for k = 1:length(jx),
-                        [R(jxo(k),jyo(k)),n(jxo(k),jyo(k))] = sumskipnan((iy(:,jx(k)) - iy(:,jy(k))).^2);	% NN is the number of non-missing values
-                end;
-        else
-                for k = 1:length(jx),
-                        %ik = ~any(isnan(X(:,[jx(k),jy(k)])),2);
-                        ik = ~isnan(X(:,jx(k))) & ~isnan(X(:,jy(k)));
-                        il = ranks(X(ik,[jx(k),jy(k)]));
-                        % NN is the number of non-missing values
-                        [R(jxo(k),jyo(k)),n(jxo(k),jyo(k))] = sumskipnan((il(:,1) - il(:,2)).^2);
-                end;
+        for k = 1:length(jx)
+            [R(jxo(k),jyo(k)),n(jxo(k),jyo(k))] = sumskipnan((iy(:,jx(k)) - iy(:,jy(k))).^2);       % NN is the number of non-missing values
+        end
+    else
+        for k = 1:length(jx)
+            %ik = ~any(isnan(X(:,[jx(k),jy(k)])),2);
+            ik = ~isnan(X(:,jx(k))) & ~isnan(X(:,jy(k)));
+            il = ranks(X(ik,[jx(k),jy(k)]));
+            % NN is the number of non-missing values
+            [R(jxo(k),jyo(k)),n(jxo(k),jyo(k))] = sumskipnan((il(:,1) - il(:,2)).^2);
+        end
         X = ranks(X);
-        end;
-        R = 1 - 6 * R ./ (n.*(n.*n-1));
+    end
+    R = 1 - 6 * R ./ (n.*(n.*n-1));
 
-elseif strcmp(lower(Mode(1:7)),'partial');
-        fprintf(2,'Error CORRCOEF: use PARTCORRCOEF \n',Mode);
+elseif strcmp(lower(Mode(1:7)),'partial')
+    fprintf(2,'Error CORRCOEF: use PARTCORRCOEF \n',Mode);
 
-        return;
+    return
 
-elseif strcmp(lower(Mode(1:7)),'kendall');
-        fprintf(2,'Error CORRCOEF: mode ''%s'' not implemented yet.\n',Mode);
+elseif strcmp(lower(Mode(1:7)),'kendall')
+    fprintf(2,'Error CORRCOEF: mode ''%s'' not implemented yet.\n',Mode);
 
-        return;
+    return
 else
-        fprintf(2,'Error CORRCOEF: unknown mode ''%s''\n',Mode);
-end;
+    fprintf(2,'Error CORRCOEF: unknown mode ''%s''\n',Mode);
+end
 
-if (NARG<2),
-        warning(FLAG_WARNING);  % restore warning status
-        return;
-end;
+if (NARG<2)
+    warning(FLAG_WARNING);  % restore warning status
+    return
+end
 
 
 % CONFIDENCE INTERVAL
 if isfield(mode,'alpha')
     alpha = mode.alpha;
-elseif exist('flag_implicit_significance','file'),
-        alpha = flag_implicit_significance;
+elseif exist('flag_implicit_significance','file')
+    alpha = flag_implicit_significance;
 else
     alpha = 0.01;
-end;
+end
 % fprintf(1,'CORRCOEF: confidence interval is based on alpha=%f\n',alpha);
 
 
 % SIGNIFICANCE TEST
 R(isnan(R))=0;
 tmp = 1 - R.*R;
-tmp(tmp<0) = 0;		% prevent tmp<0 i.e. imag(t)~=0
+tmp(tmp<0) = 0;         % prevent tmp<0 i.e. imag(t)~=0
 t   = R.*sqrt(max(NN-2,0)./tmp);
 
-if exist('t_cdf','file');
-        sig = t_cdf(t,NN-2);
-elseif exist('tcdf','file')>1;
-        sig = tcdf(t,NN-2);
+if exist('t_cdf','file')
+    sig = t_cdf(t,NN-2);
+elseif exist('tcdf','file')>1
+    sig = tcdf(t,NN-2);
 else
-        fprintf('CORRCOEF: significance test not completed because of missing TCDF-function\n')
-        sig = repmat(nan,size(R));
-end;
+    fprintf('CORRCOEF: significance test not completed because of missing TCDF-function\n')
+    sig = repmat(nan,size(R));
+end
 sig  = 2 * min(sig,1 - sig);
 
 
-if NARG<3,
+if NARG<3
     warning(FLAG_WARNING);  % restore warning status
-        return;
-end;
+    return
+end
 
 
 tmp = R;
-%tmp(ix1 | ix2) = nan;		% avoid division-by-zero warning
+%tmp(ix1 | ix2) = nan;          % avoid division-by-zero warning
 z   = log((1+tmp)./(1-tmp))/2;  % Fisher transformation [21]
-%sz = 1./sqrt(NN-3);		% standard error of z
-sz  = sqrt(2)*erfinv(1-alpha)./sqrt(NN-3);	% confidence interval for alpha of z
+                                %sz = 1./sqrt(NN-3);            % standard error of z
+sz  = sqrt(2)*erfinv(1-alpha)./sqrt(NN-3);      % confidence interval for alpha of z
 
 ci1 = tanh(z-sz);
 ci2 = tanh(z+sz);
 
-%ci1(isnan(ci1))=R(isnan(ci1));	% in case of isnan(ci), the interval limits are exactly the R value
+%ci1(isnan(ci1))=R(isnan(ci1)); % in case of isnan(ci), the interval limits are exactly the R value
 %ci2(isnan(ci2))=R(isnan(ci2));
 
-if (NARG<5) || ~YESNAN,
+if (NARG<5) || ~YESNAN
     nan_sig = repmat(NaN,size(R));
     warning(FLAG_WARNING);  % restore warning status
-    return;
-end;
+    return
+end
 
 %%%%% ----- check independence of NaNs (missing values) -----
 [nan_R, nan_sig] = corrcoef(X,double(isnan(X)));
@@ -370,18 +370,16 @@ nan_sig(isnan(nan_R)) = nan;
 % remove diagonal elements, because these have not any meaning %
 nan_R(isnan(nan_R)) = 0;
 
-if 0, any(nan_sig(:) < alpha),
-        tmp = nan_sig(:);			% Hack to skip NaN's in MIN(X)
-        min_sig = min(tmp(~isnan(tmp)));    % Necessary, because Octave returns NaN rather than min(X) for min(NaN,X)
-        fprintf(1,'CORRCOFF Warning: Missing Values (i.e. NaNs) are not independent of data (p-value=%f)\n', min_sig);
-        fprintf(1,'   Its recommended to remove all samples (i.e. rows) with any missing value (NaN).\n');
-        fprintf(1,'   The null-hypotheses (NaNs are uncorrelated) is rejected for the following parameter pair(s).\n');
-        [ix,iy] = find(nan_sig < alpha);
-        disp([ix,iy])
-end;
+if 0, any(nan_sig(:) < alpha)
+    tmp = nan_sig(:);                       % Hack to skip NaN's in MIN(X)
+    min_sig = min(tmp(~isnan(tmp)));    % Necessary, because Octave returns NaN rather than min(X) for min(NaN,X)
+    fprintf(1,'CORRCOFF Warning: Missing Values (i.e. NaNs) are not independent of data (p-value=%f)\n', min_sig);
+    fprintf(1,'   Its recommended to remove all samples (i.e. rows) with any missing value (NaN).\n');
+    fprintf(1,'   The null-hypotheses (NaNs are uncorrelated) is rejected for the following parameter pair(s).\n');
+    [ix,iy] = find(nan_sig < alpha);
+    disp([ix,iy])
+end
 
 %%%%% ----- end of independence check ------
 
 warning(FLAG_WARNING);  % restore warning status
-return;
-
diff --git a/matlab/missing/corrcoef/flag_implicit_skip_nan.m b/matlab/missing/corrcoef/flag_implicit_skip_nan.m
index 409b9f696..e8fd0fec6 100644
--- a/matlab/missing/corrcoef/flag_implicit_skip_nan.m
+++ b/matlab/missing/corrcoef/flag_implicit_skip_nan.m
@@ -1,6 +1,6 @@
 function FLAG = flag_implicit_skip_nan(i)
 % FLAG_IMPLICIT_SKIP_NAN sets and gets default mode for handling NaNs
-%	1 skips NaN's (the default mode if no mode is set)
+%       1 skips NaN's (the default mode if no mode is set)
 %   0 NaNs are propagated; input NaN's give NaN's at the output
 %
 % FLAG = flag_implicit_skip_nan()
@@ -9,15 +9,15 @@ function FLAG = flag_implicit_skip_nan(i)
 % flag_implicit_skip_nan(FLAG)    % sets mode
 %
 % prevFLAG = flag_implicit_skip_nan(nextFLAG)
-%	gets previous set FLAG and sets FLAG for the future
+%       gets previous set FLAG and sets FLAG for the future
 % flag_implicit_skip_nan(prevFLAG)
-%	resets FLAG to previous mode
+%       resets FLAG to previous mode
 %
 % It is used in:
-%	SUMSKIPNAN, MEDIAN, QUANTILES, TRIMEAN
+%       SUMSKIPNAN, MEDIAN, QUANTILES, TRIMEAN
 % and affects many other functions like:
-%	CENTER, KURTOSIS, MAD, MEAN, MOMENT, RMS, SEM, SKEWNESS,
-%	STATISTIC, STD, VAR, ZSCORE etc.
+%       CENTER, KURTOSIS, MAD, MEAN, MOMENT, RMS, SEM, SKEWNESS,
+%       STATISTIC, STD, VAR, ZSCORE etc.
 %
 % The mode is stored in the global variable FLAG_implicit_skip_nan
 % It is recommended to use flag_implicit_skip_nan(1) as default and
@@ -40,27 +40,28 @@ function FLAG = flag_implicit_skip_nan(i)
 %    along with this program; if not, write to the Free Software
 %    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
-%	$Id: flag_implicit_skip_nan.m 8351 2011-06-24 17:35:07Z carandraug $
+%       $Id: flag_implicit_skip_nan.m 8351 2011-06-24 17:35:07Z carandraug $
+
 %   Copyright (C) 2001-2003,2009 by Alois Schloegl <alois.schloegl@gmail.com>
-%   Copyright (C) 2014 Dynare Team
+%   Copyright (C) 2014-2017 Dynare Team
+%
 %       This function is part of the NaN-toolbox
 %       http://pub.ist.ac.at/~schloegl/matlab/NaN/
 
 
 persistent FLAG_implicit_skip_nan;
 
-%% if strcmp(version,'3.6'), FLAG_implicit_skip_nan=(1==1); end;	%% hack for the use with Freemat3.6
+%% if strcmp(version,'3.6'), FLAG_implicit_skip_nan=(1==1); end;        %% hack for the use with Freemat3.6
 
 %%% set DEFAULT value of FLAG
-if isempty(FLAG_implicit_skip_nan),
+if isempty(FLAG_implicit_skip_nan)
     FLAG_implicit_skip_nan = (1==1); %logical(1); % logical.m not available on 2.0.16
-end;
+end
 
 FLAG = FLAG_implicit_skip_nan;
-if nargin>0,
+if nargin>0
     FLAG_implicit_skip_nan = (i~=0); %logical(i); %logical.m not available in 2.0.16
     if (~i)
         warning('flag_implicit_skipnan(0): You are warned!!! You have turned off skipping NaN in sumskipnan. This is not recommended. Make sure you really know what you do.')
-    end;
-end;
-
+    end
+end
diff --git a/matlab/missing/corrcoef/sumskipnan.m b/matlab/missing/corrcoef/sumskipnan.m
index 78f8ecbc1..a1054c3f8 100644
--- a/matlab/missing/corrcoef/sumskipnan.m
+++ b/matlab/missing/corrcoef/sumskipnan.m
@@ -13,13 +13,13 @@ function [o,count,SSQ] = sumskipnan(x, DIM, W)
 % [Y,N,SSQ] = sumskipnan(x [,DIM])
 % [...] = sumskipnan(x, DIM, W)
 %
-% x	input data
-% DIM	dimension (default: [])
-%	empty DIM sets DIM to first non singleton dimension
-% W	weight vector for weighted sum, numel(W) must fit size(x,DIM)
-% Y	resulting sum
-% N	number of valid (not missing) elements
-% SSQ	sum of squares
+% x     input data
+% DIM   dimension (default: [])
+%       empty DIM sets DIM to first non singleton dimension
+% W     weight vector for weighted sum, numel(W) must fit size(x,DIM)
+% Y     resulting sum
+% N     number of valid (not missing) elements
+% SSQ   sum of squares
 %
 % the function FLAG_NANS_OCCURED() returns whether any value in x
 %  is a not-a-number (NaN)
@@ -47,21 +47,22 @@ function [o,count,SSQ] = sumskipnan(x, DIM, W)
 %    You should have received a copy of the GNU General Public License
 %    along with this program; If not, see <http://www.gnu.org/licenses/>.
 
-%	$Id: sumskipnan.m 9033 2011-11-08 20:58:07Z schloegl $
+%       $Id: sumskipnan.m 9033 2011-11-08 20:58:07Z schloegl $
+%
 %       Copyright (C) 2000-2005,2009,2011 by Alois Schloegl <alois.schloegl@gmail.com>
-%       Copyright (C) 2014 Dynare Team
+%       Copyright (C) 2014-2017 Dynare Team
 %       This function is part of the NaN-toolbox
 %       http://pub.ist.ac.at/~schloegl/matlab/NaN/
 
 
 global FLAG_NANS_OCCURED;
 
-if nargin<2,
-        DIM = [];
-end;
-if nargin<3,
-        W = [];
-end;
+if nargin<2
+    DIM = [];
+end
+if nargin<3
+    W = [];
+end
 
 % an efficient implementation in C of the following lines
 % could significantly increase performance
@@ -73,24 +74,24 @@ end;
 %   if ~isnan(i(k))
 %   {   o     += x(k);
 %               count += 1;
-%		tmp    = x(k)*x(k)
-%		o2    += tmp;
-%		o3    += tmp.*tmp;
+%               tmp    = x(k)*x(k)
+%               o2    += tmp;
+%               o3    += tmp.*tmp;
 %       };
 
-if isempty(DIM),
-        DIM = find(size(x)>1,1);
-        if isempty(DIM), DIM = 1; end;
+if isempty(DIM)
+    DIM = find(size(x)>1,1);
+    if isempty(DIM), DIM = 1; end
 end
-if (DIM<1), DIM = 1; end; %% Hack, because min([])=0 for FreeMat v3.5
+if (DIM<1), DIM = 1; end %% Hack, because min([])=0 for FreeMat v3.5
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % non-float data
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-if  (isempty(W) && (~(isa(x,'float') || isa(x,'double')))) || ~flag_implicit_skip_nan(), %%% skip always NaN's
+if  (isempty(W) && (~(isa(x,'float') || isa(x,'double')))) || ~flag_implicit_skip_nan() %%% skip always NaN's
     if ~isempty(W)
         error('SUMSKIPNAN: weighted sum of integers not supported, yet');
-    end;
+    end
     x = double(x);
     o = sum(x,DIM);
     if nargout>1
@@ -101,16 +102,16 @@ if  (isempty(W) && (~(isa(x,'float') || isa(x,'double')))) || ~flag_implicit_ski
         if nargout>2
             x = x.*x;
             SSQ = sum(x,DIM);
-        end;
-    end;
-    return;
-end;
+        end
+    end
+    return
+end
 
 if (length(size(x))<DIM)
     error('SUMSKIPNAN: DIM argument larger than number of dimensions of x');
 elseif ~isempty(W) && (size(x,DIM)~=numel(W))
     error('SUMSKIPNAN: size of weight vector does not match size(x,DIM)');
-end;
+end
 
 %% mex and oct files expect double
 x = double(x);
@@ -124,18 +125,18 @@ try
     %% using sumskipnan_mex.mex
 
     %% !!! hack: FLAG_NANS_OCCURED is an output argument, reserve memory !!!
-    if isempty(FLAG_NANS_OCCURED),
+    if isempty(FLAG_NANS_OCCURED)
         FLAG_NANS_OCCURED = logical(0);  % default value
-    end;
+    end
 
-    if (nargout<2),
+    if (nargout<2)
         o = sumskipnan_mex(real(x),DIM,FLAG_NANS_OCCURED,W);
         if (~isreal(x))
             io = sumskipnan_mex(imag(x),DIM,FLAG_NANS_OCCURED,W);
             o  = o + i*io;
-        end;
-        return;
-    elseif (nargout==2),
+        end
+        return
+    elseif (nargout==2)
         [o,count] = sumskipnan_mex(real(x),DIM,FLAG_NANS_OCCURED,W);
         if (~isreal(x))
             [io,icount] = sumskipnan_mex(imag(x),DIM,FLAG_NANS_OCCURED,W);
@@ -143,10 +144,10 @@ try
                 error('Number of NaNs differ for REAL and IMAG part');
             else
                 o  = o+i*io;
-            end;
-        end;
-        return;
-    elseif (nargout>=3),
+            end
+        end
+        return
+    elseif (nargout>=3)
         [o,count,SSQ] = sumskipnan_mex(real(x),DIM,FLAG_NANS_OCCURED,W);
         if (~isreal(x))
             [io,icount,iSSQ] = sumskipnan_mex(imag(x),DIM,FLAG_NANS_OCCURED,W);
@@ -155,23 +156,23 @@ try
             else
                 o  = o+i*io;
                 SSQ = SSQ+iSSQ;
-            end;
-        end;
-        return;
-    end;
-end;
+            end
+        end
+        return
+    end
+end
 
 if ~isempty(W)
     error('weighted sumskipnan requires sumskipnan_mex');
-end;
+end
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % count non-NaN's
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-if nargout>1,
-        count = sum(x==x,DIM);
+if nargout>1
+    count = sum(x==x,DIM);
     FLAG_NANS_OCCURED = any(count(:)<size(x,DIM));
-end;
+end
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % replace NaN's with zero
@@ -179,16 +180,13 @@ end;
 x(x~=x) = 0;
 o = sum(x,DIM);
 
-if nargout>2,
-        x = real(x).^2 + imag(x).^2;
-        SSQ = sum(x,DIM);
-end;
+if nargout>2
+    x = real(x).^2 + imag(x).^2;
+    SSQ = sum(x,DIM);
+end
 
 %!assert(sumskipnan([1,2],1),[1,2])
 %!assert(sumskipnan([1,NaN],2),1)
 %!assert(sumskipnan([1,NaN],2),1)
 %!assert(sumskipnan([nan,1,4,5]),10)
 %!assert(sumskipnan([nan,1,4,5]',1,[3;2;1;0]),6)
-
-
-
diff --git a/matlab/missing/corrcoef/tcdf.m b/matlab/missing/corrcoef/tcdf.m
index c282e0a17..8d76f7657 100644
--- a/matlab/missing/corrcoef/tcdf.m
+++ b/matlab/missing/corrcoef/tcdf.m
@@ -11,9 +11,11 @@ function p = tcdf(x,n)
 
 % Reference(s):
 
-%	$Id: tcdf.m 9033 2011-11-08 20:58:07Z schloegl $
-%	Copyright (C) 2000-2003,2009 by Alois Schloegl <alois.schloegl@gmail.com>
-%   Copyright (C) 2014 Dynare Team
+%       $Id: tcdf.m 9033 2011-11-08 20:58:07Z schloegl $
+
+%   Copyright (C) 2000-2003,2009 by Alois Schloegl <alois.schloegl@gmail.com>
+%   Copyright (C) 2014-2017 Dynare Team
+%
 %       This is part of the NaN-toolbox. For more details see
 %       http://pub.ist.ac.at/~schloegl/matlab/NaN/
 
@@ -37,10 +39,10 @@ if all(size(x)==1)
 elseif all(size(n)==1)
     n = repmat(n,size(x));
 elseif all(size(x)==size(n))
-    ;	%% OK, do nothing
+    % OK, do nothing
 else
     error('size of input arguments must be equal or scalar')
-end;
+end
 
 % allocate memory
 p = zeros(size(x));
diff --git a/matlab/missing/ilu/ilu.m b/matlab/missing/ilu/ilu.m
index 4b4fe2338..6e53e59df 100644
--- a/matlab/missing/ilu/ilu.m
+++ b/matlab/missing/ilu/ilu.m
@@ -1,7 +1,7 @@
 function [L, U, P] = ilu(A, setup)
 % Partially implement function ilu using the (now deprecated) luinc
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -18,20 +18,20 @@ function [L, U, P] = ilu(A, setup)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-  if nargout ~= 2
-      error('Only two output arguments supported')
-  end
-  if nargin ~= 2
-      error('Only two input arguments supported')
-  end
-
-  if isfield(setup, 'milu')
-      if setup.milu == 'off'
-          setup.milu = 0;
-      else
-          error(['Unsupported milu: ' setup.milu ])
-      end
-  end
-  
-  [L, U] = luinc(A, setup);
+if nargout ~= 2
+    error('Only two output arguments supported')
+end
+if nargin ~= 2
+    error('Only two input arguments supported')
+end
+
+if isfield(setup, 'milu')
+    if setup.milu == 'off'
+        setup.milu = 0;
+    else
+        error(['Unsupported milu: ' setup.milu ])
+    end
+end
+
+[L, U] = luinc(A, setup);
 end
diff --git a/matlab/missing/issquare/issquare.m b/matlab/missing/issquare/issquare.m
index 4d4eb2b57..0b28884a0 100644
--- a/matlab/missing/issquare/issquare.m
+++ b/matlab/missing/issquare/issquare.m
@@ -27,7 +27,7 @@ function i = issquare(A)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -46,7 +46,7 @@ function i = issquare(A)
 
 d = size(A);
 if (length(d)==2) && (d(1)==d(2))
-  i = d(1);
+    i = d(1);
 else
-  i = 0;
+    i = 0;
 end
diff --git a/matlab/missing/ordeig/ordeig.m b/matlab/missing/ordeig/ordeig.m
index 6004fd86f..e7ddfd744 100644
--- a/matlab/missing/ordeig/ordeig.m
+++ b/matlab/missing/ordeig/ordeig.m
@@ -11,7 +11,7 @@ function eigs = ordeig(t)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,7 +34,7 @@ i = 1;
 while i <= n
     if i == n
         eigs(n) = t(n,n);
-        break;
+        break
     elseif t(i+1,i) == 0
         eigs(i) = t(i,i);
         i = i+1;
diff --git a/matlab/missing/stats/betacdf.m b/matlab/missing/stats/betacdf.m
index 2ba7cc53e..d1ac509f7 100644
--- a/matlab/missing/stats/betacdf.m
+++ b/matlab/missing/stats/betacdf.m
@@ -10,7 +10,7 @@ function cdf = betacdf (x, a, b)
 % Original author: KH <Kurt.Hornik@wu-wien.ac.at>
 
 % Copyright (C) 1995, 1996, 1997, 2005, 2006, 2007 Kurt Hornik
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -61,4 +61,3 @@ if (any (k))
 end
 
 end
-
diff --git a/matlab/missing/stats/betainv.m b/matlab/missing/stats/betainv.m
index 8273fc356..a7300d1b1 100644
--- a/matlab/missing/stats/betainv.m
+++ b/matlab/missing/stats/betainv.m
@@ -84,7 +84,7 @@ if (any (k))
         end
         h = y_old - y_new;
         if (max (abs (h)) < sqrt (eps))
-            break;
+            break
         end
         y_old = y_new;
     end
diff --git a/matlab/missing/stats/betarnd.m b/matlab/missing/stats/betarnd.m
index f27fca441..a2d0c9fe8 100644
--- a/matlab/missing/stats/betarnd.m
+++ b/matlab/missing/stats/betarnd.m
@@ -1,19 +1,19 @@
 function rnd = betarnd(a, b)
 % This function produces independent random variates from the Beta distribution.
 %
-%  INPUTS 
+%  INPUTS
 %    a       [double]    n*1 vector of positive parameters.
 %    b       [double]    n*1 vector of positive parameters.
 %
-%  OUTPUT 
+%  OUTPUT
 %    rnd     [double]    n*1 vector of independent variates from the beta(a,b) distribution.
-%                        rnd(i) is beta distributed with variance a(i)/(a(i)+b(i)) and 
-%                        variance a(i)b(i)/(a(i)+b(i))^2/(a(i)+b(i)+1).    
-%  
-%  ALGORITHMS     
+%                        rnd(i) is beta distributed with variance a(i)/(a(i)+b(i)) and
+%                        variance a(i)b(i)/(a(i)+b(i))^2/(a(i)+b(i)+1).
+%
+%  ALGORITHMS
 %    Described and Devroye (1986, chapter 9).
 
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/missing/stats/corr.m b/matlab/missing/stats/corr.m
index 21cdda767..ec2f719a1 100644
--- a/matlab/missing/stats/corr.m
+++ b/matlab/missing/stats/corr.m
@@ -25,7 +25,7 @@ function retval = corr(x, y) % --*-- Unitary tests --*--
 %! the correlation between the columns of @var{x}.
 %! @end deftypefn
 %@eod:
-% 
+%
 % Notes:    - the original Octave code has been rewritten to avoid calling cov, since
 %               there is a long-standing incompatiblity between Matlab's cov and Octave's cov
 %               (see https://savannah.gnu.org/bugs/?40751)
@@ -39,7 +39,7 @@ function retval = corr(x, y) % --*-- Unitary tests --*--
 % Copyright (C) 1993-1996 Kurt Hornik
 % Copyright (C) 1996-2015 John W. Eaton
 % Copyright (C) 2013-2015 Julien Bect
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -63,12 +63,12 @@ end
 
 % Input validation
 if (nargin==1 && ~(isnumeric (x) || islogical (x))) || ...
-    (nargin==2 && ~(isnumeric (x) || islogical (x) || isnumeric (y) || islogical (y)))
+           (nargin==2 && ~(isnumeric (x) || islogical (x) || isnumeric (y) || islogical (y)))
     error ('corr: X and Y must be numeric matrices or vectors');
 end
 
 if (nargin==1 && ~ismatrix(x)) || (nargin==2 && (~ismatrix(y) || ~ismatrix(x)))
-error ('corr: X and Y must be 2-D matrices or vectors');
+    error ('corr: X and Y must be 2-D matrices or vectors');
 end
 
 if (nargin == 2)
@@ -82,14 +82,14 @@ if isscalar(x)
     if nargin==1
         retval = NaN;
     else
-        retval = NaN(size(y));    
+        retval = NaN(size(y));
     end
-    return;
+    return
 end
 
 if nargin==2 && isscalar(y)
-    retval = NaN(size(x'));    
-    return;
+    retval = NaN(size(x'));
+    return
 end
 
 n = size (x, 1);
diff --git a/matlab/missing/stats/exprnd.m b/matlab/missing/stats/exprnd.m
index 65855db6e..b59daf904 100644
--- a/matlab/missing/stats/exprnd.m
+++ b/matlab/missing/stats/exprnd.m
@@ -2,22 +2,22 @@ function rnd = exprnd(a)
 %  Random samples from the exponential distribution with expectation a
 %  and variance a^2.
 %
-%  INPUTS 
+%  INPUTS
 %    a       [double]    m*n matrix of positive parameters
 %
-%  OUTPUT 
+%  OUTPUT
 %    rnd     [double]    m*n matrix, independent draws from the exponential
-%                        distribution rnd(j,j) has expectation a(i,j) and     
-%                        variance a(i,j)^2.   
+%                        distribution rnd(j,j) has expectation a(i,j) and
+%                        variance a(i,j)^2.
 %
-%  ALGORITHM  
+%  ALGORITHM
 %    Inverse transform sampling.
 %
 %  SPECIAL REQUIREMENTS
 %    None.
-%    
+%
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/missing/stats/gaminv.m b/matlab/missing/stats/gaminv.m
index e879616c4..96c4a0a3f 100644
--- a/matlab/missing/stats/gaminv.m
+++ b/matlab/missing/stats/gaminv.m
@@ -76,7 +76,7 @@ if (any (k))
             h = y_old - y_new;
         end
         if (max (abs (h)) < sqrt (eps))
-            break;
+            break
         end
         y_old = y_new;
     end
diff --git a/matlab/missing/stats/gamrnd.m b/matlab/missing/stats/gamrnd.m
index b75b7868f..af2124753 100644
--- a/matlab/missing/stats/gamrnd.m
+++ b/matlab/missing/stats/gamrnd.m
@@ -1,19 +1,19 @@
 function rnd = gamrnd(a,b,method)
 % This function produces independent random variates from the Gamma distribution.
 %
-%  INPUTS 
+%  INPUTS
 %    a       [double]    n*1 vector of positive parameters.
-%    b       [double]    n*1 vector of positive parameters.    
+%    b       [double]    n*1 vector of positive parameters.
 %    method  [string]    'BawensLubranoRichard' or anything else (see below).
 %
-%  OUTPUT 
+%  OUTPUT
 %    rnd     [double]    n*1 vector of independent variates from the gamma(a,b) distribution.
 %                        rnd(i) is gamma distributed with mean a(i)b(i) and variance a(i)b(i)^2.
-%  
-%  ALGORITHMS     
+%
+%  ALGORITHMS
 %    Described in Bauwens, Lubrano and Richard (1999, page 316) and Devroye (1986, chapter 9).
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -39,13 +39,13 @@ if nargin==2
     if any(a<1)
         method = 'Devroye';
         Devroye.small = 'Best'; % 'Weibull' , 'Johnk' , 'Berman' , 'GS' , 'Best'
-                                % REMARK: The first algorithm (Weibull) is producing too much extreme values. 
+                                % REMARK: The first algorithm (Weibull) is producing too much extreme values.
     end
     if ~strcmpi(method,'BauwensLubranoRichard')
-        Devroye.big = 'Best'; % 'Cheng' , 'Best' 
+        Devroye.big = 'Best'; % 'Cheng' , 'Best'
                               % REMARK 1: The first algorithm (Cheng) is still producing obviously wrong simulations.
-                              % REMARK 2: The second algorithm seems slightly slower than the algorithm advocated by Bauwens, 
-                              %           Lubrano and Richard, but the comparison depends on the value of a (this should be 
+                              % REMARK 2: The second algorithm seems slightly slower than the algorithm advocated by Bauwens,
+                              %           Lubrano and Richard, but the comparison depends on the value of a (this should be
                               %           investigated further).
     end
 else
@@ -96,7 +96,7 @@ if number_of_double_a
     if strcmpi(method,'BauwensLubranoRichard')
         % Algorithm given in Bauwens, Lubrano & Richard (1999) page 316.
         rnd(double_idx) = knuth_algorithm(a(double_idx),b(double_idx));
-    else% Algorithm given in  Devroye (1986, chapter 9) 
+    else% Algorithm given in  Devroye (1986, chapter 9)
         small_idx = find(a(double_idx)<1);
         big_idx = find(a(double_idx)>1);
         number_of_small_a = length(small_idx);
@@ -180,7 +180,7 @@ end
 gamma_variates = exprnd(ones(nn,1)).*X./(X+Y);
 
 
-function gamma_variates = berman_algorithm(a,b)    
+function gamma_variates = berman_algorithm(a,b)
 nn = length(a);
 mm = nn;
 aa = 1./a ;
@@ -206,7 +206,7 @@ Z = gamrnd(2*ones(nn,1),ones(nn,1));
 gamma_variates = Z.*X.*b ;
 
 
-function gamma_variates = ahrens_dieter_algorithm(a,b)    
+function gamma_variates = ahrens_dieter_algorithm(a,b)
 nn = length(a);
 mm = nn;
 bb = (exp(1)+a)/exp(1);
@@ -246,7 +246,7 @@ end
 gamma_variates = X.*b ;
 
 
-function gamma_variates = best_1983_algorithm(a,b)    
+function gamma_variates = best_1983_algorithm(a,b)
 nn = length(a);
 mm = nn;
 tt = .07 + .75*sqrt(1-a);
diff --git a/matlab/missing/stats/quantile.m b/matlab/missing/stats/quantile.m
index ec7dbfa64..a63baada0 100644
--- a/matlab/missing/stats/quantile.m
+++ b/matlab/missing/stats/quantile.m
@@ -8,18 +8,18 @@ function [q,N] = quantile(X, p, dim, method, weights) % --*-- Unitary tests --*-
 %   a matrix, the i-th row of Q contains the P(i)-th quantiles of each
 %   column of X.  For N-D arrays, QUANTILE2 operates along the first
 %   non-singleton dimension.
-% 
+%
 %   Q = QUANTILE2(X,P,DIM) calculates quantiles along dimension DIM.  The
 %   DIM'th dimension of Q has length LENGTH(P).
-% 
+%
 %   Q = QUANTILE2(X,P,DIM,METHOD) calculates quantiles using one of the
 %   methods described in http://en.wikipedia.org/wiki/Quantile. The method
 %   are designated 'R-1'...'R-9'; the default is R-8 as described in
 %   http://bit.ly/1kX4NcT, whereas Matlab uses 'R-5'.
-%   
+%
 %   Q = QUANTILE2(X,P,[],METHOD) uses the specified METHOD, but calculates
 %   quantiles along the first non-singleton dimension.
-% 
+%
 %   Q = QUANTILE2(X,P,[],METHOD,WEIGHTS) and QUANTILE2(X,P,[],[],WEIGHTS)
 %   uses the array WEIGHTS to weight the values in X when calculating
 %   quantiles. If no weighting is specified, the method determines the
@@ -33,12 +33,12 @@ function [q,N] = quantile(X, p, dim, method, weights) % --*-- Unitary tests --*-
 %   equal, then the weighted and unweighted index (and correpsonding
 %   quantile) are identical. The default method R-8 is used if METHOD is
 %   specified as an empty array ([]).
-% 
+%
 %   [Q,N] = QUANTILE2(...) returns an array that is the same size as Q such
 %   that N(i) is the number of points used to calculate Q(i).
-% 
+%
 %   Further reading
-%   
+%
 %   Hyndman, R.J.; Fan, Y. (November 1996). "Sample Quantiles in
 %     Statistical Packages". The American Statistician 50 (4): 361-365.
 %   Frigge, Michael; Hoaglin, David C.; Iglewicz, Boris (February 1989).
@@ -47,9 +47,9 @@ function [q,N] = quantile(X, p, dim, method, weights) % --*-- Unitary tests --*-
 
 % Original file downloaded from:
 % http://fr.mathworks.com/matlabcentral/fileexchange/46555-quantile-calculation
-% 
-% Copyright (C) 2014-2016 University of Surrey (Christopher Hummersone) 
-% Copyright (C) 2016 Dynare Team
+%
+% Copyright (C) 2014-2016 University of Surrey (Christopher Hummersone)
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -205,34 +205,34 @@ if numel(p)==numel(q)
 end
 
 function cumweights = accumulateWeights(weights, ind, n, N)
-   % ACCUMULATEWEIGHTS accumulate the weights
-    wSorted = weights(ind,n); % sort weights
-    wSorted = wSorted*N/sum(wSorted); % normalize weights to sum to N
-    cumweights = cumsum(wSorted); % cumulative weights
+% ACCUMULATEWEIGHTS accumulate the weights
+wSorted = weights(ind,n); % sort weights
+wSorted = wSorted*N/sum(wSorted); % normalize weights to sum to N
+cumweights = cumsum(wSorted); % cumulative weights
 
 function hw = weightedIndex(huw, cumweights)
-    % WEIGHTEDINDEX calculate index from cumulative weights
-    ii = find(sign(cumweights-huw)<0,1,'last');
-    jj = find(sign(cumweights-huw)>0,1,'first');
-    if isempty(ii) || isempty(jj)
-        hw = huw;
-    else
-        hw = ii + (huw-cumweights(ii))/(cumweights(jj)-cumweights(ii)); % weighted index
-    end
+% WEIGHTEDINDEX calculate index from cumulative weights
+ii = find(sign(cumweights-huw)<0,1,'last');
+jj = find(sign(cumweights-huw)>0,1,'first');
+if isempty(ii) || isempty(jj)
+    hw = huw;
+else
+    hw = ii + (huw-cumweights(ii))/(cumweights(jj)-cumweights(ii)); % weighted index
+end
 
 function y = isint(x)
-    % ISINT check if input is whole number
-    y = x==round(x);
+% ISINT check if input is whole number
+y = x==round(x);
 
 function y = rearrange(x,order,shape)
-    %REARRANGE reshape and permute to make target dim column
-    y = permute(x,order);
-    y = reshape(y,shape);
+%REARRANGE reshape and permute to make target dim column
+y = permute(x,order);
+y = reshape(y,shape);
 
 function y = irearrange(x,order,shape)
-    %IREARRANGE reshape and permute to original size
-    y = reshape(x,shape);
-    y = ipermute(y,order);
+%IREARRANGE reshape and permute to original size
+y = reshape(x,shape);
+y = ipermute(y,order);
 
 
 %@test:1
diff --git a/matlab/missing/stats/stdnormal_inv.m b/matlab/missing/stats/stdnormal_inv.m
index bc52845a5..9859efde7 100644
--- a/matlab/missing/stats/stdnormal_inv.m
+++ b/matlab/missing/stats/stdnormal_inv.m
@@ -10,7 +10,7 @@ function inv = stdnormal_inv (x)
 
 % Copyright (C) 1995, 1996, 1997, 1998, 2000, 2002, 2005, 2006, 2007
 %               Kurt Hornik
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,4 +34,3 @@ end
 inv = sqrt (2) * erfinv (2 * x - 1);
 
 end
-
diff --git a/matlab/missing/stats/wblcdf.m b/matlab/missing/stats/wblcdf.m
index 14b0fc8e8..6246a01cf 100644
--- a/matlab/missing/stats/wblcdf.m
+++ b/matlab/missing/stats/wblcdf.m
@@ -2,15 +2,15 @@ function p = wblcdf(x, scale, shape)   % --*-- Unitary tests --*--
 
 % Cumulative distribution function for the Weibull distribution.
 %
-% INPUTS 
+% INPUTS
 % - x     [double] Positive real scalar.
 % - scale [double] Positive hyperparameter.
 % - shape [double] Positive hyperparameter.
 %
-% OUTPUTS 
-% - p     [double] Positive scalar between 
+% OUTPUTS
+% - p     [double] Positive scalar between
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,7 +58,7 @@ if isinf(x)
     return
 end
 
-% Evaluate the CDF. 
+% Evaluate the CDF.
 
 p = 1-exp(-(x/scale)^shape);
 
@@ -146,4 +146,3 @@ p = 1-exp(-(x/scale)^shape);
 %$ end
 %$ T = all(t);
 %@eof:4
-
diff --git a/matlab/missing/stats/wblinv.m b/matlab/missing/stats/wblinv.m
index 1b87c9fcb..363d51801 100644
--- a/matlab/missing/stats/wblinv.m
+++ b/matlab/missing/stats/wblinv.m
@@ -2,15 +2,15 @@ function t = wblinv(proba, scale, shape)   % --*-- Unitary tests --*--
 
 % Inverse cumulative distribution function.
 %
-% INPUTS 
+% INPUTS
 % - proba [double] Probability, scalar between 0 and 1.
 % - scale [double] Positive hyperparameter.
 % - shape [double] Positive hyperparameter.
 %
-% OUTPUTS 
+% OUTPUTS
 % - t     [double] scalar such that P(X<=t)=proba
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -156,7 +156,7 @@ t = exp(log(scale)+log(-log(1-proba))/shape);
 %$               [s, abs(p-s)]
 %$           end
 %$         if isoctave
-%$           t(k) = abs(p-s)<1e-10;  
+%$           t(k) = abs(p-s)<1e-10;
 %$         else
 %$           t(k) = abs(p-s)<1e-12;
 %$         end
@@ -165,4 +165,3 @@ t = exp(log(scale)+log(-log(1-proba))/shape);
 %$ end
 %$ T = all(t);
 %@eof:4
-
diff --git a/matlab/missing/stats/wblrnd.m b/matlab/missing/stats/wblrnd.m
index 2f55bc8b7..e2a6911d9 100644
--- a/matlab/missing/stats/wblrnd.m
+++ b/matlab/missing/stats/wblrnd.m
@@ -1,14 +1,14 @@
 function rnd = wblrnd(a, b)
 % This function produces independent random variates from the Weibull distribution.
 %
-%  INPUTS 
+%  INPUTS
 %    a       [double]    m*n matrix of positive parameters (scale).
 %    b       [double]    m*n matrix of positive parameters (shape).
 %
-%  OUTPUT 
+%  OUTPUT
 %    rnd     [double]    m*n matrix of independent variates from the beta(a,b) distribution.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/missing/struct2array/struct2array.m b/matlab/missing/struct2array/struct2array.m
new file mode 100644
index 000000000..92aaab35f
--- /dev/null
+++ b/matlab/missing/struct2array/struct2array.m
@@ -0,0 +1,29 @@
+function a = struct2array(s)
+
+% INPUTS
+% - s  [struct]  with N fields, field i contains a n_i*m_i array of doubles.
+%
+% OUPUTS
+% - a  [double]  column vector with sum(n_i*m_i, i=1,...,N) elements.
+
+% Copyright (C) 2017 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/>.
+
+assert(isstruct(s), 'struct2array:: Argument has to be a structure!')
+
+c = cellfun(@vec, struct2cell(s), 'UniformOutput', false);
+a = vertcat(c{:});
\ No newline at end of file
diff --git a/matlab/missing/vec/vec.m b/matlab/missing/vec/vec.m
index 225c5f9ec..fd9e36b79 100644
--- a/matlab/missing/vec/vec.m
+++ b/matlab/missing/vec/vec.m
@@ -1,13 +1,13 @@
 function Vector = vec(Matrix)
 % This function implements the vec operator.
-% 
-% INPUTS 
+%
+% INPUTS
 %   Matrix             [double]   a squared n*n matrix.
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   Vector             [double]   a n*n vector.
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/missing_DiffuseKalmanSmootherH1_Z.m b/matlab/missing_DiffuseKalmanSmootherH1_Z.m
index a19d3fff6..5ba614f94 100644
--- a/matlab/missing_DiffuseKalmanSmootherH1_Z.m
+++ b/matlab/missing_DiffuseKalmanSmootherH1_Z.m
@@ -5,10 +5,10 @@ function [alphahat,epsilonhat,etahat,atilde,P,aK,PK,decomp,V] = missing_DiffuseK
 %
 % INPUTS
 %    T:        mm*mm matrix
-%    Z:        pp*mm matrix  
+%    Z:        pp*mm matrix
 %    R:        mm*rr matrix
 %    Q:        rr*rr matrix
-%    H:        pp*pp matrix variance of measurement errors    
+%    H:        pp*pp matrix variance of measurement errors
 %    Pinf1:    mm*mm diagonal matrix with with q ones and m-q zeros
 %    Pstar1:   mm*mm variance-covariance matrix with stationary variables
 %    Y:        pp*1 vector
@@ -22,7 +22,7 @@ function [alphahat,epsilonhat,etahat,atilde,P,aK,PK,decomp,V] = missing_DiffuseK
 %    decomp_flag  if true, compute filter decomposition
 %    state_uncertainty_flag     if true, compute uncertainty about smoothed
 %                               state estimate
-%             
+%
 % OUTPUTS
 %    alphahat: smoothed variables (a_{t|T})
 %    epsilonhat:smoothed measurement errors
@@ -36,20 +36,20 @@ function [alphahat,epsilonhat,etahat,atilde,P,aK,PK,decomp,V] = missing_DiffuseK
 %              matrices (meaningless for periods 1:d)
 %    decomp:   decomposition of the effect of shocks on filtered values
 %    V:        3D array of state uncertainty matrices
-%  
+%
 % Notes:
 %   Outputs are stored in decision-rule order, i.e. to get variables in order of declaration
 %   as in M_.endo_names, ones needs code along the lines of:
 %   variables_declaration_order(dr.order_var,:) = alphahat
-% 
+%
 % SPECIAL REQUIREMENTS
 %   See "Filtering and Smoothing of State Vector for Diffuse State Space
-%   Models", S.J. Koopman and J. Durbin (2003, in Journal of Time Series 
-%   Analysis, vol. 24(1), pp. 85-98). 
+%   Models", S.J. Koopman and J. Durbin (2003, in Journal of Time Series
+%   Analysis, vol. 24(1), pp. 85-98).
 %   Durbin/Koopman (2012): "Time Series Analysis by State Space Methods", Oxford University Press,
 %   Second Edition, Ch. 5
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -70,7 +70,7 @@ function [alphahat,epsilonhat,etahat,atilde,P,aK,PK,decomp,V] = missing_DiffuseK
 % new output argument aK (1-step to k-step predictions)
 % new options_.nk: the max step ahed prediction in aK (default is 4)
 % new crit1 value for rank of Pinf
-% it is assured that P is symmetric 
+% it is assured that P is symmetric
 
 d = 0;
 decomp = [];
@@ -92,9 +92,9 @@ Lstar           = zeros(mm,mm,smpl);
 Kstar           = zeros(mm,pp,smpl);
 Kinf            = zeros(mm,pp,smpl);
 P               = zeros(mm,mm,smpl+1);
-Pstar           = zeros(spstar(1),spstar(2),smpl+1); 
+Pstar           = zeros(spstar(1),spstar(2),smpl+1);
 Pstar(:,:,1)    = Pstar1;
-Pinf            = zeros(spinf(1),spinf(2),smpl+1); 
+Pinf            = zeros(spinf(1),spinf(2),smpl+1);
 Pinf(:,:,1)     = Pinf1;
 rr              = size(Q,1);
 QQ              = R*Q*transpose(R);
@@ -127,9 +127,9 @@ while rank(Pinf(:,:,t+1),diffuse_kalman_tol) && t<smpl
         ZZ = Z(di,:);                                                       %span selector matrix
         v(di,t)= Y(di,t) - ZZ*a(:,t);                                       %get prediction error v^(0) in (5.13) DK (2012)
         Finf = ZZ*Pinf(:,:,t)*ZZ';                                          % (5.7) in DK (2012)
-        if rcond(Finf) < diffuse_kalman_tol                                 %F_{\infty,t} = 0 
+        if rcond(Finf) < diffuse_kalman_tol                                 %F_{\infty,t} = 0
             if ~all(abs(Finf(:)) < diffuse_kalman_tol)                      %rank-deficient but not rank 0
-                % The univariate diffuse kalman filter should be used.
+                                                                            % The univariate diffuse kalman filter should be used.
                 alphahat = Inf;
                 return
             else                                                            %rank of F_{\infty,t} is 0
@@ -200,13 +200,13 @@ while notsteady && t<smpl
         if any(diag(F)<kalman_tol) || rcond(F./(sig*sig')) < kalman_tol
             alphahat = Inf;
             return
-        end    
+        end
         iF(di,di,t)   = inv(F./(sig*sig'))./(sig*sig');
         PZI         = P(:,:,t)*ZZ'*iF(di,di,t);
         atilde(:,t) = a(:,t) + PZI*v(di,t);
         K(:,di,t)    = T*PZI;
         L(:,:,t)    = T-K(:,di,t)*ZZ;
-		P(:,:,t+1)  = T*P(:,:,t)*L(:,:,t)' + QQ;
+        P(:,:,t+1)  = T*P(:,:,t)*L(:,:,t)' + QQ;
     end
     a(:,t+1)    = T*atilde(:,t);
     Pf          = P(:,:,t);
@@ -267,8 +267,8 @@ while t>d+1
     end
 end
 if d %diffuse periods
-    % initialize r_d^(0) and r_d^(1) as below DK (2012), eq. 5.23
-    r0 = zeros(mm,d+1); 
+     % initialize r_d^(0) and r_d^(1) as below DK (2012), eq. 5.23
+    r0 = zeros(mm,d+1);
     r0(:,d+1) = r(:,d+1);   %set r0_{d}, i.e. shifted by one period
     r1 = zeros(mm,d+1);     %set r1_{d}, i.e. shifted by one period
     if state_uncertainty_flag
@@ -284,7 +284,7 @@ if d %diffuse periods
             if ~Finf_singular(1,t)
                 r0(:,t) = Linf(:,:,t)'*r0(:,t+1);                                   % DK (2012), eq. 5.21 where L^(0) is named Linf
                 r1(:,t) = Z(di,:)'*(iFinf(di,di,t)*v(di,t)-Kstar(:,di,t)'*T'*r0(:,t+1)) ...
-                    + Linf(:,:,t)'*r1(:,t+1);                                       % DK (2012), eq. 5.21, noting that i) F^(1)=(F^Inf)^(-1)(see 5.10), ii) where L^(0) is named Linf, and iii) Kstar=T^{-1}*K^(1)
+                          + Linf(:,:,t)'*r1(:,t+1);                                       % DK (2012), eq. 5.21, noting that i) F^(1)=(F^Inf)^(-1)(see 5.10), ii) where L^(0) is named Linf, and iii) Kstar=T^{-1}*K^(1)
                 if state_uncertainty_flag
                     L_1=(-T*Kstar(:,di,t)*Z(di,:));                                     % noting that Kstar=T^{-1}*K^(1)
                     N(:,:,t)=Linf(:,:,t)'*N(:,:,t+1)*Linf(:,:,t);                       % DK (2012), eq. 5.19, noting that L^(0) is named Linf
@@ -301,7 +301,7 @@ if d %diffuse periods
                 r1(:,t) = T'*r1(:,t+1);                                             % DK (2003), eq. (14)
                 if state_uncertainty_flag
                     N(:,:,t)=Z(di,:)'*iFstar(di,di,t)*Z(di,:)...
-                        +Lstar(:,:,t)'*N(:,:,t+1)*Lstar(:,:,t);                     % DK (2003), eq. (14)
+                             +Lstar(:,:,t)'*N(:,:,t+1)*Lstar(:,:,t);                     % DK (2003), eq. (14)
                     N_1(:,:,t)=T'*N_1(:,:,t+1)*Lstar(:,:,t);                            % DK (2003), eq. (14)
                     N_2(:,:,t)=T'*N_2(:,:,t+1)*T';                                      % DK (2003), eq. (14)
                 end
@@ -311,9 +311,9 @@ if d %diffuse periods
         etahat(:,t)     = QRt*r0(:,t);                                              % DK (2012), p. 135
         if state_uncertainty_flag
             V(:,:,t)=Pstar(:,:,t)-Pstar(:,:,t)*N(:,:,t)*Pstar(:,:,t)...
-                -(Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t))'...
-                - Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t)...
-                - Pinf(:,:,t)*N_2(:,:,t)*Pinf(:,:,t);                                   % DK (2012), eq. 5.30
+                     -(Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t))'...
+                     - Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t)...
+                     - Pinf(:,:,t)*N_2(:,:,t)*Pinf(:,:,t);                                   % DK (2012), eq. 5.30
         end
     end
 end
diff --git a/matlab/missing_DiffuseKalmanSmootherH3_Z.m b/matlab/missing_DiffuseKalmanSmootherH3_Z.m
index c5beeedc7..de40741fc 100644
--- a/matlab/missing_DiffuseKalmanSmootherH3_Z.m
+++ b/matlab/missing_DiffuseKalmanSmootherH3_Z.m
@@ -43,20 +43,20 @@ function [alphahat,epsilonhat,etahat,a,P,aK,PK,decomp,V] = missing_DiffuseKalman
 %   variables_declaration_order(dr.order_var,:) = alphahat
 %
 % Algorithm:
-% 
+%
 %   Uses the univariate filter as described in Durbin/Koopman (2012): "Time
 %   Series Analysis by State Space Methods", Oxford University Press,
 %   Second Edition, Ch. 6.4 + 7.2.5
-%   and 
+%   and
 %   Koopman/Durbin (2000): "Fast Filtering and Smoothing for Multivariatze State Space
 %   Models", in Journal of Time Series Analysis, vol. 21(3), pp. 281-296.
 %
 % SPECIAL REQUIREMENTS
 %   See "Filtering and Smoothing of State Vector for Diffuse State Space
-%   Models", S.J. Koopman and J. Durbin (2003), in Journal of Time Series 
-%   Analysis, vol. 24(1), pp. 85-98. 
+%   Models", S.J. Koopman and J. Durbin (2003), in Journal of Time Series
+%   Analysis, vol. 24(1), pp. 85-98.
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -78,10 +78,10 @@ function [alphahat,epsilonhat,etahat,a,P,aK,PK,decomp,V] = missing_DiffuseKalman
 % New input argument nk: max order of predictions in aK
 
 
-if size(H,2)>1 
+if size(H,2)>1
     error('missing_DiffuseKalmanSmootherH3_Z:: H is not a vector. This must not happens')
 end
-    
+
 d = 0;
 decomp = [];
 spinf           = size(Pinf1);
@@ -100,9 +100,9 @@ Kinf            = zeros(spstar(1),pp,smpl);
 P               = zeros(mm,mm,smpl+1);
 P1              = P;
 PK              = zeros(nk,mm,mm,smpl+nk);
-Pstar           = zeros(spstar(1),spstar(2),smpl); 
+Pstar           = zeros(spstar(1),spstar(2),smpl);
 Pstar(:,:,1)    = Pstar1;
-Pinf            = zeros(spinf(1),spinf(2),smpl); 
+Pinf            = zeros(spinf(1),spinf(2),smpl);
 Pinf(:,:,1)     = Pinf1;
 Pstar1          = Pstar;
 Pinf1           = Pinf;
@@ -122,7 +122,11 @@ end
 
 t = 0;
 icc=0;
-newRank = rank(Pinf(:,:,1),diffuse_kalman_tol);
+if ~isempty(Pinf(:,:,1))
+    newRank = rank(Z*Pinf(:,:,1)*Z',diffuse_kalman_tol);
+else
+    newRank = rank(Pinf(:,:,1),diffuse_kalman_tol);
+end
 while newRank && t < smpl
     t = t+1;
     a(:,t) = a1(:,t);
@@ -131,13 +135,13 @@ while newRank && t < smpl
     di = data_index{t}';
     for i=di
         Zi = Z(i,:);
-        v(i,t)      = Y(i,t)-Zi*a(:,t);                                     % nu_{t,i} in 6.13 in DK (2012) 
+        v(i,t)      = Y(i,t)-Zi*a(:,t);                                     % nu_{t,i} in 6.13 in DK (2012)
         Fstar(i,t)  = Zi*Pstar(:,:,t)*Zi' +H(i);                            % F_{*,t} in 5.7 in DK (2012), relies on H being diagonal
         Finf(i,t)   = Zi*Pinf(:,:,t)*Zi';                                   % F_{\infty,t} in 5.7 in DK (2012)
         Kstar(:,i,t) = Pstar(:,:,t)*Zi';                                    % KD (2000), eq. (15)
         if Finf(i,t) > diffuse_kalman_tol && newRank                        % F_{\infty,t,i} = 0, use upper part of bracket on p. 175 DK (2012) for w_{t,i}
             icc=icc+1;
-            Kinf(:,i,t)       = Pinf(:,:,t)*Zi';                            % KD (2000), eq. (15)                         
+            Kinf(:,i,t)       = Pinf(:,:,t)*Zi';                            % KD (2000), eq. (15)
             Kinf_Finf         = Kinf(:,i,t)/Finf(i,t);
             a(:,t)            = a(:,t) + Kinf_Finf*v(i,t);                  % KD (2000), eq. (16)
             Pstar(:,:,t)      = Pstar(:,:,t) + ...
@@ -145,33 +149,41 @@ while newRank && t < smpl
                 Kstar(:,i,t)*Kinf_Finf' - ...
                 Kinf_Finf*Kstar(:,i,t)';                                    % KD (2000), eq. (16)
             Pinf(:,:,t)       = Pinf(:,:,t) - Kinf(:,i,t)*Kinf(:,i,t)'/Finf(i,t); % KD (2000), eq. (16)
-        elseif Fstar(i,t) > kalman_tol 
+        elseif Fstar(i,t) > kalman_tol
             a(:,t)            = a(:,t) + Kstar(:,i,t)*v(i,t)/Fstar(i,t);    % KD (2000), eq. (17)
             Pstar(:,:,t)      = Pstar(:,:,t) - Kstar(:,i,t)*Kstar(:,i,t)'/Fstar(i,t);   % KD (2000), eq. (17)
-            % Pinf is passed through unaltered, see eq. (17) of
-            % Koopman/Durbin (2000)
+                                                                                        % Pinf is passed through unaltered, see eq. (17) of
+                                                                                        % Koopman/Durbin (2000)
         else
             % do nothing as a_{t,i+1}=a_{t,i} and P_{t,i+1}=P_{t,i}, see
-            % p. 157, DK (2012)        
+            % p. 157, DK (2012)
         end
     end
     if newRank
-        oldRank = rank(Pinf(:,:,t),diffuse_kalman_tol);
+        if ~isempty(Pinf(:,:,t))
+            oldRank = rank(Z*Pinf(:,:,t)*Z',diffuse_kalman_tol);
+        else
+            oldRank = rank(Pinf(:,:,t),diffuse_kalman_tol);
+        end
     else
         oldRank = 0;
     end
     a1(:,t+1) = T*a(:,t);
-    aK(1,:,t+1) = a1(:,t+1); 
+    aK(1,:,t+1) = a1(:,t+1);
     for jnk=2:nk
         aK(jnk,:,t+jnk) = T*dynare_squeeze(aK(jnk-1,:,t+jnk-1));
     end
     Pstar(:,:,t+1) = T*Pstar(:,:,t)*T'+ QQ;
     Pinf(:,:,t+1) = T*Pinf(:,:,t)*T';
     if newRank
-        newRank       = rank(Pinf(:,:,t+1),diffuse_kalman_tol);
+        if ~isempty(Pinf(:,:,t+1))
+            newRank = rank(Z*Pinf(:,:,t+1)*Z',diffuse_kalman_tol);
+        else
+            newRank = rank(Pinf(:,:,t+1),diffuse_kalman_tol);
+        end
     end
     if oldRank ~= newRank
-        disp('univariate_diffuse_kalman_filter:: T does influence the rank of Pinf!')   
+        disp('univariate_diffuse_kalman_filter:: T does influence the rank of Pinf!')
     end
 end
 
@@ -194,7 +206,7 @@ while notsteady && t<smpl
     for i=di
         Zi = Z(i,:);
         v(i,t)  = Y(i,t) - Zi*a(:,t);                                       % nu_{t,i} in 6.13 in DK (2012)
-        Fi(i,t) = Zi*P(:,:,t)*Zi' + H(i);                                   % F_{t,i} in 6.13 in DK (2012), relies on H being diagonal 
+        Fi(i,t) = Zi*P(:,:,t)*Zi' + H(i);                                   % F_{t,i} in 6.13 in DK (2012), relies on H being diagonal
         Ki(:,i,t) = P(:,:,t)*Zi';                                           % K_{t,i}*F_(i,t) in 6.13 in DK (2012)
         if Fi(i,t) > kalman_tol
             a(:,t) = a(:,t) + Ki(:,i,t)*v(i,t)/Fi(i,t);                     %filtering according to (6.13) in DK (2012)
@@ -204,18 +216,18 @@ while notsteady && t<smpl
             % p. 157, DK (2012)
         end
     end
-    a1(:,t+1) = T*a(:,t);                                                   %transition according to (6.14) in DK (2012) 
+    a1(:,t+1) = T*a(:,t);                                                   %transition according to (6.14) in DK (2012)
     Pf          = P(:,:,t);
-    aK(1,:,t+1) = a1(:,t+1); 
+    aK(1,:,t+1) = a1(:,t+1);
     for jnk=1:nk
         Pf = T*Pf*T' + QQ;
         PK(jnk,:,:,t+jnk) = Pf;
         if jnk>1
-            aK(jnk,:,t+jnk) = T*dynare_squeeze(aK(jnk-1,:,t+jnk-1));    
+            aK(jnk,:,t+jnk) = T*dynare_squeeze(aK(jnk-1,:,t+jnk-1));
         end
     end
-    P(:,:,t+1) = T*P(:,:,t)*T' + QQ;                                        %transition according to (6.14) in DK (2012) 
-    %  notsteady   = ~(max(max(abs(P(:,:,t+1)-P(:,:,t))))<kalman_tol);
+    P(:,:,t+1) = T*P(:,:,t)*T' + QQ;                                        %transition according to (6.14) in DK (2012)
+                                                                            %  notsteady   = ~(max(max(abs(P(:,:,t+1)-P(:,:,t))))<kalman_tol);
 end
 % $$$ P_s=tril(P(:,:,t))+tril(P(:,:,t),-1)';
 % $$$ P1_s=tril(P1(:,:,t))+tril(P1(:,:,t),-1)';
@@ -267,18 +279,18 @@ while t > d+1
             end
         end
     end
-    r(:,t) = ri;                                                            % DK (2012), below 6.15, r_{t-1}=r_{t,0} 
+    r(:,t) = ri;                                                            % DK (2012), below 6.15, r_{t-1}=r_{t,0}
     alphahat(:,t) = a1(:,t) + P1(:,:,t)*r(:,t);
     etahat(:,t) = QRt*r(:,t);
-    ri = T'*ri;                                                             % KD (2003), eq. (23), equation for r_{t-1,p_{t-1}} 
+    ri = T'*ri;                                                             % KD (2003), eq. (23), equation for r_{t-1,p_{t-1}}
     if state_uncertainty_flag
-        N(:,:,t) = Ni;                                                          % DK (2012), below 6.15, N_{t-1}=N_{t,0} 
+        N(:,:,t) = Ni;                                                          % DK (2012), below 6.15, N_{t-1}=N_{t,0}
         V(:,:,t) = P1(:,:,t)-P1(:,:,t)*N(:,:,t)*P1(:,:,t);                      % KD (2000), eq. (7) with N_{t-1} stored in N(:,:,t)
-        Ni = T'*Ni*T;                                                           % KD (2000), eq. (23), equation for N_{t-1,p_{t-1}} 
+        Ni = T'*Ni*T;                                                           % KD (2000), eq. (23), equation for N_{t-1,p_{t-1}}
     end
 end
 if d
-    r0 = zeros(mm,d); 
+    r0 = zeros(mm,d);
     r0(:,d) = ri;
     r1 = zeros(mm,d);
     if state_uncertainty_flag
@@ -292,10 +304,10 @@ if d
         di = flipud(data_index{t})';
         for i = di
             if Finf(i,t) > diffuse_kalman_tol
-                % recursions need to be from highest to lowest term in order to not 
+                % recursions need to be from highest to lowest term in order to not
                 % overwrite lower terms still needed in this step
                 Linf    = eye(mm) - Kinf(:,i,t)*Z(i,:)/Finf(i,t);
-                L0      = (Kinf(:,i,t)*(Fstar(i,t)/Finf(i,t))-Kstar(:,i,t))*Z(i,:)/Finf(i,t);            
+                L0      = (Kinf(:,i,t)*(Fstar(i,t)/Finf(i,t))-Kstar(:,i,t))*Z(i,:)/Finf(i,t);
                 r1(:,t) = Z(i,:)'*v(i,t)/Finf(i,t) + ...
                           L0'*r0(:,t) + ...
                           Linf'*r1(:,t);   % KD (2000), eq. (25) for r_1
@@ -323,9 +335,9 @@ if d
         etahat(:,t)   = QRt*r(:,t);                                         % KD (2000), eq. (27)
         if state_uncertainty_flag
             V(:,:,t)=Pstar(:,:,t)-Pstar(:,:,t)*N_0(:,:,t)*Pstar(:,:,t)...
-                -(Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t))'...
-                - Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t)...
-                - Pinf(:,:,t)*N_2(:,:,t)*Pinf(:,:,t);                       % DK (2012), eq. 5.30
+                     -(Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t))'...
+                     - Pinf(:,:,t)*N_1(:,:,t)*Pstar(:,:,t)...
+                     - Pinf(:,:,t)*N_2(:,:,t)*Pinf(:,:,t);                       % DK (2012), eq. 5.30
         end
         if t > 1
             r0(:,t-1) = T'*r0(:,t);                                         % KD (2000), below eq. (25) r_{t-1,p_{t-1}}=T'*r_{t,0}
@@ -350,11 +362,11 @@ if decomp_flag
                 ri_d = Z(i,:)'/Fi(i,t)*v(i,t)+ri_d-Ki(:,i,t)'*ri_d/Fi(i,t)*Z(i,:)';
             end
         end
-        
+
         % calculate eta_tm1t
         eta_tm1t = QRt*ri_d;
         % calculate decomposition
-        Ttok = eye(mm,mm); 
+        Ttok = eye(mm,mm);
         AAA = P1(:,:,t)*Z'*ZRQinv*Z*R;
         for h = 1:nk
             BBB = Ttok*AAA;
@@ -367,3 +379,9 @@ if decomp_flag
 end
 
 epsilonhat = Y - Z*alphahat;
+
+
+if (d==smpl)
+    warning(['missing_DiffuseKalmanSmootherH3_Z:: There isn''t enough information to estimate the initial conditions of the nonstationary variables']);
+    return
+end
diff --git a/matlab/mode_check.m b/matlab/mode_check.m
index 8d216bcbf..2df26ff0c 100644
--- a/matlab/mode_check.m
+++ b/matlab/mode_check.m
@@ -40,7 +40,7 @@ function mode_check(fun,x,hessian_mat,DynareDataset,DatasetInfo,DynareOptions,Mo
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,13 +58,13 @@ function mode_check(fun,x,hessian_mat,DynareDataset,DatasetInfo,DynareOptions,Mo
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 TeX = DynareOptions.TeX;
-if ~isempty(hessian_mat);
+if ~isempty(hessian_mat)
     [ s_min, k ] = min(diag(hessian_mat));
 end
 
 fval = feval(fun,x,DynareDataset,DatasetInfo,DynareOptions,Model,EstimatedParameters,BayesInfo,BoundsInfo,DynareResults);
 
-if ~isempty(hessian_mat);
+if ~isempty(hessian_mat)
     skipline()
     disp('MODE CHECK')
     skipline()
@@ -85,18 +85,18 @@ if TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
 end
 
 ll = DynareOptions.mode_check.neighbourhood_size;
-if isinf(ll),
+if isinf(ll)
     DynareOptions.mode_check.symmetric_plots = 0;
 end
 
 mcheck = struct('cross',struct(),'emode',struct());
 
-for plt = 1:nbplt,
+for plt = 1:nbplt
     if TeX
         NAMES = [];
         TeXNAMES = [];
     end
-    hh = dyn_figure(DynareOptions,'Name','Mode check plots');
+    hh = dyn_figure(DynareOptions.nodisplay,'Name','Mode check plots');
     for k=1:min(nstar,length(x)-(plt-1)*nstar)
         subplot(nr,nc,k)
         kk = (plt-1)*nstar+k;
@@ -121,7 +121,7 @@ for plt = 1:nbplt,
         elseif isequal(x(kk),BoundsInfo.ub(kk))
             binding_upper_bound=1;
             bound_value=BoundsInfo.ub(kk);
-        end      
+        end
         if DynareOptions.mode_check.symmetric_plots && ~binding_lower_bound && ~binding_upper_bound
             if l2<(1+ll)*x(kk) %test whether upper bound is too small due to prior binding
                 l1 = x(kk) - (l2-x(kk)); %adjust lower bound to become closer
@@ -134,7 +134,7 @@ for plt = 1:nbplt,
         z1 = l1:((x(kk)-l1)/(DynareOptions.mode_check.number_of_points/2)):x(kk);
         z2 = x(kk):((l2-x(kk))/(DynareOptions.mode_check.number_of_points/2)):l2;
         z  = union(z1,z2);
-        if DynareOptions.mode_check.nolik==0,
+        if DynareOptions.mode_check.nolik==0
             y = zeros(length(z),2);
             dy = priordens(xx,BayesInfo.pshape,BayesInfo.p6,BayesInfo.p7,BayesInfo.p3,BayesInfo.p4);
         end
@@ -174,7 +174,7 @@ for plt = 1:nbplt,
         hold off
         drawnow
     end
-    if DynareOptions.mode_check.nolik==0,
+    if DynareOptions.mode_check.nolik==0
         if isoctave
             axes('outerposition',[0.3 0.93 0.42 0.07],'box','on'),
         else
@@ -187,7 +187,7 @@ for plt = 1:nbplt,
         text(0.25,0.5,'log-post')
         text(0.69,0.5,'log-lik kernel')
     end
-    dyn_saveas(hh,[ Model.fname '_CheckPlots' int2str(plt) ],DynareOptions);
+    dyn_saveas(hh,[ Model.fname '_CheckPlots' int2str(plt) ],DynareOptions.nodisplay,DynareOptions.graph_format);
     if TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
         % TeX eps loader file
         fprintf(fidTeX,'\\begin{figure}[H]\n');
@@ -203,7 +203,7 @@ for plt = 1:nbplt,
     end
 end
 if TeX && any(strcmp('eps',cellstr(DynareOptions.graph_format)))
-        fclose(fidTeX);
+    fclose(fidTeX);
 end
 
 OutputDirectoryName = CheckPath('modecheck',Model.dname);
diff --git a/matlab/model_comparison.m b/matlab/model_comparison.m
index fd179b454..07935af6f 100644
--- a/matlab/model_comparison.m
+++ b/matlab/model_comparison.m
@@ -5,9 +5,9 @@ function oo = model_comparison(ModelNames,ModelPriors,oo,options_,fname)
 %
 % INPUTS
 %    ModelNames       [string]     m*1 cell array of string.
-%    ModelPriors      [double]     m*1 vector of prior probabilities 
+%    ModelPriors      [double]     m*1 vector of prior probabilities
 %    oo               [struct]     Dynare results structure
-%    options_         [struct]     Dynare options structure 
+%    options_         [struct]     Dynare options structure
 %    fname            [string]     name of the current mod-file
 %
 % OUTPUTS
@@ -20,7 +20,7 @@ function oo = model_comparison(ModelNames,ModelPriors,oo,options_,fname)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2007-2015 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -61,14 +61,14 @@ if isfield(options_,'mc_marginal_density')
     type = options_.mc_marginal_density;
     if strcmp(type,'laplace') || strcmp(type,'Laplace')
         type = 'LaplaceApproximation';
-        title = 'Model Comparison (based on Laplace approximation)'; 
-    elseif strcmp(type,'modifiedharmonicmean') || strcmp(type,'ModifiedHarmonicMean') 
+        title = 'Model Comparison (based on Laplace approximation)';
+    elseif strcmp(type,'modifiedharmonicmean') || strcmp(type,'ModifiedHarmonicMean')
         type = 'ModifiedHarmonicMean';
-        title = 'Model Comparison (based on Modified Harmonic Mean Estimator)'; 
+        title = 'Model Comparison (based on Modified Harmonic Mean Estimator)';
     end
 else
     type = 'LaplaceApproximation';
-    title = 'Model Comparison (based on Laplace approximation)'; 
+    title = 'Model Comparison (based on Laplace approximation)';
 end
 
 % Get the estimated logged marginal densities.
@@ -87,7 +87,7 @@ for i=1:NumberOfModels
         end
     end
     try
-        eval(['MarginalLogDensity(i) = mstruct.oo_.MarginalDensity.' type ';']) 
+        eval(['MarginalLogDensity(i) = mstruct.oo_.MarginalDensity.' type ';'])
     catch
         if strcmpi(type,'LaplaceApproximation')
             if isfield(mstruct.oo_,'mle_mode')
@@ -119,13 +119,13 @@ if prior_flag
     labels = char('Priors','Log Marginal Density','Bayes Ratio', ...
                   'Posterior Model Probability');
     field_labels={'Prior','Log_Marginal_Density','Bayes_Ratio', ...
-                  'Posterior_Model_Probability'};          
+                  'Posterior_Model_Probability'};
     values = [ModelPriors';MarginalLogDensity';exp(lmpd-lmpd(1))'; ...
               elmpd'/sum(elmpd)];
 else
     labels = char('Priors','Log Marginal Density','Bayes Ratio','Posterior Odds Ratio', ...
                   'Posterior Model Probability');
-    field_labels={'Prior','Log_Marginal_Density','Bayes_Ratio','Posterior_Odds_Ratio','Posterior_Model_Probability'};          
+    field_labels={'Prior','Log_Marginal_Density','Bayes_Ratio','Posterior_Odds_Ratio','Posterior_Model_Probability'};
     values = [ModelPriors';MarginalLogDensity'; exp(MarginalLogDensity-MarginalLogDensity(1))'; ...
               exp(lmpd-lmpd(1))'; elmpd'/sum(elmpd)];
 end
@@ -148,7 +148,7 @@ if options_.TeX
     for ii=1:size(labels,1)
         labels_tex=strvcat(labels_tex,strrep(labels(ii,:),' ', '\ '));
     end
-    
+
     dyn_latex_table(M_temp,options_,title,['model_comparison',type],headers_tex,labels_tex,values,0,16,6);
 end
 
diff --git a/matlab/model_diagnostics.m b/matlab/model_diagnostics.m
index 32a01725d..673429115 100644
--- a/matlab/model_diagnostics.m
+++ b/matlab/model_diagnostics.m
@@ -1,22 +1,22 @@
 function model_diagnostics(M,options,oo)
 % function model_diagnostics(M,options,oo)
-%   computes various diagnostics on the model 
+%   computes various diagnostics on the model
 % INPUTS
-%   M         [matlab structure] Definition of the model.           
+%   M         [matlab structure] Definition of the model.
 %   options   [matlab structure] Global options.
-%   oo        [matlab structure] Results 
-%    
+%   oo        [matlab structure] Results
+%
 % OUTPUTS
 %   none
-%    
+%
 % ALGORITHM
 %   ...
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 1996-2013 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ end
 info=test_for_deep_parameters_calibration(M);
 if info
     problem_dummy=1;
-end;
+end
 
 % check if ys is steady state
 options.debug=1; %locally set debug option to 1
@@ -83,7 +83,7 @@ if check1(1)
     if any(isinf(dr.ys))
         disp(['MODEL_DIAGNOSTICS: Steady state contains Inf'])
     end
-    return;
+    return
 end
 
 if ~isreal(dr.ys)
@@ -108,7 +108,7 @@ 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');
+                                         'evaluate', 'static');
         else
             [chk, res, jacob] = bytecode(dr.ys, exo, M.params, dr.ys, 1, exo, ...
                                          'evaluate', 'static',['block=' ...
@@ -173,8 +173,8 @@ for b=1:nb
         end
     end
 end
-    
-if singularity_problem 
+
+if singularity_problem
     try
         options_check=options;
         options_check.noprint=1;
@@ -205,29 +205,29 @@ if ~options.block
     if options.order == 1
         if (options.bytecode)
             [chck, junk, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
-                M.params, dr.ys, 1);
+                                            M.params, dr.ys, 1);
             jacobia_ = [loc_dr.g1 loc_dr.g1_x loc_dr.g1_xd];
         else
             [junk,jacobia_] = feval([M.fname '_dynamic'],z(iyr0),exo_simul, ...
-                M.params, dr.ys, it_);
-        end;
+                                    M.params, dr.ys, it_);
+        end
     elseif options.order >= 2
         if (options.bytecode)
             [chck, junk, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
-                M.params, dr.ys, 1);
+                                            M.params, dr.ys, 1);
             jacobia_ = [loc_dr.g1 loc_dr.g1_x];
         else
             [junk,jacobia_,hessian1] = feval([M.fname '_dynamic'],z(iyr0),...
-                exo_simul, ...
-                M.params, dr.ys, it_);
-        end;
+                                             exo_simul, ...
+                                             M.params, dr.ys, it_);
+        end
         if options.use_dll
             % In USE_DLL mode, the hessian is in the 3-column sparse representation
             hessian1 = sparse(hessian1(:,1), hessian1(:,2), hessian1(:,3), ...
-                size(jacobia_, 1), size(jacobia_, 2)*size(jacobia_, 2));
+                              size(jacobia_, 1), size(jacobia_, 2)*size(jacobia_, 2));
         end
     end
-    
+
     if any(any(isinf(jacobia_) | isnan(jacobia_)))
         problem_dummy=1;
         [infrow,infcol]=find(isinf(jacobia_) | isnan(jacobia_));
@@ -245,7 +245,7 @@ if ~options.block
             problem_dummy=1;
             fprintf('\nMODEL_DIAGNOSTICS: The Hessian of the dynamic model contains Inf or NaN.\n')
         end
-    end    
+    end
 else
     fprintf('\nMODEL_DIAGNOSTICS: This command currently does not support the block option for checking.\n')
     fprintf('\nMODEL_DIAGNOSTICS: the dynamic model. You may want to disable it for doing model_diagnostics. Skipping this part.\n')
@@ -254,4 +254,3 @@ end
 if problem_dummy==0
     fprintf('MODEL_DIAGNOSTICS:  No obvious problems with this mod-file were detected.\n')
 end
-
diff --git a/matlab/model_info.m b/matlab/model_info.m
index d99ca4807..e27779225 100644
--- a/matlab/model_info.m
+++ b/matlab/model_info.m
@@ -1,7 +1,7 @@
-function model_info(varargin);
+function model_info(varargin)
 %function model_info;
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,27 +23,27 @@ if sum(strcmp(varargin,'static')) > 0
     static_ = 1;
 else
     static_ = 0;
-end;
+end
 if sum(strcmp(varargin,'incidence')) > 0
     incidence = 1;
 else
     incidence = 0;
-end;
+end
 if static_
-        fprintf('                                          Informations about %s (static model)\n',M_.fname);
-        block_structre_str = 'block_structure_stat';
-        nb_leadlag = 1;
-    else
-        fprintf('                                          Informations about %s (dynamic model)\n',M_.fname);
-        block_structre_str = 'block_structure';
-        nb_leadlag = 3;
-    end;
+    fprintf('                                          Informations about %s (static model)\n',M_.fname);
+    block_structre_str = 'block_structure_stat';
+    nb_leadlag = 1;
+else
+    fprintf('                                          Informations about %s (dynamic model)\n',M_.fname);
+    block_structre_str = 'block_structure';
+    nb_leadlag = 3;
+end
 if(isfield(M_,block_structre_str))
     if static_
         block_structure = M_.block_structure_stat;
     else
         block_structure = M_.block_structure;
-    end;
+    end
     fprintf(strcat('                                          ===================',char(ones(1,length(M_.fname))*'='),'\n\n'));
     nb_blocks=length(block_structure.block);
     fprintf('The model has %d equations and is decomposed in %d blocks as follow:\n',M_.endo_nbr,nb_blocks);
@@ -54,15 +54,15 @@ if(isfield(M_,block_structre_str))
         size_block=length(block_structure.block(i).equation);
         if(i>1)
             fprintf('|------------|------------|--------------------------------|----------------|---------------------------------|\n');
-        end;
+        end
         for j=1:size_block
             if(j==1)
                 fprintf('| %10d | %10d | %30s | %14d | %-6d %24s |\n',i,size_block,Sym_type(block_structure.block(i).Simulation_Type),block_structure.block(i).equation(j),block_structure.block(i).variable(j),M_.endo_names(block_structure.block(i).variable(j),:));
             else
                 fprintf('| %10s | %10s | %30s | %14d | %-6d %24s |\n','','','',block_structure.block(i).equation(j),block_structure.block(i).variable(j),M_.endo_names(block_structure.block(i).variable(j),:));
-            end;
-        end;
-    end;
+            end
+        end
+    end
     fprintf('===============================================================================================================\n');
     fprintf('\n');
     if static_
@@ -71,16 +71,16 @@ if(isfield(M_,block_structre_str))
             IM=sortrows(block_structure.incidence.sparse_IM,2);
         else
             IM=[];
-        end;
+        end
         size_IM=size(IM,1);
         last=99999999;
         for i=1:size_IM
             if(last~=IM(i,2))
                 fprintf('\n%-30s',M_.endo_names(IM(i,2),:));
-            end;
+            end
             fprintf(' %5d',IM(i,1));
             last=IM(i,2);
-        end;
+        end
         fprintf('\n\n');
     else
         for k=1:M_.maximum_endo_lag+M_.maximum_endo_lead+1
@@ -90,25 +90,25 @@ if(isfield(M_,block_structre_str))
                 fprintf('%-30s %s %d','the variable','is used in equations with lag ',M_.maximum_endo_lag+1-k);
             else
                 fprintf('%-30s %s %d','the variable','is used in equations with lead ',k-(M_.maximum_endo_lag+1));
-            end;
+            end
             if(size(block_structure.incidence(k).sparse_IM,1)>0)
                 IM=sortrows(block_structure.incidence(k).sparse_IM,2);
             else
                 IM=[];
-            end;
+            end
             size_IM=size(IM,1);
             last=99999999;
             for i=1:size_IM
                 if(last~=IM(i,2))
                     fprintf('\n%-30s',M_.endo_names(IM(i,2),:));
-                end;
+                end
                 fprintf(' %5d',IM(i,1));
                 last=IM(i,2);
-            end;
+            end
             fprintf('\n\n');
-        end;
-    end;
-    
+        end
+    end
+
     %printing the gross incidence matrix
     IM_star = char([kron(ones(M_.endo_nbr, M_.endo_nbr-1), double(blanks(3))) double(blanks(M_.endo_nbr)')]);
     for i = 1:nb_leadlag
@@ -118,9 +118,9 @@ if(isfield(M_,block_structre_str))
                 IM_star(block_structure.incidence(i).sparse_IM(j,1), 3 * (block_structure.incidence(i).sparse_IM(j,2) - 1) + 1) = 'X';
             else
                 IM_star(block_structure.incidence(i).sparse_IM(j,1), 3 * (block_structure.incidence(i).sparse_IM(j,2) - 1) + 1) = '1';
-            end;
-        end;
-    end;
+            end
+        end
+    end
     seq = 1: M_.endo_nbr;
     blank = [ blanks(size(M_.endo_names,2)); blanks(size(M_.endo_names,2))];
     for i = 1:M_.endo_nbr
@@ -128,15 +128,15 @@ if(isfield(M_,block_structre_str))
             var_names = [blank; M_.endo_names(i,:)];
         else
             var_names = [var_names; blank; M_.endo_names(i,:)];
-        end;
-    end;
+        end
+    end
     if incidence
         topp = [char(kron(double(blanks(ceil(log10(M_.endo_nbr)))),ones(size(M_.endo_names,2),1))) var_names' ];
         bott = [int2str(seq') blanks(M_.endo_nbr)' blanks(M_.endo_nbr)' IM_star];
         fprintf('\n                                          Gross incidence matrix\n');
         fprintf('                                          =======================\n');
         disp([topp; bott]);
-    
+
         %printing the reordered incidence matrix
         IM_star_reordered = char([kron(ones(M_.endo_nbr, M_.endo_nbr-1), double(blanks(3))) double(blanks(M_.endo_nbr)')]);
         eq(block_structure.equation_reordered) = seq;
@@ -145,9 +145,9 @@ if(isfield(M_,block_structre_str))
         cur_block = 1;
         for i = 1:M_.endo_nbr
             past_block = cur_block;
-            while ismember(block_structure.variable_reordered(i), block_structure.block(cur_block).variable) == 0;
+            while ismember(block_structure.variable_reordered(i), block_structure.block(cur_block).variable) == 0
                 cur_block = cur_block + 1;
-            end;
+            end
             if i == 1
                 var_names = [blank; M_.endo_names(block_structure.variable_reordered(i),:)];
             else
@@ -156,8 +156,8 @@ if(isfield(M_,block_structre_str))
                 else
                     var_names = [var_names; blank; M_.endo_names(block_structure.variable_reordered(i),:)];
                 end
-            end;
-        end;
+            end
+        end
         topp = [char(kron(double(blanks(ceil(log10(M_.endo_nbr)))),ones(size(M_.endo_names,2),1))) var_names' ];
         n_state_var = length(M_.state_var);
         IM_state_var = zeros(n_state_var, n_state_var);
@@ -172,49 +172,49 @@ if(isfield(M_,block_structre_str))
                     [tfi, loci] = ismember(block_structure.incidence(i).sparse_IM(j,1), state_equation);
                     if tfi
                         IM_state_var(loci, loc) = 1;
-                    end;
+                    end
                 else
                     IM_star_reordered(eq(block_structure.incidence(i).sparse_IM(j,1)), 3 * (va(block_structure.incidence(i).sparse_IM(j,2)) - 1) + 1) = '1';
-                end;
-            end;
-        end;
+                end
+            end
+        end
         fprintf('1: non nul element, X: non nul element related to a state variable\n');
-        
+
         cur_block = 1;
         i_last = 0;
         block = {};
-        for i = 1:n_state_var;
+        for i = 1:n_state_var
             past_block = cur_block;
-            while ismember(M_.state_var(i), block_structure.block(cur_block).variable) == 0;
+            while ismember(M_.state_var(i), block_structure.block(cur_block).variable) == 0
                 cur_block = cur_block + 1;
-            end;
+            end
             if (past_block ~= cur_block) || (past_block == cur_block && i == n_state_var)
                 block(past_block).IM_state_var(1:(i - 1 - i_last), 1:i - 1) = IM_state_var(i_last+1:i - 1, 1:i - 1);
                 i_last = i - 1;
-            end;
-        end;
+            end
+        end
         cur_block = 1;
         for i = 1:M_.endo_nbr
             past_block = cur_block;
-            while ismember(block_structure.variable_reordered(i), block_structure.block(cur_block).variable) == 0;
+            while ismember(block_structure.variable_reordered(i), block_structure.block(cur_block).variable) == 0
                 cur_block = cur_block + 1;
-            end;
+            end
             if past_block ~= cur_block
                 for j = 1:i-1
-                   IM_star_reordered(j, 3 * (i - 1) - 1) = '|';
-                end;
-            end;
+                    IM_star_reordered(j, 3 * (i - 1) - 1) = '|';
+                end
+            end
         end
-        
+
         bott = [int2str(block_structure.equation_reordered') blanks(M_.endo_nbr)' blanks(M_.endo_nbr)' IM_star_reordered];
         fprintf('\n                                          Reordered incidence matrix\n');
         fprintf('                                          ==========================\n');
         disp([topp; bott]);
         fprintf('1: non nul element, X: non nul element related to a state variable\n');
-     end;
+    end
 else
     fprintf('There is no block decomposition of the model.\nUse ''block'' model''s option.\n');
-end;
+end
 
 function ret=Sym_type(type)
 UNKNOWN=0;
@@ -229,33 +229,30 @@ SOLVE_TWO_BOUNDARIES_COMPLETE=8;
 EVALUATE_FORWARD_R=9;
 EVALUATE_BACKWARD_R=10;
 switch (type)
-  case (UNKNOWN),
+  case (UNKNOWN)
     ret='UNKNOWN                     ';
-  case {EVALUATE_FORWARD,EVALUATE_FORWARD_R},
+  case {EVALUATE_FORWARD,EVALUATE_FORWARD_R}
     ret='EVALUATE FORWARD            ';
-  case {EVALUATE_BACKWARD,EVALUATE_BACKWARD_R},
+  case {EVALUATE_BACKWARD,EVALUATE_BACKWARD_R}
     ret='EVALUATE BACKWARD            ';
-  case SOLVE_FORWARD_SIMPLE,
+  case SOLVE_FORWARD_SIMPLE
     ret='SOLVE FORWARD SIMPLE        ';
-  case SOLVE_BACKWARD_SIMPLE,
+  case SOLVE_BACKWARD_SIMPLE
     ret='SOLVE BACKWARD SIMPLE        ';
-  case SOLVE_TWO_BOUNDARIES_SIMPLE,
+  case SOLVE_TWO_BOUNDARIES_SIMPLE
     ret='SOLVE TWO BOUNDARIES SIMPLE  ';
-  case SOLVE_FORWARD_COMPLETE,
+  case SOLVE_FORWARD_COMPLETE
     ret='SOLVE FORWARD COMPLETE      ';
-  case SOLVE_BACKWARD_COMPLETE,
+  case SOLVE_BACKWARD_COMPLETE
     ret='SOLVE BACKWARD COMPLETE      ';
-  case SOLVE_TWO_BOUNDARIES_COMPLETE,
+  case SOLVE_TWO_BOUNDARIES_COMPLETE
     ret='SOLVE TWO BOUNDARIES COMPLETE';
-end;
+end
 
 
 function ret = barre(n)
 s = [];
-for i=1:n;
+for i=1:n
     s = [s '|'];
-end;
+end
 ret = s;
-
-
-
diff --git a/matlab/model_inversion.m b/matlab/model_inversion.m
new file mode 100644
index 000000000..4d01412f9
--- /dev/null
+++ b/matlab/model_inversion.m
@@ -0,0 +1,106 @@
+function [endogenousvariables, exogenousvariables] = model_inversion(constraints, ...
+                                                  exogenousvariables, ...
+                                                  initialconditions, DynareModel, DynareOptions, DynareOutput)
+
+% INPUTS
+% - constraints         [dseries]        with N constrained endogenous variables from t1 to t2.
+% - exogenousvariables  [dseries]        with Q exogenous variables.
+% - initialconditions   [dseries]        with M endogenous variables starting before t1 (M initialcond must contain at least the state variables).
+% - DynareModel         [struct]         M_, Dynare global structure containing informations related to the model.
+% - DynareOptions       [struct]         options_, Dynare global structure containing all the options.
+%
+% OUTPUTS
+% - endogenous          [dseries]
+% - exogenous           [dseries]
+%
+% REMARKS
+
+% Copyright (C) 2017 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 ~isequal(nargin, 6)
+    error('model_inversion: This routine require six input arguments!')
+end
+
+if ~isdseries(constraints)
+    error('model_inversion: First input argument must be a dseries object!')
+end
+
+if ~isdseries(exogenousvariables)
+    error('model_inversion: Second input argument must be a dseries object!')
+end
+
+if ~isdseries(initialconditions)
+    error('model_inversion: Third input argument must be a dseries object!')
+end
+
+if ~isstruct(DynareModel)
+    error('model_inversion: Last input argument must be structures (M_)!')
+end
+
+% Set range where the endogenous variables are constrained.
+crange = constraints.dates;
+
+% Check that the number of instruments match the number of constrained endogenous variables.
+instruments = exogenousvariables(crange);
+freeinnovations = instruments.name(find(all(isnan(instruments))));
+if ~isequal(length(freeinnovations), constraints.vobs)
+    error('model_inversion: The number of instruments must be equal to the number of constrained variables!')
+end
+
+% Check if some of the exogenous variables are given.
+observed_exogenous_variables_flag = false;
+if exogenousvariables.vobs>constraints.vobs
+    observed_exogenous_variables_flag = true;
+end
+
+% Get the list of endogenous and exogenous variables.
+endo_names = cellstr(DynareModel.endo_names);
+exo_names = cellstr(DynareModel.exo_names);
+
+% Use specidalized routine if the model is backward looking.
+if ~DynareModel.maximum_lead
+    [endogenousvariables, exogenousvariables] = ...
+        backward_model_inversion(constraints, exogenousvariables, initialconditions, ...
+                                 endo_names, exo_names, freeinnovations, ...
+                                 DynareModel, DynareOptions, DynareOutput);
+    return
+end
+
+% Initialize fplan
+fplan = init_plan(crange);
+
+% Set the exogenous observed variables.
+if observed_exogenous_variables_flag
+    list_of_observed_exogenous_variables = setdiff(exo_names, freeinnovations);
+    observed_exogenous_variables = exogenousvariables{list_of_observed_exogenous_variables{:}};
+    for i=1:length(list_of_observed_exogenous_variables)
+        fplan = basic_plan(fplan, list_of_observed_exogenous_variables{i}, ...
+                           'surprise', crange, observed_exogenous_variables{list_of_observed_exogenous_variables{i}}.data(2:length(crange)+1));
+    end
+end
+
+% Set constrained path for the endogenous variables.
+for i = 1:constraints.vobs
+    fplan = flip_plan(fplan, constraints.name{i}, freeinnovations{i}, 'surprise', crange, transpose(constraints.data(:,i)));
+end
+
+% Identify the innovations (model inversion)
+f = det_cond_forecast(fplan, initialconditions, crange);
+
+endogenousvariables = f{endo_names{:}};
+exogenousvariables = f{exo_names{:}};
\ No newline at end of file
diff --git a/matlab/modules/dates b/matlab/modules/dates
index f37d52302..f1dd6aa1e 160000
--- a/matlab/modules/dates
+++ b/matlab/modules/dates
@@ -1 +1 @@
-Subproject commit f37d5230207dc4ddcb5a8fbe9c2ee21721db8e7c
+Subproject commit f1dd6aa1e166f5dee77241737252260f7ea50946
diff --git a/matlab/modules/dseries b/matlab/modules/dseries
index 280a93467..6b77c21cd 160000
--- a/matlab/modules/dseries
+++ b/matlab/modules/dseries
@@ -1 +1 @@
-Subproject commit 280a93467913c001ec1db68bfb699123e44b34b3
+Subproject commit 6b77c21cd8d57935ff5aea121e2e3818264ce43f
diff --git a/matlab/modules/reporting b/matlab/modules/reporting
index ac6a420a2..bc59736f5 160000
--- a/matlab/modules/reporting
+++ b/matlab/modules/reporting
@@ -1 +1 @@
-Subproject commit ac6a420a28feeb68b43a8fdb7a6ea9e0bec0b7ae
+Subproject commit bc59736f5b50454cea925c99b98a757a0494f3e8
diff --git a/matlab/moment_function.m b/matlab/moment_function.m
index af0488a59..fb42db9e8 100644
--- a/matlab/moment_function.m
+++ b/matlab/moment_function.m
@@ -3,19 +3,19 @@ function [g,grad,hess,flag] = moment_function(xparams,sample_moments,dataset,opt
 % ).
 %
 % INPUTS:
-%  xparams          [double]  p*1 vector of estimated parameters. 
+%  xparams          [double]  p*1 vector of estimated parameters.
 %  sample_moments   [double]  n*1 vector of sample moments (n>=p).
 %  options          [      ]  Structure defining options for SMM.
 %  parallel         [      ]  Structure defining the parallel mode settings (optional).
 %
-% OUTPUTS: 
+% OUTPUTS:
 %  g                [double]  n*1 vector, the gap between simulated and sample moments.
 %  flag             [intger]  empty matrix.
 %
 % SPECIAL REQUIREMENTS
 %  The user has to provide a file where the moment conditions are defined.
 
-% Copyright (C) 2010-2012 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ function [g,grad,hess,flag] = moment_function(xparams,sample_moments,dataset,opt
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 global M_ options_
 persistent mainStream mainState
@@ -61,7 +61,7 @@ end
 
 if penalty>0
     flag = 0;
-    return;
+    return
 end
 
 save('estimated_parameters.mat','xparams');
@@ -106,7 +106,7 @@ else% parallel mode.
             end
         end
         for j=1:parallel(i).number_of_jobs
-            if (strcmpi(hostname,machine) && j>1) || ~strcmpi(hostname,machine)  
+            if (strcmpi(hostname,machine) && j>1) || ~strcmpi(hostname,machine)
                 job_number = job_number + 1;
                 unix(['ssh -A ' parallel(i).login '@' machine ' ./call_matlab_session.sh job' int2str(job_number) '.m &']);
             end
@@ -117,7 +117,7 @@ else% parallel mode.
     eval('job1;')
     tElapsedMasterJob = etime(clock, tStartMasterJob);
     TimeLimit = tElapsedMasterJob*1.2;
-    % Master waits for the  slaves' output... 
+    % Master waits for the  slaves' output...
     tStart = clock;
     tElapsed = 0;
     while tElapsed<TimeLimit
@@ -132,7 +132,7 @@ else% parallel mode.
             simulated_moments = load(['./intermediary_results_from_master_and_slaves/simulated_moments_slave_' int2str(i) '.dat'],'-ascii');
             tmp = tmp + simulated_moments;
         end
-        simulated_moments = tmp / job_number;        
+        simulated_moments = tmp / job_number;
     catch
         flag = 0;
         return
diff --git a/matlab/moments.m b/matlab/moments.m
index f295336aa..910332118 100644
--- a/matlab/moments.m
+++ b/matlab/moments.m
@@ -1,7 +1,7 @@
 function m = moments(X,order)
 % Returns the central sample moment of X specified by the positive integer order.
 %
-% Note that the cross moments are only computed if order=2, in this case the 
+% Note that the cross moments are only computed if order=2, in this case the
 % output is a matrix.
 %
 % INPUTS
@@ -14,7 +14,7 @@ function m = moments(X,order)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2009-2010 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ms-sbvar/auto/sbvar_identification.el b/matlab/ms-sbvar/auto/sbvar_identification.el
deleted file mode 100644
index 637bf66f6..000000000
--- a/matlab/ms-sbvar/auto/sbvar_identification.el
+++ /dev/null
@@ -1,8 +0,0 @@
-(TeX-add-style-hook "sbvar_identification"
- (lambda ()
-    (TeX-run-style-hooks
-     "latex2e"
-     "art10"
-     "article"
-     "")))
-
diff --git a/matlab/ms-sbvar/check_datafile_years_assigned.m b/matlab/ms-sbvar/check_datafile_years_assigned.m
index 7df9611dc..36eb671d5 100644
--- a/matlab/ms-sbvar/check_datafile_years_assigned.m
+++ b/matlab/ms-sbvar/check_datafile_years_assigned.m
@@ -8,7 +8,7 @@ function [final_year,final_subperiod]=check_datafile_years_assigned(options_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ms-sbvar/clean_files_for_second_type_of_mex.m b/matlab/ms-sbvar/clean_files_for_second_type_of_mex.m
index d29b532bf..b1361a49b 100644
--- a/matlab/ms-sbvar/clean_files_for_second_type_of_mex.m
+++ b/matlab/ms-sbvar/clean_files_for_second_type_of_mex.m
@@ -11,7 +11,7 @@ function clean_files_for_second_type_of_mex(M_, options_, type)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,12 +34,12 @@ if ~strcmp(tagtouse, options_.ms.output_file_tag)
 end
 
 switch type
-    case 'irf'
-        clean_ms_irf_files(tagtouse);
-    case 'forecast'
-        clean_ms_forecast_files(tagtouse);
-    case 'variance_decomposition'
-        clean_ms_variance_decomposition_files(tagtouse);
-    otherwise
-        error('clean_files_for_second_type_of_mex: should not arrive here');
+  case 'irf'
+    clean_ms_irf_files(tagtouse);
+  case 'forecast'
+    clean_ms_forecast_files(tagtouse);
+  case 'variance_decomposition'
+    clean_ms_variance_decomposition_files(tagtouse);
+  otherwise
+    error('clean_files_for_second_type_of_mex: should not arrive here');
 end
diff --git a/matlab/ms-sbvar/clean_ms_simulation_files.m b/matlab/ms-sbvar/clean_ms_simulation_files.m
index b6a807859..19ec8480b 100644
--- a/matlab/ms-sbvar/clean_ms_simulation_files.m
+++ b/matlab/ms-sbvar/clean_ms_simulation_files.m
@@ -11,7 +11,7 @@ function clean_ms_simulation_files(file_tag)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ms-sbvar/dyn_save_graph.m b/matlab/ms-sbvar/dyn_save_graph.m
index e3ae96326..46623f7c9 100644
--- a/matlab/ms-sbvar/dyn_save_graph.m
+++ b/matlab/ms-sbvar/dyn_save_graph.m
@@ -9,11 +9,11 @@ function dyn_save_graph(dirname,graph_name,graph_formats,TeX,names,texnames,capt
 %
 % OUTPUTS
 %   none
-%    
+%
 % SPECIAL REQUIREMENTS
 %    none
 %
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,40 +30,40 @@ function dyn_save_graph(dirname,graph_name,graph_formats,TeX,names,texnames,capt
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    create_dir(dirname);
-    graph_name = [dirname filesep regexprep(graph_name,' ','_')];
-    if nargin <= 2
-        TeX = 0;
-    elseif nargin <= 4
-        names = {};
-        texnames = {};
-    elseif nargin <= 6
-        caption = '';
+create_dir(dirname);
+graph_name = [dirname filesep regexprep(graph_name,' ','_')];
+if nargin <= 2
+    TeX = 0;
+elseif nargin <= 4
+    names = {};
+    texnames = {};
+elseif nargin <= 6
+    caption = '';
+end
+
+if graph_formats.eps || TeX
+    print([ graph_name '.eps' ],'-depsc2');
+end
+if graph_formats.pdf && ~isoctave
+    print(graph_name,'-dpdf');
+end
+if graph_formats.fig && ~isoctave
+    print(graph_name,'-dfig');
+end
+
+if TeX
+    fh = fopen([graph_name '.tex'],'w');
+    for i=1:length(names)
+        fprintf(fh,'\\psfrag{%s}[1][][0.5][0]{%s}\n',names{i},texnames{i});
     end
-    
-    if graph_formats.eps || TeX
-        print([ graph_name '.eps' ],'-depsc2');
-    end
-    if graph_formats.pdf && ~isoctave
-        print(graph_name,'-dpdf');
-    end
-    if graph_formats.fig && ~isoctave
-        print(graph_name,'-dfig');
-    end
-    
-    if TeX
-        fh = fopen([graph_name '.tex'],'w');
-        for i=1:length(names)
-            fprintf(fh,'\\psfrag{%s}[1][][0.5][0]{%s}\n',names{i},texnames{i});
-        end
-        fprintf(fh,'\\centering \n');
-        fprintf(fh,'\\includegraphics[width=0.8\\textwidth]{%s}\n',graph_name);
-        if caption
-            fprintf(fh,'\\caption{%s}',caption);
-        end
-        fprintf(fh,'\\label{Fig:%s}\n',graph_name);
-        fprintf(fh,'\\end{figure}\n');
-        fprintf(fh,'\n');
-        fprintf(fh,'%% End of TeX file.\n');
-        fclose(fh);
+    fprintf(fh,'\\centering \n');
+    fprintf(fh,'\\includegraphics[width=0.8\\textwidth]{%s}\n',graph_name);
+    if caption
+        fprintf(fh,'\\caption{%s}',caption);
     end
+    fprintf(fh,'\\label{Fig:%s}\n',graph_name);
+    fprintf(fh,'\\end{figure}\n');
+    fprintf(fh,'\n');
+    fprintf(fh,'%% End of TeX file.\n');
+    fclose(fh);
+end
diff --git a/matlab/ms-sbvar/identification/exclusions.m b/matlab/ms-sbvar/identification/exclusions.m
index 5e7d3ef5c..5361c2ef4 100644
--- a/matlab/ms-sbvar/identification/exclusions.m
+++ b/matlab/ms-sbvar/identification/exclusions.m
@@ -16,7 +16,7 @@ function [Ui,Vi,n0,np,ixmC0Pres,Qi,Ri] = exclusions(nvar,nexo,options_ms)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -47,25 +47,25 @@ np = zeros(nvar,1);
 k = nlags*nvar+1;
 
 for n=1:nvar
- Qi{n} = zeros(nvar,nvar);
- sQ = size(Qi1{n});
- if all(sQ) > 0
-     Qi{n}(1:sQ(1),1:sQ(2)) = Qi1{n};
- end
- Ri{n} = zeros(k,k);
- sR = size(Ri1{n});
- if all(sR) > 0
-     Ri{n}(1:sR(1),1:sR(2)) = Ri1{n};
- end
+    Qi{n} = zeros(nvar,nvar);
+    sQ = size(Qi1{n});
+    if all(sQ) > 0
+        Qi{n}(1:sQ(1),1:sQ(2)) = Qi1{n};
+    end
+    Ri{n} = zeros(k,k);
+    sR = size(Ri1{n});
+    if all(sR) > 0
+        Ri{n}(1:sR(1),1:sR(2)) = Ri1{n};
+    end
 
- if options_ms.constants_exclusion
+    if options_ms.constants_exclusion
         Ri{n}(sR(1)+1,k) = 1;
- end
+    end
 
- Ui{n} = null(Qi{n});
- Vi{n} = null(Ri{n});
- n0(n) = size(Ui{n},2);
- np(n) = size(Vi{n},2);
+    Ui{n} = null(Qi{n});
+    Vi{n} = null(Ri{n});
+    n0(n) = size(Ui{n},2);
+    np(n) = size(Vi{n},2);
 end
 
 ixmC0Pres = NaN;
\ No newline at end of file
diff --git a/matlab/ms-sbvar/identification/lower_cholesky.m b/matlab/ms-sbvar/identification/lower_cholesky.m
index 2af96ca9b..a88954091 100644
--- a/matlab/ms-sbvar/identification/lower_cholesky.m
+++ b/matlab/ms-sbvar/identification/lower_cholesky.m
@@ -16,7 +16,7 @@ function [Ui,Vi,n0,np,ixmC0Pres] = lower_cholesky(nvar,nexo,options_ms)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,11 +41,11 @@ Vi = cell(nvar,1);
 n0 = zeros(nvar,1);
 np = zeros(nvar,1);
 if (nargin==2)
-   nexo = 1; 
+    nexo = 1;
 elseif (nargin==3)
-   indxC0Pres = 0;
+    indxC0Pres = 0;
 end
-k = lags*nvar+nexo; 
+k = lags*nvar+nexo;
 Qi = zeros(nvar,nvar,nvar);
 Ri = zeros(k,k,nvar);
 
@@ -61,11 +61,11 @@ if options_ms.constants_exclusion
     end
 end
 
-for n=1:nvar 
-   Ui{n} = null(Qi(:,:,n));
-   Vi{n} = null(Ri(:,:,n));
-   n0(n) = size(Ui{n},2);
-   np(n) = size(Vi{n},2);
+for n=1:nvar
+    Ui{n} = null(Qi(:,:,n));
+    Vi{n} = null(Ri(:,:,n));
+    n0(n) = size(Ui{n},2);
+    np(n) = size(Vi{n},2);
 end
 
 ixmC0Pres = NaN;
\ No newline at end of file
diff --git a/matlab/ms-sbvar/identification/upper_cholesky.m b/matlab/ms-sbvar/identification/upper_cholesky.m
index 7f4d2027c..8645214b1 100644
--- a/matlab/ms-sbvar/identification/upper_cholesky.m
+++ b/matlab/ms-sbvar/identification/upper_cholesky.m
@@ -16,7 +16,7 @@ function [Ui,Vi,n0,np,ixmC0Pres] = upper_cholesky(nvar,nexo,options_ms)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,9 +42,9 @@ n0 = zeros(nvar,1);
 np = zeros(nvar,1);
 
 if (nargin==2)
-   nexo = 1;
+    nexo = 1;
 elseif (nargin==3)
-   indxC0Pres = 0;
+    indxC0Pres = 0;
 end
 
 k = lags*nvar+nexo;
@@ -52,8 +52,8 @@ Qi = zeros(nvar,nvar,nvar);
 Ri = zeros(k,k,nvar);
 
 for ii=2:nvar
-  Qi(ii-1,ii-1,ii)=1;
-  Qi(:,:,ii)=Qi(:,:,ii)+Qi(:,:,ii-1);
+    Qi(ii-1,ii-1,ii)=1;
+    Qi(:,:,ii)=Qi(:,:,ii)+Qi(:,:,ii-1);
 end
 
 if options_ms.constants_exclusion
@@ -62,11 +62,11 @@ if options_ms.constants_exclusion
     end
 end
 
-for n=1:nvar 
-   Ui{n} = null(Qi(:,:,n));
-   Vi{n} = null(Ri(:,:,n));
-   n0(n) = size(Ui{n},2);
-   np(n) = size(Vi{n},2);
+for n=1:nvar
+    Ui{n} = null(Qi(:,:,n));
+    Vi{n} = null(Ri(:,:,n));
+    n0(n) = size(Ui{n},2);
+    np(n) = size(Vi{n},2);
 end
 
 ixmC0Pres = NaN;
\ No newline at end of file
diff --git a/matlab/ms-sbvar/initialize_ms_sbvar_options.m b/matlab/ms-sbvar/initialize_ms_sbvar_options.m
index 61255652b..b618aef3c 100644
--- a/matlab/ms-sbvar/initialize_ms_sbvar_options.m
+++ b/matlab/ms-sbvar/initialize_ms_sbvar_options.m
@@ -12,7 +12,7 @@ function options_=initialize_ms_sbvar_options(M_, options_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ms-sbvar/ms_estimation.m b/matlab/ms-sbvar/ms_estimation.m
index 6d5eec32d..495a483ee 100644
--- a/matlab/ms-sbvar/ms_estimation.m
+++ b/matlab/ms-sbvar/ms_estimation.m
@@ -14,7 +14,7 @@ function [options_, oo_]=ms_estimation(M_, options_, oo_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -45,7 +45,7 @@ else
             exist(['matlab_' options_.ms.file_tag '.prn'],'file') ~= 2 || ...
             exist([options_.ms.file_tag '_markov_file.dat'],'file') ~= 2
         error(['You must run ms_estimation without no_create_init as '...
-            'you are missing an initialization file it needs.']);
+               'you are missing an initialization file it needs.']);
     end
     if ~strcmp(options_.ms.file_tag, options_.ms.output_file_tag)
         clean_ms_estimation_files(options_.ms.output_file_tag);
diff --git a/matlab/ms-sbvar/ms_forecast.m b/matlab/ms-sbvar/ms_forecast.m
index 55030c902..e8949c9ae 100644
--- a/matlab/ms-sbvar/ms_forecast.m
+++ b/matlab/ms-sbvar/ms_forecast.m
@@ -14,7 +14,7 @@ function [options_, oo_]=ms_forecast(M_, options_, oo_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2016 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -89,30 +89,30 @@ if options_.ms.regimes
     for regime_i=1:n_regimes
         forecast_title = ['Forecast, Regimes ' num2str(regime_i)];
         forecast_data = load([forecastdir filesep 'forecasts_percentiles_regime_' ...
-            num2str(regime_i-1) '_' options_.ms.output_file_tag ...
-            '.out'], '-ascii');
+                            num2str(regime_i-1) '_' options_.ms.output_file_tag ...
+                            '.out'], '-ascii');
         forecast_data = reshape_ascii_forecast_data(M_.endo_nbr, ...
-            percentiles_size, options_.ms.horizon, forecast_data);
+                                                    percentiles_size, options_.ms.horizon, forecast_data);
         save([forecastdir filesep 'forecast_regime_' num2str(regime_i-1) '.mat'], ...
-            'forecast_data');
+             'forecast_data');
         plot_ms_forecast(M_, options_, forecast_data, forecast_title);
     end
 else
     if options_.ms.regime
         forecast_data = load([forecastdir filesep 'forecasts_percentiles_regime_' ...
-            num2str(options_.ms.regime-1) '_' options_.ms.output_file_tag ...
-            '.out'], '-ascii');
+                            num2str(options_.ms.regime-1) '_' options_.ms.output_file_tag ...
+                            '.out'], '-ascii');
         forecast_title = ['Forecast, Regime ' num2str(options_.ms.regime)];
         save_filename = ['forecast_regime_' num2str(options_.ms.regime-1) '.mat'];
     else
         forecast_data = load([forecastdir filesep 'forecasts_percentiles_' ...
-            options_.ms.output_file_tag '.out'], '-ascii');
+                            options_.ms.output_file_tag '.out'], '-ascii');
         forecast_title = 'Forecast';
         save_filename = 'forecast.mat';
     end
 
     forecast_data = reshape_ascii_forecast_data(M_.endo_nbr, ...
-        percentiles_size, options_.ms.horizon, forecast_data);
+                                                percentiles_size, options_.ms.horizon, forecast_data);
     save([forecastdir filesep save_filename], 'forecast_data');
     plot_ms_forecast(M_, options_, forecast_data, forecast_title);
 end
diff --git a/matlab/ms-sbvar/ms_irf.m b/matlab/ms-sbvar/ms_irf.m
index 32718aa29..47d1a8490 100644
--- a/matlab/ms-sbvar/ms_irf.m
+++ b/matlab/ms-sbvar/ms_irf.m
@@ -15,7 +15,7 @@ function [options_, oo_]=ms_irf(varlist, M_, options_, oo_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2016 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -91,34 +91,34 @@ if options_.ms.regimes
     for regime_i=1:n_regimes
         irf_title = ['Impulse Responses, Regime ' num2str(regime_i)];
         irf_data = load([irfdir filesep 'ir_percentiles_regime_' ...
-            num2str(regime_i-1) '_' options_.ms.output_file_tag ...
-            '.out'], '-ascii');
+                         num2str(regime_i-1) '_' options_.ms.output_file_tag ...
+                         '.out'], '-ascii');
         irf_data = reshape_ascii_irf_data(M_.endo_nbr, percentiles_size, ...
-            options_.ms.horizon, irf_data);
+                                          options_.ms.horizon, irf_data);
         save([irfdir filesep 'irf_regime_' num2str(regime_i-1) '.mat'], 'irf_data');
         plot_ms_irf(M_, options_, irf_data, irf_title, varlist);
     end
 else
     if options_.ms.regime
         irf_data = load([irfdir filesep 'ir_percentiles_regime_' ...
-            num2str(options_.ms.regime-1) '_' options_.ms.output_file_tag ...
-            '.out'], '-ascii');
+                         num2str(options_.ms.regime-1) '_' options_.ms.output_file_tag ...
+                         '.out'], '-ascii');
         irf_title = ['Impulse Response, Regime ' num2str(options_.ms.regime)];
         save_filename = ['irf_regime_' num2str(options_.ms.regime-1) '.mat'];
     elseif options_.ms.filtered_probabilities
         irf_data = load([irfdir filesep 'ir_percentiles_filtered_' ...
-            options_.ms.output_file_tag '.out'], '-ascii');
+                         options_.ms.output_file_tag '.out'], '-ascii');
         irf_title = 'Impulse Response Filtered';
         save_filename = 'irf.mat';
     else
         irf_data = load([irfdir filesep 'ir_percentiles_ergodic_' ...
-            options_.ms.output_file_tag '.out'], '-ascii');
+                         options_.ms.output_file_tag '.out'], '-ascii');
         irf_title = 'Impulse Response Ergodic';
         save_filename = 'irf.mat';
     end
 
     irf_data = reshape_ascii_irf_data(M_.endo_nbr, percentiles_size, ...
-        options_.ms.horizon, irf_data);
+                                      options_.ms.horizon, irf_data);
     save([irfdir filesep save_filename], 'irf_data');
     plot_ms_irf(M_, options_, irf_data, irf_title, varlist);
 end
diff --git a/matlab/ms-sbvar/ms_mardd.m b/matlab/ms-sbvar/ms_mardd.m
index 9932f0186..bd522807d 100644
--- a/matlab/ms-sbvar/ms_mardd.m
+++ b/matlab/ms-sbvar/ms_mardd.m
@@ -6,7 +6,7 @@ function ms_mardd(options_)
 %
 % Tao Zha, September 1999.  Quick revisions, May 2003.  Final revision, September 2004.
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -25,26 +25,26 @@ function ms_mardd(options_)
 
 msstart2     % start the program in which everyhting is initialized through msstart2.m
 if ~options_.ms.indxestima
-   warning(' ')
-   disp('You must set IxEstima=1 in msstart to run this program')
-	disp('Press ctrl-c to abort now')
-	pause
+    warning(' ')
+    disp('You must set IxEstima=1 in msstart to run this program')
+    disp('Press ctrl-c to abort now')
+    pause
 end
 
 A0xhat = zeros(size(A0hat));
 Apxhat = zeros(size(Aphat));
 if (0)
-   %Robustness check to see if the same result is obtained with the purterbation of the parameters.
-   for k=1:nvar
-      bk = Uiconst{k}'*A0hat(:,k);
-      gk = Viconst{k}'*Aphat(:,k);
-      A0xhat(:,k) =  Uiconst{k}*(bk + 5.2*randn(size(bk)));   % Perturbing the posterior estimate.
-      Apxhat(:,k) = Viconst{k}*(gk + 5.2*randn(size(gk)));      % Perturbing the posterior estimate.
-   end
+    %Robustness check to see if the same result is obtained with the purterbation of the parameters.
+    for k=1:nvar
+        bk = Uiconst{k}'*A0hat(:,k);
+        gk = Viconst{k}'*Aphat(:,k);
+        A0xhat(:,k) =  Uiconst{k}*(bk + 5.2*randn(size(bk)));   % Perturbing the posterior estimate.
+        Apxhat(:,k) = Viconst{k}*(gk + 5.2*randn(size(gk)));      % Perturbing the posterior estimate.
+    end
 else
-   %At the posterior estimate.
-   A0xhat = A0hat;   % ML estimate of A0
-   Apxhat = Aphat;      % ML estimate of A+
+    %At the posterior estimate.
+    A0xhat = A0hat;   % ML estimate of A0
+    Apxhat = Aphat;      % ML estimate of A+
 end
 %--- Rename variables.
 YatYa = yty;
@@ -59,40 +59,40 @@ XatXa = xtx;
 vlog_a0p = 0;
 Yexpt=0;  % exponential term for Y in p(Y|A0,A+) at some point such as the peak
 Apexpt=0.0;  % 0.0 because we have chosen posterior estimate of A+ as A+*.  Exponential term for A+ conditional on A0 and Y
-%======= Computing the log prior pdf of a0a+ and the exponential term for Y in p(Y|A0,A+).
+             %======= Computing the log prior pdf of a0a+ and the exponential term for Y in p(Y|A0,A+).
 for k=1:nvar
-   a0k = A0xhat(:,k);  % meaningful parameters in the kth equation.
-   apk = Apxhat(:,k);  % meaningful parameters in the kth equation.
+    a0k = A0xhat(:,k);  % meaningful parameters in the kth equation.
+    apk = Apxhat(:,k);  % meaningful parameters in the kth equation.
 
-   %--- Prior settings.
-   S0bar = H0invtld{k};  %See Claim 2 on p.69b.
-   Spbar = Hpinvtld{k};
-   bk = Uiconst{k}'*a0k;  % free parameters in the kth equation.
-   gk = Viconst{k}'*apk;  % free parameters in the kth equation.
-   gbark = Ptld{k}*bk;   % bar: prior
+    %--- Prior settings.
+    S0bar = H0invtld{k};  %See Claim 2 on p.69b.
+    Spbar = Hpinvtld{k};
+    bk = Uiconst{k}'*a0k;  % free parameters in the kth equation.
+    gk = Viconst{k}'*apk;  % free parameters in the kth equation.
+    gbark = Ptld{k}*bk;   % bar: prior
 
-   %--- The exponential term for Y in p(Y|A0,A+)
-   Yexpt = Yexpt - 0.5*(a0k'*YatYa*a0k - 2*apk'*XatYa*a0k + apk'*XatXa*apk);
-   %--- The log prior pdf.
-   vlog_a0p = vlog_a0p - 0.5*(size(Uiconst{k},2)+size(Viconst{k},2))*log(2*pi) + 0.5*log(abs(det(S0bar))) + ...
-         0.5*log(abs(det(Spbar))) - 0.5*(bk'*S0bar*bk+(gk-gbark)'*Spbar*(gk-gbark));
-   %--- For p(A+|Y,a0) only.
-   tmpd = gk - Pmat{k}*bk;
-   Apexpt = Apexpt - 0.5*tmpd'*(Hpinv{k}*tmpd);
+    %--- The exponential term for Y in p(Y|A0,A+)
+    Yexpt = Yexpt - 0.5*(a0k'*YatYa*a0k - 2*apk'*XatYa*a0k + apk'*XatXa*apk);
+    %--- The log prior pdf.
+    vlog_a0p = vlog_a0p - 0.5*(size(Uiconst{k},2)+size(Viconst{k},2))*log(2*pi) + 0.5*log(abs(det(S0bar))) + ...
+        0.5*log(abs(det(Spbar))) - 0.5*(bk'*S0bar*bk+(gk-gbark)'*Spbar*(gk-gbark));
+    %--- For p(A+|Y,a0) only.
+    tmpd = gk - Pmat{k}*bk;
+    Apexpt = Apexpt - 0.5*tmpd'*(Hpinv{k}*tmpd);
 end
 vlog_a0p
 
 %--------- The log value of p(Y|A0,A+) at some point such as the peak. ----------
 %--------- Note that logMarLHres is the same as vlog_Y_a, just to double check. ----------
 vlog_Y_a = -0.5*nvar*fss*log(2*pi) + fss*log(abs(det(A0xhat))) + Yexpt
-                 % a: given a0 and a+
+% a: given a0 and a+
 logMarLHres = 0;   % Initialize log of the marginal likelihood (restricted or constant parameters).
 for ki=1:fss   %ndobs+1:fss     % Forward recursion to get the marginal likelihood.  See F on p.19 and pp. 48-49.
-   %----  Restricted log marginal likelihood function (constant parameters).
-   [A0l,A0u] = lu(A0xhat);
-   ada = sum(log(abs(diag(A0u))));   % log|A0|
-   termexp = y(ki,:)*A0xhat - phi(ki,:)*Apxhat;   % 1-by-nvar
-   logMarLHres = logMarLHres - (0.5*nvar)*log(2*pi) + ada - 0.5*termexp*termexp';  % log value
+               %----  Restricted log marginal likelihood function (constant parameters).
+    [A0l,A0u] = lu(A0xhat);
+    ada = sum(log(abs(diag(A0u))));   % log|A0|
+    termexp = y(ki,:)*A0xhat - phi(ki,:)*Apxhat;   % 1-by-nvar
+    logMarLHres = logMarLHres - (0.5*nvar)*log(2*pi) + ada - 0.5*termexp*termexp';  % log value
 end
 logMarLHres
 
@@ -101,8 +101,8 @@ logMarLHres
 totparsp = 0.0;
 tmpd = 0.0;
 for k=1:nvar
-   totparsp = totparsp + size(Viconst{k},2);
-   tmpd = tmpd + 0.5*log(abs(det(Hpinv{k})));
+    totparsp = totparsp + size(Viconst{k},2);
+    tmpd = tmpd + 0.5*log(abs(det(Hpinv{k})));
 end
 vlog_ap_Ya0 = -0.5*totparsp*log(2*pi) + tmpd + Apexpt;
 
@@ -117,65 +117,65 @@ vlog_ap_Ya0 = -0.5*totparsp*log(2*pi) + tmpd + Apexpt;
 [Tinv,UT] = fn_gibbsrvar_setup(H0inv, Uiconst, Hpinv, Pmat, Viconst, nvar, fss);
 %
 vlog_a0_Yao = zeros(nvar,1);
-  % the log value of p(a0k|Y,ao) where ao: other a's at some point such as the peak of ONLY some a0's
+% the log value of p(a0k|Y,ao) where ao: other a's at some point such as the peak of ONLY some a0's
 vlog=zeros(ndraws2,1);
 for k=1:nvar
-   bk = Uiconst{k}'*A0xhat(:,k);
-   indx_ks=[k:nvar];  % the columns that exclude 1-(k-1)th columns
-   A0gbs0 = A0hat;   % starting at some point such as the peak
-   nk = n0(k);
+    bk = Uiconst{k}'*A0xhat(:,k);
+    indx_ks=[k:nvar];  % the columns that exclude 1-(k-1)th columns
+    A0gbs0 = A0hat;   % starting at some point such as the peak
+    nk = n0(k);
 
-   if k<nvar
-      %--------- The 1st set of draws to be tossed away. ------------------
-      for draws = 1:ndraws1
-         if ~mod(draws,nbuffer)
-            skipline()
-            disp(sprintf('The %dth column or equation in A0 with %d 1st tossed-away draws in Gibbs',k,draws))
-         end
-         A0gbs1 = fn_gibbsrvar(A0gbs0,UT,nvar,fss,n0,indx_ks);
-         A0gbs0=A0gbs1;    % repeat the Gibbs sampling
-      end
+    if k<nvar
+        %--------- The 1st set of draws to be tossed away. ------------------
+        for draws = 1:ndraws1
+            if ~mod(draws,nbuffer)
+                skipline()
+                disp(sprintf('The %dth column or equation in A0 with %d 1st tossed-away draws in Gibbs',k,draws))
+            end
+            A0gbs1 = fn_gibbsrvar(A0gbs0,UT,nvar,fss,n0,indx_ks);
+            A0gbs0=A0gbs1;    % repeat the Gibbs sampling
+        end
 
 
-      %--------- The 2nd set of draws to be used. ------------------
-      for draws = 1:ndraws2
-         if ~mod(draws,nbuffer)
-            skipline()
-            disp(sprintf('The %dth column or equation in A0 with %d usable draws in Gibbs',k,draws))
-         end
-         [A0gbs1, Wcell] = fn_gibbsrvar(A0gbs0,UT,nvar,fss,n0,indx_ks);
-         %------ See p.71, Forecast (II).
-         %------ Computing p(a0_k|Y,a_others) at some point such as the peak along the dimensions of indx_ks.
-         Vk = Tinv{k}\Wcell{k};  %V_k on p.71 of Forecast (II).
-         gbeta = Vk\bk;  % inv(V_k)*b_k on p.71 of Forecast (II) where alpha_k = b_k in our notation.
-         [Vtq,Vtr]=qr(Vk',0);  %To get inv(V_k)'*inv(V_k) in (*) on p.71 of Forecast (II).
-         %
-         vlog(draws) = 0.5*(fss+nk)*log(fss)-log(abs(det(Vk)))-0.5*(nk-1)*log(2*pi)-...
-                  0.5*(fss+1)*log(2)-gammaln(0.5*(fss+1))+fss*log(abs(gbeta(1)))-...
-                  0.5*fss*bk'*(Vtr\(Vtr'\bk));
+        %--------- The 2nd set of draws to be used. ------------------
+        for draws = 1:ndraws2
+            if ~mod(draws,nbuffer)
+                skipline()
+                disp(sprintf('The %dth column or equation in A0 with %d usable draws in Gibbs',k,draws))
+            end
+            [A0gbs1, Wcell] = fn_gibbsrvar(A0gbs0,UT,nvar,fss,n0,indx_ks);
+            %------ See p.71, Forecast (II).
+            %------ Computing p(a0_k|Y,a_others) at some point such as the peak along the dimensions of indx_ks.
+            Vk = Tinv{k}\Wcell{k};  %V_k on p.71 of Forecast (II).
+            gbeta = Vk\bk;  % inv(V_k)*b_k on p.71 of Forecast (II) where alpha_k = b_k in our notation.
+            [Vtq,Vtr]=qr(Vk',0);  %To get inv(V_k)'*inv(V_k) in (*) on p.71 of Forecast (II).
+                                  %
+            vlog(draws) = 0.5*(fss+nk)*log(fss)-log(abs(det(Vk)))-0.5*(nk-1)*log(2*pi)-...
+                0.5*(fss+1)*log(2)-gammaln(0.5*(fss+1))+fss*log(abs(gbeta(1)))-...
+                0.5*fss*bk'*(Vtr\(Vtr'\bk));
 
-         A0gbs0=A0gbs1;    % repeat the Gibbs sampling
-      end
-      vlogm=max(vlog);
-      qlog=vlog-vlogm;
-      vlogxhat=vlogm-log(ndraws2)+log(sum(exp(qlog)));
-      vlog_a0_Yao(k) = vlogxhat;
-         % The log value of p(a0_k|Y,a_others) where a_others: other a's at some point such as the peak of ONLY some a0's
-   else
-      skipline()
-      disp(sprintf('The last(6th) column or equation in A0 with no Gibbs draws'))
-      [A0gbs1, Wcell] = fn_gibbsrvar(A0gbs0,UT,nvar,fss,n0,indx_ks)
-      %------ See p.71, Forecast (II).
-      %------ Computing p(a0_k|Y,a_others) at some point such as the peak along the dimensions of indx_ks.
-      Vk = Tinv{k}\Wcell{k};  %V_k on p.71 of Forecast (II).
-      gbeta = Vk\bk;  % inv(V_k)*b_k on p.71 of Forecast (II) where alpha_k = b_k in our notation.
-      [Vtq,Vtr]=qr(Vk',0);  %To get inv(V_k)'*inv(V_k) in (*) on p.71 of Forecast (II).
-      %
-      vloglast = 0.5*(fss+nk)*log(fss)-log(abs(det(Vk)))-0.5*(nk-1)*log(2*pi)-...
-               0.5*(fss+1)*log(2)-gammaln(0.5*(fss+1))+fss*log(abs(gbeta(1)))-...
-               0.5*fss*bk'*(Vtr\(Vtr'\bk));
-      vlog_a0_Yao(k) = vloglast;
-   end
+            A0gbs0=A0gbs1;    % repeat the Gibbs sampling
+        end
+        vlogm=max(vlog);
+        qlog=vlog-vlogm;
+        vlogxhat=vlogm-log(ndraws2)+log(sum(exp(qlog)));
+        vlog_a0_Yao(k) = vlogxhat;
+        % The log value of p(a0_k|Y,a_others) where a_others: other a's at some point such as the peak of ONLY some a0's
+    else
+        skipline()
+        disp(sprintf('The last(6th) column or equation in A0 with no Gibbs draws'))
+        [A0gbs1, Wcell] = fn_gibbsrvar(A0gbs0,UT,nvar,fss,n0,indx_ks)
+        %------ See p.71, Forecast (II).
+        %------ Computing p(a0_k|Y,a_others) at some point such as the peak along the dimensions of indx_ks.
+        Vk = Tinv{k}\Wcell{k};  %V_k on p.71 of Forecast (II).
+        gbeta = Vk\bk;  % inv(V_k)*b_k on p.71 of Forecast (II) where alpha_k = b_k in our notation.
+        [Vtq,Vtr]=qr(Vk',0);  %To get inv(V_k)'*inv(V_k) in (*) on p.71 of Forecast (II).
+                              %
+        vloglast = 0.5*(fss+nk)*log(fss)-log(abs(det(Vk)))-0.5*(nk-1)*log(2*pi)-...
+            0.5*(fss+1)*log(2)-gammaln(0.5*(fss+1))+fss*log(abs(gbeta(1)))-...
+            0.5*fss*bk'*(Vtr\(Vtr'\bk));
+        vlog_a0_Yao(k) = vloglast;
+    end
 end
 ndraws2
 
diff --git a/matlab/ms-sbvar/ms_sbvar_setup.m b/matlab/ms-sbvar/ms_sbvar_setup.m
index 181a6f7d2..a195cc491 100644
--- a/matlab/ms-sbvar/ms_sbvar_setup.m
+++ b/matlab/ms-sbvar/ms_sbvar_setup.m
@@ -11,7 +11,7 @@ function ms_sbvar_setup(options_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2012 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,7 +29,7 @@ function ms_sbvar_setup(options_)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 options_.data = read_variables(options_.datafile, ...
-    options_.varobs, [], options_.xls_sheet, options_.xls_range);
+                               options_.varobs, [], options_.xls_sheet, options_.xls_range);
 [options_.ms.final_year,options_.ms.final_subperiod] = check_datafile_years_assigned(options_);
 
 if options_.ms.upper_cholesky
@@ -243,10 +243,10 @@ if indxPrior
     else
         [Pi,H0multi,Hpmulti,H0invmulti,Hpinvmulti] = fn_rnrprior(nvar,q_m,options_.ms.nlags,xdgel,mu);
     end
-    
+
     %*** Combines asymmetric prior with linear restrictions
     [Ptld,H0invtld,Hpinvtld] = fn_rlrprior(Ui,Vi,Pi,H0multi,Hpmulti,nvar);
-    
+
     %*** Obtains the posterior matrices for estimation and inference
     [Pmat,H0inv,Hpinv] = fn_rlrpostr(xtx,xty,yty,Ptld,H0invtld,Hpinvtld,Ui,Vi);
 else
@@ -258,7 +258,7 @@ if Rform
     %*** Obtain the ML estimate
     A0hatinv = chol(H0inv{1}/fss);   % upper triangular but lower triangular choleski
     A0hat=inv(A0hatinv);
-    
+
     Aphat = Pmat{1}*A0hat;
 else
     %*** Obtain the ML estimate
@@ -271,16 +271,16 @@ else
     [fhat,xhat,grad,Hhat,itct,fcount,retcodehat] = csminwel('fn_a0freefun',x,H0,'fn_a0freegrad',crit,nit,Ui,nvar,n0,fss,H0inv);
 
     A0hat = fn_tran_b2a(xhat,Ui,nvar,n0);
-    
+
     xhat = fn_tran_a2b(A0hat,Ui,nvar,n0);
     [Aphat,ghat] = fn_gfmean(xhat,Pmat,Vi,nvar,ncoef,n0,np);
     if indxC0Pres
         Fhatur0P = Fhat;  % ur: unrestriced across A0 and A+
         for ki = 1:size(ixmC0Pres,1)   % loop through the number of equations in which
-            % cross-A0-A+ restrictions occur. See St. Louis Note p.5.
+                                       % cross-A0-A+ restrictions occur. See St. Louis Note p.5.
             ixeq = ixmC0Pres{ki}(1,1);   % index for the jth equation in consideration.
             Lit = Vi{ixeq}(ixmC0Pres{ki}(:,2),:);  % transposed restriction matrix Li
-            % V_j(i,:) in f_j(i) = V_j(i,:)*g_j
+                                                   % V_j(i,:) in f_j(i) = V_j(i,:)*g_j
             ci = ixmC0Pres{ki}(:,4) .* A0hat(ixmC0Pres{ki}(:,3),ixeq);
             % s * a_j(h) in the restriction f_j(i) = s * a_j(h).
             LtH = Lit/Hpinv{ixeq};
diff --git a/matlab/ms-sbvar/ms_simulation.m b/matlab/ms-sbvar/ms_simulation.m
index 04a2e1eea..f7832e035 100644
--- a/matlab/ms-sbvar/ms_simulation.m
+++ b/matlab/ms-sbvar/ms_simulation.m
@@ -14,7 +14,7 @@ function [options_, oo_]=ms_simulation(M_, options_, oo_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ms-sbvar/ms_variance_decomposition.m b/matlab/ms-sbvar/ms_variance_decomposition.m
index 553488acd..1fe73ddbc 100644
--- a/matlab/ms-sbvar/ms_variance_decomposition.m
+++ b/matlab/ms-sbvar/ms_variance_decomposition.m
@@ -14,7 +14,7 @@ function [options_, oo_]=ms_variance_decomposition(M_, options_, oo_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2016 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -85,7 +85,7 @@ if options_.ms.regime || options_.ms.regimes
     outfile = [outfile 'regime_'];
     if options_.ms.regime
         outfile = [outfile num2str(options_.ms.regime-1) ...
-            '_' options_.ms.output_file_tag '.out'];
+                   '_' options_.ms.output_file_tag '.out'];
     end
 elseif options_.ms.filtered_probabilities
     outfile = [outfile 'filtered_' options_.ms.output_file_tag '.out'];
@@ -103,7 +103,7 @@ if options_.ms.regimes
     for regime_i=1:n_regimes
         vd_title = ['Variance Decomposition, Regime ' num2str(regime_i)];
         vd_data = load([outfile num2str(regime_i-1) '_' ...
-            options_.ms.output_file_tag '.out'], '-ascii');
+                        options_.ms.output_file_tag '.out'], '-ascii');
         vd_data = reshape_ascii_variance_decomposition_data( ...
             M_.endo_nbr, percentiles_size, options_.ms.horizon, vd_data);
         save([vddir filesep 'variance_decomposition_regime_' num2str(regime_i-1) '.mat'], 'vd_data');
diff --git a/matlab/ms-sbvar/ms_write_markov_file.m b/matlab/ms-sbvar/ms_write_markov_file.m
index 02b934a3e..7eaa5925f 100644
--- a/matlab/ms-sbvar/ms_write_markov_file.m
+++ b/matlab/ms-sbvar/ms_write_markov_file.m
@@ -10,7 +10,7 @@ function ms_write_markov_file(fname, options)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,136 +27,136 @@ function ms_write_markov_file(fname, options)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    n_chains = length(options.ms.ms_chain);
-    nvars = length(options.varobs);
-    
-    fh = fopen(fname,'w');
-    %/******************************************************************************/
-    %/********************* Markov State Variable Information **********************/
-    %/******************************************************************************/
-    
-    fprintf(fh,'//== Markov State Variables with Simple Restrictions ==//\n\n');
-    
-    
-    %//This number is NOT used but read in.
-    fprintf(fh,'//== Number Observations ==//\n');
-    fprintf(fh,'0\n\n');
+n_chains = length(options.ms.ms_chain);
+nvars = length(options.varobs);
 
-    fprintf(fh,'//== Number independent state variables ==//\n');
-    fprintf(fh,'%d\n\n',n_chains);
+fh = fopen(fname,'w');
+%/******************************************************************************/
+%/********************* Markov State Variable Information **********************/
+%/******************************************************************************/
 
+fprintf(fh,'//== Markov State Variables with Simple Restrictions ==//\n\n');
+
+
+%//This number is NOT used but read in.
+fprintf(fh,'//== Number Observations ==//\n');
+fprintf(fh,'0\n\n');
+
+fprintf(fh,'//== Number independent state variables ==//\n');
+fprintf(fh,'%d\n\n',n_chains);
+
+for i_chain = 1:n_chains
+
+    %//=====================================================//
+    %//== state_variable[i] (1 <= i <= n_state_variables) ==//
+    %//=====================================================//
+    fprintf(fh,'//== Number of states for state_variable[%d] ==//\n', ...
+            i_chain);
+    n_states = length(options.ms.ms_chain(i_chain).regime);
+    fprintf(fh,'%d\n\n',n_states);
+
+    %//== 03/15/06: DW TVBVAR code reads the data below and overwrite the prior data read somewhere else if any.
+    %//== Each column contains the parameters for a Dirichlet prior on the corresponding
+    %//== column of the transition matrix.  Each element must be positive.  For each column,
+    %//== the relative size of the prior elements determine the relative size of the elements
+    %//== of the transition matrix and overall larger sizes implies a tighter prior.
+    fprintf(fh,['//== Transition matrix prior for state_variable[%d] ==//\n'], ...
+            i_chain);
+    Alpha = ones(n_states,n_states);
+    for i_state = 1:n_states
+        p = 1-1/options.ms.ms_chain(i_chain).regime(i_state).duration;
+        Alpha(i_state,i_state) = p*(n_states-1)/(1-p);
+        fprintf(fh,'%22.16f',Alpha(i_state,:));
+        fprintf(fh,'\n');
+    end
+
+    fprintf(fh,['\n//== Dirichlet dimensions for state_variable[%d] ' ...
+                '==//\n'],i_chain);
+    %        fprintf(fh,'%d ',repmat(n_states,1,n_states));
+    fprintf(fh,'%d ',repmat(2,1,n_states));
+    fprintf(fh,'\n\n');
+
+    %//== The jth restriction matrix is n_states-by-free[j].  Each row of the restriction
+    %//== matrix has exactly one non-zero entry and the sum of each column must be one.
+    fprintf(fh,['//== Column restrictions for state_variable[%d] ' ...
+                '==//\n'],i_chain);
+    for i_state = 1:n_states
+        if i_state == 1
+            M = eye(n_states,2);
+        elseif i_state == n_states
+            M = [zeros(n_states-2,2); eye(2)];
+        else
+            M = zeros(n_states,2);
+            M(i_state+[-1 1],1) = ones(2,1)/2;
+            M(i_state,2) = 1;
+            disp(M)
+        end
+        for j_state = 1:n_states
+            fprintf(fh,'%f ',M(j_state,:));
+            fprintf(fh,'\n');
+        end
+        fprintf(fh,'\n');
+    end
+end
+
+%/******************************************************************************/
+%/******************************* VAR Parameters *******************************/
+%/******************************************************************************/
+%//NOT read
+fprintf(fh,'//== Number Variables ==//\n');
+fprintf(fh,'%d\n\n',nvars);
+
+%//NOT read
+fprintf(fh,'//== Number Lags ==//\n');
+fprintf(fh,'%d\n\n',options.ms.nlags);
+
+%//NOT read
+fprintf(fh,'//== Exogenous Variables ==//\n');
+fprintf(fh,'1\n\n');
+
+
+%//== nvar x n_state_variables matrix.  In the jth row, a non-zero value implies that
+%this state variable controls the jth column of A0 and Aplus
+fprintf(fh,['//== Controlling states variables for coefficients ==//\' ...
+            'n']);
+
+for i_var = 1:nvars
     for i_chain = 1:n_chains
-
-        %//=====================================================//
-        %//== state_variable[i] (1 <= i <= n_state_variables) ==//
-        %//=====================================================//
-        fprintf(fh,'//== Number of states for state_variable[%d] ==//\n', ...
-                i_chain);
-        n_states = length(options.ms.ms_chain(i_chain).regime);
-        fprintf(fh,'%d\n\n',n_states);
-
-        %//== 03/15/06: DW TVBVAR code reads the data below and overwrite the prior data read somewhere else if any.
-        %//== Each column contains the parameters for a Dirichlet prior on the corresponding
-        %//== column of the transition matrix.  Each element must be positive.  For each column,
-        %//== the relative size of the prior elements determine the relative size of the elements
-        %//== of the transition matrix and overall larger sizes implies a tighter prior.
-        fprintf(fh,['//== Transition matrix prior for state_variable[%d] ==//\n'], ...
-          i_chain);
-        Alpha = ones(n_states,n_states);
-        for i_state = 1:n_states
-            p = 1-1/options.ms.ms_chain(i_chain).regime(i_state).duration;
-            Alpha(i_state,i_state) = p*(n_states-1)/(1-p);
-            fprintf(fh,'%22.16f',Alpha(i_state,:));
-            fprintf(fh,'\n');
+        if ~isfield(options.ms.ms_chain(i_chain),'svar_coefficients') ...
+                || isempty(options.ms.ms_chain(i_chain).svar_coefficients)
+            i_equations = 0;
+        else
+            i_equations = ...
+                options.ms.ms_chain(i_chain).svar_coefficients.equations;
         end
- 
-        fprintf(fh,['\n//== Dirichlet dimensions for state_variable[%d] ' ...
-                    '==//\n'],i_chain);
-        %        fprintf(fh,'%d ',repmat(n_states,1,n_states));
-        fprintf(fh,'%d ',repmat(2,1,n_states));
-        fprintf(fh,'\n\n');
-
-        %//== The jth restriction matrix is n_states-by-free[j].  Each row of the restriction
-        %//== matrix has exactly one non-zero entry and the sum of each column must be one.
-        fprintf(fh,['//== Column restrictions for state_variable[%d] ' ...
-                    '==//\n'],i_chain);
-        for i_state = 1:n_states
-            if i_state == 1
-                M = eye(n_states,2);
-            elseif i_state == n_states
-                M = [zeros(n_states-2,2); eye(2)];
-            else
-                M = zeros(n_states,2);
-                M(i_state+[-1 1],1) = ones(2,1)/2;
-                M(i_state,2) = 1;
-                disp(M)
-            end
-            for j_state = 1:n_states
-                fprintf(fh,'%f ',M(j_state,:));
-                fprintf(fh,'\n');
-            end
-            fprintf(fh,'\n');
+        if strcmp(i_equations,'ALL') || any(i_equations == i_var)
+            fprintf(fh,'%d ',1);
+        else
+            fprintf(fh,'%d ',0);
         end
     end
+    fprintf(fh,'\n');
+end
 
-    %/******************************************************************************/
-    %/******************************* VAR Parameters *******************************/
-    %/******************************************************************************/
-    %//NOT read
-    fprintf(fh,'//== Number Variables ==//\n');
-    fprintf(fh,'%d\n\n',nvars);
-
-    %//NOT read
-    fprintf(fh,'//== Number Lags ==//\n');
-    fprintf(fh,'%d\n\n',options.ms.nlags);
-
-    %//NOT read
-    fprintf(fh,'//== Exogenous Variables ==//\n');
-    fprintf(fh,'1\n\n');
-
-
-    %//== nvar x n_state_variables matrix.  In the jth row, a non-zero value implies that
-    %this state variable controls the jth column of A0 and Aplus
-    fprintf(fh,['//== Controlling states variables for coefficients ==//\' ...
-                'n']);
-    
-    for i_var = 1:nvars
-        for i_chain = 1:n_chains
-            if ~isfield(options.ms.ms_chain(i_chain),'svar_coefficients') ...
-                    || isempty(options.ms.ms_chain(i_chain).svar_coefficients)
-                i_equations = 0;
-            else
-                i_equations = ...
-                    options.ms.ms_chain(i_chain).svar_coefficients.equations; 
-            end
-            if strcmp(i_equations,'ALL') || any(i_equations == i_var)
-                fprintf(fh,'%d ',1);
-            else
-                fprintf(fh,'%d ',0);
-            end
+%//== nvar x n_state_variables matrix.  In the jth row, a non-zero value implies that
+%this state variable controls the jth diagonal element of Xi
+fprintf(fh,'\n//== Controlling states variables for variance ==//\n');
+for i_var = 1:nvars
+    for i_chain = 1:n_chains
+        if ~isfield(options.ms.ms_chain(i_chain),'svar_variances') ...
+                || isempty(options.ms.ms_chain(i_chain).svar_variances)
+            i_equations = 0;
+        else
+            i_equations = ...
+                options.ms.ms_chain(i_chain).svar_variances.equations;
         end
-        fprintf(fh,'\n');
-    end
-
-    %//== nvar x n_state_variables matrix.  In the jth row, a non-zero value implies that
-    %this state variable controls the jth diagonal element of Xi
-    fprintf(fh,'\n//== Controlling states variables for variance ==//\n');
-    for i_var = 1:nvars
-        for i_chain = 1:n_chains
-            if ~isfield(options.ms.ms_chain(i_chain),'svar_variances') ...
-                    || isempty(options.ms.ms_chain(i_chain).svar_variances)
-                    i_equations = 0;
-            else
-                i_equations = ...
-                    options.ms.ms_chain(i_chain).svar_variances.equations; 
-            end
-            if strcmp(i_equations,'ALL') || any(i_equations == i_var)
-                fprintf(fh,'%d ',1);
-            else
-                fprintf(fh,'%d ',0);
-            end
+        if strcmp(i_equations,'ALL') || any(i_equations == i_var)
+            fprintf(fh,'%d ',1);
+        else
+            fprintf(fh,'%d ',0);
         end
-        fprintf(fh,'\n');
     end
+    fprintf(fh,'\n');
+end
 
-    fclose(fh);
+fclose(fh);
diff --git a/matlab/ms-sbvar/ms_write_mhm_input.m b/matlab/ms-sbvar/ms_write_mhm_input.m
index 57854d59a..26ec655cd 100644
--- a/matlab/ms-sbvar/ms_write_mhm_input.m
+++ b/matlab/ms-sbvar/ms_write_mhm_input.m
@@ -11,7 +11,7 @@ function ms_write_mhm_input(fname, options_ms)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,41 +28,41 @@ function ms_write_mhm_input(fname, options_ms)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    fh = fopen(fname,'w');
+fh = fopen(fname,'w');
 
 
-    fprintf(fh,'/**********************************************************\n');
-    fprintf(fh,' *** This input file is read by swzmsbvar_mhm_1 and swzmsbvar_mhm_1.exe only, NOT by swzmsbvar_printdraws.exe.\n');
-    fprintf(fh,' ***\n');
-    fprintf(fh,' **********************************************************/\n');
+fprintf(fh,'/**********************************************************\n');
+fprintf(fh,' *** This input file is read by swzmsbvar_mhm_1 and swzmsbvar_mhm_1.exe only, NOT by swzmsbvar_printdraws.exe.\n');
+fprintf(fh,' ***\n');
+fprintf(fh,' **********************************************************/\n');
 
-    fprintf(fh,'\n\n//------------- 1st set of posterior draws to find optimal scales for Metropolis (30000). ---------------\n');
-    fprintf(fh,'//== number draws for first burn-in ==//  //For determining the Metropolis scales only.\n');
-    fprintf(fh,'%d\n\n',options_ms.draws_nbr_burn_in_1);
+fprintf(fh,'\n\n//------------- 1st set of posterior draws to find optimal scales for Metropolis (30000). ---------------\n');
+fprintf(fh,'//== number draws for first burn-in ==//  //For determining the Metropolis scales only.\n');
+fprintf(fh,'%d\n\n',options_ms.draws_nbr_burn_in_1);
 
-    fprintf(fh,'//------------- MCMC burn-in draws once the Metropolis scales (previous stage) are fixed. --------------\n');
-    fprintf(fh,'//------------- 2nd set of standard burn-in posterior draws to throw away the initial draws (10000). ---------------\n');
-    fprintf(fh,'//== number draws for second burn-in ==//\n');
-    fprintf(fh,'%d\n\n',options_ms.draws_nbr_burn_in_2);
+fprintf(fh,'//------------- MCMC burn-in draws once the Metropolis scales (previous stage) are fixed. --------------\n');
+fprintf(fh,'//------------- 2nd set of standard burn-in posterior draws to throw away the initial draws (10000). ---------------\n');
+fprintf(fh,'//== number draws for second burn-in ==//\n');
+fprintf(fh,'%d\n\n',options_ms.draws_nbr_burn_in_2);
 
-    fprintf(fh,'//--------------- 1st set of posterior draws to compute the mean and variance for the weighting function in the MHM (200000) ----------------\n');
-    fprintf(fh,'//== number draws to estimate mean and variance ==//\n');
-    fprintf(fh,'%d\n\n',options_ms.draws_nbr_mean_var_estimate);
+fprintf(fh,'//--------------- 1st set of posterior draws to compute the mean and variance for the weighting function in the MHM (200000) ----------------\n');
+fprintf(fh,'//== number draws to estimate mean and variance ==//\n');
+fprintf(fh,'%d\n\n',options_ms.draws_nbr_mean_var_estimate);
 
-    fprintf(fh,'//--------------- Only applied to mhm_2 process: total number of MCMC draws = thinning factor * 2nd set of saved posterior draws ----------------\n');
-    fprintf(fh,'//== thinning factor for modified harmonic mean process ==//\n');
-    fprintf(fh,'%d\n\n',options_ms.thinning_factor);
+fprintf(fh,'//--------------- Only applied to mhm_2 process: total number of MCMC draws = thinning factor * 2nd set of saved posterior draws ----------------\n');
+fprintf(fh,'//== thinning factor for modified harmonic mean process ==//\n');
+fprintf(fh,'%d\n\n',options_ms.thinning_factor);
 
-    fprintf(fh,'//--------------- 2nd set of saved posterior draws from MHM_2 (second stage): saved draws AFTER thinning (1000000) ----------------\n');
-    fprintf(fh,'//== number draws for modified harmonic mean process ==//\n');
-    fprintf(fh,'%d\n\n',options_ms.draws_nbr_modified_harmonic_mean);
+fprintf(fh,'//--------------- 2nd set of saved posterior draws from MHM_2 (second stage): saved draws AFTER thinning (1000000) ----------------\n');
+fprintf(fh,'//== number draws for modified harmonic mean process ==//\n');
+fprintf(fh,'%d\n\n',options_ms.draws_nbr_modified_harmonic_mean);
 
-    fprintf(fh,'//------- 1st stage: computing all three tightness factors for Dirichlet.  ---------\n');
-    fprintf(fh,'//------- 2nd stage: hard-code the second scale factor (in principle, we can do all three). ---------\n');
-    fprintf(fh,'//------- It seems that Dan''s code only use the first element of the following scales.  The scale applies to the Dirichlet''s hyperparameter alpha for the diagonal of the transition matrix in the weighting function.  Note that the weighting function for the transition matrix parameters is Dirichlet. ---------\n');
-            
-    fprintf(fh,'//== scale values for Dirichlet distribution ==//\n');
-    fprintf(fh,'3\n\n');
-    fprintf(fh,'%f ',options_ms.dirichlet_scale);
-    fprintf(fh,'\n');
-    fclose(fh);
\ No newline at end of file
+fprintf(fh,'//------- 1st stage: computing all three tightness factors for Dirichlet.  ---------\n');
+fprintf(fh,'//------- 2nd stage: hard-code the second scale factor (in principle, we can do all three). ---------\n');
+fprintf(fh,'//------- It seems that Dan''s code only use the first element of the following scales.  The scale applies to the Dirichlet''s hyperparameter alpha for the diagonal of the transition matrix in the weighting function.  Note that the weighting function for the transition matrix parameters is Dirichlet. ---------\n');
+
+fprintf(fh,'//== scale values for Dirichlet distribution ==//\n');
+fprintf(fh,'3\n\n');
+fprintf(fh,'%f ',options_ms.dirichlet_scale);
+fprintf(fh,'\n');
+fclose(fh);
\ No newline at end of file
diff --git a/matlab/ms-sbvar/msstart2.m b/matlab/ms-sbvar/msstart2.m
index 6fa5861cd..d02a2338d 100644
--- a/matlab/ms-sbvar/msstart2.m
+++ b/matlab/ms-sbvar/msstart2.m
@@ -12,7 +12,7 @@
 %
 % February 2004
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -45,17 +45,17 @@ msstart_setup
 %options_.ms.Indxcol = [1:nvar];  % a vector of random columns in which MC draws are made.
 %
 %options_.ms.indxparr = 1;  % 1: parameters random;  0: no randomness in parameters
-               % Note, when 0, there is no effect from the values of options_.ms.IndxAp, options_.ms.Aband, etc.
+% Note, when 0, there is no effect from the values of options_.ms.IndxAp, options_.ms.Aband, etc.
 %options_.ms.indxovr = 0;   % 1: distributions for other variables of interest; 0: no distribution.
-               % Example:  joint distribution of a(1) and a(2).  Only for specific purposes
+% Example:  joint distribution of a(1) and a(2).  Only for specific purposes
 %options_.ms.Aband = 1;     % 1: error bands with only A0 and A+ random.
 %options_.ms.IndxAp = 1;    % 1: generate draws of A+; 0: no such draws.
-               % Note: when options_.ms.IndxAp=0, there is no effect from the values of options_.ms.options_.ms.options_.ms.options_.ms.indximf, IndxFore,
-               %         or options_.ms.apband.
+% Note: when options_.ms.IndxAp=0, there is no effect from the values of options_.ms.options_.ms.options_.ms.options_.ms.indximf, IndxFore,
+%         or options_.ms.apband.
 %options_.ms.apband = 1;    % 1: error bands for A+; 0: no error bands for A+.
 %*** The following (impulse responses and forecasts) is used only if options_.ms.IndxAp=1
 %options_.ms.indximf = 1;   % 1: generate draws of impulse responses; 0: no such draws (thus no effect
-               %      from options_.ms.imfband)
+%      from options_.ms.imfband)
 %options_.ms.imfband = 1;   % 1: error bands for impulse responses; 0: no error bands
 %options_.ms.indxfore = 0;  % 1: generate draws of forecasts; 0: no such draws (thus no effect from options_.ms.foreband)
 %options_.ms.foreband = 0;  % 1: error bands for out-of-sample forecasts; 0: no error bands
@@ -64,23 +64,23 @@ msstart_setup
 rnum = nvar;      % number of rows in the graph
 cnum = 1;      % number of columns in the graph
 if rnum*cnum<nvar
-   warning('rnum*cnum must be at least as large as nvar')
-   disp('Hit any key to continue, or ctrl-c to abort')
-   pause
+    warning('rnum*cnum must be at least as large as nvar')
+    disp('Hit any key to continue, or ctrl-c to abort')
+    pause
 end
 %options_.ms.indxgimfhat = 1;  % 1: plot ML impulse responses; 0: no plot
 %options_.ms.indxestima = 1;  %1: ML estimation; 0: no estimation and data only
 %
 IndxNmlr = [1 0 0 0 0 0];  % imported by nmlzvar.m
-    % Index for which normalization rule to choose
-    % Only one of the elments in IndxNmlr can be non-zero
-    % IndxNmlr(1): ML A distance rule (supposed to be the best)
-    % IndxNmlr(2): ML Ahat distance rule (to approximate IndxNmlr(1))
-    % IndxNmlr(3): ML Euclidean distance rule (not invariant to scale)
-    % IndxNmlr(4): Positive diagonal rule
-    % IndxNmlr(5): Positive inv(A) diagonal rule (if ~IndxNmlr(5), no need for A0inu,
-    %                                      so let A0inu=[])
-    % IndxNmlr(6): Assigned postive rule (such as off-diagonal elements).  Added 1/3/00
+                           % Index for which normalization rule to choose
+                           % Only one of the elments in IndxNmlr can be non-zero
+                           % IndxNmlr(1): ML A distance rule (supposed to be the best)
+                           % IndxNmlr(2): ML Ahat distance rule (to approximate IndxNmlr(1))
+                           % IndxNmlr(3): ML Euclidean distance rule (not invariant to scale)
+                           % IndxNmlr(4): Positive diagonal rule
+                           % IndxNmlr(5): Positive inv(A) diagonal rule (if ~IndxNmlr(5), no need for A0inu,
+                           %                                      so let A0inu=[])
+                           % IndxNmlr(6): Assigned postive rule (such as off-diagonal elements).  Added 1/3/00
 
 
 %%%%----------------------------------------
@@ -90,7 +90,7 @@ IndxNmlr = [1 0 0 0 0 0];  % imported by nmlzvar.m
 nconstr1=nfqm;      % number of the 1st set of constraints
 nconstr2=options_.forecast ;     % number of the 2nd set of constraints
 nconstr=nconstr1+nconstr2;   % q: 4 years -- 4*12 months.
-                         % When 0, no conditions directly on variables <<>>
+                             % When 0, no conditions directly on variables <<>>
 nconstr=0 ;  %6*nconstr1;
 options_.ms.eq_ms = [];      % location of MS equation; if [], all shocks
 PorR = [4*ones(nconstr1,1);2*ones(nconstr1,1);3*ones(nconstr1,1)];   % the variable conditioned.  1: Pcm; 3: FFR; 4: CPI
@@ -102,32 +102,32 @@ PorR = [PorR;1*ones(nconstr1,1);5*ones(nconstr1,1);6*ones(nconstr1,1)];
 % Conditions directly on future shocks
 %
 %options_.ms.cms = 0     % 1: condition on ms shocks; 0: disable this and "fidcnderr.m" gives
-             %   unconditional forecasts if nconstr = 0 as well;  <<>>
+%   unconditional forecasts if nconstr = 0 as well;  <<>>
 %options_.ms.ncms = 0;   % number of the stance of policy; 0 if no tightening or loosening
 %options_.ms.eq_cms = 1;  % location of MS shocks
 options_.ms.tlindx = 1*ones(1,options_.ms.ncms);  % 1-by-options_.ms.ncms vector; 1: tightening; 0: loosen
 options_.ms.tlnumber = [0.5 0.5 0 0];  %94:4 % [2 2 1.5 1.5]; %79:9  %[1.5 1.5 1 1]; 90:9
-                          % 1-by-options_.ms.ncms vector; cut-off point for MS shocks
+                                       % 1-by-options_.ms.ncms vector; cut-off point for MS shocks
 TLmean = zeros(1,options_.ms.ncms);
-              % unconditional, i.e., 0 mean, for the final report in the paper
+% unconditional, i.e., 0 mean, for the final report in the paper
 if options_.ms.cms
-   options_.ms.eq_ms = [];
-   % At least at this point, it makes no sense to have DLS type of options_.ms.eq_ms; 10/12/98
-   if all(isfinite(options_.ms.tlnumber))
-      for k=1:options_.ms.ncms
-         TLmean(k) = lcnmean(options_.ms.tlnumber(k),options_.ms.tlindx(k));
-                      % shock mean magnitude. 1: tight; 0: loose
-                      % Never used for any subsequent computation but
-                      %   simply used for the final report in the paper.
-         %options_.ms.tlnumber(k) = fzero('lcutoff',0,[],[],TLmean(k))
-                % get an idea about the cutoff point given TLmean instead
+    options_.ms.eq_ms = [];
+    % At least at this point, it makes no sense to have DLS type of options_.ms.eq_ms; 10/12/98
+    if all(isfinite(options_.ms.tlnumber))
+        for k=1:options_.ms.ncms
+            TLmean(k) = lcnmean(options_.ms.tlnumber(k),options_.ms.tlindx(k));
+            % shock mean magnitude. 1: tight; 0: loose
+            % Never used for any subsequent computation but
+            %   simply used for the final report in the paper.
+            %options_.ms.tlnumber(k) = fzero('lcutoff',0,[],[],TLmean(k))
+            % get an idea about the cutoff point given TLmean instead
 
-      end
-   end
+        end
+    end
 else
-   options_.ms.ncms = 0;   % only for the use of the graph by msprobg.m
-   options_.ms.tlnumber = NaN*ones(1,options_.ms.ncms);
-               % -infinity, only for the use of the graph by msprobg.m
+    options_.ms.ncms = 0;   % only for the use of the graph by msprobg.m
+    options_.ms.tlnumber = NaN*ones(1,options_.ms.ncms);
+    % -infinity, only for the use of the graph by msprobg.m
 end
 
 
@@ -135,22 +135,22 @@ end
 % Soft conditions on variables
 %
 %cnum = 0  % # of band condtions; when 0, disable this option
-  % Note (different from "fidencon") that each condition corres. to variable
+% Note (different from "fidencon") that each condition corres. to variable
 %options_.ms.banact = 1;    % 1: use infor on actual; 0:  preset without infor on actual
 if cnum
-   banindx = cell(cnum,1);  % index for each variable or conditon
-   banstp = cell(cnum,1);    % steps:  annual in general
-   banvar = zeros(cnum,1);    % varables:  annual in general
-   banval = cell(cnum,1);    % band value (each variable occupy a cell)
-   badval{1} = zeros(length(banstp{1}),2);   % 2: lower or higher bound
+    banindx = cell(cnum,1);  % index for each variable or conditon
+    banstp = cell(cnum,1);    % steps:  annual in general
+    banvar = zeros(cnum,1);    % varables:  annual in general
+    banval = cell(cnum,1);    % band value (each variable occupy a cell)
+    badval{1} = zeros(length(banstp{1}),2);   % 2: lower or higher bound
 
-   banstp{1} = 1:4;      % 3 or 4 years
-   banvar(1) = 3;      % 3: FFR; 5: CPI
-   if ~options_.ms.banact
-      for i=1:length(banstp{1})
-         banval{1}(i,:) = [5.0 10.0];
-      end
-   end
+    banstp{1} = 1:4;      % 3 or 4 years
+    banvar(1) = 3;      % 3: FFR; 5: CPI
+    if ~options_.ms.banact
+        for i=1:length(banstp{1})
+            banval{1}(i,:) = [5.0 10.0];
+        end
+    end
 end
 %
 pause(1)
@@ -171,60 +171,60 @@ pause(1)
 %(1)--------------------------------------
 %
 if (options_.ms.freq==12)
-   nStart=(yrStart-options_.ms.initial_year )*12+qmStart-options_.ms.initial_subperiod ;  % positive number of months at the start
-   nEnd=(yrEnd-options_.ms.final_year )*12+qmEnd-options_.ms.final_subperiod ;     % negative number of months towards end
+    nStart=(yrStart-options_.ms.initial_year )*12+qmStart-options_.ms.initial_subperiod ;  % positive number of months at the start
+    nEnd=(yrEnd-options_.ms.final_year )*12+qmEnd-options_.ms.final_subperiod ;     % negative number of months towards end
 elseif (options_.ms.freq==4)
-   nStart=(yrStart-options_.ms.initial_year )*4+qmStart-options_.ms.initial_subperiod ;  % positive number of months at the start
-   nEnd=(yrEnd-options_.ms.final_year )*4+qmEnd-options_.ms.final_subperiod ;     % negative number of months towards end
+    nStart=(yrStart-options_.ms.initial_year )*4+qmStart-options_.ms.initial_subperiod ;  % positive number of months at the start
+    nEnd=(yrEnd-options_.ms.final_year )*4+qmEnd-options_.ms.final_subperiod ;     % negative number of months towards end
 elseif (options_.ms.freq==1)
-   nStart=(yrStart-options_.ms.initial_year )*1+qmStart-options_.ms.initial_subperiod ;  % positive number of months at the start
-   nEnd=(yrEnd-options_.ms.final_year )*1+qmEnd-options_.ms.final_subperiod ;     % negative number of months towards end
+    nStart=(yrStart-options_.ms.initial_year )*1+qmStart-options_.ms.initial_subperiod ;  % positive number of months at the start
+    nEnd=(yrEnd-options_.ms.final_year )*1+qmEnd-options_.ms.final_subperiod ;     % negative number of months towards end
 else
-   error('Error: this code is only good for monthly/quarterly/yearly data!!!')
-   return
+    error('Error: this code is only good for monthly/quarterly/yearly data!!!')
+    return
 end
 %
 if nEnd>0 || nStart<0
-   disp('Warning: this particular sample consider is out of bounds of the data!!!')
-   return
+    disp('Warning: this particular sample consider is out of bounds of the data!!!')
+    return
 end
 %***  Note, both xdgel and xdata have the same start with the specific sample
 xdgel=options_.data(nStart+1:nData+nEnd,options_.ms.vlist);
-      % gel: general options_.data within sample (nSample)
+% gel: general options_.data within sample (nSample)
 if ~(nSample==size(xdgel,1))
-   warning('The sample size (including options_.ms.nlags ) and data are incompatible')
-   disp('Check to make sure nSample and size(xdgel,1) are the same')
-   return
+    warning('The sample size (including options_.ms.nlags ) and data are incompatible')
+    disp('Check to make sure nSample and size(xdgel,1) are the same')
+    return
 end
 %
 baddata = find(isnan(xdgel));
 if ~isempty(baddata)
-   warning('Some data for this selected sample are actually unavailable.')
-   disp('Hit any key to continue, or ctrl-c to abort')
-   pause
+    warning('Some data for this selected sample are actually unavailable.')
+    disp('Hit any key to continue, or ctrl-c to abort')
+    pause
 end
 %
 if options_.ms.initial_subperiod ==1
-   yrB = options_.ms.initial_year ; qmB = options_.ms.initial_subperiod ;
+    yrB = options_.ms.initial_year ; qmB = options_.ms.initial_subperiod ;
 else
-   yrB = options_.ms.initial_year +1; qmB = 1;
+    yrB = options_.ms.initial_year +1; qmB = 1;
 end
 yrF = options_.ms.final_year ; qmF = options_.ms.final_subperiod ;
 [Mdate,tmp] = fn_calyrqm(options_.ms.freq,[options_.ms.initial_year  options_.ms.initial_subperiod ],[options_.ms.final_year options_.ms.final_subperiod ]);
 xdatae=[Mdate options_.data(1:nData,options_.ms.vlist)];
-      % beyond sample into forecast horizon until the end of the data options_.ms.final_year :options_.ms.final_subperiod 
-      % Note: may contain NaN data.  So must be careful about its use
+% beyond sample into forecast horizon until the end of the data options_.ms.final_year :options_.ms.final_subperiod
+% Note: may contain NaN data.  So must be careful about its use
 
 %=========== Obtain prior-period, period-to-last period, and annual growth rates
 [yactyrge,yactyre,yactqmyge,yactqmge,yactqme] = fn_datana(xdatae,options_.ms.freq,options_.ms.log_var,options_.ms.percent_var,[yrB qmB],[yrF qmF]);
 qdates = zeros(size(yactqmyge,1),1);
 for ki=1:length(qdates)
-   qdates(ki) = yactqmyge(1,1) + (yactqmyge(1,2)+ki-2)/options_.ms.freq;
+    qdates(ki) = yactqmyge(1,1) + (yactqmyge(1,2)+ki-2)/options_.ms.freq;
 end
 for ki=1:nvar
-   figure
-   plot(qdates, yactqmyge(:,2+ki)/100)
-   xlabel(options_.ms.varlist{ki})
+    figure
+    plot(qdates, yactqmyge(:,2+ki)/100)
+    xlabel(options_.ms.varlist{ki})
 end
 save outactqmygdata.prn yactqmyge -ascii
 
@@ -236,11 +236,11 @@ spstr1 = 'disp([sprintf(';
 spstr2 = '%4.0f %2.0f';
 yactyrget=yactyrge';
 for ki=1:length(options_.ms.vlist)
-   if ki==length(options_.ms.vlist)
-      spstr2 = [spstr2 ' %8.3f\n'];
-   else
-      spstr2 = [spstr2 ' %8.3f'];
-   end
+    if ki==length(options_.ms.vlist)
+        spstr2 = [spstr2 ' %8.3f\n'];
+    else
+        spstr2 = [spstr2 ' %8.3f'];
+    end
 end
 spstr = [spstr1 'spstr2' ', yactyrget)])'];
 eval(spstr)
@@ -251,11 +251,11 @@ fid = fopen('outyrqm.prn','w');
 fpstr1 = 'fprintf(fid,';
 fpstr2 = '%4.0f %2.0f';
 for ki=1:nvar
-   if ki==nvar
-      fpstr2 = [fpstr2 ' %8.3f\n'];
-   else
-      fpstr2 = [fpstr2 ' %8.3f'];
-   end
+    if ki==nvar
+        fpstr2 = [fpstr2 ' %8.3f\n'];
+    else
+        fpstr2 = [fpstr2 ' %8.3f'];
+    end
 end
 fpstr = [fpstr1 'fpstr2' ', yactyrget);'];
 eval(fpstr)
@@ -264,479 +264,479 @@ fclose(fid);
 
 
 if options_.ms.indxestima
-   %(2)----------------------------------------------------------------------------
-   % Estimation
-   % ML forecast and impulse responses
-   % Hard or soft conditions for conditional forecasts
-   %(2)----------------------------------------------------------------------------
-   %
-   %* Arranged data information, WITHOUT dummy obs when 0 after mu is used.  See fn_rnrprior_covres_dobs.m for using the dummy
-   %    observations as part of an explicit prior.
-   [xtx,xty,yty,fss,phi,y,ncoef,xr,Bh] = fn_dataxy(nvar,options_.ms.nlags ,xdgel,mu,0,nexo);
-   if qmStart+options_.ms.nlags -options_.ms.dummy_obs >0
-      qmStartEsti = rem(qmStart+options_.ms.nlags -options_.ms.dummy_obs ,options_.ms.freq);   % dummy observations are included in the sample.
-      if (~qmStartEsti)
-         qmStartEsti = options_.ms.freq;
-      end
-      yrStartEsti = yrStart + floor((qmStart+options_.ms.nlags -options_.ms.dummy_obs )/(options_.ms.freq+0.01));
+    %(2)----------------------------------------------------------------------------
+    % Estimation
+    % ML forecast and impulse responses
+    % Hard or soft conditions for conditional forecasts
+    %(2)----------------------------------------------------------------------------
+    %
+    %* Arranged data information, WITHOUT dummy obs when 0 after mu is used.  See fn_rnrprior_covres_dobs.m for using the dummy
+    %    observations as part of an explicit prior.
+    [xtx,xty,yty,fss,phi,y,ncoef,xr,Bh] = fn_dataxy(nvar,options_.ms.nlags ,xdgel,mu,0,nexo);
+    if qmStart+options_.ms.nlags -options_.ms.dummy_obs >0
+        qmStartEsti = rem(qmStart+options_.ms.nlags -options_.ms.dummy_obs ,options_.ms.freq);   % dummy observations are included in the sample.
+        if (~qmStartEsti)
+            qmStartEsti = options_.ms.freq;
+        end
+        yrStartEsti = yrStart + floor((qmStart+options_.ms.nlags -options_.ms.dummy_obs )/(options_.ms.freq+0.01));
         % + 0.01 (or any number < 1)  is used so that qmStart+options_.ms.nlags -options_.ms.dummy_obs ==?*options_.ms.freq doesn't give us an extra year forward.
-   else
-      qmStartEsti = options_.ms.freq + rem(qmStart+options_.ms.nlags -options_.ms.dummy_obs ,options_.ms.freq);   % dummy observations are included in the sample.
-      if (qmStart+options_.ms.nlags -options_.ms.dummy_obs ==0)
-         yrStartEsti = yrStart - 1;   % one year back.
-      else
-         yrStartEsti = yrStart + floor((qmStart+options_.ms.nlags -options_.ms.dummy_obs )/(options_.ms.freq-0.01));
-        % - 0.01 (or any number < 1)  is used so that qmStart+options_.ms.nlags -options_.ms.dummy_obs ==-?*options_.ms.freq give us an extra year back.
-      end
-   end
-   dateswd = fn_dataext([yrStartEsti qmStartEsti],[yrEnd qmEnd],xdatae(:,[1:2]));  % dates with dummies
-   phie = [dateswd phi];
-   ye = [dateswd y];
+    else
+        qmStartEsti = options_.ms.freq + rem(qmStart+options_.ms.nlags -options_.ms.dummy_obs ,options_.ms.freq);   % dummy observations are included in the sample.
+        if (qmStart+options_.ms.nlags -options_.ms.dummy_obs ==0)
+            yrStartEsti = yrStart - 1;   % one year back.
+        else
+            yrStartEsti = yrStart + floor((qmStart+options_.ms.nlags -options_.ms.dummy_obs )/(options_.ms.freq-0.01));
+            % - 0.01 (or any number < 1)  is used so that qmStart+options_.ms.nlags -options_.ms.dummy_obs ==-?*options_.ms.freq give us an extra year back.
+        end
+    end
+    dateswd = fn_dataext([yrStartEsti qmStartEsti],[yrEnd qmEnd],xdatae(:,[1:2]));  % dates with dummies
+    phie = [dateswd phi];
+    ye = [dateswd y];
 
-   %* Obtain linear restrictions
-   [Uiconst,Viconst,n0,np,ixmC0Pres] = feval(options_.ms.restriction_fname,nvar,nexo,options_.ms );
-   if min(n0)==0
-      skipline()
-      warning('A0: restrictions in dlrprior.m give no free parameter in one of equations')
-      disp('Press ctrl-c to abort')
-      pause
-   elseif min(np)==0
-      skipline()
-      warning('Ap: Restrictions in dlrprior.m give no free parameter in one of equations')
-      disp('Press ctrl-c to abort')
-      pause
-   end
+    %* Obtain linear restrictions
+    [Uiconst,Viconst,n0,np,ixmC0Pres] = feval(options_.ms.restriction_fname,nvar,nexo,options_.ms );
+    if min(n0)==0
+        skipline()
+        warning('A0: restrictions in dlrprior.m give no free parameter in one of equations')
+        disp('Press ctrl-c to abort')
+        pause
+    elseif min(np)==0
+        skipline()
+        warning('Ap: Restrictions in dlrprior.m give no free parameter in one of equations')
+        disp('Press ctrl-c to abort')
+        pause
+    end
 
-   if options_.ms.contemp_reduced_form 
-      Uiconst=cell(nvar,1); Viconst=cell(ncoef,1);
-      for kj=1:nvar
-         Uiconst{kj} = eye(nvar);  Viconst{kj} = eye(ncoef);
-      end
-   end
+    if options_.ms.contemp_reduced_form
+        Uiconst=cell(nvar,1); Viconst=cell(ncoef,1);
+        for kj=1:nvar
+            Uiconst{kj} = eye(nvar);  Viconst{kj} = eye(ncoef);
+        end
+    end
 
-   if options_.ms.bayesian_prior 
-      %*** Obtains asymmetric prior (with no linear restrictions) with dummy observations as part of an explicit prior (i.e,
-      %      reflected in Hpmulti and Hpinvmulti).  See Forecast II, pp.69a-69b for details.
-      if 1  % Liquidity effect prior on both MS and MD equations.
-         [Pi,H0multi,Hpmulti,H0invmulti,Hpinvmulti] = fn_rnrprior_covres_dobs(nvar,options_.ms.freq,options_.ms.nlags ,xdgel,mu,indxDummy,hpmsmd,indxmsmdeqn);
-      else
-         [Pi,H0multi,Hpmulti,H0invmulti,Hpinvmulti] = fn_rnrprior(nvar,options_.ms.freq,options_.ms.nlags ,xdgel,mu);
-      end
+    if options_.ms.bayesian_prior
+        %*** Obtains asymmetric prior (with no linear restrictions) with dummy observations as part of an explicit prior (i.e,
+        %      reflected in Hpmulti and Hpinvmulti).  See Forecast II, pp.69a-69b for details.
+        if 1  % Liquidity effect prior on both MS and MD equations.
+            [Pi,H0multi,Hpmulti,H0invmulti,Hpinvmulti] = fn_rnrprior_covres_dobs(nvar,options_.ms.freq,options_.ms.nlags ,xdgel,mu,indxDummy,hpmsmd,indxmsmdeqn);
+        else
+            [Pi,H0multi,Hpmulti,H0invmulti,Hpinvmulti] = fn_rnrprior(nvar,options_.ms.freq,options_.ms.nlags ,xdgel,mu);
+        end
 
-      %*** Combines asymmetric prior with linear restrictions
-      [Ptld,H0invtld,Hpinvtld] = fn_rlrprior(Uiconst,Viconst,Pi,H0multi,Hpmulti,nvar);
+        %*** Combines asymmetric prior with linear restrictions
+        [Ptld,H0invtld,Hpinvtld] = fn_rlrprior(Uiconst,Viconst,Pi,H0multi,Hpmulti,nvar);
 
-      %*** Obtains the posterior matrices for estimation and inference
-      [Pmat,H0inv,Hpinv] = fn_rlrpostr(xtx,xty,yty,Ptld,H0invtld,Hpinvtld,Uiconst,Viconst);
+        %*** Obtains the posterior matrices for estimation and inference
+        [Pmat,H0inv,Hpinv] = fn_rlrpostr(xtx,xty,yty,Ptld,H0invtld,Hpinvtld,Uiconst,Viconst);
 
-      if options_.ms.contemp_reduced_form 
-         %*** Obtain the ML estimate
-         A0hatinv = chol(H0inv{1}/fss);   % upper triangular but lower triangular choleski
-         A0hat=inv(A0hatinv);
-         a0indx = find(A0hat);
-      else
-         %*** Obtain the ML estimate
-         %   load idenml
-         x = 10*rand(sum(n0),1);
-         H0 = eye(sum(n0));
-         crit = 1.0e-9;
-         nit = 10000;
-         %
-         [fhat,xhat,grad,Hhat,itct,fcount,retcodehat] = ...
-               csminwel('fn_a0freefun',x,H0,'fn_a0freegrad',crit,nit,Uiconst,nvar,n0,fss,H0inv);
+        if options_.ms.contemp_reduced_form
+            %*** Obtain the ML estimate
+            A0hatinv = chol(H0inv{1}/fss);   % upper triangular but lower triangular choleski
+            A0hat=inv(A0hatinv);
+            a0indx = find(A0hat);
+        else
+            %*** Obtain the ML estimate
+            %   load idenml
+            x = 10*rand(sum(n0),1);
+            H0 = eye(sum(n0));
+            crit = 1.0e-9;
+            nit = 10000;
+            %
+            [fhat,xhat,grad,Hhat,itct,fcount,retcodehat] = ...
+                csminwel('fn_a0freefun',x,H0,'fn_a0freegrad',crit,nit,Uiconst,nvar,n0,fss,H0inv);
 
-         A0hat = fn_tran_b2a(xhat,Uiconst,nvar,n0)
-         A0hatinv = inv(A0hat);
-         fhat
-         xhat
-         grad
-         itct
-         fcount
-         retcodehat
-         save outm.mat xhat A0hat A0hatinv grad fhat itct itct fcount retcodehat
-      end
-   else
-      %*** Obtain the posterior matrices for estimation and inference
-      [Pmat,H0inv,Hpinv] = fn_dlrpostr(xtx,xty,yty,Uiconst,Viconst);
+            A0hat = fn_tran_b2a(xhat,Uiconst,nvar,n0)
+            A0hatinv = inv(A0hat);
+            fhat
+            xhat
+            grad
+            itct
+            fcount
+            retcodehat
+            save outm.mat xhat A0hat A0hatinv grad fhat itct itct fcount retcodehat
+        end
+    else
+        %*** Obtain the posterior matrices for estimation and inference
+        [Pmat,H0inv,Hpinv] = fn_dlrpostr(xtx,xty,yty,Uiconst,Viconst);
 
-      if options_.ms.contemp_reduced_form 
-         %*** Obtain the ML estimate
-         A0hatinv = chol(H0inv{1}/fss);   % upper triangular but lower triangular choleski
-         A0hat=inv(A0hatinv);
-         a0indx = find(A0hat);
-      else
-         %*** Obtain the ML estimate
-         %   load idenml
-         x = 10*rand(sum(n0),1);
-         H0 = eye(sum(n0));
-         crit = 1.0e-9;
-         nit = 10000;
-         %
-         [fhat,xhat,grad,Hhat,itct,fcount,retcodehat] = ...
-               csminwel('fn_a0freefun',x,H0,'fn_a0freegrad',crit,nit,Uiconst,nvar,n0,fss,H0inv);
+        if options_.ms.contemp_reduced_form
+            %*** Obtain the ML estimate
+            A0hatinv = chol(H0inv{1}/fss);   % upper triangular but lower triangular choleski
+            A0hat=inv(A0hatinv);
+            a0indx = find(A0hat);
+        else
+            %*** Obtain the ML estimate
+            %   load idenml
+            x = 10*rand(sum(n0),1);
+            H0 = eye(sum(n0));
+            crit = 1.0e-9;
+            nit = 10000;
+            %
+            [fhat,xhat,grad,Hhat,itct,fcount,retcodehat] = ...
+                csminwel('fn_a0freefun',x,H0,'fn_a0freegrad',crit,nit,Uiconst,nvar,n0,fss,H0inv);
 
-         A0hat = fn_tran_b2a(xhat,Uiconst,nvar,n0)
-         A0hatinv = inv(A0hat);
-         fhat
-         xhat
-         grad
-         itct
-         fcount
-         retcodehat
-         save outm.mat xhat A0hat A0hatinv grad fhat itct itct fcount retcodehat
-      end
-   end
+            A0hat = fn_tran_b2a(xhat,Uiconst,nvar,n0)
+            A0hatinv = inv(A0hat);
+            fhat
+            xhat
+            grad
+            itct
+            fcount
+            retcodehat
+            save outm.mat xhat A0hat A0hatinv grad fhat itct itct fcount retcodehat
+        end
+    end
 
-   %**** impulse responses
-   swish = A0hatinv;       % each column corresponds to an equation
-   if options_.ms.contemp_reduced_form 
-      xhat = A0hat(a0indx);
-      Bhat=Pmat{1};
-      Fhat = Bhat*A0hat
-      ghat = NaN;
-   else
-      xhat = fn_tran_a2b(A0hat,Uiconst,nvar,n0);
-      [Fhat,ghat] = fn_gfmean(xhat,Pmat,Viconst,nvar,ncoef,n0,np);
-      if options_.ms.cross_restrictions 
-         Fhatur0P = Fhat;  % ur: unrestriced across A0 and A+
-         for ki = 1:size(ixmC0Pres,1)   % loop through the number of equations in which
-                     % cross-A0-A+ restrictions occur. See St. Louis Note p.5.
-            ixeq = ixmC0Pres{ki}(1,1);   % index for the jth equation in consideration.
-            Lit = Viconst{ixeq}(ixmC0Pres{ki}(:,2),:);  % transposed restriction matrix Li
-                     % V_j(i,:) in f_j(i) = V_j(i,:)*g_j
-            ci = ixmC0Pres{ki}(:,4) .* A0hat(ixmC0Pres{ki}(:,3),ixeq);
-                     % s * a_j(h) in the restriction f_j(i) = s * a_j(h).
-            LtH = Lit/Hpinv{ixeq};
-            HLV = LtH'/(LtH*Lit');
-            gihat = Viconst{ixeq}'*Fhatur0P(:,ixeq);
-            Fhat(:,ixeq) = Viconst{ixeq}*(gihat + HLV*(ci-Lit*gihat));
-         end
-      end
-      Fhat
-      Bhat = Fhat/A0hat;   % ncoef-by-nvar reduced form lagged parameters.
-   end
-   nn = [nvar options_.ms.nlags  imstp];
-   imfhat = fn_impulse(Bhat,swish,nn);    % in the form that is congenial to RATS
-   imf3hat=reshape(imfhat,size(imfhat,1),nvar,nvar);
-            % imf3: row--steps, column--nvar responses, 3rd dimension--nvar shocks
-   imf3shat=permute(imf3hat,[1 3 2]);
-            % imf3s: permuted so that row--steps, column--nvar shocks,
-            %                                3rd dimension--nvar responses
-            % Note: reshape(imf3s(1,:,:),nvar,nvar) = A0in  (columns -- equations)
-   if options_.ms.indxgimfhat
-      figure
-   end
-   scaleout = fn_imcgraph(imfhat,nvar,imstp,xlab,ylab,options_.ms.indxgimfhat);
-   imfstd = max(abs(scaleout)');   % row: nvar (largest number); used for standard deviations
+    %**** impulse responses
+    swish = A0hatinv;       % each column corresponds to an equation
+    if options_.ms.contemp_reduced_form
+        xhat = A0hat(a0indx);
+        Bhat=Pmat{1};
+        Fhat = Bhat*A0hat
+        ghat = NaN;
+    else
+        xhat = fn_tran_a2b(A0hat,Uiconst,nvar,n0);
+        [Fhat,ghat] = fn_gfmean(xhat,Pmat,Viconst,nvar,ncoef,n0,np);
+        if options_.ms.cross_restrictions
+            Fhatur0P = Fhat;  % ur: unrestriced across A0 and A+
+            for ki = 1:size(ixmC0Pres,1)   % loop through the number of equations in which
+                                           % cross-A0-A+ restrictions occur. See St. Louis Note p.5.
+                ixeq = ixmC0Pres{ki}(1,1);   % index for the jth equation in consideration.
+                Lit = Viconst{ixeq}(ixmC0Pres{ki}(:,2),:);  % transposed restriction matrix Li
+                                                            % V_j(i,:) in f_j(i) = V_j(i,:)*g_j
+                ci = ixmC0Pres{ki}(:,4) .* A0hat(ixmC0Pres{ki}(:,3),ixeq);
+                % s * a_j(h) in the restriction f_j(i) = s * a_j(h).
+                LtH = Lit/Hpinv{ixeq};
+                HLV = LtH'/(LtH*Lit');
+                gihat = Viconst{ixeq}'*Fhatur0P(:,ixeq);
+                Fhat(:,ixeq) = Viconst{ixeq}*(gihat + HLV*(ci-Lit*gihat));
+            end
+        end
+        Fhat
+        Bhat = Fhat/A0hat;   % ncoef-by-nvar reduced form lagged parameters.
+    end
+    nn = [nvar options_.ms.nlags  imstp];
+    imfhat = fn_impulse(Bhat,swish,nn);    % in the form that is congenial to RATS
+    imf3hat=reshape(imfhat,size(imfhat,1),nvar,nvar);
+    % imf3: row--steps, column--nvar responses, 3rd dimension--nvar shocks
+    imf3shat=permute(imf3hat,[1 3 2]);
+    % imf3s: permuted so that row--steps, column--nvar shocks,
+    %                                3rd dimension--nvar responses
+    % Note: reshape(imf3s(1,:,:),nvar,nvar) = A0in  (columns -- equations)
+    if options_.ms.indxgimfhat
+        figure
+    end
+    scaleout = fn_imcgraph(imfhat,nvar,imstp,xlab,ylab,options_.ms.indxgimfhat);
+    imfstd = max(abs(scaleout)');   % row: nvar (largest number); used for standard deviations
 
-   %
-   %  %**** save stds. of both data and impulse responses in idfile1
-   %  temp = [std(yactqmyge(:,3:end)); std(yactyrge(:,3:end)); imfstd];  %<<>>
-   %  save idenyimstd.prn temp -ascii   % export forecast and impulse response to the file "idenyimstd.prn", 3-by-nvar
-   %  %
-   %  %**** save stds. of both data and impulse responses in idfile1
-   %  temp = [std(yactqmyge(:,3:end)); std(yactyrge(:,3:end)); imfstd];  %<<>>
-   %  save idenyimstd.prn temp -ascii   % export forecast and impulse response to the file "idenyimstd.prn", 3-by-nvar
-   %  if options_.ms.indxparr
-   %     idfile1='idenyimstd';
-   %  end
+    %
+    %  %**** save stds. of both data and impulse responses in idfile1
+    %  temp = [std(yactqmyge(:,3:end)); std(yactyrge(:,3:end)); imfstd];  %<<>>
+    %  save idenyimstd.prn temp -ascii   % export forecast and impulse response to the file "idenyimstd.prn", 3-by-nvar
+    %  %
+    %  %**** save stds. of both data and impulse responses in idfile1
+    %  temp = [std(yactqmyge(:,3:end)); std(yactyrge(:,3:end)); imfstd];  %<<>>
+    %  save idenyimstd.prn temp -ascii   % export forecast and impulse response to the file "idenyimstd.prn", 3-by-nvar
+    %  if options_.ms.indxparr
+    %     idfile1='idenyimstd';
+    %  end
 
-   %=====================================
-   % Now, out-of-sample forecasts. Note: Hm1t does not change with A0.
-   %=====================================
-   %
-   % * updating the last row of X (phi) with the current (last row of) y.
-   tcwx = nvar*options_.ms.nlags ;  % total coefficeint without exogenous variables
-   phil = phi(size(phi,1),:);
-   phil(nvar+1:tcwx) = phil(1:tcwx-nvar);
-   phil(1:nvar) = y(end,:);
-   %*** exogenous variables excluding constant terms
-   if (nexo>1)
-      Xexoe = fn_dataext([yrEnd qmEnd],[yrEnd qmEnd],xdatae(:,[1:2 2+nvar+1:2+nvar+nexo-1]));
-      phil(1,tcwx+1:tcwx+nexo-1) = Xexoe(1,3:end);
-   end
-   %
-   %*** ML unconditional point forecast
-   nn = [nvar options_.ms.nlags  nfqm];
-   if nexo<2
-      yforehat = fn_forecast(Bhat,phil,nn);    % nfqm-by-nvar, in log
-   else
-      Xfexoe = fn_dataext(fdates(1,:),fdates(numel(fdates),:),xdatae(:,[1:2 2+nvar+1:2+nvar+nexo-1]));
-      %Xfexoe = fn_dataext(fdates(1,:),fdates(end,:),xdatae(:,[1:2 2+nvar+1:2+nvar+nexo-1]));
-      yforehat = fn_forecast(Bhat,phil,nn,nexo,Xfexoe(:,3:end));    % nfqm-by-nvar, in log
-   end
-   yforehate = [fdates yforehat];
-   %
-   yact1e = fn_dataext([yrEnd-nayr 1],[yrEnd qmEnd],xdatae(:,1:nvar+2));
-   if options_.ms.real_pseudo_forecast
-      %yact2e = fn_dataext([yrEnd-nayr 1],E2yrqm,xdatae);
-      yact2e = fn_dataext([yrEnd-nayr 1],[fdates(end,1) options_.ms.freq],xdatae(:,1:nvar+2));
-   else
-      yact2e=yact1e;
-   end
-   yafhate = [yact1e; yforehate];  % actual and forecast
-   %
-   %===== Converted to mg, qg, and calendar yg
-   %
-   [yafyrghate,yafyrhate,yafqmyghate] = fn_datana(yafhate,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
-                  % actual and forecast growth rates
-   [yact2yrge,yact2yre,yact2qmyge] = fn_datana(yact2e,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
-                  % only actual growth rates
-   yafyrghate
-   if options_.ms.indxgforhat
-      keyindx = [1:nvar];
-      conlab=['unconditional'];
+    %=====================================
+    % Now, out-of-sample forecasts. Note: Hm1t does not change with A0.
+    %=====================================
+    %
+    % * updating the last row of X (phi) with the current (last row of) y.
+    tcwx = nvar*options_.ms.nlags ;  % total coefficeint without exogenous variables
+    phil = phi(size(phi,1),:);
+    phil(nvar+1:tcwx) = phil(1:tcwx-nvar);
+    phil(1:nvar) = y(end,:);
+    %*** exogenous variables excluding constant terms
+    if (nexo>1)
+        Xexoe = fn_dataext([yrEnd qmEnd],[yrEnd qmEnd],xdatae(:,[1:2 2+nvar+1:2+nvar+nexo-1]));
+        phil(1,tcwx+1:tcwx+nexo-1) = Xexoe(1,3:end);
+    end
+    %
+    %*** ML unconditional point forecast
+    nn = [nvar options_.ms.nlags  nfqm];
+    if nexo<2
+        yforehat = fn_forecast(Bhat,phil,nn);    % nfqm-by-nvar, in log
+    else
+        Xfexoe = fn_dataext(fdates(1,:),fdates(numel(fdates),:),xdatae(:,[1:2 2+nvar+1:2+nvar+nexo-1]));
+        %Xfexoe = fn_dataext(fdates(1,:),fdates(end,:),xdatae(:,[1:2 2+nvar+1:2+nvar+nexo-1]));
+        yforehat = fn_forecast(Bhat,phil,nn,nexo,Xfexoe(:,3:end));    % nfqm-by-nvar, in log
+    end
+    yforehate = [fdates yforehat];
+    %
+    yact1e = fn_dataext([yrEnd-nayr 1],[yrEnd qmEnd],xdatae(:,1:nvar+2));
+    if options_.ms.real_pseudo_forecast
+        %yact2e = fn_dataext([yrEnd-nayr 1],E2yrqm,xdatae);
+        yact2e = fn_dataext([yrEnd-nayr 1],[fdates(end,1) options_.ms.freq],xdatae(:,1:nvar+2));
+    else
+        yact2e=yact1e;
+    end
+    yafhate = [yact1e; yforehate];  % actual and forecast
+                                    %
+                                    %===== Converted to mg, qg, and calendar yg
+                                    %
+    [yafyrghate,yafyrhate,yafqmyghate] = fn_datana(yafhate,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
+    % actual and forecast growth rates
+    [yact2yrge,yact2yre,yact2qmyge] = fn_datana(yact2e,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
+    % only actual growth rates
+    yafyrghate
+    if options_.ms.indxgforhat
+        keyindx = [1:nvar];
+        conlab=['unconditional'];
 
-      figure
-      yafyrghate(:,3:end) = yafyrghate(:,3:end)/100;
-      yact2yrge(:,3:end) = yact2yrge(:,3:end)/100;
-      fn_foregraph(yafyrghate,yact2yrge,keyindx,rnum,cnum,options_.ms.freq,ylab,forelabel,conlab)
-   end
+        figure
+        yafyrghate(:,3:end) = yafyrghate(:,3:end)/100;
+        yact2yrge(:,3:end) = yact2yrge(:,3:end)/100;
+        fn_foregraph(yafyrghate,yact2yrge,keyindx,rnum,cnum,options_.ms.freq,ylab,forelabel,conlab)
+    end
 
-   %-------------------------------------------------
-   % Setup for point conditional forecast
-   % ML Conditional Forecast
-   %-------------------------------------------------
-   %
-   %% See Zha's note "Forecast (1)" p. 5, RATS manual (some errors in RATS), etc.
-   %
-   %% Some notations:  y(t+1) = y(t)B1 + e(t+1)inv(A0). e(t+1) is 1-by-n.
-   %%    Let r(t+1)=e(t+1)inv(A0) + e(t+2)C + .... where inv(A0) is impulse
-   %%          response at t=1, C at t=2, etc. The row of inv(A0) or C is
-   %%          all responses to one shock.
-   %%    Let r be q-by-1 (such as r(1) = r(t+1)
-   %%                 = y(t+1) (constrained) - y(t+1) (forecast)).
-   %%    Use impulse responses to find out R (k-by-q) where k=nvar*nsteps
-   %%        where nsteps the largest constrained step.  The key of the program
-   %%        is to creat R using impulse responses
-   %%    Optimal solution for shock e where R'*e=r and e is k-by-1 is
-   %%                 e = R*inv(R'*R)*r.
-   %
+    %-------------------------------------------------
+    % Setup for point conditional forecast
+    % ML Conditional Forecast
+    %-------------------------------------------------
+    %
+    %% See Zha's note "Forecast (1)" p. 5, RATS manual (some errors in RATS), etc.
+    %
+    %% Some notations:  y(t+1) = y(t)B1 + e(t+1)inv(A0). e(t+1) is 1-by-n.
+    %%    Let r(t+1)=e(t+1)inv(A0) + e(t+2)C + .... where inv(A0) is impulse
+    %%          response at t=1, C at t=2, etc. The row of inv(A0) or C is
+    %%          all responses to one shock.
+    %%    Let r be q-by-1 (such as r(1) = r(t+1)
+    %%                 = y(t+1) (constrained) - y(t+1) (forecast)).
+    %%    Use impulse responses to find out R (k-by-q) where k=nvar*nsteps
+    %%        where nsteps the largest constrained step.  The key of the program
+    %%        is to creat R using impulse responses
+    %%    Optimal solution for shock e where R'*e=r and e is k-by-1 is
+    %%                 e = R*inv(R'*R)*r.
+    %
 
-   if (nconstr > 0)
-      %*** initializing
-      stepcon=cell(nconstr,1);  % initializing, value y conditioned
-      valuecon=zeros(nconstr,1);  % initializing, value y conditioned
-      varcon=zeros(nconstr,1);  % initializing, endogous variables conditioned
-      varcon(:)=PorR;     % 1: Pcm; 3: FFR; 5: CPI
+    if (nconstr > 0)
+        %*** initializing
+        stepcon=cell(nconstr,1);  % initializing, value y conditioned
+        valuecon=zeros(nconstr,1);  % initializing, value y conditioned
+        varcon=zeros(nconstr,1);  % initializing, endogous variables conditioned
+        varcon(:)=PorR;     % 1: Pcm; 3: FFR; 5: CPI
 
-      %
-      for i=1:nconstr
-         if i<=nconstr1
-            stepcon{i}=i;      % FFR
-         elseif i<=2*nconstr1
-            stepcon{i}=i-nconstr1;      % FFR
-         elseif i<=3*nconstr1
-            stepcon{i}=i-2*nconstr1;      % FFR
-         elseif i<=4*nconstr1
-            stepcon{i}=i-3*nconstr1;      % FFR
-         elseif i<=5*nconstr1
-            stepcon{i}=i-4*nconstr1;      % FFR
-         elseif i<=6*nconstr1
-            stepcon{i}=i-5*nconstr1;      % FFR
-         end
-      end
-
-%      for i=1:nconstr
-%         stepcon{i}=i;      % FFR
-%      end
-
-%      bend=12;
-%      stepcon{1}=[1:bend]'; % average over
-%      stepcon{nconstr1+1}=[1:options_.ms.freq-qmSub]';  % average over the remaing months in 1st forecast year
-%      stepcon{nconstr1+2}=[options_.ms.freq-qmSub+1:options_.ms.freq-qmSub+12]';    % average over 12 months next year
-%      stepcon{nconstr1+3}=[options_.ms.freq-qmSub+13:options_.ms.freq-qmSub+24]';    % average over 12 months. 3rd year
-%      stepcon{nconstr1+4}=[options_.ms.freq-qmSub+25:options_.ms.freq-qmSub+36]';    % average over 12 months. 4th year
-
-%      %**** avearage condition over, say, options_.ms.freq periods
-%      if qmEnd==options_.ms.freq
-%         stepcon{1}=[1:options_.ms.freq]';  % average over the remaing periods in 1st forecast year
-%      else
-%         stepcon{1}=[1:options_.ms.freq-qmEnd]';  % average over the remaing periods in 1st forecast year
-%      end
-%      for kj=2:nconstr
-%         stepcon{kj}=[length(stepcon{kj-1})+1:length(stepcon{kj-1})+options_.ms.freq]';    % average over 12 months next year
-%      end
-
-      if options_.ms.real_pseudo_forecast
-%         %*** conditions in every period
-%         for i=1:nconstr
-%            valuecon(i) = yact(actup+i,varcon(i));
-%            %valuecon(i) = mean( yact(actup+1:actup+bend,varcon(i)) );
-%            %valuecon(i) = 0.060;      % 95:01
-%            %valuecon(i) = (0.0475+0.055)/2;   % 94:10
-%         end
-
-%         %*** average condtions over,say, options_.ms.freq periods.
-%         for i=nconstr1+1:nconstr1+nconstr2
-%            i=1;
-%            valuecon(nconstr1+i) = ( ( mean(ylast12Cal(:,varcon(nconstr1+i)),1) + ...
-%                 log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100) )*options_.ms.freq - ...
-%                 yCal_1(:,varcon(nconstr1+i)) ) ./ length(stepcon{nconstr1+i});
-%                             % the same as unconditional "yactCalyg" 1st calendar year
-%            i=2;
-%            valuecon(nconstr1+i) = mean(ylast12Cal(:,varcon(nconstr1+i))) +  ...
-%                 log(1+yactCalyg(yAg-yFg+1,varcon(nconstr1+i))/100) ...
-%                                + log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100);
-%                                    % the same as actual "yactCalgy" 2nd calendar year
-%            i=3;
-%            valuecon(nconstr1+i) = valuecon(nconstr1+i-1) + ...
-%                                        log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100);
-%                                    % the same as actual "yactCalgy" 3rd calendar year
-%            %i=4;
-%            %valuecon(nconstr1+i) = valuecon(nconstr1+i-1) + ...
-%            %                            log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100);
-%                                    % the same as actual "yactCalgy" 4th calendar year
-%         end
-
-         %*** conditions in every period
-         vpntM = fn_dataext(E1yrqm, E2yrqm,xdatae); % point value matrix with dates
-         %     vaveM = fn_dataext([yrEnd+1 0],[yrEnd+options_.forecast  0],yact2yre); % average value matrix with dates
-         for i=1:nconstr
+        %
+        for i=1:nconstr
             if i<=nconstr1
-               valuecon(i) = vpntM(i,2+varcon(i)); % 2: first 2 elements are dates
+                stepcon{i}=i;      % FFR
             elseif i<=2*nconstr1
-               valuecon(i) = vpntM(i-nconstr1,2+varcon(i));
+                stepcon{i}=i-nconstr1;      % FFR
             elseif i<=3*nconstr1
-               valuecon(i) = vpntM(i-2*nconstr1,2+varcon(i));
+                stepcon{i}=i-2*nconstr1;      % FFR
             elseif i<=4*nconstr1
-               valuecon(i) = vpntM(i-3*nconstr1,2+varcon(i));
+                stepcon{i}=i-3*nconstr1;      % FFR
             elseif i<=5*nconstr1
-               valuecon(i) = vpntM(i-4*nconstr1,2+varcon(i));
+                stepcon{i}=i-4*nconstr1;      % FFR
             elseif i<=6*nconstr1
-               valuecon(i) = vpntM(i-5*nconstr1,2+varcon(i));
+                stepcon{i}=i-5*nconstr1;      % FFR
             end
-         end
+        end
 
-%         %*** average condtions over,say, options_.ms.freq periods.
-%         if qmEnd==options_.ms.freq
-%            vaveM = fn_dataext([yrEnd+1 0],[yrEnd+options_.forecast  0],yact2yre); % average value matrix with dates
-%            valuecon(1) = vaveM(1,2+varcon(1));  % 2: first 2 elements are dates
-%         else
-%            vaveM = fn_dataext([yrEnd 0],[yrEnd+options_.forecast  0],yact2yre); % average value matrix with dates
-%            yactrem = fn_dataext([yrEnd qmEnd+1],[yrEnd options_.ms.freq],xdatae);
-%            valuecon(1) = sum(yactrem(:,2+varcon(1)),1)/length(stepcon{1});
-%                                    % 2: first 2 elements are dates
-%         end
-%         for kj=2:nconstr
-%            valuecon(kj) = vaveM(kj,2+varcon(kj));  % 2: first 2 elements are dates
-%         end
-      else
-         vpntM = dataext([yrEnd qmEnd+1],[yrEnd qmEnd+2],xdatae); % point value matrix with dates
-         for i=1:nconstr
-            if i<=nconstr1
-               valuecon(i) = vpntM(i,2+varcon(i)); % 2: first 2 elements are dates; Poil
-            elseif i<=2*nconstr1
-               valuecon(i) = vpntM(i-nconstr1,2+varcon(i)); % 2: first 2 elements are dates; M2
-            elseif i<=3*nconstr1
-               valuecon(i) = vpntM(i-2*nconstr1,2+varcon(i)); % 2: first 2 elements are dates; FFR
-            elseif i<=4*nconstr1
-               valuecon(i) = vpntM(i-3*nconstr1,2+varcon(i)); % 2: first 2 elements are dates; CPI
-            elseif i<=5*nconstr1
-               valuecon(i) = vpntM(i-4*nconstr1,2+varcon(i)); % 2: first 2 elements are dates; U
-            elseif i<=5*nconstr1+nconstr2
-               valuecon(i)=xdata(end,5)+(i-5*nconstr1)*log(1.001)/options_.ms.freq;  %CPI
-            elseif i<=5*nconstr1+2*nconstr2
-               valuecon(i)=0.0725;  %FFR
-            else
-               valuecon(i)=xdata(end,6)+(i-5*nconstr1-2*nconstr2)*0.01/nfqm;  %U
+        %      for i=1:nconstr
+        %         stepcon{i}=i;      % FFR
+        %      end
+
+        %      bend=12;
+        %      stepcon{1}=[1:bend]'; % average over
+        %      stepcon{nconstr1+1}=[1:options_.ms.freq-qmSub]';  % average over the remaing months in 1st forecast year
+        %      stepcon{nconstr1+2}=[options_.ms.freq-qmSub+1:options_.ms.freq-qmSub+12]';    % average over 12 months next year
+        %      stepcon{nconstr1+3}=[options_.ms.freq-qmSub+13:options_.ms.freq-qmSub+24]';    % average over 12 months. 3rd year
+        %      stepcon{nconstr1+4}=[options_.ms.freq-qmSub+25:options_.ms.freq-qmSub+36]';    % average over 12 months. 4th year
+
+        %      %**** avearage condition over, say, options_.ms.freq periods
+        %      if qmEnd==options_.ms.freq
+        %         stepcon{1}=[1:options_.ms.freq]';  % average over the remaing periods in 1st forecast year
+        %      else
+        %         stepcon{1}=[1:options_.ms.freq-qmEnd]';  % average over the remaing periods in 1st forecast year
+        %      end
+        %      for kj=2:nconstr
+        %         stepcon{kj}=[length(stepcon{kj-1})+1:length(stepcon{kj-1})+options_.ms.freq]';    % average over 12 months next year
+        %      end
+
+        if options_.ms.real_pseudo_forecast
+            %         %*** conditions in every period
+            %         for i=1:nconstr
+            %            valuecon(i) = yact(actup+i,varcon(i));
+            %            %valuecon(i) = mean( yact(actup+1:actup+bend,varcon(i)) );
+            %            %valuecon(i) = 0.060;      % 95:01
+            %            %valuecon(i) = (0.0475+0.055)/2;   % 94:10
+            %         end
+
+            %         %*** average condtions over,say, options_.ms.freq periods.
+            %         for i=nconstr1+1:nconstr1+nconstr2
+            %            i=1;
+            %            valuecon(nconstr1+i) = ( ( mean(ylast12Cal(:,varcon(nconstr1+i)),1) + ...
+            %                 log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100) )*options_.ms.freq - ...
+            %                 yCal_1(:,varcon(nconstr1+i)) ) ./ length(stepcon{nconstr1+i});
+            %                             % the same as unconditional "yactCalyg" 1st calendar year
+            %            i=2;
+            %            valuecon(nconstr1+i) = mean(ylast12Cal(:,varcon(nconstr1+i))) +  ...
+            %                 log(1+yactCalyg(yAg-yFg+1,varcon(nconstr1+i))/100) ...
+            %                                + log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100);
+            %                                    % the same as actual "yactCalgy" 2nd calendar year
+            %            i=3;
+            %            valuecon(nconstr1+i) = valuecon(nconstr1+i-1) + ...
+            %                                        log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100);
+            %                                    % the same as actual "yactCalgy" 3rd calendar year
+            %            %i=4;
+            %            %valuecon(nconstr1+i) = valuecon(nconstr1+i-1) + ...
+            %            %                            log(1+yactCalyg(yAg-yFg+i,varcon(nconstr1+i))/100);
+            %                                    % the same as actual "yactCalgy" 4th calendar year
+            %         end
+
+            %*** conditions in every period
+            vpntM = fn_dataext(E1yrqm, E2yrqm,xdatae); % point value matrix with dates
+                                                       %     vaveM = fn_dataext([yrEnd+1 0],[yrEnd+options_.forecast  0],yact2yre); % average value matrix with dates
+            for i=1:nconstr
+                if i<=nconstr1
+                    valuecon(i) = vpntM(i,2+varcon(i)); % 2: first 2 elements are dates
+                elseif i<=2*nconstr1
+                    valuecon(i) = vpntM(i-nconstr1,2+varcon(i));
+                elseif i<=3*nconstr1
+                    valuecon(i) = vpntM(i-2*nconstr1,2+varcon(i));
+                elseif i<=4*nconstr1
+                    valuecon(i) = vpntM(i-3*nconstr1,2+varcon(i));
+                elseif i<=5*nconstr1
+                    valuecon(i) = vpntM(i-4*nconstr1,2+varcon(i));
+                elseif i<=6*nconstr1
+                    valuecon(i) = vpntM(i-5*nconstr1,2+varcon(i));
+                end
             end
-         end
-         %valuecon(i) = 0.060;      % 95:01
-      end
-   else
-      valuecon = [];
-      stepcon = [];
-      varcon = [];
-   end
 
-   nstepsm = 0;   % initializing, the maximum step in all constraints
-   for i=1:nconstr
-      nstepsm = max([nstepsm max(stepcon{i})]);
-   end
+            %         %*** average condtions over,say, options_.ms.freq periods.
+            %         if qmEnd==options_.ms.freq
+            %            vaveM = fn_dataext([yrEnd+1 0],[yrEnd+options_.forecast  0],yact2yre); % average value matrix with dates
+            %            valuecon(1) = vaveM(1,2+varcon(1));  % 2: first 2 elements are dates
+            %         else
+            %            vaveM = fn_dataext([yrEnd 0],[yrEnd+options_.forecast  0],yact2yre); % average value matrix with dates
+            %            yactrem = fn_dataext([yrEnd qmEnd+1],[yrEnd options_.ms.freq],xdatae);
+            %            valuecon(1) = sum(yactrem(:,2+varcon(1)),1)/length(stepcon{1});
+            %                                    % 2: first 2 elements are dates
+            %         end
+            %         for kj=2:nconstr
+            %            valuecon(kj) = vaveM(kj,2+varcon(kj));  % 2: first 2 elements are dates
+            %         end
+        else
+            vpntM = dataext([yrEnd qmEnd+1],[yrEnd qmEnd+2],xdatae); % point value matrix with dates
+            for i=1:nconstr
+                if i<=nconstr1
+                    valuecon(i) = vpntM(i,2+varcon(i)); % 2: first 2 elements are dates; Poil
+                elseif i<=2*nconstr1
+                    valuecon(i) = vpntM(i-nconstr1,2+varcon(i)); % 2: first 2 elements are dates; M2
+                elseif i<=3*nconstr1
+                    valuecon(i) = vpntM(i-2*nconstr1,2+varcon(i)); % 2: first 2 elements are dates; FFR
+                elseif i<=4*nconstr1
+                    valuecon(i) = vpntM(i-3*nconstr1,2+varcon(i)); % 2: first 2 elements are dates; CPI
+                elseif i<=5*nconstr1
+                    valuecon(i) = vpntM(i-4*nconstr1,2+varcon(i)); % 2: first 2 elements are dates; U
+                elseif i<=5*nconstr1+nconstr2
+                    valuecon(i)=xdata(end,5)+(i-5*nconstr1)*log(1.001)/options_.ms.freq;  %CPI
+                elseif i<=5*nconstr1+2*nconstr2
+                    valuecon(i)=0.0725;  %FFR
+                else
+                    valuecon(i)=xdata(end,6)+(i-5*nconstr1-2*nconstr2)*0.01/nfqm;  %U
+                end
+            end
+            %valuecon(i) = 0.060;      % 95:01
+        end
+    else
+        valuecon = [];
+        stepcon = [];
+        varcon = [];
+    end
 
-   if cnum
-      if options_.ms.real_pseudo_forecast && options_.ms.banact
-         for i=1:length(banstp{1})
-            banval{1}(1:length(banstp{1}),1) = ...
-                yactCalyg(yAg-yFg+1:yAg-yFg+length(banstp{1}),banvar(1)) - 2;
-            banval{1}(1:length(banstp{1}),2) = ...
-                yactCalyg(yAg-yFg+1:yAg-yFg+length(banstp{1}),banvar(1)) + 2;
-         end
-      end
-   end
+    nstepsm = 0;   % initializing, the maximum step in all constraints
+    for i=1:nconstr
+        nstepsm = max([nstepsm max(stepcon{i})]);
+    end
+
+    if cnum
+        if options_.ms.real_pseudo_forecast && options_.ms.banact
+            for i=1:length(banstp{1})
+                banval{1}(1:length(banstp{1}),1) = ...
+                    yactCalyg(yAg-yFg+1:yAg-yFg+length(banstp{1}),banvar(1)) - 2;
+                banval{1}(1:length(banstp{1}),2) = ...
+                    yactCalyg(yAg-yFg+1:yAg-yFg+length(banstp{1}),banvar(1)) + 2;
+            end
+        end
+    end
 
 
-   %===================================================
-   % ML conditional forecast
-   %===================================================
-   %/*
-   [ychat,Estr,rcon] = fn_fcstidcnd(valuecon,stepcon,varcon,nstepsm,...
-            nconstr,options_.ms.eq_ms,nvar,options_.ms.nlags ,phil,0,0,yforehat,imf3shat,A0hat,Bhat,...
-            nfqm,options_.ms.tlindx,options_.ms.tlnumber,options_.ms.ncms,options_.ms.eq_cms);
-   ychate = [fdates ychat];
-   yachate = [yact1e; ychate];  % actual and condtional forecast
-   %===== Converted to mg, qg, and calendar yg
-   [yacyrghate,yacyrhate,yacqmyghate] = fn_datana(yachate,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
-                         % actual and conditional forecast growth rates
-   if options_.ms.indxgdls && nconstr
-      keyindx = [1:nvar];
-      %  conlab=['conditional on' ylab{PorR(1)}];
-      conlab=['v-conditions'];
+    %===================================================
+    % ML conditional forecast
+    %===================================================
+    %/*
+    [ychat,Estr,rcon] = fn_fcstidcnd(valuecon,stepcon,varcon,nstepsm,...
+                                     nconstr,options_.ms.eq_ms,nvar,options_.ms.nlags ,phil,0,0,yforehat,imf3shat,A0hat,Bhat,...
+                                     nfqm,options_.ms.tlindx,options_.ms.tlnumber,options_.ms.ncms,options_.ms.eq_cms);
+    ychate = [fdates ychat];
+    yachate = [yact1e; ychate];  % actual and condtional forecast
+                                 %===== Converted to mg, qg, and calendar yg
+    [yacyrghate,yacyrhate,yacqmyghate] = fn_datana(yachate,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
+    % actual and conditional forecast growth rates
+    if options_.ms.indxgdls && nconstr
+        keyindx = [1:nvar];
+        %  conlab=['conditional on' ylab{PorR(1)}];
+        conlab=['v-conditions'];
 
-      figure
-      fn_foregraph(yafyrghate,yact2yrge,keyindx,rnum,cnum,options_.ms.freq,ylab,forelabel,conlab)
-   end
+        figure
+        fn_foregraph(yafyrghate,yact2yrge,keyindx,rnum,cnum,options_.ms.freq,ylab,forelabel,conlab)
+    end
 
-   if options_.ms.ncsk
-      Estr = zeros(nfqm,nvar);
-      Estr(1:2,:) = [
-         -2.1838      -1.5779      0.53064    -0.099425     -0.69269      -1.0391
-         1.9407       3.3138     -0.10563     -0.55457     -0.68772       1.3534
-                     ];
-      Estr(3:6,3) = [0.5*ones(1,4)]';     % MD shocks
+    if options_.ms.ncsk
+        Estr = zeros(nfqm,nvar);
+        Estr(1:2,:) = [
+            -2.1838      -1.5779      0.53064    -0.099425     -0.69269      -1.0391
+            1.9407       3.3138     -0.10563     -0.55457     -0.68772       1.3534
+                      ];
+        Estr(3:6,3) = [0.5*ones(1,4)]';     % MD shocks
 
-      Estr(3:10,2) = [1.5 1.5 1.5*ones(1,6)]';    % MS shocks
+        Estr(3:10,2) = [1.5 1.5 1.5*ones(1,6)]';    % MS shocks
 
-      %Estr(3:6,6) = 1*ones(4,1);      % U shocks
-      %Estr(8:11,4) = 1*ones(4,1);      % y shocks
+        %Estr(3:6,6) = 1*ones(4,1);      % U shocks
+        %Estr(8:11,4) = 1*ones(4,1);      % y shocks
 
-      %Estr(3:10,2) = [2.5 2.5 1.5*ones(1,6)]';    % MS shocks alone
+        %Estr(3:10,2) = [2.5 2.5 1.5*ones(1,6)]';    % MS shocks alone
 
-      nn = [nvar options_.ms.noptions_.ms.nlags  nfqm];
-      ycEhat = forefixe(A0hat,Bhat,phil,nn,Estr);
-      ycEhate = [fdates ycEhat];
-      yacEhate = [yact1e; ycEhate];  % actual and condtional forecast
-      %===== Converted to mg, qg, and calendar yg
-      [yacEyrghate,yacEyrhate,yacEqmyghate] = datana(yacEhate,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
-                           % actual and conditional forecast growth rates
-      disp([sprintf('%4.0f %2.0f %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f\n',yacEyrghate')])
+        nn = [nvar options_.ms.noptions_.ms.nlags  nfqm];
+        ycEhat = forefixe(A0hat,Bhat,phil,nn,Estr);
+        ycEhate = [fdates ycEhat];
+        yacEhate = [yact1e; ycEhate];  % actual and condtional forecast
+                                       %===== Converted to mg, qg, and calendar yg
+        [yacEyrghate,yacEyrhate,yacEqmyghate] = datana(yacEhate,options_.ms.freq,options_.ms.log_var(1:nlogeno),options_.ms.percent_var(1:npereno));
+        % actual and conditional forecast growth rates
+        disp([sprintf('%4.0f %2.0f %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f\n',yacEyrghate')])
 
-      if 1
-         keyindx = [1:nvar];
-         %  conlab=['conditional on' ylab{PorR(1)}];
-         conlab=['shock-conditions'];
+        if 1
+            keyindx = [1:nvar];
+            %  conlab=['conditional on' ylab{PorR(1)}];
+            conlab=['shock-conditions'];
 
-         figure
-         gyrfore(yacEyrghate,yact2yrge,keyindx,rnum,cnum,ylab,forelabel,conlab)
-      end
-   end
+            figure
+            gyrfore(yacEyrghate,yact2yrge,keyindx,rnum,cnum,ylab,forelabel,conlab)
+        end
+    end
 
-   %-----------------------------------------------------------
-   % Compute structural shocks for the whole sample period excluding dummy observations.
-   %-----------------------------------------------------------
-   ywod = y(options_.ms.dummy_obs +1:end,:);     % without dummy observations
-   phiwod=phi(options_.ms.dummy_obs +1:end,:);    % without dummy observations
-   eplhat=ywod*A0hat-phiwod*Fhat;
-   qmStartWod = mod(qmStart+options_.ms.nlags ,options_.ms.freq);
-   if (~qmStartWod)
-      qmStartWod = options_.ms.freq;
-   end
-   yrStartWod = yrStart + floor((qmStart+options_.ms.nlags -1)/options_.ms.freq);
-   dateswod = fn_dataext([yrStartWod qmStartWod],[yrEnd qmEnd],xdatae(:,[1:2]));
-   eplhate = [dateswod eplhat];
+    %-----------------------------------------------------------
+    % Compute structural shocks for the whole sample period excluding dummy observations.
+    %-----------------------------------------------------------
+    ywod = y(options_.ms.dummy_obs +1:end,:);     % without dummy observations
+    phiwod=phi(options_.ms.dummy_obs +1:end,:);    % without dummy observations
+    eplhat=ywod*A0hat-phiwod*Fhat;
+    qmStartWod = mod(qmStart+options_.ms.nlags ,options_.ms.freq);
+    if (~qmStartWod)
+        qmStartWod = options_.ms.freq;
+    end
+    yrStartWod = yrStart + floor((qmStart+options_.ms.nlags -1)/options_.ms.freq);
+    dateswod = fn_dataext([yrStartWod qmStartWod],[yrEnd qmEnd],xdatae(:,[1:2]));
+    eplhate = [dateswod eplhat];
 
-   Aphat = Fhat;
+    Aphat = Fhat;
 end
 
 %----------------------------------------
@@ -745,11 +745,11 @@ end
 %   from different idfile's.
 %----------------------------------------
 %
-%if ~options_.ms.contemp_reduced_form 
+%if ~options_.ms.contemp_reduced_form
 %   SpHR=A0in'*A0in;
 %end
 %%
-%if ~isnan(SpHR) && ~options_.ms.contemp_reduced_form 
+%if ~isnan(SpHR) && ~options_.ms.contemp_reduced_form
 %   warning(' ')
 %   disp('Make sure you run the program with options_.ms.contemp_reduced_form =1 first.')
 %   disp('Otherwise, the following test results such as Schwartz are incorrect.')
diff --git a/matlab/ms-sbvar/msstart_setup.m b/matlab/ms-sbvar/msstart_setup.m
index 37b6e27e9..b32b92da4 100644
--- a/matlab/ms-sbvar/msstart_setup.m
+++ b/matlab/ms-sbvar/msstart_setup.m
@@ -1,6 +1,6 @@
 %function []= msstart_setup(options_)
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -26,14 +26,14 @@
 % Exordium I
 %===========================================
 format short g     % format
-%
-%options_.ms.freq = 4;   % quarters or months
-%options_.ms.initial_year=1959;   % beginning of the year
-%options_.ms.initial_subperiod=1;    % begining of the quarter or month
-%options_.ms.final_year=2005;   % final year
-%options_.ms.final_subperiod=4;    % final month or quarter
+                   %
+                   %options_.ms.freq = 4;   % quarters or months
+                   %options_.ms.initial_year=1959;   % beginning of the year
+                   %options_.ms.initial_subperiod=1;    % begining of the quarter or month
+                   %options_.ms.final_year=2005;   % final year
+                   %options_.ms.final_subperiod=4;    % final month or quarter
 nData=(options_.ms.final_year-options_.ms.initial_year)*options_.ms.freq + (options_.ms.final_subperiod-options_.ms.initial_subperiod+1);
-       % total number of the available data -- this is all you have
+% total number of the available data -- this is all you have
 
 %*** Load data and series
 %load datainf_argen.prn      % the default name for the variable is "options_.ms.data".
@@ -61,19 +61,19 @@ nvar = length(options_.varobs);   % number of endogenous variables
 nlogeno = length(options_.ms.log_var);  % number of endogenous variables in options_.ms.log_var
 npereno = length(options_.ms.percent_var);  % number of endogenous variables in options_.ms.percent_var
 if (nvar~=(nlogeno+npereno))
-   skipline()
-   warning('Check xlab, nlogeno or npereno to make sure of endogenous variables in options_.ms.vlist')
-   disp('Press ctrl-c to abort')
-   return
+    skipline()
+    warning('Check xlab, nlogeno or npereno to make sure of endogenous variables in options_.ms.vlist')
+    disp('Press ctrl-c to abort')
+    return
 elseif (nvar==length(options_.ms.vlist))
-   nexo=1;    % only constants as an exogenous variable.  The default setting.
+    nexo=1;    % only constants as an exogenous variable.  The default setting.
 elseif (nvar<length(options_.ms.vlist))
-   nexo=length(options_.ms.vlist)-nvar+1;
+    nexo=length(options_.ms.vlist)-nvar+1;
 else
-   skipline()
-   warning('Make sure there are only nvar endogenous variables in options_.ms.vlist')
-   disp('Press ctrl-c to abort')
-   return
+    skipline()
+    warning('Make sure there are only nvar endogenous variables in options_.ms.vlist')
+    disp('Press ctrl-c to abort')
+    return
 end
 
 
@@ -84,24 +84,24 @@ yrEnd=options_.ms.final_year;
 qmEnd=options_.ms.final_subperiod;
 %options_.forecast = 4;   % number of years for forecasting
 if options_.forecast<1
-   error('To be safe, the number of forecast years should be at least 1')
+    error('To be safe, the number of forecast years should be at least 1')
 end
 forelabel = [num2str(yrEnd) ':' num2str(qmEnd) ' Forecast'];
 
 nSample=(yrEnd-yrStart)*options_.ms.freq + (qmEnd-qmStart+1);
 if qmEnd==options_.ms.freq
-   E1yrqm = [yrEnd+1 1];  % first year and quarter (month) after the sample
+    E1yrqm = [yrEnd+1 1];  % first year and quarter (month) after the sample
 else
-   E1yrqm = [yrEnd qmEnd+1];  % first year and quarter (month) after the sample
+    E1yrqm = [yrEnd qmEnd+1];  % first year and quarter (month) after the sample
 end
 E2yrqm = [yrEnd+options_.forecast qmEnd];   % end at the last month (quarter) of a calendar year after the sample
 [fdates,nfqm]=fn_calyrqm(options_.ms.freq,E1yrqm,E2yrqm);   % forecast dates and number of forecast dates
 [sdates,nsqm] = fn_calyrqm(options_.ms.freq,[yrStart qmStart],[yrEnd qmEnd]);
-   % sdates: dates for the whole sample (including options_.ms.nlags)
+% sdates: dates for the whole sample (including options_.ms.nlags)
 if nSample~=nsqm
-   warning('Make sure that nSample is consistent with the size of sdates')
-   disp('Hit any key to continue, or ctrl-c to abort')
-   pause
+    warning('Make sure that nSample is consistent with the size of sdates')
+    disp('Hit any key to continue, or ctrl-c to abort')
+    pause
 end
 imstp = 4*options_.ms.freq;    % <<>>  impulse responses (4 years)
 nayr = 4; %options_.forecast;  % number of years before forecasting for plotting.
@@ -110,18 +110,18 @@ nayr = 4; %options_.forecast;  % number of years before forecasting for plotting
 %------- Prior, etc. -------
 %options_.ms.nlags = 4;        % number of options_.ms.nlags
 %options_.ms.cross_restrictions = 0;   % 1: cross-A0-and-A+ restrictions; 0: options_.ms.restriction_fname is all we have
-            % Example for indxOres==1: restrictions of the form P(t) = P(t-1).
+% Example for indxOres==1: restrictions of the form P(t) = P(t-1).
 %options_.ms.contemp_reduced_form = 0;  % 1: contemporaneous recursive reduced form; 0: restricted (non-recursive) form
 %options_.ms.real_pseudo_forecast = 0;  % 1: options_.ms.real_pseudo_forecast forecasts; 0: real time forecasts
 %options_.ms.bayesian_prior = 1;  % 1: Bayesian prior; 0: no prior
 indxDummy = options_.ms.bayesian_prior;  % 1: add dummy observations to the data; 0: no dummy added.
-%options_.ms.dummy_obs = 0;  % No dummy observations for xtx, phi, fss, xdatae, etc.  Dummy observations are used as an explicit prior in fn_rnrprior_covres_dobs.m.
-%if indxDummy
-%   options_.ms.dummy_obs=nvar+1;         % number of dummy observations
-%else
-%   options_.ms.dummy_obs=0;    % no dummy observations
-%end
-%=== The following mu is effective only if options_.ms.bayesian_prior==1.
+                                         %options_.ms.dummy_obs = 0;  % No dummy observations for xtx, phi, fss, xdatae, etc.  Dummy observations are used as an explicit prior in fn_rnrprior_covres_dobs.m.
+                                         %if indxDummy
+                                         %   options_.ms.dummy_obs=nvar+1;         % number of dummy observations
+                                         %else
+                                         %   options_.ms.dummy_obs=0;    % no dummy observations
+                                         %end
+                                         %=== The following mu is effective only if options_.ms.bayesian_prior==1.
 
 mu = options_.ms.coefficients_prior_hyperparameters;
 
@@ -142,20 +142,15 @@ tdf = 3;          % degrees of freedom for t-dist for initial draw of the MC loo
 nbuffer = 1000;        % a block or buffer of draws (buffer) that is saved to the disk (not memory)
 ndraws1=1*nbuffer;         % 1st part of Monte Carlo draws
 ndraws2=10*ndraws1;        % 2nd part of Monte Carlo draws
-% seednumber = options_.DynareRandomStreams.seed; %7910;    %472534;   % if 0, random state at each clock time
-%            % good one 420 for [29 45], [29 54]
-% if seednumber
-%    randn('state',seednumber);
-%    rand('state',seednumber);
-% else
-%    randn('state',fix(100*sum(clock)));
-%    rand('state',fix(100*sum(clock)));
-% end
-%  nstarts=1         % number of starting points
-%  imndraws = nstarts*ndraws2;   % total draws for impulse responses or forecasts
-%<<<<<<<<<<<<<<<<<<<
-
-
-
-
-
+                           % seednumber = options_.DynareRandomStreams.seed; %7910;    %472534;   % if 0, random state at each clock time
+                           %            % good one 420 for [29 45], [29 54]
+                           % if seednumber
+                           %    randn('state',seednumber);
+                           %    rand('state',seednumber);
+                           % else
+                           %    randn('state',fix(100*sum(clock)));
+                           %    rand('state',fix(100*sum(clock)));
+                           % end
+                           %  nstarts=1         % number of starting points
+                           %  imndraws = nstarts*ndraws2;   % total draws for impulse responses or forecasts
+                           %<<<<<<<<<<<<<<<<<<<
diff --git a/matlab/ms-sbvar/plot_ms_forecast.m b/matlab/ms-sbvar/plot_ms_forecast.m
index c6f0661f3..61f986e90 100644
--- a/matlab/ms-sbvar/plot_ms_forecast.m
+++ b/matlab/ms-sbvar/plot_ms_forecast.m
@@ -15,7 +15,7 @@ function plot_ms_forecast(M_, options_, forecast, figure_name)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,122 +32,122 @@ function plot_ms_forecast(M_, options_, forecast, figure_name)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    nc = 2;
-    nr = 2;
-    nvars = M_.endo_nbr;
-    endo_names = M_.endo_names;
-    var_list = endo_names(1:M_.orig_endo_nbr,:);
-    names = {};
-    tex_names = {};
-    m = 1;
-    for i = 1:size(var_list)
-        tmp = strmatch(var_list(i,:),endo_names,'exact');
-        if isempty(tmp)
-            error([var_list(i,:) ' isn''t and endogenous variable'])
-        end
-        tex_name = deblank(M_.endo_names_tex(i,:));
-        if ~isempty(tex_name)
-            names{m} = deblank(var_list(i,:));
-            tex_names{m} = tex_name;
-            m = m + 1;
-        end
+nc = 2;
+nr = 2;
+nvars = M_.endo_nbr;
+endo_names = M_.endo_names;
+var_list = endo_names(1:M_.orig_endo_nbr,:);
+names = {};
+tex_names = {};
+m = 1;
+for i = 1:size(var_list)
+    tmp = strmatch(var_list(i,:),endo_names,'exact');
+    if isempty(tmp)
+        error([var_list(i,:) ' isn''t and endogenous variable'])
     end
+    tex_name = deblank(M_.endo_names_tex(i,:));
+    if ~isempty(tex_name)
+        names{m} = deblank(var_list(i,:));
+        tex_names{m} = tex_name;
+        m = m + 1;
+    end
+end
 
-    dims = size(forecast);
-    if (length(dims) == 2)
-        % Point Forecast (horizon x nvars )
-        horizon = dims(1);
-        num_percentiles = 1;
-    elseif (length(dims) == 3)
-        % Banded Forecast
-        horizon = dims(2);
-        num_percentiles = dims(1);
-    else
-        error('The impulse response matrix passed to be plotted does not appear to be the correct size');
-    end
+dims = size(forecast);
+if (length(dims) == 2)
+    % Point Forecast (horizon x nvars )
+    horizon = dims(1);
+    num_percentiles = 1;
+elseif (length(dims) == 3)
+    % Banded Forecast
+    horizon = dims(2);
+    num_percentiles = dims(1);
+else
+    error('The impulse response matrix passed to be plotted does not appear to be the correct size');
+end
 
-    if num_percentiles == 1
-        plot_point_forecast(forecast, nvars, nr, nc, var_list, figure_name, ...
-            options_.graph_save_formats, options_.TeX, names, tex_names, ...
-            [options_.ms.output_file_tag filesep 'Output' filesep 'Forecast']);
-    else
-        plot_banded_forecast(forecast, nvars, nr, nc, var_list, num_percentiles, ...
-            figure_name, options_.graph_save_formats, options_.TeX, names, tex_names, ...
-            [options_.ms.output_file_tag filesep 'Output' filesep 'Forecast']);
-    end
+if num_percentiles == 1
+    plot_point_forecast(forecast, nvars, nr, nc, var_list, figure_name, ...
+                        options_.graph_save_formats, options_.TeX, names, tex_names, ...
+                        [options_.ms.output_file_tag filesep 'Output' filesep 'Forecast']);
+else
+    plot_banded_forecast(forecast, nvars, nr, nc, var_list, num_percentiles, ...
+                         figure_name, options_.graph_save_formats, options_.TeX, names, tex_names, ...
+                         [options_.ms.output_file_tag filesep 'Output' filesep 'Forecast']);
+end
 
 end
 
 function plot_point_forecast(forecast,nvars,nr,nc,endo_names,figure_name,save_graph_formats,TeX,names,tex_names,dirname)
-    if nvars > nr*nc
-        graph_name = ['MS (1) ' figure_name];
-        figure('Name', graph_name);
-    else
-        graph_name = figure_name;
-        figure('Name', graph_name);
-    end
-    m = 1;
-    n_fig = 1;
-    for j=1:nvars
-        if m > nr*nc
-            graph_name = ['MS (' int2str(n_fig) ') ' figure_name];
-            dyn_save_graph(dirname,['MS-forecast-' int2str(n_fig)],...
-                           save_graph_formats,TeX,names,tex_names,graph_name);
-            n_fig =n_fig+1;
-            figure('Name', graph_name);
-            m = 1;
-        end
-        subplot(nr,nc,m);
-        vn = deblank(endo_names(j,:));
-        plot(forecast(:,j))
-        title(vn,'Interpreter','none');
-        grid on;
-        m = m+1;
-    end
-    if m > 1
+if nvars > nr*nc
+    graph_name = ['MS (1) ' figure_name];
+    figure('Name', graph_name);
+else
+    graph_name = figure_name;
+    figure('Name', graph_name);
+end
+m = 1;
+n_fig = 1;
+for j=1:nvars
+    if m > nr*nc
+        graph_name = ['MS (' int2str(n_fig) ') ' figure_name];
         dyn_save_graph(dirname,['MS-forecast-' int2str(n_fig)],...
                        save_graph_formats,TeX,names,tex_names,graph_name);
+        n_fig =n_fig+1;
+        figure('Name', graph_name);
+        m = 1;
     end
+    subplot(nr,nc,m);
+    vn = deblank(endo_names(j,:));
+    plot(forecast(:,j))
+    title(vn,'Interpreter','none');
+    grid on;
+    m = m+1;
+end
+if m > 1
+    dyn_save_graph(dirname,['MS-forecast-' int2str(n_fig)],...
+                   save_graph_formats,TeX,names,tex_names,graph_name);
+end
 end
 
 function plot_banded_forecast(forecast,nvars,nr,nc,endo_names,num_percentiles,figure_name,save_graph_formats,TeX,names,tex_names,dirname)
-    if nvars > nr*nc
-        graph_name = ['MS (1) ' figure_name];
-        figure('Name', graph_name);
-    else
-        graph_name = figure_name;
-        figure('Name', graph_name);
-    end
-    m = 1;
-    n_fig = 1;
-    for j=1:nvars
-        if m > nr*nc
-            graph_name = ['MS (' int2str(n_fig) ') ' figure_name];
-            dyn_save_graph(dirname,['MS-forecast-' int2str(n_fig)],...
-                           save_graph_formats,TeX,names,tex_names,graph_name);
-            n_fig =n_fig+1;
-            figure('Name',graph_name);
-            m = 1;
-        end
-        subplot(nr,nc,m);
-        vn = deblank(endo_names(j,:));
-        for k=1:num_percentiles
-            if ceil(num_percentiles/2) == k
-                plot(forecast(k,:,j),'LineWidth',1.5)
-            else
-                plot(forecast(k,:,j),'LineWidth',1.1)
-            end
-            if k==1
-                hold on;
-            end
-        end
-        title(vn,'Interpreter','none');
-        hold off
-        grid on;
-        m = m+1;
-    end
-    if m > 1
+if nvars > nr*nc
+    graph_name = ['MS (1) ' figure_name];
+    figure('Name', graph_name);
+else
+    graph_name = figure_name;
+    figure('Name', graph_name);
+end
+m = 1;
+n_fig = 1;
+for j=1:nvars
+    if m > nr*nc
+        graph_name = ['MS (' int2str(n_fig) ') ' figure_name];
         dyn_save_graph(dirname,['MS-forecast-' int2str(n_fig)],...
                        save_graph_formats,TeX,names,tex_names,graph_name);
+        n_fig =n_fig+1;
+        figure('Name',graph_name);
+        m = 1;
     end
+    subplot(nr,nc,m);
+    vn = deblank(endo_names(j,:));
+    for k=1:num_percentiles
+        if ceil(num_percentiles/2) == k
+            plot(forecast(k,:,j),'LineWidth',1.5)
+        else
+            plot(forecast(k,:,j),'LineWidth',1.1)
+        end
+        if k==1
+            hold on;
+        end
+    end
+    title(vn,'Interpreter','none');
+    hold off
+    grid on;
+    m = m+1;
+end
+if m > 1
+    dyn_save_graph(dirname,['MS-forecast-' int2str(n_fig)],...
+                   save_graph_formats,TeX,names,tex_names,graph_name);
+end
 end
diff --git a/matlab/ms-sbvar/plot_ms_irf.m b/matlab/ms-sbvar/plot_ms_irf.m
index 82c972747..3bff3773b 100644
--- a/matlab/ms-sbvar/plot_ms_irf.m
+++ b/matlab/ms-sbvar/plot_ms_irf.m
@@ -15,7 +15,7 @@ function plot_ms_irf(M_, options_, irf, figure_name, varlist)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,108 +32,108 @@ function plot_ms_irf(M_, options_, irf, figure_name, varlist)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    if nargin < 4
-        figure_name = '';
+if nargin < 4
+    figure_name = '';
+end
+
+nvars = M_.endo_nbr;
+endo_names = M_.endo_names;
+
+if isempty(varlist)
+    var_list = endo_names(1:M_.orig_endo_nbr,:);
+end
+
+names = {};
+tex_names = {};
+m = 1;
+for i = 1:size(var_list)
+    tmp = strmatch(var_list(i,:),endo_names,'exact');
+    if isempty(tmp)
+        error([var_list(i,:) ' isn''t and endogenous variable'])
     end
-
-    nvars = M_.endo_nbr;
-    endo_names = M_.endo_names;
-
-    if isempty(varlist)
-        var_list = endo_names(1:M_.orig_endo_nbr,:);
+    tex_name = deblank(M_.endo_names_tex(tmp,:));
+    if ~isempty(tex_name)
+        names{m} = deblank(var_list(i,:));
+        tex_names{m} = tex_name;
+        m = m + 1;
     end
+end
 
-    names = {};
-    tex_names = {};
-    m = 1;
-    for i = 1:size(var_list)
-        tmp = strmatch(var_list(i,:),endo_names,'exact');
-        if isempty(tmp)
-            error([var_list(i,:) ' isn''t and endogenous variable'])
-        end
-        tex_name = deblank(M_.endo_names_tex(tmp,:));
-        if ~isempty(tex_name)
-            names{m} = deblank(var_list(i,:));
-            tex_names{m} = tex_name;
-            m = m + 1;
+for i=1:M_.exo_nbr
+    tex_name = deblank(M_.exo_names_tex(i,:));
+    if ~isempty(tex_name)
+        names{m} = deblank(M_.exo_names(i,:));
+        tex_names{m} = tex_name;
+        m = m + 1;
+    end
+end
+
+dims = size(irf);
+if (length(dims) == 2)
+    % Point IRF (horizon x (nvarsxnvars) )
+    horizon = dims(1);
+    num_percentiles = 1;
+elseif (length(dims) == 3)
+    % Banded IRF
+    horizon = dims(2);
+    num_percentiles = dims(1);
+else
+    error('The impulse response matrix passed to be plotted does not appear to be the correct size');
+end
+
+if size(endo_names,1) ~= nvars
+    error('The names passed are not the same length as the number of variables');
+end
+
+if num_percentiles == 1
+    % loop through the shocks
+    for s=1:nvars
+        shock = zeros(horizon,nvars);
+        for i=1:nvars
+            shock(:,i) = irf(:,((i-1) + ((s-1)*nvars)+1));
         end
+        plot_point_irf_for_shock(shock, nvars,endo_names, deblank(endo_names(s,:)), ...
+                                 figure_name, [options_.ms.output_file_tag filesep 'Output' filesep 'IRF'], options_, names, tex_names);
     end
-
-    for i=1:M_.exo_nbr
-        tex_name = deblank(M_.exo_names_tex(i,:));
-        if ~isempty(tex_name)
-            names{m} = deblank(M_.exo_names(i,:));
-            tex_names{m} = tex_name;
-            m = m + 1;
-        end
-    end
-
-    dims = size(irf);
-    if (length(dims) == 2)
-        % Point IRF (horizon x (nvarsxnvars) )
-        horizon = dims(1);
-        num_percentiles = 1;
-    elseif (length(dims) == 3)
-        % Banded IRF
-        horizon = dims(2);
-        num_percentiles = dims(1);
-    else
-        error('The impulse response matrix passed to be plotted does not appear to be the correct size');
-    end
-
-    if size(endo_names,1) ~= nvars
-        error('The names passed are not the same length as the number of variables');
-    end
-
-    if num_percentiles == 1
-        % loop through the shocks
-        for s=1:nvars
-            shock = zeros(horizon,nvars);
+else
+    for s=1:nvars
+        shock = zeros(horizon,nvars,num_percentiles);
+        for n=1:num_percentiles
             for i=1:nvars
-                shock(:,i) = irf(:,((i-1) + ((s-1)*nvars)+1));
+                shock(:,i,n) = irf(n,:,((i-1) + ((s-1)*nvars)+1));
             end
-            plot_point_irf_for_shock(shock, nvars,endo_names, deblank(endo_names(s,:)), ...
-                figure_name, [options_.ms.output_file_tag filesep 'Output' filesep 'IRF'], options_, names, tex_names);
-        end
-    else
-        for s=1:nvars
-            shock = zeros(horizon,nvars,num_percentiles);
-            for n=1:num_percentiles
-                for i=1:nvars
-                    shock(:,i,n) = irf(n,:,((i-1) + ((s-1)*nvars)+1));
-                end
-            end
-            plot_banded_irf_for_shock(shock, nvars,endo_names, deblank(endo_names(s,:)), ...
-                figure_name, [options_.ms.output_file_tag filesep 'Output' filesep 'IRF'], options_, names, tex_names);
         end
+        plot_banded_irf_for_shock(shock, nvars,endo_names, deblank(endo_names(s,:)), ...
+                                  figure_name, [options_.ms.output_file_tag filesep 'Output' filesep 'IRF'], options_, names, tex_names);
     end
 end
+end
 
 function [fig] = plot_point_irf_for_shock(irf,nvars,endo_names,shock_name,figure_name,dirname,options_,names,tex_names)
-    fig = figure('Name',figure_name);
-    for k=1:nvars
-        subplot(ceil(sqrt(nvars)), ceil(sqrt(nvars)),k);
-        plot(irf(:,k))
-        disp([endo_names(k,:) ' shock from ' shock_name]);
-        title([endo_names(k,:) ' shock from ' shock_name]);
-    end
-    dyn_save_graph(dirname,[figure_name ' ' shock_name],options_.graph_save_formats, ...
-                   options_.TeX,names,tex_names,[figure_name ' ' shock_name]);
+fig = figure('Name',figure_name);
+for k=1:nvars
+    subplot(ceil(sqrt(nvars)), ceil(sqrt(nvars)),k);
+    plot(irf(:,k))
+    disp([endo_names(k,:) ' shock from ' shock_name]);
+    title([endo_names(k,:) ' shock from ' shock_name]);
+end
+dyn_save_graph(dirname,[figure_name ' ' shock_name],options_.graph_save_formats, ...
+               options_.TeX,names,tex_names,[figure_name ' ' shock_name]);
 end
 
 function [fig] = plot_banded_irf_for_shock(irf,nvars, endo_names, shock_name,figure_name,dirname,options_,names,tex_names)
-    fig = figure('Name',figure_name);
-    npercentiles = size(irf,3);
-    for k=1:nvars
-        subplot(ceil(sqrt(nvars)), ceil(sqrt(nvars)),k);
-        for nn=1:npercentiles
-            plot(irf(:,k,nn))
-            hold on
-        end
-        hold off
-        disp([endo_names(k,:) ' shock from ' shock_name]);
-        title([endo_names(k,:) ' shock from ' shock_name]);
+fig = figure('Name',figure_name);
+npercentiles = size(irf,3);
+for k=1:nvars
+    subplot(ceil(sqrt(nvars)), ceil(sqrt(nvars)),k);
+    for nn=1:npercentiles
+        plot(irf(:,k,nn))
+        hold on
     end
-    dyn_save_graph(dirname,[figure_name ' ' shock_name],options_.graph_save_formats, ...
-                   options_.TeX,names,tex_names,[figure_name ' ' shock_name]);
+    hold off
+    disp([endo_names(k,:) ' shock from ' shock_name]);
+    title([endo_names(k,:) ' shock from ' shock_name]);
+end
+dyn_save_graph(dirname,[figure_name ' ' shock_name],options_.graph_save_formats, ...
+               options_.TeX,names,tex_names,[figure_name ' ' shock_name]);
 end
diff --git a/matlab/ms-sbvar/plot_ms_probabilities.m b/matlab/ms-sbvar/plot_ms_probabilities.m
index 023ecfd44..b0e8ec7ca 100644
--- a/matlab/ms-sbvar/plot_ms_probabilities.m
+++ b/matlab/ms-sbvar/plot_ms_probabilities.m
@@ -3,7 +3,7 @@ function plot_ms_probabilities(computed_probabilities, options_)
 % Plots the regime probablities for each graph
 %
 % INPUTS
-%    computed_probabilities:      Txnstates 
+%    computed_probabilities:      Txnstates
 %
 % OUTPUTS
 %    none
@@ -11,7 +11,7 @@ function plot_ms_probabilities(computed_probabilities, options_)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,41 +27,41 @@ function plot_ms_probabilities(computed_probabilities, options_)
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-  
-  [T,num_grand_regimes] = size(computed_probabilities);
-  num_chains = length(options_.ms.ms_chain);
-  for i=1:num_chains
+
+[T,num_grand_regimes] = size(computed_probabilities);
+num_chains = length(options_.ms.ms_chain);
+for i=1:num_chains
     chains(i).num_regimes = length(options_.ms.ms_chain(i).regime);
     chains(i).probabilities = zeros([T,chains(i).num_regimes]);
-  end
-  
-  for t=1:T
+end
+
+for t=1:T
     chains = iterate_chain(computed_probabilities(t,:), t, chains, 1, num_chains);
-  end
-  
-  for i=1:num_chains
+end
+
+for i=1:num_chains
     graph_name = ['MS-Probabilities, Chain ' int2str(i)];
     figure('Name',graph_name)
     plot(chains(i).probabilities,'LineWidth', 1.2);
     ltxt = {};
     for j=1:chains(i).num_regimes
-      ltxt{j} = ['Regime ' int2str(j)];
+        ltxt{j} = ['Regime ' int2str(j)];
     end
     legend(ltxt{:});
     title(['Chain ' int2str(i)]);
     ylim([0 1.0]);
     dyn_save_graph([options_.ms.output_file_tag filesep 'Output' filesep 'Probabilities'], ['MS-Probabilities-Chain-' int2str(i)], ...
-        options_.graph_save_formats,options_.TeX,[],[],graph_name);
-  end
+                   options_.graph_save_formats,options_.TeX,[],[],graph_name);
+end
 end
 
 function [chains] = iterate_chain(probs, t, chains, chain, num_chains)
-  offset_length = length(probs)/chains(chain).num_regimes;
-  for i=1:chains(chain).num_regimes
+offset_length = length(probs)/chains(chain).num_regimes;
+for i=1:chains(chain).num_regimes
     p = probs( (i-1)*offset_length+1 : i*offset_length );
     chains(chain).probabilities(t, i) = chains(chain).probabilities(t, i) + sum( p );
     if chain < num_chains
-      chains = iterate_chain(p, t, chains, chain+1, num_chains);
+        chains = iterate_chain(p, t, chains, chain+1, num_chains);
     end
-  end
+end
 end
diff --git a/matlab/ms-sbvar/plot_ms_variance_decomposition.m b/matlab/ms-sbvar/plot_ms_variance_decomposition.m
index 7cd30dca8..d6b39ce63 100644
--- a/matlab/ms-sbvar/plot_ms_variance_decomposition.m
+++ b/matlab/ms-sbvar/plot_ms_variance_decomposition.m
@@ -9,12 +9,12 @@ function plot_ms_variance_decomposition(M_, options_, vd, figure_name, varargin)
 %    figure_name: (string)    graph name
 %
 % OPTIONAL INPUTS
-%		'data': the actual data, TxK with K=number of data series
-%		'steady': the steady state value, TxK
-%		'shock_names': to specify the names of the shocks
-%		'series_names': to specify the names of the different series
-%		'dates': pass a date vector to use, otherwise will just index on 1:T
-%		'colors': Jx3 list of the rgb colors to use for each shock
+%               'data': the actual data, TxK with K=number of data series
+%               'steady': the steady state value, TxK
+%               'shock_names': to specify the names of the shocks
+%               'series_names': to specify the names of the different series
+%               'dates': pass a date vector to use, otherwise will just index on 1:T
+%               'colors': Jx3 list of the rgb colors to use for each shock
 %
 % OUTPUTS
 %    none
@@ -22,7 +22,7 @@ function plot_ms_variance_decomposition(M_, options_, vd, figure_name, varargin)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,130 +44,130 @@ if length(size(vd)) == 3
     return;
 end
 
-    nvars = M_.endo_nbr;
-    endo_names = M_.endo_names;
+nvars = M_.endo_nbr;
+endo_names = M_.endo_names;
 
-    names = {};
-    tex_names = {};
-    m = 1;
-    for i=1:M_.orig_endo_nbr
-        tex_name = deblank(M_.endo_names_tex(i,:));
-        if ~isempty(tex_name)
-            names{m} = deblank(endo_names(i,:));
-            tex_names{m} = tex_name;
-            m = m + 1;
-        end
+names = {};
+tex_names = {};
+m = 1;
+for i=1:M_.orig_endo_nbr
+    tex_name = deblank(M_.endo_names_tex(i,:));
+    if ~isempty(tex_name)
+        names{m} = deblank(endo_names(i,:));
+        tex_names{m} = tex_name;
+        m = m + 1;
     end
-
-    dims = size(vd);
-    if length(dims) == 3
-        T = dims(1);
-        K = dims(2);
-        J = dims(3);
-        shocks = vd;
-    else
-        T = dims(1);
-        K = nvars;
-        J = nvars;
-        temp_vd = zeros(T,K,J);
-        for i=1:nvars
-            for j=1:nvars
-                temp_vd(:,i,j) = vd(:,((j-1) + ((i-1)*nvars)+1));
-            end
-        end
-        shocks = temp_vd;
-    end
-
-    for i=1:nvars
-        shock_names{i} = endo_names(i,:);
-        series_names{i} = endo_names(i,:);
-    end
-
-    x = [1:T];
-    plot_dates = 0;
-    data = 0;
-    steady = 0;
-    colors = [ .1 .1 .75
-               .8 0 0
-               1 .7 .25
-               1 1 0
-               .5 1 .5
-               .7 .7 .1
-               .5 .6 .2
-               .1 .5 .1];
-
-    % overide the defaults with optional inputs
-    for i=1:length(varargin)
-        if strcmpi(varargin{i},'data')
-            data = varargin{i+1};
-        elseif strcmpi(varargin{i},'steady')
-            steady = varargin{i+1};
-        elseif strcmpi(varargin{i},'shock_names')
-            shock_names = varargin{i+1};
-        elseif strcmpi(varargin{i},'series_names')
-            series_names = varargin{i+1};
-        elseif strcmpi(varargin{i}, 'dates')
-            x = varargin{i+1}; plot_dates = 1;
-        elseif strcmpi(varargin{i},'colors')
-            colors = varargin{i+1};
-        end
-    end
-
-    % add an extra period to the time series
-    x(T+1) = x(T) + (x(T) - x(T-1));
-
-    figure('Name',figure_name)
-    for k=1:K
-        % Go through each series
-        subplot(K,1,k);
-        sshocks = shocks(:,k,:);
-        hold on
-        % plot the stacked shocks
-        for t=1:T
-            % step through each time period
-            pos_position = 0; neg_position = 0;
-            xt = [x(t) x(t) x(t+1) x(t+1)];
-            for j=1:J
-                % stack each shock
-                st = sshocks(t,1,j);
-                if st < 0
-                    yi = st+neg_position;
-                    y = [neg_position yi yi neg_position];
-                    neg_position = yi;
-                else
-                    yi = st+pos_position;
-                    y = [pos_position yi yi pos_position];
-                    pos_position = yi;
-                end
-                fill(xt,y,colors(j,:));
-                XY(t,j,:) = y;
-            end
-        end
-        if data
-            plot(x(2:end)',data(:,k),'k','LineWidth',2.5);
-        end
-        if steady
-            plot(x(2:end)',steady(:,k), '--k','LineWidth',2.25);
-        end
-        if k==K
-            if isoctave
-                legend(shock_names,'Location','SouthOutside');
-            else
-                legend(shock_names,'Location','BestOutside','Orientation','horizontal');
-            end
-        end
-
-        hold off
-        if plot_dates
-            datetick 'x';
-        end
-        xlim([min(x),max(x)])
-        ylim([0 , 1])
-        grid on
-        title(series_names{k});
-    end
-    dyn_save_graph([options_.ms.output_file_tag filesep 'Output' ...
-        filesep 'Variance_Decomposition'], 'MS-Variance-Decomposition', ...
-        options_.graph_save_formats, options_.TeX, names, tex_names, ...
-        'Variance decomposition');
+end
+
+dims = size(vd);
+if length(dims) == 3
+    T = dims(1);
+    K = dims(2);
+    J = dims(3);
+    shocks = vd;
+else
+    T = dims(1);
+    K = nvars;
+    J = nvars;
+    temp_vd = zeros(T,K,J);
+    for i=1:nvars
+        for j=1:nvars
+            temp_vd(:,i,j) = vd(:,((j-1) + ((i-1)*nvars)+1));
+        end
+    end
+    shocks = temp_vd;
+end
+
+for i=1:nvars
+    shock_names{i} = endo_names(i,:);
+    series_names{i} = endo_names(i,:);
+end
+
+x = [1:T];
+plot_dates = 0;
+data = 0;
+steady = 0;
+colors = [ .1 .1 .75
+           .8 0 0
+           1 .7 .25
+           1 1 0
+           .5 1 .5
+           .7 .7 .1
+           .5 .6 .2
+           .1 .5 .1];
+
+% overide the defaults with optional inputs
+for i=1:length(varargin)
+    if strcmpi(varargin{i},'data')
+        data = varargin{i+1};
+    elseif strcmpi(varargin{i},'steady')
+        steady = varargin{i+1};
+    elseif strcmpi(varargin{i},'shock_names')
+        shock_names = varargin{i+1};
+    elseif strcmpi(varargin{i},'series_names')
+        series_names = varargin{i+1};
+    elseif strcmpi(varargin{i}, 'dates')
+        x = varargin{i+1}; plot_dates = 1;
+    elseif strcmpi(varargin{i},'colors')
+        colors = varargin{i+1};
+    end
+end
+
+% add an extra period to the time series
+x(T+1) = x(T) + (x(T) - x(T-1));
+
+figure('Name',figure_name)
+for k=1:K
+    % Go through each series
+    subplot(K,1,k);
+    sshocks = shocks(:,k,:);
+    hold on
+    % plot the stacked shocks
+    for t=1:T
+        % step through each time period
+        pos_position = 0; neg_position = 0;
+        xt = [x(t) x(t) x(t+1) x(t+1)];
+        for j=1:J
+            % stack each shock
+            st = sshocks(t,1,j);
+            if st < 0
+                yi = st+neg_position;
+                y = [neg_position yi yi neg_position];
+                neg_position = yi;
+            else
+                yi = st+pos_position;
+                y = [pos_position yi yi pos_position];
+                pos_position = yi;
+            end
+            fill(xt,y,colors(j,:));
+            XY(t,j,:) = y;
+        end
+    end
+    if data
+        plot(x(2:end)',data(:,k),'k','LineWidth',2.5);
+    end
+    if steady
+        plot(x(2:end)',steady(:,k), '--k','LineWidth',2.25);
+    end
+    if k==K
+        if isoctave
+            legend(shock_names,'Location','SouthOutside');
+        else
+            legend(shock_names,'Location','BestOutside','Orientation','horizontal');
+        end
+    end
+
+    hold off
+    if plot_dates
+        datetick 'x';
+    end
+    xlim([min(x),max(x)])
+    ylim([0 , 1])
+    grid on
+    title(series_names{k});
+end
+dyn_save_graph([options_.ms.output_file_tag filesep 'Output' ...
+                filesep 'Variance_Decomposition'], 'MS-Variance-Decomposition', ...
+               options_.graph_save_formats, options_.TeX, names, tex_names, ...
+               'Variance decomposition');
 end
diff --git a/matlab/ms-sbvar/plot_ms_variance_decomposition_error_bands.m b/matlab/ms-sbvar/plot_ms_variance_decomposition_error_bands.m
index cc03e87c7..d88e757b5 100644
--- a/matlab/ms-sbvar/plot_ms_variance_decomposition_error_bands.m
+++ b/matlab/ms-sbvar/plot_ms_variance_decomposition_error_bands.m
@@ -15,7 +15,7 @@ function plot_ms_variance_decomposition_error_bands(M_, options_, vddata, figure
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -79,14 +79,14 @@ for s=1:nvars
         end
     end
     plot_banded_vddata_for_shock(shock, nvars, endo_names, ...
-        deblank(endo_names(s,:)), figure_name, ...
-        [options_.ms.output_file_tag filesep 'Output' filesep 'Variance_Decomposition'], ...
-        options_, names, tex_names);
+                                 deblank(endo_names(s,:)), figure_name, ...
+                                 [options_.ms.output_file_tag filesep 'Output' filesep 'Variance_Decomposition'], ...
+                                 options_, names, tex_names);
 end
 end
 
 function [fig] = plot_banded_vddata_for_shock(vddata, nvars, endo_names, ...
-    shock_name, figure_name, dirname, options_, names, tex_names)
+                                              shock_name, figure_name, dirname, options_, names, tex_names)
 fig = figure('Name', figure_name);
 npercentiles = size(vddata,3);
 for k=1:nvars
@@ -100,6 +100,6 @@ for k=1:nvars
     title([endo_names(k,:) ' contribution to ' shock_name]);
 end
 dyn_save_graph(dirname, [figure_name ' ' shock_name], ...
-    options_.graph_save_formats, options_.TeX, names, tex_names, ...
-    [figure_name ' ' shock_name]);
+               options_.graph_save_formats, options_.TeX, names, tex_names, ...
+               [figure_name ' ' shock_name]);
 end
diff --git a/matlab/ms-sbvar/sbvar.m b/matlab/ms-sbvar/sbvar.m
index d92d7a678..874fd12ba 100644
--- a/matlab/ms-sbvar/sbvar.m
+++ b/matlab/ms-sbvar/sbvar.m
@@ -15,7 +15,7 @@ function sbvar(M, options)
 %   none.
 %
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ms-sbvar/svar_global_identification_check.m b/matlab/ms-sbvar/svar_global_identification_check.m
index 549d5c7fd..07397d18d 100644
--- a/matlab/ms-sbvar/svar_global_identification_check.m
+++ b/matlab/ms-sbvar/svar_global_identification_check.m
@@ -16,7 +16,7 @@ function indent = svar_global_identification_check(options_)
 %   Autoregressions: Theory of Identification and Algorithms for
 %   Inference" in Review of Economic Studies, 77, 665-696.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -47,7 +47,7 @@ if isequal(options_.ms.restriction_fname, 'upper_cholesky') || ...
 end
 nvar = length(options_.varobs);   % number of endogenous variables
 nexo = 1;
-   
+
 [Uiconst,Viconst,n0,np,ixmC0Pres,Qi,Ri] = exclusions(nvar,nexo,options_.ms );
 
 % order column constraints by rank
diff --git a/matlab/mult_elimination.m b/matlab/mult_elimination.m
index 3d63cfbfd..91b441d35 100644
--- a/matlab/mult_elimination.m
+++ b/matlab/mult_elimination.m
@@ -4,7 +4,7 @@ function dr=mult_elimination(varlist,M_, options_, oo_)
 % and shock variables
 %
 % INPUT
-%   none  
+%   none
 %
 % OUTPUT
 %   dr: a structure with the new decision rule
@@ -12,7 +12,7 @@ function dr=mult_elimination(varlist,M_, options_, oo_)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2003-2012 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -107,13 +107,13 @@ if nvar > 0 && options_.noprint == 0
     for i=1:length(varlist)
         k = strmatch(varlist{i},M_.endo_names(dr.order_var,:),'exact');
         headers = char(headers,varlist{i});
-        
+
         res_table(1:nm_nbr,i) = M1(k,:)';
         res_table(nm_nbr+(1:nm_nbr),i) = M2(k,:)';
         res_table(2*nm_nbr+(1:M_.exo_nbr),i) = M3(k,:)';
         res_table(2*nm_nbr+M_.exo_nbr+(1:M_.exo_nbr),i) = M4(k,:)';
     end
-    
+
     my_title='ELIMINATION OF THE MULTIPLIERS';
     lab = nstates(nil,:);
     labels = strcat(deblank(lab(i,:)),'(-1)');
diff --git a/matlab/multivariate_sample_autocovariance.m b/matlab/multivariate_sample_autocovariance.m
index 6bc0ea32e..40af07015 100644
--- a/matlab/multivariate_sample_autocovariance.m
+++ b/matlab/multivariate_sample_autocovariance.m
@@ -1,17 +1,17 @@
 function autocov = multivariate_sample_autocovariance(data,q)
 % Computes the autocovariance function of multivariate time series.
-% 
 %
-% INPUTS 
+%
+% INPUTS
 %   data            [double]       T*m matrix of data.
-%   q               [integer]      Order of the autocovariance function. 
-%    
-% OUTPUTS 
+%   q               [integer]      Order of the autocovariance function.
+%
+% OUTPUTS
 %   autocov         [double]       m*m*(q+1) array, autocovariance function.
 %
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/myboxplot.m b/matlab/myboxplot.m
index fc54607e2..b3490a4b3 100644
--- a/matlab/myboxplot.m
+++ b/matlab/myboxplot.m
@@ -4,7 +4,7 @@ function sout = myboxplot (data,notched,symbol,vertical,maxwhisker)
 %  sout = myboxplot (data,notched,symbol,vertical,maxwhisker)
 
 %
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,7 +33,7 @@ if notched==1, notched=0.25; end
 a=1-notched;
 
 % ## figure out how many data sets we have
-if iscell(data), 
+if iscell(data)
     nc = length(data);
 else
     %   if isvector(data), data = data(:); end
@@ -133,7 +133,7 @@ whisker_x(:,[chop,chop+nc]) = [];
 whisker_y(:,[chop,chop+nc]) = [];
 median_x(:,chop) = [];
 median_y(:,chop) = [];
-% % % % 
+% % % %
 % ## Add caps to the remaining whiskers
 cap_x = whisker_x;
 cap_x(1,:) =cap_x(1,:)- 0.05;
@@ -144,12 +144,12 @@ cap_y = whisker_y([1,1],:);
 % #whisker_x,whisker_y
 % #median_x,median_y
 % #cap_x,cap_y
-% 
+%
 % ## Do the plot
 
 mm=min(min(data));
 MM=max(max(data));
-if isnan(mm), mm=0; MM=0; end,
+if isnan(mm), mm=0; MM=0; end
 
 if vertical
     plot (quartile_x, quartile_y, 'b',  ...
@@ -171,7 +171,7 @@ else
     % % % % %     outliers2_y, outliers2_x, [symbol(2),"r;;"]);
 end
 
-if nargout,
+if nargout
     sout=s;
 end
 % % % endfunction
\ No newline at end of file
diff --git a/matlab/mydelete.m b/matlab/mydelete.m
index 13ef6ee9d..c28d5ad94 100644
--- a/matlab/mydelete.m
+++ b/matlab/mydelete.m
@@ -1,7 +1,7 @@
 function mydelete(fname,pname)
 % Specialized version of delete() function
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -18,16 +18,16 @@ function mydelete(fname,pname)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin ==0,
+if nargin ==0
     disp('mydelete(fname)')
     return
 end
 
-if nargin ==1,
+if nargin ==1
     pname='';
 end
 
 file_to_delete = dir([pname,fname]);
-for j=1:length(file_to_delete),
+for j=1:length(file_to_delete)
     delete([pname,file_to_delete(j).name]);
 end
diff --git a/matlab/name2index.m b/matlab/name2index.m
index b653e71c6..22d116c79 100644
--- a/matlab/name2index.m
+++ b/matlab/name2index.m
@@ -2,21 +2,21 @@ function i = name2index(options_, M_, estim_params_, type, name1, name2 )
 % Returns the index associated to an estimated object (deep parameter,
 % variance of a structural shock or measurement error, covariance between
 % two structural shocks, covariance between two measurement errors).
-%  
+%
 % INPUTS:
 %   options_        [structure]    Dynare structure.
 %   M_              [structure]    Dynare structure (related to model definition).
 %   estim_params_   [structure]    Dynare structure (related to estimation).
 %   type            [string]       'DeepParameter', 'MeasurementError' (for measurement equation error) or 'StructuralShock' (for structural shock).
-%   name1           [string]       
-%   name2           [string]    
+%   name1           [string]
+%   name2           [string]
 % OUTPUTS
 %   i               [integer]      column index (in x2, an array of mh draws) associated to name1[,name2].
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2008-2013 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -63,7 +63,7 @@ if strcmpi(type,'StructuralShock')
         end
     else% Covariance matrix off-diagonal term
         offset = nvx+nvn;
-        try 
+        try
             list_of_structural_shocks = { M_.exo_names(estim_params_.corrx(:,1),:) , M_.exo_names(estim_params_.corrx(:,2),:) };
             k1 = strmatch(name1,list_of_structural_shocks(:,1),'exact');
             k2 = strmatch(name2,list_of_structural_shocks(:,2),'exact');
diff --git a/matlab/non_linear_dsge_likelihood.m b/matlab/non_linear_dsge_likelihood.m
index 17d448927..1f56c3be4 100644
--- a/matlab/non_linear_dsge_likelihood.m
+++ b/matlab/non_linear_dsge_likelihood.m
@@ -150,7 +150,7 @@ end
 %------------------------------------------------------------------------------
 
 % Return, with endogenous penalty, if some parameters are smaller than the lower bound of the prior domain.
-if (DynareOptions.mode_compute~=1) && any(xparam1<BoundsInfo.lb)
+if isestimation(DynareOptions) && (DynareOptions.mode_compute~=1) && any(xparam1<BoundsInfo.lb)
     k = find(xparam1(:) < BoundsInfo.lb);
     fval = Inf;
     exit_flag = 0;
@@ -160,7 +160,7 @@ if (DynareOptions.mode_compute~=1) && any(xparam1<BoundsInfo.lb)
 end
 
 % Return, with endogenous penalty, if some parameters are greater than the upper bound of the prior domain.
-if (DynareOptions.mode_compute~=1) && any(xparam1>BoundsInfo.ub)
+if isestimation(DynareOptions) && (DynareOptions.mode_compute~=1) && any(xparam1>BoundsInfo.ub)
     k = find(xparam1(:)>BoundsInfo.ub);
     fval = Inf;
     exit_flag = 0;
@@ -229,8 +229,8 @@ end
 
 if info(1)
     if info(1) == 3 || info(1) == 4 || info(1) == 5 || info(1)==6 ||info(1) == 19 || ...
-            info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
-            info(1) == 81 || info(1) == 84 ||  info(1) == 85
+                info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
+                info(1) == 81 || info(1) == 84 ||  info(1) == 85
         %meaningful second entry of output that can be used
         fval = Inf;
         info(4) = info(2);
@@ -316,7 +316,8 @@ switch DynareOptions.particle.initialization
     StateVectorVariance = cov(y_');
     DynareOptions.periods = old_DynareOptionsperiods;
     clear('old_DynareOptionsperiods','y_');
-  case 3% Initial state vector covariance is a diagonal matrix.
+  case 3% Initial state vector covariance is a diagonal matrix (to be used
+        % if model has stochastic trends).
     StateVectorMean = ReducedForm.constant(mf0);
     StateVectorVariance = DynareOptions.particle.initial_state_prior_std*eye(number_of_state_variables);
   otherwise
@@ -375,4 +376,3 @@ if isinf(LIK)~=0
     exit_flag = 0;
     return
 end
-
diff --git a/matlab/occbin/call_solve_one_constraint.m b/matlab/occbin/call_solve_one_constraint.m
index b4ec1baed..65b98c431 100755
--- a/matlab/occbin/call_solve_one_constraint.m
+++ b/matlab/occbin/call_solve_one_constraint.m
@@ -1,21 +1,21 @@
-% Solve model, generate model IRFs
-[zdatalinear zdatapiecewise zdatass oobase_ Mbase_ ] = ...
-         solve_one_constraint(modnam,modnamstar,...
-                              constraint, constraint_relax,...
-                              shockssequence,irfshock,nperiods,maxiter);
-
-
-                          
-% unpack the IRFs                          
-for i=1:Mbase_.endo_nbr
-  eval([deblank(Mbase_.endo_names(i,:)),'_uncdifference=zdatalinear(:,i);']);
-  eval([deblank(Mbase_.endo_names(i,:)),'_difference=zdatapiecewise(:,i);']);
-  eval([deblank(Mbase_.endo_names(i,:)),'_ss=zdatass(i);']);
-end
-
-
-nparams = size(Mbase_.param_names,1);
-
-for i = 1:nparams
-  eval([Mbase_.param_names(i,:),'= Mbase_.params(i);']);
-end
+% Solve model, generate model IRFs
+[zdatalinear, zdatapiecewise, zdatass, oobase_, Mbase_ ] = ...
+    solve_one_constraint(modnam,modnamstar,...
+                         constraint, constraint_relax,...
+                         shockssequence,irfshock,nperiods,maxiter);
+
+
+
+% unpack the IRFs
+for i=1:Mbase_.endo_nbr
+    eval([deblank(Mbase_.endo_names(i,:)),'_uncdifference=zdatalinear(:,i);']);
+    eval([deblank(Mbase_.endo_names(i,:)),'_difference=zdatapiecewise(:,i);']);
+    eval([deblank(Mbase_.endo_names(i,:)),'_ss=zdatass(i);']);
+end
+
+
+nparams = size(Mbase_.param_names,1);
+
+for i = 1:nparams
+    eval([Mbase_.param_names(i,:),'= Mbase_.params(i);']);
+end
diff --git a/matlab/occbin/call_solve_two_constraints.m b/matlab/occbin/call_solve_two_constraints.m
index b782e6db7..5bbc1beb8 100755
--- a/matlab/occbin/call_solve_two_constraints.m
+++ b/matlab/occbin/call_solve_two_constraints.m
@@ -1,21 +1,21 @@
-[zdatalinear zdatapiecewise zdatass oobase_ Mbase_] = solve_two_constraints(...
-                 modnam_00,modnam_10,modnam_01,modnam_11,...
-                 constraint1, constraint2,...
-                 constraint_relax1, constraint_relax2,...
-                 scalefactormod,irfshock,nperiods,curb_retrench,maxiter);
-
-                           
-for i=1:Mbase_.endo_nbr
-  eval([deblank(Mbase_.endo_names(i,:)),'_uncdifference=zdatalinear(:,i);']);
-  eval([deblank(Mbase_.endo_names(i,:)),'_difference=zdatapiecewise(:,i);']);
-  eval([deblank(Mbase_.endo_names(i,:)),'_ss=zdatass(i);']);
-end
-
-constraint1_difference = process_constraint(constraint1,'_difference',Mbase_.endo_names,0);
-constraint2_difference = process_constraint(constraint2,'_difference',Mbase_.endo_names,0);
-
-nparams = size(Mbase_.param_names,1);
- 
-for i = 1:nparams
-   eval([Mbase_.param_names(i,:),'= Mbase_.params(i);']);
-end
+[zdatalinear, zdatapiecewise, zdatass, oobase_, Mbase_] = solve_two_constraints(...
+    modnam_00,modnam_10,modnam_01,modnam_11,...
+    constraint1, constraint2,...
+    constraint_relax1, constraint_relax2,...
+    scalefactormod,irfshock,nperiods,curb_retrench,maxiter);
+
+
+for i=1:Mbase_.endo_nbr
+    eval([deblank(Mbase_.endo_names(i,:)),'_uncdifference=zdatalinear(:,i);']);
+    eval([deblank(Mbase_.endo_names(i,:)),'_difference=zdatapiecewise(:,i);']);
+    eval([deblank(Mbase_.endo_names(i,:)),'_ss=zdatass(i);']);
+end
+
+constraint1_difference = process_constraint(constraint1,'_difference',Mbase_.endo_names,0);
+constraint2_difference = process_constraint(constraint2,'_difference',Mbase_.endo_names,0);
+
+nparams = size(Mbase_.param_names,1);
+
+for i = 1:nparams
+    eval([Mbase_.param_names(i,:),'= Mbase_.params(i);']);
+end
diff --git a/matlab/occbin/get_deriv.m b/matlab/occbin/get_deriv.m
index 24f1b42ae..214b1cf42 100755
--- a/matlab/occbin/get_deriv.m
+++ b/matlab/occbin/get_deriv.m
@@ -1,83 +1,82 @@
-function [hm1,h,hl1,j,resid] = get_deriv(M_,ys_)
-
-iy_ = M_.lead_lag_incidence;
-it_ = 1;
-
-x = zeros(1,M_.exo_nbr);
-
-% For most models, there are leads, lags and current values of variables
-if size(iy_,1)==3
-  % find non-zero columns of hm1
-  lag_cols = find(iy_(1,:)~=0);
-  % find non-zero columns of h
-  con_cols = find(iy_(2,:));
-  % find non-zero columns of hl1
-  lea_cols = find(iy_(3,:));
-  
-% If models either lacks leads or lags, iy_ will have two rows   
-% In this case, we guess that the row with more nonzeros is the row with current variables
-elseif size(iy_,1)==2
-  % if first row has more nonzero entries than the second, assume model lacks lagged variables 
-  if length(find(iy_(1,:)))>length(find(iy_(2,:)))
-  warning('Model does not have lagged endogenous variables')
-  con_cols = find(iy_(1,:));
-  lea_cols = find(iy_(2,:));
-  lag_cols = [];
-  else
-  warning('Model does not have expected future endogenous variables')
-  lag_cols = find(iy_(1,:));
-  con_cols = find(iy_(2,:));
-  lea_cols = [];
-  end
-  
-end
-    
-  
- 
-% find number of entries for y vector
-ny = length(find(iy_~=0));
-
-% build steady state y
-y = ys_(lag_cols);
-y = [y;ys_(con_cols)];
-y = [y;ys_(lea_cols)];
-
- 
-if ismac
-eval(['[resid,g1]=',M_.fname,'_dynamic(y,x, M_.params, ys_, it_);']);
-% Older versions of DYNARE for Mac did not include ys_ in the call structure    
-%eval(['[resid,g1]=',M_.fname,'_dynamic(y,x, M_.params, it_);']);
-else
-eval(['[resid,g1]=',M_.fname,'_dynamic(y,x, M_.params, ys_, it_);']);
-end
-
- 
-hm1=zeros(M_.endo_nbr);
-h = hm1;
-hl1 = hm1;
-j = zeros(M_.endo_nbr,M_.exo_nbr);
-
- 
-% build hm1
-nlag_cols = length(lag_cols);
-for i=1:nlag_cols
-    hm1(:,lag_cols(i)) = g1(:,i);
-end
-
-% build h
-ncon_cols = length(con_cols);
-for i=1:ncon_cols
-    h(:,con_cols(i)) = g1(:,i+nlag_cols);
-end
-
-% build hl1
-nlea_cols = length(lea_cols);
-for i=1:nlea_cols
-    hl1(:,lea_cols(i)) = g1(:,i+nlag_cols+ncon_cols);
-end
-
- 
-for i = 1:M_.exo_nbr;
-    j(:,i) =g1(:,i+ny);
-end
-
+function [hm1,h,hl1,j,resid] = get_deriv(M_,ys_)
+
+iy_ = M_.lead_lag_incidence;
+it_ = 1;
+
+x = zeros(1,M_.exo_nbr);
+
+% For most models, there are leads, lags and current values of variables
+if size(iy_,1)==3
+    % find non-zero columns of hm1
+    lag_cols = find(iy_(1,:)~=0);
+    % find non-zero columns of h
+    con_cols = find(iy_(2,:));
+    % find non-zero columns of hl1
+    lea_cols = find(iy_(3,:));
+
+    % If models either lacks leads or lags, iy_ will have two rows
+    % In this case, we guess that the row with more nonzeros is the row with current variables
+elseif size(iy_,1)==2
+    % if first row has more nonzero entries than the second, assume model lacks lagged variables
+    if length(find(iy_(1,:)))>length(find(iy_(2,:)))
+        warning('Model does not have lagged endogenous variables')
+        con_cols = find(iy_(1,:));
+        lea_cols = find(iy_(2,:));
+        lag_cols = [];
+    else
+        warning('Model does not have expected future endogenous variables')
+        lag_cols = find(iy_(1,:));
+        con_cols = find(iy_(2,:));
+        lea_cols = [];
+    end
+
+end
+
+
+
+% find number of entries for y vector
+ny = length(find(iy_~=0));
+
+% build steady state y
+y = ys_(lag_cols);
+y = [y;ys_(con_cols)];
+y = [y;ys_(lea_cols)];
+
+
+if ismac
+    eval(['[resid,g1]=',M_.fname,'_dynamic(y,x, M_.params, ys_, it_);']);
+    % Older versions of DYNARE for Mac did not include ys_ in the call structure
+    %eval(['[resid,g1]=',M_.fname,'_dynamic(y,x, M_.params, it_);']);
+else
+    eval(['[resid,g1]=',M_.fname,'_dynamic(y,x, M_.params, ys_, it_);']);
+end
+
+
+hm1=zeros(M_.endo_nbr);
+h = hm1;
+hl1 = hm1;
+j = zeros(M_.endo_nbr,M_.exo_nbr);
+
+
+% build hm1
+nlag_cols = length(lag_cols);
+for i=1:nlag_cols
+    hm1(:,lag_cols(i)) = g1(:,i);
+end
+
+% build h
+ncon_cols = length(con_cols);
+for i=1:ncon_cols
+    h(:,con_cols(i)) = g1(:,i+nlag_cols);
+end
+
+% build hl1
+nlea_cols = length(lea_cols);
+for i=1:nlea_cols
+    hl1(:,lea_cols(i)) = g1(:,i+nlag_cols+ncon_cols);
+end
+
+
+for i = 1:M_.exo_nbr
+    j(:,i) =g1(:,i+ny);
+end
diff --git a/matlab/occbin/get_pq.m b/matlab/occbin/get_pq.m
index 5caab79af..99888b806 100755
--- a/matlab/occbin/get_pq.m
+++ b/matlab/occbin/get_pq.m
@@ -1,28 +1,28 @@
-function [p,q]=get_pq(dr_,nstatic,nfwrd);
-
-nvars = size(dr_.ghx,1);
-nshocks = size(dr_.ghu,2);
-statevar_pos = (nstatic +1):(nvars-nfwrd);
-
-p = zeros(nvars);
-% interlace matrix
-nnotzero = length(statevar_pos);
-for i=1:nnotzero
-    p(:,statevar_pos(i)) = dr_.ghx(:,i);
-end
-
-% reorder p matrix according to order in lgy_
-inverse_order = zeros(nvars,1);
-for i=1:nvars
-    inverse_order(i) = find(i==dr_.order_var);
-end
-
-p_reordered = zeros(nvars);
-q = zeros(nvars,nshocks);
-for i=1:nvars
-    for j=1:nvars
-        p_reordered(i,j)=p(inverse_order(i),inverse_order(j)); 
-    end
-    q(i,:)=dr_.ghu(inverse_order(i),:); 
-end
+function [p,q]=get_pq(dr_,nstatic,nfwrd)
+
+nvars = size(dr_.ghx,1);
+nshocks = size(dr_.ghu,2);
+statevar_pos = (nstatic +1):(nvars-nfwrd);
+
+p = zeros(nvars);
+% interlace matrix
+nnotzero = length(statevar_pos);
+for i=1:nnotzero
+    p(:,statevar_pos(i)) = dr_.ghx(:,i);
+end
+
+% reorder p matrix according to order in lgy_
+inverse_order = zeros(nvars,1);
+for i=1:nvars
+    inverse_order(i) = find(i==dr_.order_var);
+end
+
+p_reordered = zeros(nvars);
+q = zeros(nvars,nshocks);
+for i=1:nvars
+    for j=1:nvars
+        p_reordered(i,j)=p(inverse_order(i),inverse_order(j));
+    end
+    q(i,:)=dr_.ghu(inverse_order(i),:);
+end
 p=p_reordered;
\ No newline at end of file
diff --git a/matlab/occbin/makechart.m b/matlab/occbin/makechart.m
index a3801e956..934e8463b 100755
--- a/matlab/occbin/makechart.m
+++ b/matlab/occbin/makechart.m
@@ -1,81 +1,81 @@
-function makechart(titlelist,legendlist,figlabel,ylabels,zdata1,zdata2,zdata3)
-
-
-
-figure
-
-titlelist = char(strrep(cellstr(titlelist),'_','.'));
-
-ndsets=3;       % default, changed below as applicable
-if nargin==5
-    zdata2=nan*zdata1;
-    zdata3=nan*zdata1;
-    ndsets =1;
-elseif nargin == 6
-    zdata3 =nan*zdata1;
-    ndsets=2;
-elseif ((nargin>8) | (nargin <=4))
-    error ('makechart takes 5 to 6 arguments')
-end
-
-nobs = size(zdata1,1);
-xvalues = (1:nobs)';
-
-nvars = size(titlelist,1);
-if nvars==1 
-    nrows=1;
-    ncols = 1;
-elseif nvars==2
-    nrows =2;
-    ncols = 1;
-elseif (nvars == 3 | nvars ==4)
-    nrows = 2;
-    ncols =2;
-elseif (nvars==5 |nvars ==6)
-    nrows = 3;
-    ncols = 2;
-elseif (nvars==7 | nvars==8)
-    nrows = 4;
-    ncols = 2;
-elseif (nvars==9 | nvars==10)
-    nrows = 5;
-    ncols = 2;
-else 
-    error('too many variables (makechart)')
-end
-
-for i = 1:nvars
-    subplot(nrows,ncols,i)
-    h1=plot(xvalues,zdata1(:,i),'b-','linewidth',2); hold on
-    h1=plot(xvalues,zdata2(:,i),'r--','linewidth',2); hold on
-    h2=plot(xvalues,zdata3(:,i),'b-','LineWidth',3);
-    [x0 x1 y10 y11] = pickaxes(xvalues,zdata1(:,i));
-    [x0 x1 y20 y21] = pickaxes(xvalues,zdata2(:,i));
-    [x0 x1 y30 y31] = pickaxes(xvalues,zdata3(:,i));
-    y0 = min([y10,y20,y30]);
-    y1 = max([y11,y21,y31]);
-    if y0==y1
-        y1=y0+1;
-    end
-    
-    axis([x0 x1 y0 y1])
-    set(h1);
-
-    if i==1 && isempty(legendlist)==0
-        legend(legendlist)
-        text('String',figlabel,'Units','normalized','Position',[1.2 1.24],...
-       'FontSize',14,'FontWeight','bold','HorizontalAlignment','center');
-    end
- 
-    if i==nvars | i==nvars-1
-        xlabel('Time');
-    end
-%     set(gca,'XTick',xtick)
-%     set(gca,'XTickLabel',xticklabel)
-    
-    title([num2str(i),'. ',titlelist(i,:)]);
-    ylabel(ylabels(i,:))
-end
-
-% sets printing preferences
-%printpref
+function makechart(titlelist,legendlist,figlabel,ylabels,zdata1,zdata2,zdata3)
+
+
+
+figure
+
+titlelist = char(strrep(cellstr(titlelist),'_','.'));
+
+ndsets=3;       % default, changed below as applicable
+if nargin==5
+    zdata2=nan*zdata1;
+    zdata3=nan*zdata1;
+    ndsets =1;
+elseif nargin == 6
+    zdata3 =nan*zdata1;
+    ndsets=2;
+elseif ((nargin>8) | (nargin <=4))
+    error ('makechart takes 5 to 6 arguments')
+end
+
+nobs = size(zdata1,1);
+xvalues = (1:nobs)';
+
+nvars = size(titlelist,1);
+if nvars==1
+    nrows=1;
+    ncols = 1;
+elseif nvars==2
+    nrows =2;
+    ncols = 1;
+elseif (nvars == 3 | nvars ==4)
+    nrows = 2;
+    ncols =2;
+elseif (nvars==5 |nvars ==6)
+    nrows = 3;
+    ncols = 2;
+elseif (nvars==7 | nvars==8)
+    nrows = 4;
+    ncols = 2;
+elseif (nvars==9 | nvars==10)
+    nrows = 5;
+    ncols = 2;
+else
+    error('too many variables (makechart)')
+end
+
+for i = 1:nvars
+    subplot(nrows,ncols,i)
+    h1=plot(xvalues,zdata1(:,i),'b-','linewidth',2); hold on
+    h1=plot(xvalues,zdata2(:,i),'r--','linewidth',2); hold on
+    h2=plot(xvalues,zdata3(:,i),'b-','LineWidth',3);
+    [x0, x1, y10, y11] = pickaxes(xvalues,zdata1(:,i));
+    [x0, x1, y20, y21] = pickaxes(xvalues,zdata2(:,i));
+    [x0, x1, y30, y31] = pickaxes(xvalues,zdata3(:,i));
+    y0 = min([y10,y20,y30]);
+    y1 = max([y11,y21,y31]);
+    if y0==y1
+        y1=y0+1;
+    end
+
+    axis([x0 x1 y0 y1])
+    set(h1);
+
+    if i==1 && isempty(legendlist)==0
+        legend(legendlist)
+        text('String',figlabel,'Units','normalized','Position',[1.2 1.24],...
+             'FontSize',14,'FontWeight','bold','HorizontalAlignment','center');
+    end
+
+    if i==nvars | i==nvars-1
+        xlabel('Time');
+    end
+    %     set(gca,'XTick',xtick)
+    %     set(gca,'XTickLabel',xticklabel)
+
+    title([num2str(i),'. ',titlelist(i,:)]);
+    ylabel(ylabels(i,:))
+end
+
+% sets printing preferences
+%printpref
diff --git a/matlab/occbin/makechart9.m b/matlab/occbin/makechart9.m
index c6e65afcd..264f9f58f 100755
--- a/matlab/occbin/makechart9.m
+++ b/matlab/occbin/makechart9.m
@@ -1,136 +1,136 @@
-function makechart9(titlelist,legendlist,figlabel,yearshock,ylabels,...
-    zdata1,zdata2,zdata3,zdata4,zdata5,zdata6,zdata7)
-
-
-
-figure
-
-titlelist = char(strrep(cellstr(titlelist),'_','.'));
-
-ndsets=7;       % default, changed below as applicable
-if nargin==6
-    zdata2=nan*zdata1;
-    zdata3=nan*zdata1;
-    zdata4=nan*zdata1;
-    zdata5=nan*zdata1;
-    zdata6=nan*zdata1;
-    zdata7=nan*zdata1;
-    ndsets =1;
-elseif nargin==7
-    zdata3=nan*zdata1;
-    zdata4=nan*zdata1;
-    zdata5=nan*zdata1;
-    zdata6=nan*zdata1;
-    zdata7=nan*zdata1;
-    ndsets =2;
-elseif nargin == 8
-    zdata4 =nan*zdata1;
-    zdata5 =nan*zdata1;
-    zdata6=nan*zdata1;
-    zdata7=nan*zdata1;
-    ndsets=3;
-elseif nargin == 9
-    zdata5 =nan*zdata1;
-    zdata6=nan*zdata1;
-    zdata7=nan*zdata1;
-    ndsets=4;
-elseif nargin == 10
-    zdata6 =nan*zdata1;
-    zdata7=nan*zdata1;
-    ndsets=5;
-elseif nargin == 11
-    zdata7=nan*zdata1;
-    ndsets=6;
-elseif ((nargin>=13) | (nargin <=3))
-    error ('makechart takes 4 to 10 arguments')
-end
-
-nobs = size(zdata1,1);
-
-if yearshock>-100
-xvalues = yearshock+(0:nobs-1)'/4; % Matteo plot year on x axis
-else
-xvalues = (1:nobs)'; % Matteo plot year on x axis
-end
-
-nvars = size(titlelist,1);
-if nvars==1 
-    nrows=1;
-    ncols = 1;
-elseif nvars==2
-    nrows =2;
-    ncols = 1;
-elseif nvars == 3 
-    nrows = 3;
-    ncols = 1;
-elseif nvars==4 
-    nrows = 2;
-    ncols = 2;
-elseif (nvars==5 | nvars ==6)
-     nrows = 3;
-    ncols = 2; 
-elseif (nvars==7 | nvars==8)
-    nrows = 4;
-    ncols = 2;
-elseif nvars>8 & nvars<=12;
-    nrows = 3;
-    ncols = 4;
-elseif nvars>12 & nvars<=15;
-    nrows = 5;
-    ncols = 3;
-else 
-    error('too many variables (makechart)')
-end
-
-
-for i = 1:nvars
-    subplot(nrows,ncols,i)
-    h1=plot(xvalues,zdata1(:,i),'k',...
-        xvalues,zdata2(:,i),'r',...
-        xvalues,zdata3(:,i),'b',...
-        xvalues,zdata4(:,i),'g',...
-        xvalues,zdata5(:,i),'g',...
-        xvalues,zdata6(:,i),'c',...
-        xvalues,zdata7(:,i),'y');
-    [x0 x1 y10 y11] = pickaxes(xvalues,zdata1(:,i));
-    [x0 x1 y20 y21] = pickaxes(xvalues,zdata2(:,i));
-    [x0 x1 y30 y31] = pickaxes(xvalues,zdata3(:,i));
-    [x0 x1 y40 y41] = pickaxes(xvalues,zdata4(:,i));
-    [x0 x1 y50 y51] = pickaxes(xvalues,zdata5(:,i));
-    [x0 x1 y60 y61] = pickaxes(xvalues,zdata6(:,i));
-    [x0 x1 y70 y71] = pickaxes(xvalues,zdata7(:,i));
-     grid on
-    y0 = min([y10,y20,y30,y40,y50,y60,y70]);
-    y1 = max([y11,y21,y31,y41,y51,y61,y71]);
-    if y0==y1
-        y1=y0+1;
-    end
-    
-    axis([x0 x1 y0 y1])
-    set(h1,'linewidth',2);
-    if i==1
-      if numel(strvcat(legendlist(1,:)))
-        h=legend(legendlist,'Location','Northwest');
-        set(h,'Fontsize',8)
-      end
-    end
-    if i==1
-        if nvars>3
-        text('String',figlabel,'Units','normalized','Position',[1.2 1.21],...
-       'FontSize',13,'FontWeight','bold','HorizontalAlignment','center');
-        else
-        text('String',figlabel,'Units','normalized','Position',[0.4 1.24],...
-       'FontSize',13,'FontWeight','bold','HorizontalAlignment','center');
-        end
-    end
- 
-    %set(gca,'XTick',xtick)
-    %set(gca,'XTickLabel',xticklabel)
-    
-    title(titlelist(i,:),'Fontsize',11);
-    ylabel(ylabels(i,:))
-
-end
-
-% sets printing preferences
-%printpref
+function makechart9(titlelist,legendlist,figlabel,yearshock,ylabels,...
+                    zdata1,zdata2,zdata3,zdata4,zdata5,zdata6,zdata7)
+
+
+
+figure
+
+titlelist = char(strrep(cellstr(titlelist),'_','.'));
+
+ndsets=7;       % default, changed below as applicable
+if nargin==6
+    zdata2=nan*zdata1;
+    zdata3=nan*zdata1;
+    zdata4=nan*zdata1;
+    zdata5=nan*zdata1;
+    zdata6=nan*zdata1;
+    zdata7=nan*zdata1;
+    ndsets =1;
+elseif nargin==7
+    zdata3=nan*zdata1;
+    zdata4=nan*zdata1;
+    zdata5=nan*zdata1;
+    zdata6=nan*zdata1;
+    zdata7=nan*zdata1;
+    ndsets =2;
+elseif nargin == 8
+    zdata4 =nan*zdata1;
+    zdata5 =nan*zdata1;
+    zdata6=nan*zdata1;
+    zdata7=nan*zdata1;
+    ndsets=3;
+elseif nargin == 9
+    zdata5 =nan*zdata1;
+    zdata6=nan*zdata1;
+    zdata7=nan*zdata1;
+    ndsets=4;
+elseif nargin == 10
+    zdata6 =nan*zdata1;
+    zdata7=nan*zdata1;
+    ndsets=5;
+elseif nargin == 11
+    zdata7=nan*zdata1;
+    ndsets=6;
+elseif ((nargin>=13) | (nargin <=3))
+    error ('makechart takes 4 to 10 arguments')
+end
+
+nobs = size(zdata1,1);
+
+if yearshock>-100
+    xvalues = yearshock+(0:nobs-1)'/4; % Matteo plot year on x axis
+else
+    xvalues = (1:nobs)'; % Matteo plot year on x axis
+end
+
+nvars = size(titlelist,1);
+if nvars==1
+    nrows=1;
+    ncols = 1;
+elseif nvars==2
+    nrows =2;
+    ncols = 1;
+elseif nvars == 3
+    nrows = 3;
+    ncols = 1;
+elseif nvars==4
+    nrows = 2;
+    ncols = 2;
+elseif (nvars==5 | nvars ==6)
+    nrows = 3;
+    ncols = 2;
+elseif (nvars==7 | nvars==8)
+    nrows = 4;
+    ncols = 2;
+elseif nvars>8 & nvars<=12
+    nrows = 3;
+    ncols = 4;
+elseif nvars>12 & nvars<=15
+    nrows = 5;
+    ncols = 3;
+else
+    error('too many variables (makechart)')
+end
+
+
+for i = 1:nvars
+    subplot(nrows,ncols,i)
+    h1=plot(xvalues,zdata1(:,i),'k',...
+            xvalues,zdata2(:,i),'r',...
+            xvalues,zdata3(:,i),'b',...
+            xvalues,zdata4(:,i),'g',...
+            xvalues,zdata5(:,i),'g',...
+            xvalues,zdata6(:,i),'c',...
+            xvalues,zdata7(:,i),'y');
+    [x0, x1, y10, y11] = pickaxes(xvalues,zdata1(:,i));
+    [x0, x1, y20, y21] = pickaxes(xvalues,zdata2(:,i));
+    [x0, x1, y30, y31] = pickaxes(xvalues,zdata3(:,i));
+    [x0, x1, y40, y41] = pickaxes(xvalues,zdata4(:,i));
+    [x0, x1, y50, y51] = pickaxes(xvalues,zdata5(:,i));
+    [x0, x1, y60, y61] = pickaxes(xvalues,zdata6(:,i));
+    [x0, x1, y70, y71] = pickaxes(xvalues,zdata7(:,i));
+    grid on
+    y0 = min([y10,y20,y30,y40,y50,y60,y70]);
+    y1 = max([y11,y21,y31,y41,y51,y61,y71]);
+    if y0==y1
+        y1=y0+1;
+    end
+
+    axis([x0 x1 y0 y1])
+    set(h1,'linewidth',2);
+    if i==1
+        if numel(strvcat(legendlist(1,:)))
+            h=legend(legendlist,'Location','Northwest');
+            set(h,'Fontsize',8)
+        end
+    end
+    if i==1
+        if nvars>3
+            text('String',figlabel,'Units','normalized','Position',[1.2 1.21],...
+                 'FontSize',13,'FontWeight','bold','HorizontalAlignment','center');
+        else
+            text('String',figlabel,'Units','normalized','Position',[0.4 1.24],...
+                 'FontSize',13,'FontWeight','bold','HorizontalAlignment','center');
+        end
+    end
+
+    %set(gca,'XTick',xtick)
+    %set(gca,'XTickLabel',xticklabel)
+
+    title(titlelist(i,:),'Fontsize',11);
+    ylabel(ylabels(i,:))
+
+end
+
+% sets printing preferences
+%printpref
diff --git a/matlab/occbin/map_regime.m b/matlab/occbin/map_regime.m
index a3ed88b47..702b011f9 100755
--- a/matlab/occbin/map_regime.m
+++ b/matlab/occbin/map_regime.m
@@ -1,25 +1,24 @@
-function [regime regimestart]=map_regimes(violvecbool)
-
-nperiods = length(violvecbool)-1;
-
-% analyse violvec and isolate contiguous periods in the other regime.
-            regime(1) = violvecbool(1);
-            regimeindx = 1;
-            regimestart(1) = 1;
-            for i=2:nperiods
-                if violvecbool(i)~=regime(regimeindx)
-                    regimeindx=regimeindx+1;
-                    regime(regimeindx) = violvecbool(i);
-                    regimestart(regimeindx)=i;
-                end
-            end
-            
-            
-            if (regime(1) == 1 & length(regimestart)==1)
-                warning('Increase nperiods');
-            end
-            
-            if (regime(end)==1)
-                warning('Increase nperiods');
-            end
-            
+function [regime, regimestart]=map_regime(violvecbool)
+
+nperiods = length(violvecbool)-1;
+
+% analyse violvec and isolate contiguous periods in the other regime.
+regime(1) = violvecbool(1);
+regimeindx = 1;
+regimestart(1) = 1;
+for i=2:nperiods
+    if violvecbool(i)~=regime(regimeindx)
+        regimeindx=regimeindx+1;
+        regime(regimeindx) = violvecbool(i);
+        regimestart(regimeindx)=i;
+    end
+end
+
+
+if (regime(1) == 1 & length(regimestart)==1)
+    warning('Increase nperiods');
+end
+
+if (regime(end)==1)
+    warning('Increase nperiods');
+end
diff --git a/matlab/occbin/mkdata.m b/matlab/occbin/mkdata.m
index a7f855743..f22fb45f6 100755
--- a/matlab/occbin/mkdata.m
+++ b/matlab/occbin/mkdata.m
@@ -1,63 +1,63 @@
-function [zdata]=mkdata(nperiods,decrulea,decruleb,endog_,exog_,wishlist,irfshock,scalefactormod,init)
-
-%[nsim, ksim, ysim, isim, csim] = mkdata(nperiods,cofb,endog_)
-
-% given decision rule 
-neqs = size(endog_,1);
-
-if  nargin<9
-   init = zeros(neqs,1);
-end
-
-if  nargin<8
-    scalefactormod=1;
-end
-
-if nargin<7
-    error('Not enough inputs')
-end
-
-history = zeros(neqs,nperiods+1);
-
-    nshocks = size(irfshock,1);
-    for i = 1:nshocks
-        shockpos = strmatch(irfshock(i,:),exog_,'exact');
-        if ~isempty(shockpos)
-            irfshockpos(i) = shockpos;
-        else
-            error(['Shock ',irfshock(i,:),' is not in the model']);
-        end
-    end
-
-
-% generate data
-% history will contain data, the state vector at each period in time will
-% be stored columnwise.
-history = zeros(neqs,nperiods);
-history(:,1)= init;
-
-lengthshock = size(scalefactormod,1);
-
-errvec = zeros(size(exog_,1),1);
-
-for i = 2:nperiods+1
-    if i<=(lengthshock+1)
-        for j = 1:nshocks
-            errvec(irfshockpos(j)) = scalefactormod(i-1,j);
-        end
-        history(:,i) = decrulea * history(:,i-1)+decruleb*errvec;
-    else
-    % update endogenous variables
-    history(:,i) = decrulea * history(:,i-1);
-    end
-end
-
-% extract desired variables
-nwish=size(wishlist,1);
-wishpos = zeros(nwish,1);
-
-history=history';
-for i=1:nwish
-    wishpos(i) = strmatch(wishlist(i,:),endog_,'exact');
-end
+function [zdata]=mkdata(nperiods,decrulea,decruleb,endog_,exog_,wishlist,irfshock,scalefactormod,init)
+
+%[nsim, ksim, ysim, isim, csim] = mkdata(nperiods,cofb,endog_)
+
+% given decision rule
+neqs = size(endog_,1);
+
+if  nargin<9
+    init = zeros(neqs,1);
+end
+
+if  nargin<8
+    scalefactormod=1;
+end
+
+if nargin<7
+    error('Not enough inputs')
+end
+
+history = zeros(neqs,nperiods+1);
+
+nshocks = size(irfshock,1);
+for i = 1:nshocks
+    shockpos = strmatch(irfshock(i,:),exog_,'exact');
+    if ~isempty(shockpos)
+        irfshockpos(i) = shockpos;
+    else
+        error(['Shock ',irfshock(i,:),' is not in the model']);
+    end
+end
+
+
+% generate data
+% history will contain data, the state vector at each period in time will
+% be stored columnwise.
+history = zeros(neqs,nperiods);
+history(:,1)= init;
+
+lengthshock = size(scalefactormod,1);
+
+errvec = zeros(size(exog_,1),1);
+
+for i = 2:nperiods+1
+    if i<=(lengthshock+1)
+        for j = 1:nshocks
+            errvec(irfshockpos(j)) = scalefactormod(i-1,j);
+        end
+        history(:,i) = decrulea * history(:,i-1)+decruleb*errvec;
+    else
+        % update endogenous variables
+        history(:,i) = decrulea * history(:,i-1);
+    end
+end
+
+% extract desired variables
+nwish=size(wishlist,1);
+wishpos = zeros(nwish,1);
+
+history=history';
+for i=1:nwish
+    wishpos(i) = strmatch(wishlist(i,:),endog_,'exact');
+end
 zdata = history(2:end,wishpos);
\ No newline at end of file
diff --git a/matlab/occbin/mkdatap_anticipated.m b/matlab/occbin/mkdatap_anticipated.m
index 524d3dd5d..a9c924966 100755
--- a/matlab/occbin/mkdatap_anticipated.m
+++ b/matlab/occbin/mkdatap_anticipated.m
@@ -1,125 +1,125 @@
-function [zdata]=mkdatap_anticipated(nperiods,decrulea,decruleb,...
-    cof,Jbarmat,cofstar,Jstarbarmat,Dstarbarmat,...
-    regime,regimestart,violvecbool,...
-    endog_,exog_,irfshock,scalefactormod,init)
-
-
-
-nvars = size(endog_,1);
-
-
-if nargin<16
-    init=zeros(nvars,1);
-end
-
-if nargin<15;
-    scalefactormod=1;
-end
-
-
-nshocks = size(irfshock,1);
-for i = 1:nshocks
-    shockpos = strmatch(irfshock(i,:),exog_,'exact');
-    if ~isempty(shockpos)
-        irfshockpos(i) = shockpos;
-    else
-        error(['Shock ',irfshock(i,:),' is not in the model']);
-    end
-end
-
-
-nregimes = length(regime);
-
-Cbarmat = cof(:,1:nvars);
-Bbarmat = cof(:,nvars+1:2*nvars);
-Abarmat = cof(:,2*nvars+1:3*nvars);
-
-
-% cofstar contains the system for the model when the constraint binds
-Cstarbarmat = cofstar(:,1:nvars);
-Bstarbarmat = cofstar(:,nvars+1:2*nvars);
-Astarbarmat = cofstar(:,2*nvars+1:3*nvars);
-
-% get the time-dependent decision rules
-
-Tmax = regimestart(nregimes)-1;  % Tmax is the position of the last period
-% when the constraint binds
-
-if Tmax > 0
-    P = zeros(nvars,nvars,Tmax);
-    D = zeros(nvars,Tmax);
-    
-    
-    invmat = inv((Astarbarmat*decrulea+Bstarbarmat));
-    P(:,:,Tmax) = -invmat*Cstarbarmat;
-    D(:,Tmax) = -invmat*Dstarbarmat;
-    
-    
-    % equivalent to pre-multiplying by the inverse above if the target
-    % matrix is invertible. Otherwise it yields the minimum state solution
-    %P(:,:,Tmax) = -(Astarbarmat*decrulea+Bstarbarmat)\Cstarbarmat;
-    %D(:,Tmax) = -(Astarbarmat*decrulea+Bstarbarmat)\Dstarbarmat;
-    
- 
-    for i = Tmax-1:-1:1
-        
-        if violvecbool(i)
-            invmat = inv(Bstarbarmat+Astarbarmat*P(:,:,i+1));
-            P(:,:,i)=-invmat*Cstarbarmat;
-            D(:,i) = -invmat*(Astarbarmat*D(:,i+1)+Dstarbarmat);
-        else
-            invmat = inv(Bbarmat+Abarmat*P(:,:,i+1));
-            P(:,:,i)=-invmat*Cbarmat;
-            D(:,i) = -invmat*(Abarmat*D(:,i+1));
-        end
-    end
-
-if Tmax > 1    
-if violvecbool(1)
-    E = -invmat*Jstarbarmat;
-else
-    E = -invmat*Jbarmat;
-end
-else
-    invmat = inv(Astarbarmat*decrulea+Bstarbarmat);
-    E = -invmat*Jstarbarmat;
-
-end
-
-    
-end
-
-% generate data
-% history will contain data, the state vector at each period in time will
-% be stored columnwise.
-history = zeros(nvars,nperiods+1);
-history(:,1) = init;
-errvec = zeros(size(exog_,1),1);
-
-% deal with predetermined conditions
-for i = 1:nshocks
-    errvec(irfshockpos(i)) = scalefactormod(i);
-end
-
-% deal with shocks
-irfpos =1;
-if irfpos <=Tmax
-    history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
-        D(:,irfpos) + E*errvec;
-else
-    history(:,irfpos+1) = decrulea*history(:,irfpos)+decruleb*errvec;
-end
-
-% all other periods
-for irfpos=2:nperiods+1
-    if irfpos <=Tmax
-        history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
-            D(:,irfpos);
-    else
-        history(:,irfpos+1) = decrulea*history(:,irfpos);
-    end
-end
-
-
-history=history';
+function [zdata]=mkdatap_anticipated(nperiods,decrulea,decruleb,...
+                                     cof,Jbarmat,cofstar,Jstarbarmat,Dstarbarmat,...
+                                     regime,regimestart,violvecbool,...
+                                     endog_,exog_,irfshock,scalefactormod,init)
+
+
+
+nvars = size(endog_,1);
+
+
+if nargin<16
+    init=zeros(nvars,1);
+end
+
+if nargin<15
+    scalefactormod=1;
+end
+
+
+nshocks = size(irfshock,1);
+for i = 1:nshocks
+    shockpos = strmatch(irfshock(i,:),exog_,'exact');
+    if ~isempty(shockpos)
+        irfshockpos(i) = shockpos;
+    else
+        error(['Shock ',irfshock(i,:),' is not in the model']);
+    end
+end
+
+
+nregimes = length(regime);
+
+Cbarmat = cof(:,1:nvars);
+Bbarmat = cof(:,nvars+1:2*nvars);
+Abarmat = cof(:,2*nvars+1:3*nvars);
+
+
+% cofstar contains the system for the model when the constraint binds
+Cstarbarmat = cofstar(:,1:nvars);
+Bstarbarmat = cofstar(:,nvars+1:2*nvars);
+Astarbarmat = cofstar(:,2*nvars+1:3*nvars);
+
+% get the time-dependent decision rules
+
+Tmax = regimestart(nregimes)-1;  % Tmax is the position of the last period
+                                 % when the constraint binds
+
+if Tmax > 0
+    P = zeros(nvars,nvars,Tmax);
+    D = zeros(nvars,Tmax);
+
+
+    invmat = inv((Astarbarmat*decrulea+Bstarbarmat));
+    P(:,:,Tmax) = -invmat*Cstarbarmat;
+    D(:,Tmax) = -invmat*Dstarbarmat;
+
+
+    % equivalent to pre-multiplying by the inverse above if the target
+    % matrix is invertible. Otherwise it yields the minimum state solution
+    %P(:,:,Tmax) = -(Astarbarmat*decrulea+Bstarbarmat)\Cstarbarmat;
+    %D(:,Tmax) = -(Astarbarmat*decrulea+Bstarbarmat)\Dstarbarmat;
+
+
+    for i = Tmax-1:-1:1
+
+        if violvecbool(i)
+            invmat = inv(Bstarbarmat+Astarbarmat*P(:,:,i+1));
+            P(:,:,i)=-invmat*Cstarbarmat;
+            D(:,i) = -invmat*(Astarbarmat*D(:,i+1)+Dstarbarmat);
+        else
+            invmat = inv(Bbarmat+Abarmat*P(:,:,i+1));
+            P(:,:,i)=-invmat*Cbarmat;
+            D(:,i) = -invmat*(Abarmat*D(:,i+1));
+        end
+    end
+
+    if Tmax > 1
+        if violvecbool(1)
+            E = -invmat*Jstarbarmat;
+        else
+            E = -invmat*Jbarmat;
+        end
+    else
+        invmat = inv(Astarbarmat*decrulea+Bstarbarmat);
+        E = -invmat*Jstarbarmat;
+
+    end
+
+
+end
+
+% generate data
+% history will contain data, the state vector at each period in time will
+% be stored columnwise.
+history = zeros(nvars,nperiods+1);
+history(:,1) = init;
+errvec = zeros(size(exog_,1),1);
+
+% deal with predetermined conditions
+for i = 1:nshocks
+    errvec(irfshockpos(i)) = scalefactormod(i);
+end
+
+% deal with shocks
+irfpos =1;
+if irfpos <=Tmax
+    history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
+        D(:,irfpos) + E*errvec;
+else
+    history(:,irfpos+1) = decrulea*history(:,irfpos)+decruleb*errvec;
+end
+
+% all other periods
+for irfpos=2:nperiods+1
+    if irfpos <=Tmax
+        history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
+            D(:,irfpos);
+    else
+        history(:,irfpos+1) = decrulea*history(:,irfpos);
+    end
+end
+
+
+history=history';
 zdata = history(2:end,:);
\ No newline at end of file
diff --git a/matlab/occbin/mkdatap_anticipated_2constraints.m b/matlab/occbin/mkdatap_anticipated_2constraints.m
index b05c90d6d..496f5a931 100755
--- a/matlab/occbin/mkdatap_anticipated_2constraints.m
+++ b/matlab/occbin/mkdatap_anticipated_2constraints.m
@@ -1,180 +1,180 @@
-function [zdata]=mkdatap_anticipated_2constraints_alt(nperiods,decrulea,decruleb,...
-    cof,Jbarmat,...
-    cof10,Jbarmat10,Dbarmat10,...
-    cof01,Jbarmat01,Dbarmat01,...
-    cof11,Jbarmat11,Dbarmat11,...
-    regime1,regimestart1,...
-    regime2,regimestart2,...
-    violvecbool,endog_,exog_,...
-    irfshock,scalefactormod,init)
-
-
-nvars = size(endog_,1);
-
-
-if nargin<16
-    init=zeros(nvars,1);
-end
-
-if nargin<15;
-    scalefactormod=1;
-end
-
-
-nshocks = size(irfshock,1);
-for i = 1:nshocks
-    shockpos = strmatch(irfshock(i,:),exog_,'exact');
-    if ~isempty(shockpos)
-        irfshockpos(i) = shockpos;
-    else
-        error(['Shock ',irfshock(i,:),' is not in the model']);
-    end
-end
-
-
-
-Cbarmat = cof(:,1:nvars);
-Bbarmat = cof(:,nvars+1:2*nvars);
-Abarmat = cof(:,2*nvars+1:3*nvars);
-
-
-% cofstar contains the system for the model when the constraint binds
-
-
-Cbarmat10 = cof10(:,1:nvars);
-Bbarmat10 = cof10(:,nvars+1:2*nvars);
-Abarmat10 = cof10(:,2*nvars+1:3*nvars);
-
-Cbarmat01 = cof01(:,1:nvars);
-Bbarmat01 = cof01(:,nvars+1:2*nvars);
-Abarmat01 = cof01(:,2*nvars+1:3*nvars);
-
-Cbarmat11 = cof11(:,1:nvars);
-Bbarmat11 = cof11(:,nvars+1:2*nvars);
-Abarmat11 = cof11(:,2*nvars+1:3*nvars);
-
-% get the time-dependent decision rules
-nregimes1 = length(regime1);
-nregimes2 = length(regime2);
-
-Tmax = max([regimestart1(nregimes1) regimestart2(nregimes2)])-1;  % Tmax is the position of the last period
-% when the constraint binds
-
-if Tmax > 0
-    P = zeros(nvars,nvars,Tmax);
-    D = zeros(nvars,Tmax);
-    
-%     invmat = inv((Astarbarmat*decrulea+Bstarbarmat));
-%     P(:,:,Tmax) = -invmat*Cstarbarmat;
-%     D(:,Tmax) = -invmat*Dstarbarmat;
-    
-    
-    if (violvecbool(Tmax,1) & ~violvecbool(Tmax,2))
-    %XXX fix next three lines
-    invmat = inv((Abarmat10*decrulea+Bbarmat10));
-    P(:,:,Tmax) = -invmat*Cbarmat10;
-    D(:,Tmax) = -invmat*Dbarmat10;  
-    elseif (violvecbool(Tmax,1) & violvecbool(Tmax,2))
-    invmat = inv((Abarmat11*decrulea+Bbarmat11));
-    P(:,:,Tmax) = -invmat*Cbarmat11;
-    D(:,Tmax) = -invmat*Dbarmat11;
-    else
-    invmat = inv((Abarmat01*decrulea+Bbarmat01));
-    P(:,:,Tmax) = -invmat*Cbarmat01;
-    D(:,Tmax) = -invmat*Dbarmat01;  
-    end
-    
-    
-    
-    
-    for i = Tmax-1:-1:1        
-        
-        if (violvecbool(i,1) & ~violvecbool(i,2))
-            invmat = inv(Bbarmat10+Abarmat10*P(:,:,i+1));
-            P(:,:,i)=-invmat*Cbarmat10;
-            D(:,i) = -invmat*(Abarmat10*D(:,i+1)+Dbarmat10);
-        elseif (~violvecbool(i,1) & violvecbool(i,2))
-            invmat = inv(Bbarmat01+Abarmat01*P(:,:,i+1));
-            P(:,:,i)=-invmat*Cbarmat01;
-            D(:,i) = -invmat*(Abarmat01*D(:,i+1)+Dbarmat01);
-        elseif (violvecbool(i,1) & violvecbool(i,2))
-            invmat = inv(Bbarmat11+Abarmat11*P(:,:,i+1));
-            P(:,:,i)=-invmat*Cbarmat11;
-            D(:,i) = -invmat*(Abarmat11*D(:,i+1)+Dbarmat11);
-        else
-            invmat = inv(Bbarmat+Abarmat*P(:,:,i+1));
-            P(:,:,i)=-invmat*Cbarmat;
-            D(:,i) = -invmat*(Abarmat*D(:,i+1));
-        end
-        
-    end
-
-    
-% Double check the appropriate invmat in each case
-% right now -- inherited from previous loop
-if Tmax > 1
-    
-    if ( ~violvecbool(1,1) & violvecbool(1,2) )
-        E = -invmat*Jbarmat01;
-    elseif ( violvecbool(1,1) & ~violvecbool(1,2) )
-        E = -invmat*Jbarmat10;
-    elseif ( violvecbool(1,1) & violvecbool(1,2) )
-        E = -invmat*Jbarmat11;
-    else
-        E = -invmat*Jbarmat;
-    end
-    
-else  % Tmax is equal to 1    
-%     invmat = inv((Astarbarmat*decrulea+Bstarbarmat));
-%     E = -invmat*Jstarbarmat;
-    
-    if ( ~violvecbool(1,1) & violvecbool(1,2) )
-       invmat = inv((Abarmat01*decrulea+Bbarmat01));
-       E = -invmat*Jbarmat01;  
-    elseif ( violvecbool(1,1) & violvecbool(1,2) )
-        invmat = inv((Abarmat11*decrulea+Bbarmat11));
-        E = -invmat*Jbarmat11;     
-    else
-        invmat = inv((Abarmat10*decrulea+Bbarmat10));
-        E = -invmat*Jbarmat10;
-            
-    end
-    
-end
-
-    
-end
-
-% generate data
-% history will contain data, the state vector at each period in time will
-% be stored columnwise.
-history = zeros(nvars,nperiods+1);
-history(:,1) = init;
-errvec = zeros(size(exog_,1),1);
-
-for i = 1:nshocks
-    errvec(irfshockpos(i)) = scalefactormod(i);
-end
-
-% deal with shocks
-irfpos =1;
-if irfpos <=Tmax
-    history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
-        D(:,irfpos) + E*errvec;
-else
-    history(:,irfpos+1) = decrulea*history(:,irfpos)+decruleb*errvec;
-end
-
-% all other periods
-for irfpos=2:nperiods+1
-    if irfpos <=Tmax
-        history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
-            D(:,irfpos);
-    else
-        history(:,irfpos+1) = decrulea*history(:,irfpos);
-    end
-end
-
-
-history=history';
+function [zdata]=mkdatap_anticipated_2constraints(nperiods,decrulea,decruleb,...
+                                                  cof,Jbarmat,...
+                                                  cof10,Jbarmat10,Dbarmat10,...
+                                                  cof01,Jbarmat01,Dbarmat01,...
+                                                  cof11,Jbarmat11,Dbarmat11,...
+                                                  regime1,regimestart1,...
+                                                  regime2,regimestart2,...
+                                                  violvecbool,endog_,exog_,...
+                                                  irfshock,scalefactormod,init)
+
+
+nvars = size(endog_,1);
+
+
+if nargin<16
+    init=zeros(nvars,1);
+end
+
+if nargin<15
+    scalefactormod=1;
+end
+
+
+nshocks = size(irfshock,1);
+for i = 1:nshocks
+    shockpos = strmatch(irfshock(i,:),exog_,'exact');
+    if ~isempty(shockpos)
+        irfshockpos(i) = shockpos;
+    else
+        error(['Shock ',irfshock(i,:),' is not in the model']);
+    end
+end
+
+
+
+Cbarmat = cof(:,1:nvars);
+Bbarmat = cof(:,nvars+1:2*nvars);
+Abarmat = cof(:,2*nvars+1:3*nvars);
+
+
+% cofstar contains the system for the model when the constraint binds
+
+
+Cbarmat10 = cof10(:,1:nvars);
+Bbarmat10 = cof10(:,nvars+1:2*nvars);
+Abarmat10 = cof10(:,2*nvars+1:3*nvars);
+
+Cbarmat01 = cof01(:,1:nvars);
+Bbarmat01 = cof01(:,nvars+1:2*nvars);
+Abarmat01 = cof01(:,2*nvars+1:3*nvars);
+
+Cbarmat11 = cof11(:,1:nvars);
+Bbarmat11 = cof11(:,nvars+1:2*nvars);
+Abarmat11 = cof11(:,2*nvars+1:3*nvars);
+
+% get the time-dependent decision rules
+nregimes1 = length(regime1);
+nregimes2 = length(regime2);
+
+Tmax = max([regimestart1(nregimes1) regimestart2(nregimes2)])-1;  % Tmax is the position of the last period
+                                                                  % when the constraint binds
+
+if Tmax > 0
+    P = zeros(nvars,nvars,Tmax);
+    D = zeros(nvars,Tmax);
+
+    %     invmat = inv((Astarbarmat*decrulea+Bstarbarmat));
+    %     P(:,:,Tmax) = -invmat*Cstarbarmat;
+    %     D(:,Tmax) = -invmat*Dstarbarmat;
+
+
+    if (violvecbool(Tmax,1) & ~violvecbool(Tmax,2))
+        %XXX fix next three lines
+        invmat = inv((Abarmat10*decrulea+Bbarmat10));
+        P(:,:,Tmax) = -invmat*Cbarmat10;
+        D(:,Tmax) = -invmat*Dbarmat10;
+    elseif (violvecbool(Tmax,1) & violvecbool(Tmax,2))
+        invmat = inv((Abarmat11*decrulea+Bbarmat11));
+        P(:,:,Tmax) = -invmat*Cbarmat11;
+        D(:,Tmax) = -invmat*Dbarmat11;
+    else
+        invmat = inv((Abarmat01*decrulea+Bbarmat01));
+        P(:,:,Tmax) = -invmat*Cbarmat01;
+        D(:,Tmax) = -invmat*Dbarmat01;
+    end
+
+
+
+
+    for i = Tmax-1:-1:1
+
+        if (violvecbool(i,1) & ~violvecbool(i,2))
+            invmat = inv(Bbarmat10+Abarmat10*P(:,:,i+1));
+            P(:,:,i)=-invmat*Cbarmat10;
+            D(:,i) = -invmat*(Abarmat10*D(:,i+1)+Dbarmat10);
+        elseif (~violvecbool(i,1) & violvecbool(i,2))
+            invmat = inv(Bbarmat01+Abarmat01*P(:,:,i+1));
+            P(:,:,i)=-invmat*Cbarmat01;
+            D(:,i) = -invmat*(Abarmat01*D(:,i+1)+Dbarmat01);
+        elseif (violvecbool(i,1) & violvecbool(i,2))
+            invmat = inv(Bbarmat11+Abarmat11*P(:,:,i+1));
+            P(:,:,i)=-invmat*Cbarmat11;
+            D(:,i) = -invmat*(Abarmat11*D(:,i+1)+Dbarmat11);
+        else
+            invmat = inv(Bbarmat+Abarmat*P(:,:,i+1));
+            P(:,:,i)=-invmat*Cbarmat;
+            D(:,i) = -invmat*(Abarmat*D(:,i+1));
+        end
+
+    end
+
+
+    % Double check the appropriate invmat in each case
+    % right now -- inherited from previous loop
+    if Tmax > 1
+
+        if ( ~violvecbool(1,1) & violvecbool(1,2) )
+            E = -invmat*Jbarmat01;
+        elseif ( violvecbool(1,1) & ~violvecbool(1,2) )
+            E = -invmat*Jbarmat10;
+        elseif ( violvecbool(1,1) & violvecbool(1,2) )
+            E = -invmat*Jbarmat11;
+        else
+            E = -invmat*Jbarmat;
+        end
+
+    else  % Tmax is equal to 1
+          %     invmat = inv((Astarbarmat*decrulea+Bstarbarmat));
+          %     E = -invmat*Jstarbarmat;
+
+        if ( ~violvecbool(1,1) & violvecbool(1,2) )
+            invmat = inv((Abarmat01*decrulea+Bbarmat01));
+            E = -invmat*Jbarmat01;
+        elseif ( violvecbool(1,1) & violvecbool(1,2) )
+            invmat = inv((Abarmat11*decrulea+Bbarmat11));
+            E = -invmat*Jbarmat11;
+        else
+            invmat = inv((Abarmat10*decrulea+Bbarmat10));
+            E = -invmat*Jbarmat10;
+
+        end
+
+    end
+
+
+end
+
+% generate data
+% history will contain data, the state vector at each period in time will
+% be stored columnwise.
+history = zeros(nvars,nperiods+1);
+history(:,1) = init;
+errvec = zeros(size(exog_,1),1);
+
+for i = 1:nshocks
+    errvec(irfshockpos(i)) = scalefactormod(i);
+end
+
+% deal with shocks
+irfpos =1;
+if irfpos <=Tmax
+    history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
+        D(:,irfpos) + E*errvec;
+else
+    history(:,irfpos+1) = decrulea*history(:,irfpos)+decruleb*errvec;
+end
+
+% all other periods
+for irfpos=2:nperiods+1
+    if irfpos <=Tmax
+        history(:,irfpos+1) = P(:,:,irfpos)* history(:,irfpos)+...
+            D(:,irfpos);
+    else
+        history(:,irfpos+1) = decrulea*history(:,irfpos);
+    end
+end
+
+
+history=history';
 zdata = history(2:end,:);
\ No newline at end of file
diff --git a/matlab/occbin/pickaxes.m b/matlab/occbin/pickaxes.m
index 46c4b79c6..26c9b6b1a 100755
--- a/matlab/occbin/pickaxes.m
+++ b/matlab/occbin/pickaxes.m
@@ -1,16 +1,16 @@
-function [x0,x1,y0,y1] = pickaxes(xvalues,yvalues)
-
-x0=xvalues(1);
-nobs = length(xvalues);
-x1=xvalues(nobs);
-
-maxy = max(yvalues);
-miny = min(yvalues);
-
-
-y0 = miny - .05*abs(miny);
-if (miny>0 & y0<0) 
-    y0 = 0;
-end
-
-y1 = maxy + .05*abs(maxy);
+function [x0,x1,y0,y1] = pickaxes(xvalues,yvalues)
+
+x0=xvalues(1);
+nobs = length(xvalues);
+x1=xvalues(nobs);
+
+maxy = max(yvalues);
+miny = min(yvalues);
+
+
+y0 = miny - .05*abs(miny);
+if (miny>0 & y0<0)
+    y0 = 0;
+end
+
+y1 = maxy + .05*abs(maxy);
diff --git a/matlab/occbin/process_constraint.m b/matlab/occbin/process_constraint.m
index d20911175..2d2b35f36 100755
--- a/matlab/occbin/process_constraint.m
+++ b/matlab/occbin/process_constraint.m
@@ -1,38 +1,38 @@
-% this function looks for occurrences of the endogenous variables in
-% endo_names in the input string constraint
-% all occurrences of the endogenous variables are appended a suffix
-% if the invert_switch is true, the direction of the inequality in the
-% constraint is inverted
-
-function constraint1 = process_constraint(constraint,suffix,endo_names,invert_switch)
-
-% create a list of delimiters that can separate parameters and endogenoous
-% variables in the string that expresses the constraint
-delimiters = char(',',';','(',')','+','-','^','*','/',' ','>','<','=');
-
-% split the string that holds the constraint into tokens
-tokens = tokenize(constraint,delimiters);
-
-ntokens = length(tokens);
-
-% search for tokens that match the list of endogenous variables
-for i=1:ntokens
-    if ~isempty(find(strcmp(tokens(i),endo_names)))
-        % when there is a match with an endogenous variable append the
-        % suffix
-        tokens(i) = cellstr([char(tokens(i)),suffix]);
-    end
-    
-    % if the invert_switch is true
-    % reverse the direction of the inequality
-    if invert_switch
-        if  strcmp(tokens(i),cellstr('>'))
-            tokens(i) = cellstr('<');
-        elseif strcmp(tokens(i),cellstr('<'))
-            tokens(i) = cellstr('>');
-        end
-    end
-end
-
-% reassemble the tokens to create a string that expresses the constraint
+% this function looks for occurrences of the endogenous variables in
+% endo_names in the input string constraint
+% all occurrences of the endogenous variables are appended a suffix
+% if the invert_switch is true, the direction of the inequality in the
+% constraint is inverted
+
+function constraint1 = process_constraint(constraint,suffix,endo_names,invert_switch)
+
+% create a list of delimiters that can separate parameters and endogenoous
+% variables in the string that expresses the constraint
+delimiters = char(',',';','(',')','+','-','^','*','/',' ','>','<','=');
+
+% split the string that holds the constraint into tokens
+tokens = tokenize(constraint,delimiters);
+
+ntokens = length(tokens);
+
+% search for tokens that match the list of endogenous variables
+for i=1:ntokens
+    if ~isempty(find(strcmp(tokens(i),endo_names)))
+        % when there is a match with an endogenous variable append the
+        % suffix
+        tokens(i) = cellstr([char(tokens(i)),suffix]);
+    end
+
+    % if the invert_switch is true
+    % reverse the direction of the inequality
+    if invert_switch
+        if  strcmp(tokens(i),cellstr('>'))
+            tokens(i) = cellstr('<');
+        elseif strcmp(tokens(i),cellstr('<'))
+            tokens(i) = cellstr('>');
+        end
+    end
+end
+
+% reassemble the tokens to create a string that expresses the constraint
 constraint1 = strmerge(tokens);
\ No newline at end of file
diff --git a/matlab/occbin/setss.m b/matlab/occbin/setss.m
index d1c0e440a..7fc52f6c0 100755
--- a/matlab/occbin/setss.m
+++ b/matlab/occbin/setss.m
@@ -1,14 +1,13 @@
-% Script that retrieves parameter values once model is solved
-
-nendog = size(Mbase_.endo_names,1);
-
-for i=1:nendog
-  eval([deblank(Mbase_.endo_names(i,:)) '_ss = oo_.dr.ys(i); ']);
-end
-
-nparams = size(Mbase_.param_names);
-
-for i = 1:nparams
-  eval([Mbase_.param_names(i,:),'= M_.params(i);']);
-end
-
+% Script that retrieves parameter values once model is solved
+
+nendog = size(Mbase_.endo_names,1);
+
+for i=1:nendog
+    eval([deblank(Mbase_.endo_names(i,:)) '_ss = oo_.dr.ys(i); ']);
+end
+
+nparams = size(Mbase_.param_names);
+
+for i = 1:nparams
+    eval([Mbase_.param_names(i,:),'= M_.params(i);']);
+end
diff --git a/matlab/occbin/solve_no_constraint.m b/matlab/occbin/solve_no_constraint.m
index d9671409d..27af64f1c 100755
--- a/matlab/occbin/solve_no_constraint.m
+++ b/matlab/occbin/solve_no_constraint.m
@@ -1,50 +1,49 @@
-function [zdata_, zdatass_, oobase_, Mbase_ ] = ...
-    solve_no_constraint(modnam,...
-    shockssequence,irfshock,nperiods)
-
-global M_ oo_
-
-errlist = [];
-
-% solve model
-eval(['dynare ',modnam,' noclearall'])
-oobase_ = oo_;
-Mbase_ = M_;
-
-ys_ = oobase_.dr.ys;
-nvars = numel(ys_);
-zdatass_ = ys_ ;
-
-for i=1:Mbase_.endo_nbr
-  eval([deblank(Mbase_.endo_names(i,:)) '_ss = oo_.dr.ys(i); ']);
-end
-
-for i = 1:size(Mbase_.param_names)
-  eval([Mbase_.param_names(i,:),'= M_.params(i);']);
-end
-
-
-
-
-
-
-
-[hm1,h,hl1,Jbarmat] = get_deriv(Mbase_,ys_);
-cof = [hm1,h,hl1];
-
-[decrulea,decruleb]=get_pq(oobase_.dr);
-endog_ = M_.endo_names;
-exog_ =  M_.exo_names;
-
-nvars = numel(Mbase_.endo_nbr);
-
-
-nshocks = size(shockssequence,1);
-init = zeros(nvars,1);
-
-wishlist = endog_;
-nwishes = size(wishlist,1);
-
-
-zdata_ = mkdata(nperiods,decrulea,decruleb,endog_,exog_,wishlist,irfshock,shockssequence);
-
+function [zdata_, zdatass_, oobase_, Mbase_ ] = ...
+    solve_no_constraint(modnam,...
+                        shockssequence,irfshock,nperiods)
+
+global M_ oo_
+
+errlist = [];
+
+% solve model
+eval(['dynare ',modnam,' noclearall'])
+oobase_ = oo_;
+Mbase_ = M_;
+
+ys_ = oobase_.dr.ys;
+nvars = numel(ys_);
+zdatass_ = ys_ ;
+
+for i=1:Mbase_.endo_nbr
+    eval([deblank(Mbase_.endo_names(i,:)) '_ss = oo_.dr.ys(i); ']);
+end
+
+for i = 1:size(Mbase_.param_names)
+    eval([Mbase_.param_names(i,:),'= M_.params(i);']);
+end
+
+
+
+
+
+
+
+[hm1,h,hl1,Jbarmat] = get_deriv(Mbase_,ys_);
+cof = [hm1,h,hl1];
+
+[decrulea,decruleb]=get_pq(oobase_.dr);
+endog_ = M_.endo_names;
+exog_ =  M_.exo_names;
+
+nvars = numel(Mbase_.endo_nbr);
+
+
+nshocks = size(shockssequence,1);
+init = zeros(nvars,1);
+
+wishlist = endog_;
+nwishes = size(wishlist,1);
+
+
+zdata_ = mkdata(nperiods,decrulea,decruleb,endog_,exog_,wishlist,irfshock,shockssequence);
diff --git a/matlab/occbin/solve_no_constraint_noclear.m b/matlab/occbin/solve_no_constraint_noclear.m
index 309c5c546..8012f9126 100755
--- a/matlab/occbin/solve_no_constraint_noclear.m
+++ b/matlab/occbin/solve_no_constraint_noclear.m
@@ -1,48 +1,47 @@
-function [zdata oobase_ Mbase_ ] = ...
-    solve_no_constraint_noclear(modnam,...
-    shockssequence,irfshock,nperiods);
-
-global M_ oo_
-
-errlist = [];
-
-% solve model
-eval(['dynare ',modnam,'  nolog']);
-oobase_ = oo_;
-Mbase_ = M_;
-
-ys_ = oobase_.dr.ys;
-
-for i=1:Mbase_.endo_nbr
-  eval([deblank(Mbase_.endo_names(i,:)) '_ss = oo_.dr.ys(i); ']);
-end
-
-for i = 1:size(Mbase_.param_names)
-  eval([Mbase_.param_names(i,:),'= M_.params(i);']);
-end
-
-setss
-
-
-
-
-
-[hm1,h,hl1,Jbarmat] = get_deriv(Mbase_,ys_);
-cof = [hm1,h,hl1];
-
-[decrulea,decruleb]=get_pq(oobase_.dr);
-endog_ = M_.endo_names;
-exog_ =  M_.exo_names;
-
-
-nvars = numel(Mbase_.endo_nbr);
-
-nshocks = size(shockssequence,1);
-init = zeros(nvars,1);
-
-wishlist = endog_;
-nwishes = size(wishlist,1);
-
-
-zdata = mkdata(nperiods,decrulea,decruleb,endog_,exog_,wishlist,irfshock,shockssequence);
-
+function [zdata, oobase_, Mbase_ ] = ...
+    solve_no_constraint_noclear(modnam,...
+                                shockssequence,irfshock,nperiods)
+
+global M_ oo_
+
+errlist = [];
+
+% solve model
+eval(['dynare ',modnam,'  nolog']);
+oobase_ = oo_;
+Mbase_ = M_;
+
+ys_ = oobase_.dr.ys;
+
+for i=1:Mbase_.endo_nbr
+    eval([deblank(Mbase_.endo_names(i,:)) '_ss = oo_.dr.ys(i); ']);
+end
+
+for i = 1:size(Mbase_.param_names)
+    eval([Mbase_.param_names(i,:),'= M_.params(i);']);
+end
+
+setss
+
+
+
+
+
+[hm1,h,hl1,Jbarmat] = get_deriv(Mbase_,ys_);
+cof = [hm1,h,hl1];
+
+[decrulea,decruleb]=get_pq(oobase_.dr);
+endog_ = M_.endo_names;
+exog_ =  M_.exo_names;
+
+
+nvars = numel(Mbase_.endo_nbr);
+
+nshocks = size(shockssequence,1);
+init = zeros(nvars,1);
+
+wishlist = endog_;
+nwishes = size(wishlist,1);
+
+
+zdata = mkdata(nperiods,decrulea,decruleb,endog_,exog_,wishlist,irfshock,shockssequence);
diff --git a/matlab/occbin/solve_one_constraint.1.m b/matlab/occbin/solve_one_constraint.1.m
index 34e296496..aa155c234 100755
--- a/matlab/occbin/solve_one_constraint.1.m
+++ b/matlab/occbin/solve_one_constraint.1.m
@@ -1,192 +1,192 @@
-% solve_one_constraint [zdatalinear zdatapiecewise zdatass oo base M base] = solve one constraint(modnam, modnamstar, constraint, constraint relax, shockssequence, irfshock, nperiods, maxiter, init);
-% 
-% Inputs: 
-% modnam: name of .mod file for the reference regime (excludes the .mod extension).
-% modnamstar: name of .mod file for the alternative regime (excludes the .mod exten- sion).
-% constraint: the constraint (see notes 1 and 2 below). When the condition in constraint evaluates to true, the solution switches from the reference to the alternative regime.
-% constraint relax: when the condition in constraint relax evaluates to true, the solution returns to the reference regime.
-% shockssequence: a sequence of unforeseen shocks under which one wants to solve the model (size T×nshocks).
-% irfshock: label for innovation for IRFs, from Dynare .mod file (one or more of the ?varexo?).
-% nperiods: simulation horizon (can be longer than the sequence of shocks defined in shockssequence; must be long enough to ensure convergence back to the reference model at the end of the simulation horizon and may need to be varied depending on the sequence of shocks).
-% maxiter: maximum number of iterations allowed for the solution algorithm (20 if not specified).
-% init:	the initial position for the vector of state variables, in deviation from steady state (if not specified, the default is steady state). The ordering follows the definition order in the .mod files.
-%
-% Outputs:
-% zdatalinear: an array containing paths for all endogenous variables ignoring the occasionally binding constraint (the linear solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
-% zdatapiecewise: an array containing paths for all endogenous variables satisfying the occasionally binding constraint (the occbin/piecewise solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
-% zdatass: theinitialpositionforthevectorofstatevariables,indeviationfromsteady state (if not specified, the default is a vectors of zero implying that the initial conditions coincide with the steady state). The ordering follows the definition order in the .mod files.
-% oobase,Mbase: structures produced by Dynare for the reference model ? see Dynare User Guide.
-
-% Log of changes:
-% 6/17/2013 -- Luca added a trailing underscore to local variables in an
-% attempt to avoid conflicts with parameter names defined in the .mod files
-% to be processed.
-% 6/17/2013 -- Luca replaced external .m file setss.m
-
-
-function [zdatalinear_ zdatapiecewise_ zdatass_ oobase_ Mbase_  ] = ...
-    solve_one_constraint(modnam_,modnamstar_,...
-    constraint_, constraint_relax_,...
-    shockssequence_,irfshock_,nperiods_,maxiter_,init_)
-
-global M_ oo_
-
-errlist_ = [];
-
-% solve the reference model linearly
-eval(['dynare ',modnam_,' noclearall nolog '])
-oobase_ = oo_;
-Mbase_ = M_;
-
-% import locally the values of parameters assigned in the reference .mod
-% file
-for i_indx_ = 1:Mbase_.param_nbr
-  eval([Mbase_.param_names(i_indx_,:),'= M_.params(i_indx_);']);
-end
-
-% Create steady state values of the variables if needed for processing the constraint
-for i=1:Mbase_.endo_nbr
-   eval([deblank(Mbase_.endo_names(i,:)) '_ss = oobase_.dr.ys(i); ']);
-end
-
-
-% parse the .mod file for the alternative regime
-eval(['dynare ',modnamstar_,' noclearall nolog '])
-oostar_ = oo_;
-Mstar_ = M_;
-
-
-% check inputs
-if ~strcmp(Mbase_.endo_names,Mstar_.endo_names)
-    error('The two .mod files need to have exactly the same endogenous variables declared in the same order')
-end
-
-if ~strcmp(Mbase_.exo_names,Mstar_.exo_names)
-    error('The two .mod files need to have exactly the same exogenous variables declared in the same order')
-end
-
-if ~strcmp(Mbase_.param_names,Mstar_.param_names)
-    warning('The parameter list does not match across .mod files')
-end
-
-% ensure that the two models have the same parameters
-% use the parameters for the base model.
-Mstar_.params = Mbase_.params;
-
-nvars_ = Mbase_.endo_nbr;
-zdatass_ = oobase_.dr.ys;
-
-
-% get the matrices holding the first derivatives for the model
-% each regime is treated separately
-[hm1_,h_,hl1_,Jbarmat_] = get_deriv(Mbase_,zdatass_);
-cof_ = [hm1_,h_,hl1_];
-
-[hm1_,h_,hl1_,Jstarbarmat_,resid_] = get_deriv(Mstar_,zdatass_);
-cofstar_ = [hm1_,h_,hl1_];
-Dstartbarmat_ = resid_;
-
-[decrulea_,decruleb_]=get_pq(oobase_.dr);
-endog_ = M_.endo_names;
-exog_ =  M_.exo_names;
-
-
-% processes the constraints specified in the call to this function
-% uppend a suffix to each endogenous variable
-constraint_difference_ = process_constraint(constraint_,'_difference',Mbase_.endo_names,0);
-
-constraint_relax_difference_ = process_constraint(constraint_relax_,'_difference',Mbase_.endo_names,0);
-
-
-
-nshocks_ = size(shockssequence_,1);
-
-% if necessary, set default values for optional arguments
-if ~exist('init_')
-    init_ = zeros(nvars_,1);
-end
-
-if ~exist('maxiter_')
-    maxiter_ = 20;
-end
-
-if ~exist('nperiods_')
-    nperiods_ = 100;
-end
-
-
-% set some initial conditions and loop through the shocks 
-% period by period
-init_orig_ = init_;
-zdatapiecewise_ = zeros(nperiods_,nvars_);
-wishlist_ = endog_;
-nwishes_ = size(wishlist_,1);
-violvecbool_ = zeros(nperiods_+1,1);
-
-
-for ishock_ = 1:nshocks_
-    
-    changes_=1;
-    iter_ = 0;
-    
-    
-    while (changes_ & iter_<maxiter_)
-        iter_ = iter_ +1;
-        
-        % analyze when each regime starts based on current guess
-        [regime regimestart]=map_regime(violvecbool_);
-        
-        
-        % get the hypothesized piece wise linear solution
-        [zdatalinear_]=mkdatap_anticipated(nperiods_,decrulea_,decruleb_,...
-            cof_,Jbarmat_,cofstar_,Jstarbarmat_,Dstartbarmat_,...
-            regime,regimestart,violvecbool_,...
-            endog_,exog_,irfshock_,shockssequence_(ishock_,:),init_);
-        
-        for i_indx_=1:nwishes_
-            eval([deblank(wishlist_(i_indx_,:)),'_difference=zdatalinear_(:,i_indx_);']);
-        end
-        
-        
-        
-        newviolvecbool_ = eval(constraint_difference_);
-        relaxconstraint_ = eval(constraint_relax_difference_);
-        
-        
-        
-        % check if changes to the hypothesis of the duration for each
-        % regime
-        if (max(newviolvecbool_-violvecbool_>0)) | sum(relaxconstraint_(find(violvecbool_==1))>0)
-            changes_ = 1;
-        else
-            changes_ = 0;
-        end
-        
-        
-        violvecbool_ = (violvecbool_|newviolvecbool_)-(relaxconstraint_ & violvecbool_);
-        
-        
-    end
-    
-    init_ = zdatalinear_(1,:);
-    zdatapiecewise_(ishock_,:)=init_;
-    init_= init_';
-    
-    % reset violvecbool_ for next period's shock -- this resetting is 
-    % consistent with expecting no additional shocks
-    violvecbool_=[violvecbool_(2:end);0];
-    
-end
-
-% if necessary, fill in the rest of the path with the remainder of the 
-% last IRF computed.
-zdatapiecewise_(ishock_+1:end,:)=zdatalinear_(2:nperiods_-ishock_+1,:);
-
-% get the linear responses
-zdatalinear_ = mkdata(max(nperiods_,size(shockssequence_,1)),...
-                  decrulea_,decruleb_,endog_,exog_,...
-                  wishlist_,irfshock_,shockssequence_,init_orig_);
-
-if changes_ ==1
-    display('Did not converge -- increase maxiter_')
-end
+% solve_one_constraint [zdatalinear zdatapiecewise zdatass oo base M base] = solve one constraint(modnam, modnamstar, constraint, constraint relax, shockssequence, irfshock, nperiods, maxiter, init);
+%
+% Inputs:
+% modnam: name of .mod file for the reference regime (excludes the .mod extension).
+% modnamstar: name of .mod file for the alternative regime (excludes the .mod exten- sion).
+% constraint: the constraint (see notes 1 and 2 below). When the condition in constraint evaluates to true, the solution switches from the reference to the alternative regime.
+% constraint relax: when the condition in constraint relax evaluates to true, the solution returns to the reference regime.
+% shockssequence: a sequence of unforeseen shocks under which one wants to solve the model (size T×nshocks).
+% irfshock: label for innovation for IRFs, from Dynare .mod file (one or more of the ?varexo?).
+% nperiods: simulation horizon (can be longer than the sequence of shocks defined in shockssequence; must be long enough to ensure convergence back to the reference model at the end of the simulation horizon and may need to be varied depending on the sequence of shocks).
+% maxiter: maximum number of iterations allowed for the solution algorithm (20 if not specified).
+% init: the initial position for the vector of state variables, in deviation from steady state (if not specified, the default is steady state). The ordering follows the definition order in the .mod files.
+%
+% Outputs:
+% zdatalinear: an array containing paths for all endogenous variables ignoring the occasionally binding constraint (the linear solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
+% zdatapiecewise: an array containing paths for all endogenous variables satisfying the occasionally binding constraint (the occbin/piecewise solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
+% zdatass: theinitialpositionforthevectorofstatevariables,indeviationfromsteady state (if not specified, the default is a vectors of zero implying that the initial conditions coincide with the steady state). The ordering follows the definition order in the .mod files.
+% oobase,Mbase: structures produced by Dynare for the reference model ? see Dynare User Guide.
+
+% Log of changes:
+% 6/17/2013 -- Luca added a trailing underscore to local variables in an
+% attempt to avoid conflicts with parameter names defined in the .mod files
+% to be processed.
+% 6/17/2013 -- Luca replaced external .m file setss.m
+
+
+function [zdatalinear_ zdatapiecewise_ zdatass_ oobase_ Mbase_  ] = ...
+    solve_one_constraint.1(modnam_,modnamstar_,...
+                         constraint_, constraint_relax_,...
+                         shockssequence_,irfshock_,nperiods_,maxiter_,init_)
+
+global M_ oo_
+
+errlist_ = [];
+
+% solve the reference model linearly
+eval(['dynare ',modnam_,' noclearall nolog '])
+oobase_ = oo_;
+Mbase_ = M_;
+
+% import locally the values of parameters assigned in the reference .mod
+% file
+for i_indx_ = 1:Mbase_.param_nbr
+    eval([Mbase_.param_names(i_indx_,:),'= M_.params(i_indx_);']);
+end
+
+% Create steady state values of the variables if needed for processing the constraint
+for i=1:Mbase_.endo_nbr
+    eval([deblank(Mbase_.endo_names(i,:)) '_ss = oobase_.dr.ys(i); ']);
+end
+
+
+% parse the .mod file for the alternative regime
+eval(['dynare ',modnamstar_,' noclearall nolog '])
+oostar_ = oo_;
+Mstar_ = M_;
+
+
+% check inputs
+if ~strcmp(Mbase_.endo_names,Mstar_.endo_names)
+    error('The two .mod files need to have exactly the same endogenous variables declared in the same order')
+end
+
+if ~strcmp(Mbase_.exo_names,Mstar_.exo_names)
+    error('The two .mod files need to have exactly the same exogenous variables declared in the same order')
+end
+
+if ~strcmp(Mbase_.param_names,Mstar_.param_names)
+    warning('The parameter list does not match across .mod files')
+end
+
+% ensure that the two models have the same parameters
+% use the parameters for the base model.
+Mstar_.params = Mbase_.params;
+
+nvars_ = Mbase_.endo_nbr;
+zdatass_ = oobase_.dr.ys;
+
+
+% get the matrices holding the first derivatives for the model
+% each regime is treated separately
+[hm1_,h_,hl1_,Jbarmat_] = get_deriv(Mbase_,zdatass_);
+cof_ = [hm1_,h_,hl1_];
+
+[hm1_,h_,hl1_,Jstarbarmat_,resid_] = get_deriv(Mstar_,zdatass_);
+cofstar_ = [hm1_,h_,hl1_];
+Dstartbarmat_ = resid_;
+
+[decrulea_,decruleb_]=get_pq(oobase_.dr);
+endog_ = M_.endo_names;
+exog_ =  M_.exo_names;
+
+
+% processes the constraints specified in the call to this function
+% uppend a suffix to each endogenous variable
+constraint_difference_ = process_constraint(constraint_,'_difference',Mbase_.endo_names,0);
+
+constraint_relax_difference_ = process_constraint(constraint_relax_,'_difference',Mbase_.endo_names,0);
+
+
+
+nshocks_ = size(shockssequence_,1);
+
+% if necessary, set default values for optional arguments
+if ~exist('init_')
+    init_ = zeros(nvars_,1);
+end
+
+if ~exist('maxiter_')
+    maxiter_ = 20;
+end
+
+if ~exist('nperiods_')
+    nperiods_ = 100;
+end
+
+
+% set some initial conditions and loop through the shocks
+% period by period
+init_orig_ = init_;
+zdatapiecewise_ = zeros(nperiods_,nvars_);
+wishlist_ = endog_;
+nwishes_ = size(wishlist_,1);
+violvecbool_ = zeros(nperiods_+1,1);
+
+
+for ishock_ = 1:nshocks_
+
+    changes_=1;
+    iter_ = 0;
+
+
+    while (changes_ & iter_<maxiter_)
+        iter_ = iter_ +1;
+
+        % analyze when each regime starts based on current guess
+        [regime regimestart]=map_regime(violvecbool_);
+
+
+        % get the hypothesized piece wise linear solution
+        [zdatalinear_]=mkdatap_anticipated(nperiods_,decrulea_,decruleb_,...
+                                           cof_,Jbarmat_,cofstar_,Jstarbarmat_,Dstartbarmat_,...
+                                           regime,regimestart,violvecbool_,...
+                                           endog_,exog_,irfshock_,shockssequence_(ishock_,:),init_);
+
+        for i_indx_=1:nwishes_
+            eval([deblank(wishlist_(i_indx_,:)),'_difference=zdatalinear_(:,i_indx_);']);
+        end
+
+
+
+        newviolvecbool_ = eval(constraint_difference_);
+        relaxconstraint_ = eval(constraint_relax_difference_);
+
+
+
+        % check if changes to the hypothesis of the duration for each
+        % regime
+        if (max(newviolvecbool_-violvecbool_>0)) | sum(relaxconstraint_(find(violvecbool_==1))>0)
+            changes_ = 1;
+        else
+            changes_ = 0;
+        end
+
+
+        violvecbool_ = (violvecbool_|newviolvecbool_)-(relaxconstraint_ & violvecbool_);
+
+
+    end
+
+    init_ = zdatalinear_(1,:);
+    zdatapiecewise_(ishock_,:)=init_;
+    init_= init_';
+
+    % reset violvecbool_ for next period's shock -- this resetting is
+    % consistent with expecting no additional shocks
+    violvecbool_=[violvecbool_(2:end);0];
+
+end
+
+% if necessary, fill in the rest of the path with the remainder of the
+% last IRF computed.
+zdatapiecewise_(ishock_+1:end,:)=zdatalinear_(2:nperiods_-ishock_+1,:);
+
+% get the linear responses
+zdatalinear_ = mkdata(max(nperiods_,size(shockssequence_,1)),...
+                      decrulea_,decruleb_,endog_,exog_,...
+                      wishlist_,irfshock_,shockssequence_,init_orig_);
+
+if changes_ ==1
+    display('Did not converge -- increase maxiter_')
+end
diff --git a/matlab/occbin/solve_one_constraint.m b/matlab/occbin/solve_one_constraint.m
index c446f4c40..5959636bf 100755
--- a/matlab/occbin/solve_one_constraint.m
+++ b/matlab/occbin/solve_one_constraint.m
@@ -1,200 +1,200 @@
-% solve_one_constraint [zdatalinear zdatapiecewise zdatass oo base M base] = solve one constraint(modnam, modnamstar, constraint, constraint relax, shockssequence, irfshock, nperiods, maxiter, init);
-% 
-% Inputs: 
-% modnam: name of .mod file for the reference regime (excludes the .mod extension).
-% modnamstar: name of .mod file for the alternative regime (excludes the .mod exten- sion).
-% constraint: the constraint (see notes 1 and 2 below). When the condition in constraint evaluates to true, the solution switches from the reference to the alternative regime.
-% constraint relax: when the condition in constraint relax evaluates to true, the solution returns to the reference regime.
-% shockssequence: a sequence of unforeseen shocks under which one wants to solve the model (size T×nshocks).
-% irfshock: label for innovation for IRFs, from Dynare .mod file (one or more of the ?varexo?).
-% nperiods: simulation horizon (can be longer than the sequence of shocks defined in shockssequence; must be long enough to ensure convergence back to the reference model at the end of the simulation horizon and may need to be varied depending on the sequence of shocks).
-% maxiter: maximum number of iterations allowed for the solution algorithm (20 if not specified).
-% init:	the initial position for the vector of state variables, in deviation from steady state (if not specified, the default is steady state). The ordering follows the definition order in the .mod files.
-%
-% Outputs:
-% zdatalinear: an array containing paths for all endogenous variables ignoring the occasionally binding constraint (the linear solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
-% zdatapiecewise: an array containing paths for all endogenous variables satisfying the occasionally binding constraint (the occbin/piecewise solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
-% zdatass: theinitialpositionforthevectorofstatevariables,indeviationfromsteady state (if not specified, the default is a vectors of zero implying that the initial conditions coincide with the steady state). The ordering follows the definition order in the .mod files.
-% oobase,Mbase: structures produced by Dynare for the reference model ? see Dynare User Guide.
-
-% Log of changes:
-% 6/17/2013 -- Luca added a trailing underscore to local variables in an
-% attempt to avoid conflicts with parameter names defined in the .mod files
-% to be processed.
-% 6/17/2013 -- Luca replaced external .m file setss.m
-
-
-function [zdatalinear_ zdatapiecewise_ zdatass_ oobase_ Mbase_  ] = ...
-    solve_one_constraint(modnam_,modnamstar_,...
-    constraint_, constraint_relax_,...
-    shockssequence_,irfshock_,nperiods_,maxiter_,init_)
-
-global M_ oo_
-
-errlist_ = [];
-
-% solve the reference model linearly
-eval(['dynare ',modnam_,' noclearall nolog '])
-oobase_ = oo_;
-Mbase_ = M_;
-
-% import locally the values of parameters assigned in the reference .mod
-% file
-for i_indx_ = 1:Mbase_.param_nbr
-  eval([Mbase_.param_names(i_indx_,:),'= M_.params(i_indx_);']);
-end
-
-% Create steady state values of the variables if needed for processing the constraint
-for i=1:Mbase_.endo_nbr
-   eval([deblank(Mbase_.endo_names(i,:)) '_ss = oobase_.dr.ys(i); ']);
-end
-
-
-% parse the .mod file for the alternative regime
-eval(['dynare ',modnamstar_,' noclearall nolog '])
-oostar_ = oo_;
-Mstar_ = M_;
-
-
-% check inputs
-if ~strcmp(Mbase_.endo_names,Mstar_.endo_names)
-    error('The two .mod files need to have exactly the same endogenous variables declared in the same order')
-end
-
-if ~strcmp(Mbase_.exo_names,Mstar_.exo_names)
-    error('The two .mod files need to have exactly the same exogenous variables declared in the same order')
-end
-
-if ~strcmp(Mbase_.param_names,Mstar_.param_names)
-    warning('The parameter list does not match across .mod files')
-end
-
-% ensure that the two models have the same parameters
-% use the parameters for the base model.
-Mstar_.params = Mbase_.params;
-
-nvars_ = Mbase_.endo_nbr;
-zdatass_ = oobase_.dr.ys;
-
-
-% get the matrices holding the first derivatives for the model
-% each regime is treated separately
-[hm1_,h_,hl1_,Jbarmat_] = get_deriv(Mbase_,zdatass_);
-cof_ = [hm1_,h_,hl1_];
-
-[hm1_,h_,hl1_,Jstarbarmat_,resid_] = get_deriv(Mstar_,zdatass_);
-cofstar_ = [hm1_,h_,hl1_];
-Dstartbarmat_ = resid_;
-
-if isfield(Mbase_,'nfwrd')
-    % the latest Dynare distributions have moved nstatic and nfwrd
-    [decrulea_,decruleb_]=get_pq(oobase_.dr,Mbase_.nstatic,Mbase_.nfwrd);
-else
-    [decrulea_,decruleb_]=get_pq(oobase_.dr,oobase_.dr.nstatic,oobase_.dr.nfwrd);
-end
-
-endog_ = M_.endo_names;
-exog_ =  M_.exo_names;
-
-
-% processes the constraints specified in the call to this function
-% uppend a suffix to each endogenous variable
-constraint_difference_ = process_constraint(constraint_,'_difference',Mbase_.endo_names,0);
-
-constraint_relax_difference_ = process_constraint(constraint_relax_,'_difference',Mbase_.endo_names,0);
-
-
-
-nshocks_ = size(shockssequence_,1);
-
-% if necessary, set default values for optional arguments
-if ~exist('init_')
-    init_ = zeros(nvars_,1);
-end
-
-if ~exist('maxiter_')
-    maxiter_ = 20;
-end
-
-if ~exist('nperiods_')
-    nperiods_ = 100;
-end
-
-
-% set some initial conditions and loop through the shocks 
-% period by period
-init_orig_ = init_;
-zdatapiecewise_ = zeros(nperiods_,nvars_);
-wishlist_ = endog_;
-nwishes_ = size(wishlist_,1);
-violvecbool_ = zeros(nperiods_+1,1);
-
-
-for ishock_ = 1:nshocks_
-    
-    changes_=1;
-    iter_ = 0;
-    
-    
-    while (changes_ & iter_<maxiter_)
-        iter_ = iter_ +1;
-        
-        % analyze when each regime starts based on current guess
-        [regime regimestart]=map_regime(violvecbool_);
-        
-        
-        
-        % get the hypothesized piece wise linear solution
-        [zdatalinear_]=mkdatap_anticipated(nperiods_,decrulea_,decruleb_,...
-            cof_,Jbarmat_,cofstar_,Jstarbarmat_,Dstartbarmat_,...
-            regime,regimestart,violvecbool_,...
-            endog_,exog_,irfshock_,shockssequence_(ishock_,:),init_);
-        
-        for i_indx_=1:nwishes_
-            eval([deblank(wishlist_(i_indx_,:)),'_difference=zdatalinear_(:,i_indx_);']);
-        end
-        
-        
-        
-        newviolvecbool_ = eval(constraint_difference_);
-        relaxconstraint_ = eval(constraint_relax_difference_);
-        
-        
-        
-        % check if changes to the hypothesis of the duration for each
-        % regime
-        if (max(newviolvecbool_-violvecbool_>0)) | sum(relaxconstraint_(find(violvecbool_==1))>0)
-            changes_ = 1;
-        else
-            changes_ = 0;
-        end
-        
-        
-        
-        violvecbool_ = (violvecbool_|newviolvecbool_)-(relaxconstraint_ & violvecbool_);
-                
-        
-    end
-    
-    init_ = zdatalinear_(1,:);
-    zdatapiecewise_(ishock_,:)=init_;
-    init_= init_';
-    
-    % reset violvecbool_ for next period's shock -- this resetting is 
-    % consistent with expecting no additional shocks
-    violvecbool_=[violvecbool_(2:end);0];
-    
-end
-
-% if necessary, fill in the rest of the path with the remainder of the 
-% last IRF computed.
-zdatapiecewise_(ishock_+1:end,:)=zdatalinear_(2:nperiods_-ishock_+1,:);
-
-% get the linear responses
-zdatalinear_ = mkdata(max(nperiods_,size(shockssequence_,1)),...
-                  decrulea_,decruleb_,endog_,exog_,...
-                  wishlist_,irfshock_,shockssequence_,init_orig_);
-
-if changes_ ==1
-    display('Did not converge -- increase maxiter_')
-end
+% solve_one_constraint [zdatalinear zdatapiecewise zdatass oo base M base] = solve one constraint(modnam, modnamstar, constraint, constraint relax, shockssequence, irfshock, nperiods, maxiter, init);
+%
+% Inputs:
+% modnam: name of .mod file for the reference regime (excludes the .mod extension).
+% modnamstar: name of .mod file for the alternative regime (excludes the .mod exten- sion).
+% constraint: the constraint (see notes 1 and 2 below). When the condition in constraint evaluates to true, the solution switches from the reference to the alternative regime.
+% constraint relax: when the condition in constraint relax evaluates to true, the solution returns to the reference regime.
+% shockssequence: a sequence of unforeseen shocks under which one wants to solve the model (size T×nshocks).
+% irfshock: label for innovation for IRFs, from Dynare .mod file (one or more of the ?varexo?).
+% nperiods: simulation horizon (can be longer than the sequence of shocks defined in shockssequence; must be long enough to ensure convergence back to the reference model at the end of the simulation horizon and may need to be varied depending on the sequence of shocks).
+% maxiter: maximum number of iterations allowed for the solution algorithm (20 if not specified).
+% init: the initial position for the vector of state variables, in deviation from steady state (if not specified, the default is steady state). The ordering follows the definition order in the .mod files.
+%
+% Outputs:
+% zdatalinear: an array containing paths for all endogenous variables ignoring the occasionally binding constraint (the linear solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
+% zdatapiecewise: an array containing paths for all endogenous variables satisfying the occasionally binding constraint (the occbin/piecewise solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
+% zdatass: theinitialpositionforthevectorofstatevariables,indeviationfromsteady state (if not specified, the default is a vectors of zero implying that the initial conditions coincide with the steady state). The ordering follows the definition order in the .mod files.
+% oobase,Mbase: structures produced by Dynare for the reference model ? see Dynare User Guide.
+
+% Log of changes:
+% 6/17/2013 -- Luca added a trailing underscore to local variables in an
+% attempt to avoid conflicts with parameter names defined in the .mod files
+% to be processed.
+% 6/17/2013 -- Luca replaced external .m file setss.m
+
+
+function [zdatalinear_, zdatapiecewise_, zdatass_, oobase_, Mbase_  ] = ...
+    solve_one_constraint(modnam_,modnamstar_,...
+                         constraint_, constraint_relax_,...
+                         shockssequence_,irfshock_,nperiods_,maxiter_,init_)
+
+global M_ oo_
+
+errlist_ = [];
+
+% solve the reference model linearly
+eval(['dynare ',modnam_,' noclearall nolog '])
+oobase_ = oo_;
+Mbase_ = M_;
+
+% import locally the values of parameters assigned in the reference .mod
+% file
+for i_indx_ = 1:Mbase_.param_nbr
+    eval([Mbase_.param_names(i_indx_,:),'= M_.params(i_indx_);']);
+end
+
+% Create steady state values of the variables if needed for processing the constraint
+for i=1:Mbase_.endo_nbr
+    eval([deblank(Mbase_.endo_names(i,:)) '_ss = oobase_.dr.ys(i); ']);
+end
+
+
+% parse the .mod file for the alternative regime
+eval(['dynare ',modnamstar_,' noclearall nolog '])
+oostar_ = oo_;
+Mstar_ = M_;
+
+
+% check inputs
+if ~strcmp(Mbase_.endo_names,Mstar_.endo_names)
+    error('The two .mod files need to have exactly the same endogenous variables declared in the same order')
+end
+
+if ~strcmp(Mbase_.exo_names,Mstar_.exo_names)
+    error('The two .mod files need to have exactly the same exogenous variables declared in the same order')
+end
+
+if ~strcmp(Mbase_.param_names,Mstar_.param_names)
+    warning('The parameter list does not match across .mod files')
+end
+
+% ensure that the two models have the same parameters
+% use the parameters for the base model.
+Mstar_.params = Mbase_.params;
+
+nvars_ = Mbase_.endo_nbr;
+zdatass_ = oobase_.dr.ys;
+
+
+% get the matrices holding the first derivatives for the model
+% each regime is treated separately
+[hm1_,h_,hl1_,Jbarmat_] = get_deriv(Mbase_,zdatass_);
+cof_ = [hm1_,h_,hl1_];
+
+[hm1_,h_,hl1_,Jstarbarmat_,resid_] = get_deriv(Mstar_,zdatass_);
+cofstar_ = [hm1_,h_,hl1_];
+Dstartbarmat_ = resid_;
+
+if isfield(Mbase_,'nfwrd')
+    % the latest Dynare distributions have moved nstatic and nfwrd
+    [decrulea_,decruleb_]=get_pq(oobase_.dr,Mbase_.nstatic,Mbase_.nfwrd);
+else
+    [decrulea_,decruleb_]=get_pq(oobase_.dr,oobase_.dr.nstatic,oobase_.dr.nfwrd);
+end
+
+endog_ = M_.endo_names;
+exog_ =  M_.exo_names;
+
+
+% processes the constraints specified in the call to this function
+% uppend a suffix to each endogenous variable
+constraint_difference_ = process_constraint(constraint_,'_difference',Mbase_.endo_names,0);
+
+constraint_relax_difference_ = process_constraint(constraint_relax_,'_difference',Mbase_.endo_names,0);
+
+
+
+nshocks_ = size(shockssequence_,1);
+
+% if necessary, set default values for optional arguments
+if ~exist('init_')
+    init_ = zeros(nvars_,1);
+end
+
+if ~exist('maxiter_')
+    maxiter_ = 20;
+end
+
+if ~exist('nperiods_')
+    nperiods_ = 100;
+end
+
+
+% set some initial conditions and loop through the shocks
+% period by period
+init_orig_ = init_;
+zdatapiecewise_ = zeros(nperiods_,nvars_);
+wishlist_ = endog_;
+nwishes_ = size(wishlist_,1);
+violvecbool_ = zeros(nperiods_+1,1);
+
+
+for ishock_ = 1:nshocks_
+
+    changes_=1;
+    iter_ = 0;
+
+
+    while (changes_ & iter_<maxiter_)
+        iter_ = iter_ +1;
+
+        % analyze when each regime starts based on current guess
+        [regime, regimestart]=map_regime(violvecbool_);
+
+
+
+        % get the hypothesized piece wise linear solution
+        [zdatalinear_]=mkdatap_anticipated(nperiods_,decrulea_,decruleb_,...
+                                           cof_,Jbarmat_,cofstar_,Jstarbarmat_,Dstartbarmat_,...
+                                           regime,regimestart,violvecbool_,...
+                                           endog_,exog_,irfshock_,shockssequence_(ishock_,:),init_);
+
+        for i_indx_=1:nwishes_
+            eval([deblank(wishlist_(i_indx_,:)),'_difference=zdatalinear_(:,i_indx_);']);
+        end
+
+
+
+        newviolvecbool_ = eval(constraint_difference_);
+        relaxconstraint_ = eval(constraint_relax_difference_);
+
+
+
+        % check if changes to the hypothesis of the duration for each
+        % regime
+        if (max(newviolvecbool_-violvecbool_>0)) | sum(relaxconstraint_(find(violvecbool_==1))>0)
+            changes_ = 1;
+        else
+            changes_ = 0;
+        end
+
+
+
+        violvecbool_ = (violvecbool_|newviolvecbool_)-(relaxconstraint_ & violvecbool_);
+
+
+    end
+
+    init_ = zdatalinear_(1,:);
+    zdatapiecewise_(ishock_,:)=init_;
+    init_= init_';
+
+    % reset violvecbool_ for next period's shock -- this resetting is
+    % consistent with expecting no additional shocks
+    violvecbool_=[violvecbool_(2:end);0];
+
+end
+
+% if necessary, fill in the rest of the path with the remainder of the
+% last IRF computed.
+zdatapiecewise_(ishock_+1:end,:)=zdatalinear_(2:nperiods_-ishock_+1,:);
+
+% get the linear responses
+zdatalinear_ = mkdata(max(nperiods_,size(shockssequence_,1)),...
+                      decrulea_,decruleb_,endog_,exog_,...
+                      wishlist_,irfshock_,shockssequence_,init_orig_);
+
+if changes_ ==1
+    display('Did not converge -- increase maxiter_')
+end
diff --git a/matlab/occbin/solve_two_constraints.m b/matlab/occbin/solve_two_constraints.m
index dfca403a2..1b436ad00 100755
--- a/matlab/occbin/solve_two_constraints.m
+++ b/matlab/occbin/solve_two_constraints.m
@@ -1,305 +1,304 @@
-% [zdatalinear zdatapiecewise zdatass oo 00 M 00] = solve two constraints(modnam 00,modnam 10,modnam 01,modnam 11,... constraint1, constraint2,... constraint relax1, constraint relax2,... shockssequence,irfshock,nperiods,curb retrench,maxiter,init);
-% 
-% Inputs:
-% modnam 00: name of the .mod file for reference regime (excludes the .mod extension). modnam10: name of the .mod file for the alternative regime governed by the first
-% constraint.
-% modnam01: name of the .mod file for the alternative regime governed by the second constraint.
-% modnam 11: name of the .mod file for the case in which both constraints force a switch to their alternative regimes.
-% constraint1: the first constraint (see notes 1 and 2 below). If constraint1 evaluates to true, then the solution switches to the alternative regime for condition 1. In thatcase, if constraint2 (described below) evaluates to false, then the model solution switches to enforcing the conditions for an equilibrium in modnam 10. Otherwise, if constraint2 also evaluates to true, then the model solution switches to enforcing the conditions for an equilibrium in modnam 11.
-% constraint relax1: when the condition in constraint relax1 evaluates to true, the solution returns to the reference regime for constraint1.
-% constraint2: the second constraint (see notes 1 and 2 below). constraint relax2: when the condition in constraint relax2 evaluates to true, the
-% solution returns to the reference regime for constraint2. shockssequence: a sequence of unforeseen shocks under which one wants to solve the
-% model
-% irfshock: label for innovation for IRFs, from Dynare .mod file (one or more of the ?varexo?)
-% nperiods: simulation horizon (can be longer than the sequence of shocks defined in shockssequence; must be long enough to ensure convergence back to the reference model at the end of the simulation horizon and may need to be varied depending on the sequence of shocks).
-% curb retrench:	a scalar equal to 0 or 1. Default is 0. When set to 0, it updates the guess based of regimes based on the previous iteration. When set to 1, it updates in a manner similar to a Gauss-Jacobi scheme, slowing the iterations down by updating the guess of regimes only one period at a time.
-% maxiter: maximum number of iterations allowed for the solution algorithm (20 if not specified).
-% init:	the initial position for the vector of state variables, in deviation from steady state (if not specified, the default is a vector of zero implying that the initial conditions coincide with the steady state). The ordering follows the definition order in the .mod files.
-%
-% Outputs:
-% zdatalinear: an array containing paths for all endogenous variables ignoring the occasionally binding constraint (the linear solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
-% zdatapiecewise: an array containing paths for all endogenous variables satisfying the occasionally binding constraint (the occbin/piecewise solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
-% zdatass: a vector that holds the steady state values of the endogenous variables ( following the definition order in the .mod file).
-% oo00 , M00 :	structures produced by Dynare for the reference model ? see Dynare User Guide.
-
-
-% Log of changes
-% 6/17/2013 -- Luca added a trailing underscore to local variables in an
-% attempt to avoid conflicts with parameter names defined in the .mod files
-% to be processed.
-% 6/17/2013 -- Luca replaced external .m file setss.m
-
-function [ zdatalinear_ zdatapiecewise_ zdatass_ oo00_  M00_ ] = ...
-  solve_two_constraints(modnam_00_,modnam_10_,modnam_01_,modnam_11_,...
-    constrain1_, constrain2_,...
-    constraint_relax1_, constraint_relax2_,...
-    shockssequence_,irfshock_,nperiods_,curb_retrench_,maxiter_,init_)
-
-global M_ oo_
-
-
-
-% solve model
-eval(['dynare ',modnam_00_,' noclearall nolog'])
-oo00_ = oo_;
-M00_ = M_;
-
-
-for i=1:M00_.endo_nbr
-   eval([deblank(M00_.endo_names(i,:)) '_ss = oo00_.dr.ys(i); ']);
-end
-
-for i_indx_ = 1:M00_.param_nbr
-  eval([M00_.param_names(i_indx_,:),'= M00_.params(i_indx_);']);
-end
-
-
-
-eval(['dynare ',modnam_10_,' noclearall'])
-oo10_ = oo_;
-M10_ = M_;
-
-eval(['dynare ',modnam_01_,' noclearall'])
-oo01_ = oo_;
-M01_ = M_;
-
-eval(['dynare ',modnam_11_,' noclearall'])
-oo11_ = oo_;
-M11_ = M_;
-
-
-% do some error checking
-
-% check inputs
-if ~strcmp(M00_.endo_names,M10_.endo_names)
-    error([modnam_00_,' and ',modnam_10_,' need to have exactly the same endogenous variables and they need to be declared in the same order'])
-end
-
-if ~strcmp(M00_.exo_names,M10_.exo_names)
-    error([modnam_00_,' and ',modnam_10_,' need to have exactly the same exogenous variables and they need to be declared in the same order'])
-end
-
-if ~strcmp(M00_.param_names,M10_.param_names)
-    warning(['The parameter list does not match across the files ',modnam_00_,' and ',modnam_10_])
-end
-
-
-if ~strcmp(M00_.endo_names,M01_.endo_names)
-    error([modnam_00,' and ',modnam_01_,' need to have exactly the same endogenous variables and they need to be declared in the same order'])
-end
-
-if ~strcmp(M00_.exo_names,M01_.exo_names)
-    error([modnam_00_,' and ',modnam_01_,' need to have exactly the same exogenous variables and they need to be declared in the same order'])
-end
-
-if ~strcmp(M00_.param_names,M01_.param_names)
-    warning(['The parameter list does not match across the files ',modnam_00_,' and ',modnam_01_])
-end
-
-
-if ~strcmp(M00_.endo_names,M11_.endo_names)
-    error([modnam_00_,' and ',modnam_11_,' need to have exactly the same endogenous variables and they need to be declared in the same order'])
-end
-
-if ~strcmp(M00_.exo_names,M11_.exo_names)
-    error([modnam_00_,' and ',modnam_11_,' need to have exactly the same exogenous variables and they need to be declared in the same order'])
-end
-
-if ~strcmp(M00_.param_names,M11_.param_names)
-    warning(['The parameter list does not match across the files ',modnam_00_,' and ',modnam_11_])
-end
-
-
-
-
-
-nvars_ = M00_.endo_nbr;
-zdatass_ = oo00_.dr.ys;
-
-
-[hm1_,h_,hl1_,Jbarmat_] = get_deriv(M00_,zdatass_);
-cof_ = [hm1_,h_,hl1_];
-
-
-M10_.params = M00_.params;
-[hm1_,h_,hl1_,Jbarmat10_,resid_] = get_deriv(M10_,zdatass_);
-cof10_ = [hm1_,h_,hl1_];
-Dbarmat10_ = resid_;
-
-M01_.params = M00_.params;
-[hm1_,h_,hl1_,Jbarmat01_,resid_] = get_deriv(M01_,zdatass_);
-cof01_ = [hm1_,h_,hl1_];
-Dbarmat01_ = resid_;
-
-M11_.params = M00_.params;
-[hm1_,h_,hl1_,Jbarmat11_,resid_] = get_deriv(M11_,zdatass_);
-cof11_ = [hm1_,h_,hl1_];
-Dbarmat11_ = resid_;
-
-
-if isfield(M00_,'nfwrd')  % needed for bakward compatibility with older Dynare releases
-[decrulea,decruleb]=get_pq(oo00_.dr,M00_.nstatic,M00_.nfwrd);
-else
-[decrulea,decruleb]=get_pq(oo00_.dr,oo00_.dr.nstatic,oo00_.dr.nfwrd);    
-end
-endog_ = M00_.endo_names;
-exog_ =  M00_.exo_names;
-
-
-% processes the constrain so as to uppend a suffix to each
-% endogenous variables
-constraint1_difference_ = process_constraint(constrain1_,'_difference',M00_.endo_names,0);
-
-% when the last argument in process_constraint is set to 1, the
-% direction of the inequality in the constraint is inverted
-constraint_relax1_difference_ = process_constraint(constraint_relax1_,'_difference',M00_.endo_names,0);
-
-
-% processes the constrain so as to uppend a suffix to each
-% endogenous variables
-constraint2_difference_ = process_constraint(constrain2_,'_difference',M00_.endo_names,0);
-
-% when the last argument in process_constraint is set to 1, the
-% direction of the inequality in the constraint is inverted
-constraint_relax2_difference_ = process_constraint(constraint_relax2_,'_difference',M00_.endo_names,0);
-
-
-
-nshocks = size(shockssequence_,1);
-
-
-
-
-if ~exist('init_')
-    init_ = zeros(nvars_,1);
-end
-
-if ~exist('maxiter_')
-    maxiter_ = 20;
-end
-
-if ~exist('curb_retrench_')
-    curb_retrench_ = 0;
-end
-
-init_orig_ = init_;
-
-
-
-
-
-
-zdatapiecewise_ = zeros(nperiods_,nvars_);
-
-
-violvecbool_ = zeros(nperiods_+1,2);  % This sets the first guess for when
-% the constraints are going to hold.
-% The variable is a boolean with two
-% columns. The first column refers to
-% constrain1_; the second to
-% constrain2_.
-% Each row is a period in time.
-% If the boolean is true it indicates
-% the relevant constraint is expected
-% to evaluate to true.
-% The default initial guess is
-% consistent with the base model always
-% holding -- equivalent to the linear
-% solution.
-
-wishlist_ = endog_;
-nwishes_ = size(wishlist_,1);
-for ishock_ = 1:nshocks
-    
-    
-    changes_=1;
-    iter_ = 0;
-    
-    while (changes_ & iter_<maxiter_)
-        iter_ = iter_ +1;
-        
-        % analyse violvec and isolate contiguous periods in the other
-        % regime.
-        [regime1 regimestart1]=map_regime(violvecbool_(:,1));
-        [regime2 regimestart2]=map_regime(violvecbool_(:,2));
-        
-        
-        [zdatalinear_]=mkdatap_anticipated_2constraints(nperiods_,decrulea,decruleb,...
-            cof_,Jbarmat_,...
-            cof10_,Jbarmat10_,Dbarmat10_,...
-            cof01_,Jbarmat01_,Dbarmat01_,...
-            cof11_,Jbarmat11_,Dbarmat11_,...
-            regime1,regimestart1,...
-            regime2,regimestart2,...
-            violvecbool_,endog_,exog_,...
-            irfshock_,shockssequence_(ishock_,:),init_);
-        
-        for i_indx_=1:nwishes_
-            eval([deblank(wishlist_(i_indx_,:)),'_difference=zdatalinear_(:,i_indx_);']);
-        end
-        
-        
-        
-        
-        newviolvecbool1_ = eval(constraint1_difference_);
-        relaxconstraint1_ = eval(constraint_relax1_difference_);
-        
-        newviolvecbool2_ = eval(constraint2_difference_);
-        relaxconstraint2_ = eval(constraint_relax2_difference_);
-        
-        
-        
-        newviolvecbool_ = [newviolvecbool1_;newviolvecbool2_];
-        relaxconstraint_ = [relaxconstraint1_;relaxconstraint2_];
-        
-        
-        
-        % check if changes_
-        if (max(newviolvecbool_(:)-violvecbool_(:)>0)) | sum(relaxconstraint_(find(violvecbool_==1))>0)
-            changes_ = 1;
-        else
-            changes_ = 0;
-        end
-        
-        if curb_retrench_   % apply Gauss-Sidel idea of slowing down the change in the guess
-            % for the constraint -- only relax one
-            % period at a time starting from the last
-            % one when each of the constraints is true.
-            retrench = 0*violvecbool_(:);
-            if ~isempty(find(relaxconstraint1_ & violvecbool_(:,1)))
-                retrenchpos = max(find(relaxconstraint1_ & violvecbool_(:,1)));
-                retrench(retrenchpos) = 1;
-            end
-            if ~isempty(find(relaxconstraint2_ & violvecbool_(:,2)))
-                retrenchpos = max(find(relaxconstraint2_ & violvecbool_(:,2)));
-                retrench(retrenchpos+nperiods_+1) = 1;
-            end
-            violvecbool_ = (violvecbool_(:) | newviolvecbool_(:))-retrench(:);
-        else
-            violvecbool_ = (violvecbool_(:) | newviolvecbool_(:))-(relaxconstraint_(:) & violvecbool_(:));
-        end
-        
-        violvecbool_ = reshape(violvecbool_,nperiods_+1,2);
-        
-        
-        
-    end
-    if changes_ ==1
-        display('Did not converge -- increase maxiter')
-    end
-    
-    init_ = zdatalinear_(1,:);
-    zdatapiecewise_(ishock_,:)=init_;
-    init_= init_';
-    
-    % update the guess for constraint violations for next period
-    % update is consistent with expecting no additional shocks next period
-    violvecbool_=[violvecbool_(2:end,:);zeros(1,2)];
-    
-end
-
-
-zdatapiecewise_(ishock_+1:end,:)=zdatalinear_(2:nperiods_-ishock_+1,:);
-
-zdatalinear_ = mkdata(nperiods_,decrulea,decruleb,endog_,exog_,wishlist_,irfshock_,shockssequence_,init_orig_);
-
+% [zdatalinear zdatapiecewise zdatass oo 00 M 00] = solve two constraints(modnam 00,modnam 10,modnam 01,modnam 11,... constraint1, constraint2,... constraint relax1, constraint relax2,... shockssequence,irfshock,nperiods,curb retrench,maxiter,init);
+%
+% Inputs:
+% modnam 00: name of the .mod file for reference regime (excludes the .mod extension). modnam10: name of the .mod file for the alternative regime governed by the first
+% constraint.
+% modnam01: name of the .mod file for the alternative regime governed by the second constraint.
+% modnam 11: name of the .mod file for the case in which both constraints force a switch to their alternative regimes.
+% constraint1: the first constraint (see notes 1 and 2 below). If constraint1 evaluates to true, then the solution switches to the alternative regime for condition 1. In thatcase, if constraint2 (described below) evaluates to false, then the model solution switches to enforcing the conditions for an equilibrium in modnam 10. Otherwise, if constraint2 also evaluates to true, then the model solution switches to enforcing the conditions for an equilibrium in modnam 11.
+% constraint relax1: when the condition in constraint relax1 evaluates to true, the solution returns to the reference regime for constraint1.
+% constraint2: the second constraint (see notes 1 and 2 below). constraint relax2: when the condition in constraint relax2 evaluates to true, the
+% solution returns to the reference regime for constraint2. shockssequence: a sequence of unforeseen shocks under which one wants to solve the
+% model
+% irfshock: label for innovation for IRFs, from Dynare .mod file (one or more of the ?varexo?)
+% nperiods: simulation horizon (can be longer than the sequence of shocks defined in shockssequence; must be long enough to ensure convergence back to the reference model at the end of the simulation horizon and may need to be varied depending on the sequence of shocks).
+% curb retrench:        a scalar equal to 0 or 1. Default is 0. When set to 0, it updates the guess based of regimes based on the previous iteration. When set to 1, it updates in a manner similar to a Gauss-Jacobi scheme, slowing the iterations down by updating the guess of regimes only one period at a time.
+% maxiter: maximum number of iterations allowed for the solution algorithm (20 if not specified).
+% init: the initial position for the vector of state variables, in deviation from steady state (if not specified, the default is a vector of zero implying that the initial conditions coincide with the steady state). The ordering follows the definition order in the .mod files.
+%
+% Outputs:
+% zdatalinear: an array containing paths for all endogenous variables ignoring the occasionally binding constraint (the linear solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
+% zdatapiecewise: an array containing paths for all endogenous variables satisfying the occasionally binding constraint (the occbin/piecewise solution), in deviation from steady state. Each column is a variable, the order is the definition order in the .mod files.
+% zdatass: a vector that holds the steady state values of the endogenous variables ( following the definition order in the .mod file).
+% oo00 , M00 :  structures produced by Dynare for the reference model ? see Dynare User Guide.
+
+
+% Log of changes
+% 6/17/2013 -- Luca added a trailing underscore to local variables in an
+% attempt to avoid conflicts with parameter names defined in the .mod files
+% to be processed.
+% 6/17/2013 -- Luca replaced external .m file setss.m
+
+function [ zdatalinear_, zdatapiecewise_, zdatass_, oo00_ , M00_ ] = ...
+    solve_two_constraints(modnam_00_,modnam_10_,modnam_01_,modnam_11_,...
+                          constrain1_, constrain2_,...
+                          constraint_relax1_, constraint_relax2_,...
+                          shockssequence_,irfshock_,nperiods_,curb_retrench_,maxiter_,init_)
+
+global M_ oo_
+
+
+
+% solve model
+eval(['dynare ',modnam_00_,' noclearall nolog'])
+oo00_ = oo_;
+M00_ = M_;
+
+
+for i=1:M00_.endo_nbr
+    eval([deblank(M00_.endo_names(i,:)) '_ss = oo00_.dr.ys(i); ']);
+end
+
+for i_indx_ = 1:M00_.param_nbr
+    eval([M00_.param_names(i_indx_,:),'= M00_.params(i_indx_);']);
+end
+
+
+
+eval(['dynare ',modnam_10_,' noclearall'])
+oo10_ = oo_;
+M10_ = M_;
+
+eval(['dynare ',modnam_01_,' noclearall'])
+oo01_ = oo_;
+M01_ = M_;
+
+eval(['dynare ',modnam_11_,' noclearall'])
+oo11_ = oo_;
+M11_ = M_;
+
+
+% do some error checking
+
+% check inputs
+if ~strcmp(M00_.endo_names,M10_.endo_names)
+    error([modnam_00_,' and ',modnam_10_,' need to have exactly the same endogenous variables and they need to be declared in the same order'])
+end
+
+if ~strcmp(M00_.exo_names,M10_.exo_names)
+    error([modnam_00_,' and ',modnam_10_,' need to have exactly the same exogenous variables and they need to be declared in the same order'])
+end
+
+if ~strcmp(M00_.param_names,M10_.param_names)
+    warning(['The parameter list does not match across the files ',modnam_00_,' and ',modnam_10_])
+end
+
+
+if ~strcmp(M00_.endo_names,M01_.endo_names)
+    error([modnam_00,' and ',modnam_01_,' need to have exactly the same endogenous variables and they need to be declared in the same order'])
+end
+
+if ~strcmp(M00_.exo_names,M01_.exo_names)
+    error([modnam_00_,' and ',modnam_01_,' need to have exactly the same exogenous variables and they need to be declared in the same order'])
+end
+
+if ~strcmp(M00_.param_names,M01_.param_names)
+    warning(['The parameter list does not match across the files ',modnam_00_,' and ',modnam_01_])
+end
+
+
+if ~strcmp(M00_.endo_names,M11_.endo_names)
+    error([modnam_00_,' and ',modnam_11_,' need to have exactly the same endogenous variables and they need to be declared in the same order'])
+end
+
+if ~strcmp(M00_.exo_names,M11_.exo_names)
+    error([modnam_00_,' and ',modnam_11_,' need to have exactly the same exogenous variables and they need to be declared in the same order'])
+end
+
+if ~strcmp(M00_.param_names,M11_.param_names)
+    warning(['The parameter list does not match across the files ',modnam_00_,' and ',modnam_11_])
+end
+
+
+
+
+
+nvars_ = M00_.endo_nbr;
+zdatass_ = oo00_.dr.ys;
+
+
+[hm1_,h_,hl1_,Jbarmat_] = get_deriv(M00_,zdatass_);
+cof_ = [hm1_,h_,hl1_];
+
+
+M10_.params = M00_.params;
+[hm1_,h_,hl1_,Jbarmat10_,resid_] = get_deriv(M10_,zdatass_);
+cof10_ = [hm1_,h_,hl1_];
+Dbarmat10_ = resid_;
+
+M01_.params = M00_.params;
+[hm1_,h_,hl1_,Jbarmat01_,resid_] = get_deriv(M01_,zdatass_);
+cof01_ = [hm1_,h_,hl1_];
+Dbarmat01_ = resid_;
+
+M11_.params = M00_.params;
+[hm1_,h_,hl1_,Jbarmat11_,resid_] = get_deriv(M11_,zdatass_);
+cof11_ = [hm1_,h_,hl1_];
+Dbarmat11_ = resid_;
+
+
+if isfield(M00_,'nfwrd')  % needed for bakward compatibility with older Dynare releases
+    [decrulea,decruleb]=get_pq(oo00_.dr,M00_.nstatic,M00_.nfwrd);
+else
+    [decrulea,decruleb]=get_pq(oo00_.dr,oo00_.dr.nstatic,oo00_.dr.nfwrd);
+end
+endog_ = M00_.endo_names;
+exog_ =  M00_.exo_names;
+
+
+% processes the constrain so as to uppend a suffix to each
+% endogenous variables
+constraint1_difference_ = process_constraint(constrain1_,'_difference',M00_.endo_names,0);
+
+% when the last argument in process_constraint is set to 1, the
+% direction of the inequality in the constraint is inverted
+constraint_relax1_difference_ = process_constraint(constraint_relax1_,'_difference',M00_.endo_names,0);
+
+
+% processes the constrain so as to uppend a suffix to each
+% endogenous variables
+constraint2_difference_ = process_constraint(constrain2_,'_difference',M00_.endo_names,0);
+
+% when the last argument in process_constraint is set to 1, the
+% direction of the inequality in the constraint is inverted
+constraint_relax2_difference_ = process_constraint(constraint_relax2_,'_difference',M00_.endo_names,0);
+
+
+
+nshocks = size(shockssequence_,1);
+
+
+
+
+if ~exist('init_')
+    init_ = zeros(nvars_,1);
+end
+
+if ~exist('maxiter_')
+    maxiter_ = 20;
+end
+
+if ~exist('curb_retrench_')
+    curb_retrench_ = 0;
+end
+
+init_orig_ = init_;
+
+
+
+
+
+
+zdatapiecewise_ = zeros(nperiods_,nvars_);
+
+
+violvecbool_ = zeros(nperiods_+1,2);  % This sets the first guess for when
+                                      % the constraints are going to hold.
+                                      % The variable is a boolean with two
+                                      % columns. The first column refers to
+                                      % constrain1_; the second to
+                                      % constrain2_.
+                                      % Each row is a period in time.
+                                      % If the boolean is true it indicates
+                                      % the relevant constraint is expected
+                                      % to evaluate to true.
+                                      % The default initial guess is
+                                      % consistent with the base model always
+                                      % holding -- equivalent to the linear
+                                      % solution.
+
+wishlist_ = endog_;
+nwishes_ = size(wishlist_,1);
+for ishock_ = 1:nshocks
+
+
+    changes_=1;
+    iter_ = 0;
+
+    while (changes_ & iter_<maxiter_)
+        iter_ = iter_ +1;
+
+        % analyse violvec and isolate contiguous periods in the other
+        % regime.
+        [regime1, regimestart1]=map_regime(violvecbool_(:,1));
+        [regime2, regimestart2]=map_regime(violvecbool_(:,2));
+
+
+        [zdatalinear_]=mkdatap_anticipated_2constraints(nperiods_,decrulea,decruleb,...
+                                                        cof_,Jbarmat_,...
+                                                        cof10_,Jbarmat10_,Dbarmat10_,...
+                                                        cof01_,Jbarmat01_,Dbarmat01_,...
+                                                        cof11_,Jbarmat11_,Dbarmat11_,...
+                                                        regime1,regimestart1,...
+                                                        regime2,regimestart2,...
+                                                        violvecbool_,endog_,exog_,...
+                                                        irfshock_,shockssequence_(ishock_,:),init_);
+
+        for i_indx_=1:nwishes_
+            eval([deblank(wishlist_(i_indx_,:)),'_difference=zdatalinear_(:,i_indx_);']);
+        end
+
+
+
+
+        newviolvecbool1_ = eval(constraint1_difference_);
+        relaxconstraint1_ = eval(constraint_relax1_difference_);
+
+        newviolvecbool2_ = eval(constraint2_difference_);
+        relaxconstraint2_ = eval(constraint_relax2_difference_);
+
+
+
+        newviolvecbool_ = [newviolvecbool1_;newviolvecbool2_];
+        relaxconstraint_ = [relaxconstraint1_;relaxconstraint2_];
+
+
+
+        % check if changes_
+        if (max(newviolvecbool_(:)-violvecbool_(:)>0)) | sum(relaxconstraint_(find(violvecbool_==1))>0)
+            changes_ = 1;
+        else
+            changes_ = 0;
+        end
+
+        if curb_retrench_   % apply Gauss-Sidel idea of slowing down the change in the guess
+                            % for the constraint -- only relax one
+                            % period at a time starting from the last
+                            % one when each of the constraints is true.
+            retrench = 0*violvecbool_(:);
+            if ~isempty(find(relaxconstraint1_ & violvecbool_(:,1)))
+                retrenchpos = max(find(relaxconstraint1_ & violvecbool_(:,1)));
+                retrench(retrenchpos) = 1;
+            end
+            if ~isempty(find(relaxconstraint2_ & violvecbool_(:,2)))
+                retrenchpos = max(find(relaxconstraint2_ & violvecbool_(:,2)));
+                retrench(retrenchpos+nperiods_+1) = 1;
+            end
+            violvecbool_ = (violvecbool_(:) | newviolvecbool_(:))-retrench(:);
+        else
+            violvecbool_ = (violvecbool_(:) | newviolvecbool_(:))-(relaxconstraint_(:) & violvecbool_(:));
+        end
+
+        violvecbool_ = reshape(violvecbool_,nperiods_+1,2);
+
+
+
+    end
+    if changes_ ==1
+        display('Did not converge -- increase maxiter')
+    end
+
+    init_ = zdatalinear_(1,:);
+    zdatapiecewise_(ishock_,:)=init_;
+    init_= init_';
+
+    % update the guess for constraint violations for next period
+    % update is consistent with expecting no additional shocks next period
+    violvecbool_=[violvecbool_(2:end,:);zeros(1,2)];
+
+end
+
+
+zdatapiecewise_(ishock_+1:end,:)=zdatalinear_(2:nperiods_-ishock_+1,:);
+
+zdatalinear_ = mkdata(nperiods_,decrulea,decruleb,endog_,exog_,wishlist_,irfshock_,shockssequence_,init_orig_);
diff --git a/matlab/occbin/strmerge.m b/matlab/occbin/strmerge.m
index b8585df04..8aebb0099 100755
--- a/matlab/occbin/strmerge.m
+++ b/matlab/occbin/strmerge.m
@@ -1,9 +1,9 @@
-function string = strmerge(tokens)
-
-ntokens = length(tokens);
-
-string = char(tokens(1));
-
-for i=2:ntokens
-    string = [string,char(tokens(i))];
+function string = strmerge(tokens)
+
+ntokens = length(tokens);
+
+string = char(tokens(1));
+
+for i=2:ntokens
+    string = [string,char(tokens(i))];
 end
\ No newline at end of file
diff --git a/matlab/occbin/tokenize.m b/matlab/occbin/tokenize.m
index f6e9f330c..2cd8fb410 100755
--- a/matlab/occbin/tokenize.m
+++ b/matlab/occbin/tokenize.m
@@ -1,55 +1,54 @@
-function tokens = tokenize(source,delimiter)
-% syntax
-% tokens = tokenize(source,delimiters)
-%
-% source is a string to be broken into tokens
-% delimiters is a character array of single character delimiters
-% tokens is a cell string array containing the tokens
-
-
-posdelims = [];
-
-% assumes that delimiter cannot be in the first position or the last
-% position
-ndelimiters = size(delimiter,1);
-for i=1:ndelimiters
-    newpositions = strfind(source,delimiter(i,:));
-    if ~isempty(newpositions)
-        posdelims =[posdelims, newpositions];
-    end
-end
-
-% reorder posdelims in ascending order
-posdelims = sort(posdelims);
-
-if isempty(posdelims)
-    tokens = cellstr(source);
-else
-    ndelims = length(posdelims);
-    % build positions for substrings
-    delims = zeros(ndelims+1,2);
-    for i=1:ndelims+1;
-        if i==1
-                if posdelims(1) == 1
-                   tokens = cellstr(source(1));
-                else
-                   delims(i,:) = [1,posdelims(i)-1];
-                   tokens = cellstr(source([delims(i,1):delims(i,2)]));
-                   tokens = [tokens, source(posdelims(i))];
-                end
-        elseif  i==ndelims+1
-                if (posdelims(i-1) < length(source))
-                    delims(i,:) = [posdelims(i-1)+1,length(source)];
-                    tokens = [tokens, cellstr(source([delims(i,1):delims(i,2)]))];
-                end
-        else
-                if posdelims(i)>posdelims(i-1)+1
-                    delims(i,:) = [posdelims(i-1)+1,posdelims(i)-1];
-                    tokens = [tokens, cellstr(source([delims(i,1):delims(i,2)]))];
-                end
-                tokens = [tokens, source(posdelims(i))];
-        end
-    end
-
-end
-
+function tokens = tokenize(source,delimiter)
+% syntax
+% tokens = tokenize(source,delimiters)
+%
+% source is a string to be broken into tokens
+% delimiters is a character array of single character delimiters
+% tokens is a cell string array containing the tokens
+
+
+posdelims = [];
+
+% assumes that delimiter cannot be in the first position or the last
+% position
+ndelimiters = size(delimiter,1);
+for i=1:ndelimiters
+    newpositions = strfind(source,delimiter(i,:));
+    if ~isempty(newpositions)
+        posdelims =[posdelims, newpositions];
+    end
+end
+
+% reorder posdelims in ascending order
+posdelims = sort(posdelims);
+
+if isempty(posdelims)
+    tokens = cellstr(source);
+else
+    ndelims = length(posdelims);
+    % build positions for substrings
+    delims = zeros(ndelims+1,2);
+    for i=1:ndelims+1
+        if i==1
+            if posdelims(1) == 1
+                tokens = cellstr(source(1));
+            else
+                delims(i,:) = [1,posdelims(i)-1];
+                tokens = cellstr(source([delims(i,1):delims(i,2)]));
+                tokens = [tokens, source(posdelims(i))];
+            end
+        elseif  i==ndelims+1
+            if (posdelims(i-1) < length(source))
+                delims(i,:) = [posdelims(i-1)+1,length(source)];
+                tokens = [tokens, cellstr(source([delims(i,1):delims(i,2)]))];
+            end
+        else
+            if posdelims(i)>posdelims(i-1)+1
+                delims(i,:) = [posdelims(i-1)+1,posdelims(i)-1];
+                tokens = [tokens, cellstr(source([delims(i,1):delims(i,2)]))];
+            end
+            tokens = [tokens, source(posdelims(i))];
+        end
+    end
+
+end
diff --git a/matlab/octave_ver_less_than.m b/matlab/octave_ver_less_than.m
index 9d702d597..3c1a6a6a0 100644
--- a/matlab/octave_ver_less_than.m
+++ b/matlab/octave_ver_less_than.m
@@ -8,14 +8,14 @@ function r = octave_ver_less_than(verstr)
 %
 % INPUTS
 %    verstr: a string of the format 'x.y' or 'x.y.z'
-%    
+%
 % OUTPUTS
 %    r: 0 or 1
 %
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2008-2011 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/one_sided_hp_filter.m b/matlab/one_sided_hp_filter.m
index 38af32ea2..9715a3351 100644
--- a/matlab/one_sided_hp_filter.m
+++ b/matlab/one_sided_hp_filter.m
@@ -32,13 +32,13 @@ function [ytrend,ycycle]=one_sided_hp_filter(y,lambda,x_user,P_user,discard)
 %
 %       y_t=tau_t+epsilon_t
 %       (1-L)^2 tau_t=eta_t"
-% 
-%  The Kalman filter notation follows Chapter 13 of Hamilton, J.D. (1994). 
+%
+%  The Kalman filter notation follows Chapter 13 of Hamilton, J.D. (1994).
 %   Time Series Analysis, with the exception of H, which is equivalent to his H'.
 
 
 % Copyright (C) 200?-2015 Alexander Meyer-Gohde
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -63,26 +63,26 @@ end
 %Set up state space
 q=1/lambda;     % the signal-to-noise ration: i.e. var eta_t / var epsilon_t
 F=[2,-1;
-    1,0];       % state transition matrix
+   1,0];       % state transition matrix
 H=[1,0];        % observation matrix
 Q=[q,0;
-   0,0];        % covariance matrix state equation errors 
+   0,0];        % covariance matrix state equation errors
 R=1;            % variance observation equation error
 
 for k=1:n %Run the Kalman filter for each variable
     if nargin < 4 || isempty(x_user) %no intial value for state, extrapolate back two periods from the observations
-        x=[2*y(1,k)-y(2,k); 
-           3*y(1,k)-2*y(2,k)]; 
+        x=[2*y(1,k)-y(2,k);
+           3*y(1,k)-2*y(2,k)];
     else
         x=x_user(:,k);
-    end 
+    end
     if nargin < 4 || isempty(P_user) %no initial value for the MSE, set a rather high one
         P= [1e5 0;
-            0 1e5]; 
+            0 1e5];
     else
         P=P_user{k};
-    end 
-    
+    end
+
     for j=1:T %Get the estimates for each period
         [x,P]=kalman_update(F,H,Q,R,y(j,k),x,P); %get new state estimate and update recursion
         ytrend(j,k)=x(2);%second state is trend estimate
@@ -103,9 +103,9 @@ end
 
 function   [x,P]=kalman_update(F,H,Q,R,obs,x,P)
 % Updates the Kalman filter estimation of the state and MSE
-S=H*P*H'+R; 
-K=F*P*H';     
-K=K/S; 
+S=H*P*H'+R;
+K=F*P*H';
+K=K/S;
 x=F*x+K*(obs -H*x); %State estimate
 Temp=F-K*H;
 P=Temp*P*Temp';
diff --git a/matlab/optimization/apprgrdn.m b/matlab/optimization/apprgrdn.m
index 9f16e4466..2d79f0489 100644
--- a/matlab/optimization/apprgrdn.m
+++ b/matlab/optimization/apprgrdn.m
@@ -2,7 +2,7 @@ function g = apprgrdn(x,f,fun,deltax,obj,varargin)
 % g = apprgrdn(x,f,fun,deltax,obj,varargin)
 % Performs the finite difference approximation of the gradient <g> at a
 % point <x> used in solveopt
-% 
+%
 % Inputs:
 % x:        point at which to evaluate gradient
 % f:        calculated function value at a point x;
@@ -14,10 +14,10 @@ function g = apprgrdn(x,f,fun,deltax,obj,varargin)
 % Modified by Giovanni Lombardo and Johannes Pfeifer to accomodate Dynare
 % structure
 %
-% 
-% Copyright (C) 1997-2008, Alexei Kuntsevich and Franz Kappel 
+%
+% Copyright (C) 1997-2008, Alexei Kuntsevich and Franz Kappel
 % Copyright (C) 2008-2015 Giovanni Lombardo
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -38,10 +38,10 @@ n=max(size(x)); ee=ones(size(x));
 di=abs(x); idx=find(di<5e-15); di(idx)=5e-15*ee(idx);
 di=deltax.*di;
 if obj
-    idx=find(abs(di)<2e-10); 
+    idx=find(abs(di)<2e-10);
     di(idx)=2e-10*sign(di(idx));
 else
-    idx=find(abs(di)<5e-15); 
+    idx=find(abs(di)<5e-15);
     di(idx)=5e-15*sign(di(idx));
 end
 y=x;
@@ -51,7 +51,7 @@ for i=1:n
     y(i)=x(i)+di(i);
     fi=feval(fun,y,varargin{:});
     if obj
-        if fi==f,
+        if fi==f
             for j=1:3
                 di(i)=di(i)*10;  y(i)=x(i)+di(i);
                 fi=feval(fun,y,varargin{:});
diff --git a/matlab/optimization/bfgsi1.m b/matlab/optimization/bfgsi1.m
index 696ee410b..7a76a89b2 100644
--- a/matlab/optimization/bfgsi1.m
+++ b/matlab/optimization/bfgsi1.m
@@ -1,22 +1,22 @@
 function H = bfgsi1(H0,dg,dx,Verbose,Save_files)
 % H = bfgsi1(H0,dg,dx,Verbose,Save_files)
 % Update Inverse Hessian matrix
-% 
+%
 % Inputs:
 %   H0  [npar by npar]  initial inverse Hessian matrix
 %   dg  [npar by 1]     previous change in gradient
 %   dx  [npar by 1]     previous change in x;
 %   Verbose [scalar]    Indicator for silent mode
-%   Save_files [scalar] Indicator whether to save files  
-% 
+%   Save_files [scalar] Indicator whether to save files
+%
 % 6/8/93 version that updates inverse Hessian instead of Hessian
 % itself.
-% 
+%
 % Original file downloaded from:
 % http://sims.princeton.edu/yftp/optimize/mfiles/bfgsi.m
-% 
+%
 % Copyright (C) 1993-2009 Christopher Sims
-% Copyright (C) 2009-2015 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/optimization/cmaes.m b/matlab/optimization/cmaes.m
index 833dbe9b2..2ead9b50e 100644
--- a/matlab/optimization/cmaes.m
+++ b/matlab/optimization/cmaes.m
@@ -1,164 +1,164 @@
 function [xmin, ...      % minimum search point of last iteration
-	  fmin, ...      % function value of xmin
-	  counteval, ... % number of function evaluations done
-	  stopflag, ...  % stop criterion reached
-	  out, ...     % struct with various histories and solutions
-	  bestever ... % struct containing overall best solution (for convenience)
-	 ] = cmaes( ...
-    fitfun, ...    % name of objective/fitness function
-    xstart, ...    % objective variables initial point, determines N
-    insigma, ...   % initial coordinate wise standard deviation(s)
-    inopts, ...    % options struct, see defopts below
-    varargin )     % arguments passed to objective function 
-% cmaes.m, Version 3.56.beta, last change: February, 2012 
-% CMAES implements an Evolution Strategy with Covariance Matrix
-% Adaptation (CMA-ES) for nonlinear function minimization.  For
-% introductory comments and copyright (GPL) see end of file (type 
-% 'type cmaes'). cmaes.m runs with MATLAB (Windows, Linux) and, 
-% without data logging and plotting, it should run under Octave 
-% (Linux, package octave-forge is needed).
-%
-% OPTS = CMAES returns default options. 
-% OPTS = CMAES('defaults') returns default options quietly.
-% OPTS = CMAES('displayoptions') displays options. 
-% OPTS = CMAES('defaults', OPTS) supplements options OPTS with default 
-% options. 
-%
-% XMIN = CMAES(FUN, X0, SIGMA[, OPTS]) locates the minimum XMIN of
-% function FUN starting from column vector X0 with the initial
-% coordinate wise search standard deviation SIGMA.
-%
-% Input arguments: 
-%
-%  FUN is a string function name like 'myfun'. FUN takes as argument a
-%     column vector of size of X0 and returns a scalar. An easy way to
-%     implement a hard non-linear constraint is to return NaN. Then,
-%     this function evaluation is not counted and a newly sampled
-%     point is tried immediately.
-%
-%   X0 is a column vector, or a matrix, or a string. If X0 is a matrix,
-%     mean(X0, 2) is taken as initial point. If X0 is a string like
-%     '2*rand(10,1)-1', the string is evaluated first.
-%
-%   SIGMA is a scalar, or a column vector of size(X0,1), or a string
-%     that can be evaluated into one of these. SIGMA determines the
-%     initial coordinate wise standard deviations for the search.
-%     Setting SIGMA one third of the initial search region is
-%     appropriate, e.g., the initial point in [0, 6]^10 and SIGMA=2
-%     means cmaes('myfun', 3*rand(10,1), 2).  If SIGMA is missing and
-%     size(X0,2) > 1, SIGMA is set to sqrt(var(X0')'). That is, X0 is
-%     used as a sample for estimating initial mean and variance of the
-%     search distribution.
-%
-%   OPTS (an optional argument) is a struct holding additional input
-%     options. Valid field names and a short documentation can be
-%     discovered by looking at the default options (type 'cmaes'
-%     without arguments, see above). Empty or missing fields in OPTS
-%     invoke the default value, i.e. OPTS needs not to have all valid
-%     field names.  Capitalization does not matter and unambiguous
-%     abbreviations can be used for the field names. If a string is
-%     given where a numerical value is needed, the string is evaluated
-%     by eval, where 'N' expands to the problem dimension
-%     (==size(X0,1)) and 'popsize' to the population size. 
-%
-% [XMIN, FMIN, COUNTEVAL, STOPFLAG, OUT, BESTEVER] = ...
-%    CMAES(FITFUN, X0, SIGMA)
-% returns the best (minimal) point XMIN (found in the last
-% generation); function value FMIN of XMIN; the number of needed
-% function evaluations COUNTEVAL; a STOPFLAG value as cell array,
-% where possible entries are 'fitness', 'tolx', 'tolupx', 'tolfun',
-% 'maxfunevals', 'maxiter', 'stoptoresume', 'manual',
-% 'warnconditioncov', 'warnnoeffectcoord', 'warnnoeffectaxis',
-% 'warnequalfunvals', 'warnequalfunvalhist', 'bug' (use
-% e.g. any(strcmp(STOPFLAG, 'tolx')) or findstr(strcat(STOPFLAG,
-% 'tolx')) for further processing); a record struct OUT with some
-% more output, where the struct SOLUTIONS.BESTEVER contains the overall
-% best evaluated point X with function value F evaluated at evaluation
-% count EVALS. The last output argument BESTEVER equals 
-% OUT.SOLUTIONS.BESTEVER. Moreover a history of solutions and 
-% parameters is written to files according to the Log-options. 
-%
-% A regular manual stop can be achieved via the file signals.par. The
-% program is terminated if the first two non-white sequences in any
-% line of this file are 'stop' and the value of the LogFilenamePrefix
-% option (by default 'outcmaes'). Also a run can be skipped.
-% Given, for example, 'skip outcmaes run 2', skips the second run
-% if option Restarts is at least 2, and another run will be started.
-% 
-% To run the code completely silently set Disp, Save, and Log options
-% to 0.  With OPTS.LogModulo > 0 (1 by default) the most important
-% data are written to ASCII files permitting to investigate the
-% results (e.g. plot with function plotcmaesdat) even while CMAES is
-% still running (which can be quite useful on expensive objective
-% functions). When OPTS.SaveVariables==1 (default) everything is saved
-% in file OPTS.SaveFilename (default 'variablescmaes.mat') allowing to
-% resume the search afterwards by using the resume option.
-%
-% To find the best ever evaluated point load the variables typing
-% "es=load('variablescmaes')" and investigate the variable
-% es.out.solutions.bestever. 
-%
-% In case of a noisy objective function (uncertainties) set
-% OPTS.Noise.on = 1. This option interferes presumably with some 
-% termination criteria, because the step-size sigma will presumably
-% not converge to zero anymore. If CMAES was provided with a 
-% fifth argument (P1 in the below example, which is passed to the 
-% objective function FUN), this argument is multiplied with the 
-% factor given in option Noise.alphaevals, each time the detected 
-% noise exceeds a threshold. This argument can be used within 
-% FUN, for example, as averaging number to reduce the noise level.  
-%
-% OPTS.DiagonalOnly > 1 defines the number of initial iterations,
-% where the covariance matrix remains diagonal and the algorithm has
-% internally linear time complexity. OPTS.DiagonalOnly = 1 means
-% keeping the covariance matrix always diagonal and this setting
-% also exhibits linear space complexity. This can be particularly
-% useful for dimension > 100. The default is OPTS.DiagonalOnly = 0. 
-% 
-% OPTS.CMA.active = 1 turns on "active CMA" with a negative update 
-% of the covariance matrix and checks for positive definiteness. 
-% OPTS.CMA.active = 2 does not check for pos. def. and is numerically
-% faster. Active CMA usually speeds up the adaptation and might 
-% become a default in near future. 
-%
-% The primary strategy parameter to play with is OPTS.PopSize, which
-% can be increased from its default value.  Increasing the population
-% size (by default linked to increasing parent number OPTS.ParentNumber)
-% improves global search properties in exchange to speed. Speed
-% decreases, as a rule, at most linearely with increasing population
-% size. It is advisable to begin with the default small population
-% size. The options Restarts and IncPopSize can be used for an
-% automated multistart where the population size is increased by the
-% factor IncPopSize (two by default) before each restart. X0 (given as
-% string) is reevaluated for each restart. Stopping options
-% StopFunEvals, StopIter, MaxFunEvals, and Fitness terminate the
-% program, all others including MaxIter invoke another restart, where
-% the iteration counter is reset to zero.
-%
-% Examples: 
-%
-%   XMIN = cmaes('myfun', 5*ones(10,1), 1.5); starts the search at
-%   10D-point 5 and initially searches mainly between 5-3 and 5+3
-%   (+- two standard deviations), but this is not a strict bound.
-%   'myfun' is a name of a function that returns a scalar from a 10D
-%   column vector.
-%
-%   opts.LBounds = 0; opts.UBounds = 10; 
-%   X=cmaes('myfun', 10*rand(10,1), 5, opts);
-%   search within lower bound of 0 and upper bound of 10. Bounds can
-%   also be given as column vectors. If the optimum is not located
-%   on the boundary, use rather a penalty approach to handle bounds. 
-%
-%   opts=cmaes; opts.StopFitness=1e-10;
-%   X=cmaes('myfun', rand(5,1), 0.5, opts); stops the search, if
-%   the function value is smaller than 1e-10.
-%   
-%   [X, F, E, STOP, OUT] = cmaes('myfun2', 'rand(5,1)', 1, [], P1, P2); 
-%   passes two additional parameters to the function MYFUN2.
-%
+          fmin, ...      % function value of xmin
+          counteval, ... % number of function evaluations done
+          stopflag, ...  % stop criterion reached
+          out, ...     % struct with various histories and solutions
+          bestever ... % struct containing overall best solution (for convenience)
+         ] = cmaes( ...
+             fitfun, ...    % name of objective/fitness function
+             xstart, ...    % objective variables initial point, determines N
+             insigma, ...   % initial coordinate wise standard deviation(s)
+             inopts, ...    % options struct, see defopts below
+             varargin )     % arguments passed to objective function
+                            % cmaes.m, Version 3.56.beta, last change: February, 2012
+                            % CMAES implements an Evolution Strategy with Covariance Matrix
+                            % Adaptation (CMA-ES) for nonlinear function minimization.  For
+                            % introductory comments and copyright (GPL) see end of file (type
+                            % 'type cmaes'). cmaes.m runs with MATLAB (Windows, Linux) and,
+                            % without data logging and plotting, it should run under Octave
+                            % (Linux, package octave-forge is needed).
+                            %
+                            % OPTS = CMAES returns default options.
+                            % OPTS = CMAES('defaults') returns default options quietly.
+                            % OPTS = CMAES('displayoptions') displays options.
+                            % OPTS = CMAES('defaults', OPTS) supplements options OPTS with default
+                            % options.
+                            %
+                            % XMIN = CMAES(FUN, X0, SIGMA[, OPTS]) locates the minimum XMIN of
+                            % function FUN starting from column vector X0 with the initial
+                            % coordinate wise search standard deviation SIGMA.
+                            %
+                            % Input arguments:
+                            %
+                            %  FUN is a string function name like 'myfun'. FUN takes as argument a
+                            %     column vector of size of X0 and returns a scalar. An easy way to
+                            %     implement a hard non-linear constraint is to return NaN. Then,
+                            %     this function evaluation is not counted and a newly sampled
+                            %     point is tried immediately.
+                            %
+                            %   X0 is a column vector, or a matrix, or a string. If X0 is a matrix,
+                            %     mean(X0, 2) is taken as initial point. If X0 is a string like
+                            %     '2*rand(10,1)-1', the string is evaluated first.
+                            %
+                            %   SIGMA is a scalar, or a column vector of size(X0,1), or a string
+                            %     that can be evaluated into one of these. SIGMA determines the
+                            %     initial coordinate wise standard deviations for the search.
+                            %     Setting SIGMA one third of the initial search region is
+                            %     appropriate, e.g., the initial point in [0, 6]^10 and SIGMA=2
+                            %     means cmaes('myfun', 3*rand(10,1), 2).  If SIGMA is missing and
+                            %     size(X0,2) > 1, SIGMA is set to sqrt(var(X0')'). That is, X0 is
+                            %     used as a sample for estimating initial mean and variance of the
+                            %     search distribution.
+                            %
+                            %   OPTS (an optional argument) is a struct holding additional input
+                            %     options. Valid field names and a short documentation can be
+                            %     discovered by looking at the default options (type 'cmaes'
+                            %     without arguments, see above). Empty or missing fields in OPTS
+                            %     invoke the default value, i.e. OPTS needs not to have all valid
+                            %     field names.  Capitalization does not matter and unambiguous
+                            %     abbreviations can be used for the field names. If a string is
+                            %     given where a numerical value is needed, the string is evaluated
+                            %     by eval, where 'N' expands to the problem dimension
+                            %     (==size(X0,1)) and 'popsize' to the population size.
+                            %
+                            % [XMIN, FMIN, COUNTEVAL, STOPFLAG, OUT, BESTEVER] = ...
+                            %    CMAES(FITFUN, X0, SIGMA)
+                            % returns the best (minimal) point XMIN (found in the last
+                            % generation); function value FMIN of XMIN; the number of needed
+                            % function evaluations COUNTEVAL; a STOPFLAG value as cell array,
+                            % where possible entries are 'fitness', 'tolx', 'tolupx', 'tolfun',
+                            % 'maxfunevals', 'maxiter', 'stoptoresume', 'manual',
+                            % 'warnconditioncov', 'warnnoeffectcoord', 'warnnoeffectaxis',
+                            % 'warnequalfunvals', 'warnequalfunvalhist', 'bug' (use
+                            % e.g. any(strcmp(STOPFLAG, 'tolx')) or findstr(strcat(STOPFLAG,
+                            % 'tolx')) for further processing); a record struct OUT with some
+                            % more output, where the struct SOLUTIONS.BESTEVER contains the overall
+                            % best evaluated point X with function value F evaluated at evaluation
+                            % count EVALS. The last output argument BESTEVER equals
+                            % OUT.SOLUTIONS.BESTEVER. Moreover a history of solutions and
+                            % parameters is written to files according to the Log-options.
+                            %
+                            % A regular manual stop can be achieved via the file signals.par. The
+                            % program is terminated if the first two non-white sequences in any
+                            % line of this file are 'stop' and the value of the LogFilenamePrefix
+                            % option (by default 'outcmaes'). Also a run can be skipped.
+                            % Given, for example, 'skip outcmaes run 2', skips the second run
+                            % if option Restarts is at least 2, and another run will be started.
+                            %
+                            % To run the code completely silently set Disp, Save, and Log options
+                            % to 0.  With OPTS.LogModulo > 0 (1 by default) the most important
+                            % data are written to ASCII files permitting to investigate the
+                            % results (e.g. plot with function plotcmaesdat) even while CMAES is
+                            % still running (which can be quite useful on expensive objective
+                            % functions). When OPTS.SaveVariables==1 (default) everything is saved
+                            % in file OPTS.SaveFilename (default 'variablescmaes.mat') allowing to
+                            % resume the search afterwards by using the resume option.
+                            %
+                            % To find the best ever evaluated point load the variables typing
+                            % "es=load('variablescmaes')" and investigate the variable
+                            % es.out.solutions.bestever.
+                            %
+                            % In case of a noisy objective function (uncertainties) set
+                            % OPTS.Noise.on = 1. This option interferes presumably with some
+                            % termination criteria, because the step-size sigma will presumably
+                            % not converge to zero anymore. If CMAES was provided with a
+                            % fifth argument (P1 in the below example, which is passed to the
+                            % objective function FUN), this argument is multiplied with the
+                            % factor given in option Noise.alphaevals, each time the detected
+                            % noise exceeds a threshold. This argument can be used within
+                            % FUN, for example, as averaging number to reduce the noise level.
+                            %
+                            % OPTS.DiagonalOnly > 1 defines the number of initial iterations,
+                            % where the covariance matrix remains diagonal and the algorithm has
+                            % internally linear time complexity. OPTS.DiagonalOnly = 1 means
+                            % keeping the covariance matrix always diagonal and this setting
+                            % also exhibits linear space complexity. This can be particularly
+                            % useful for dimension > 100. The default is OPTS.DiagonalOnly = 0.
+                            %
+                            % OPTS.CMA.active = 1 turns on "active CMA" with a negative update
+                            % of the covariance matrix and checks for positive definiteness.
+                            % OPTS.CMA.active = 2 does not check for pos. def. and is numerically
+                            % faster. Active CMA usually speeds up the adaptation and might
+                            % become a default in near future.
+                            %
+                            % The primary strategy parameter to play with is OPTS.PopSize, which
+                            % can be increased from its default value.  Increasing the population
+                            % size (by default linked to increasing parent number OPTS.ParentNumber)
+                            % improves global search properties in exchange to speed. Speed
+                            % decreases, as a rule, at most linearely with increasing population
+                            % size. It is advisable to begin with the default small population
+                            % size. The options Restarts and IncPopSize can be used for an
+                            % automated multistart where the population size is increased by the
+                            % factor IncPopSize (two by default) before each restart. X0 (given as
+                            % string) is reevaluated for each restart. Stopping options
+                            % StopFunEvals, StopIter, MaxFunEvals, and Fitness terminate the
+                            % program, all others including MaxIter invoke another restart, where
+                            % the iteration counter is reset to zero.
+                            %
+                            % Examples:
+                            %
+                            %   XMIN = cmaes('myfun', 5*ones(10,1), 1.5); starts the search at
+                            %   10D-point 5 and initially searches mainly between 5-3 and 5+3
+                            %   (+- two standard deviations), but this is not a strict bound.
+                            %   'myfun' is a name of a function that returns a scalar from a 10D
+                            %   column vector.
+                            %
+                            %   opts.LBounds = 0; opts.UBounds = 10;
+                            %   X=cmaes('myfun', 10*rand(10,1), 5, opts);
+                            %   search within lower bound of 0 and upper bound of 10. Bounds can
+                            %   also be given as column vectors. If the optimum is not located
+                            %   on the boundary, use rather a penalty approach to handle bounds.
+                            %
+                            %   opts=cmaes; opts.StopFitness=1e-10;
+                            %   X=cmaes('myfun', rand(5,1), 0.5, opts); stops the search, if
+                            %   the function value is smaller than 1e-10.
+                            %
+                            %   [X, F, E, STOP, OUT] = cmaes('myfun2', 'rand(5,1)', 1, [], P1, P2);
+                            %   passes two additional parameters to the function MYFUN2.
+                            %
 
-% Copyright (C) 2001-2012 Nikolaus Hansen, 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2001-2012 Nikolaus Hansen,
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -176,7 +176,7 @@ function [xmin, ...      % minimum search point of last iteration
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-cmaVersion = '3.60.beta'; 
+cmaVersion = '3.60.beta';
 
 % ----------- Set Defaults for Input Parameters and Options -------------
 % These defaults may be edited for convenience
@@ -197,1596 +197,1596 @@ defopts.TolFun       = '1e-10 % stop if fun-changes smaller TolFun';
 defopts.TolHistFun   = '1e-11 % stop if back fun-changes smaller TolHistFun';
 defopts.StopOnStagnation = 'on  % stop when fitness stagnates for a long time';
 defopts.StopOnWarnings = 'yes  % ''no''==''off''==0, ''on''==''yes''==1 ';
-defopts.StopOnEqualFunctionValues = '2 + N/3  % number of iterations';  
+defopts.StopOnEqualFunctionValues = '2 + N/3  % number of iterations';
 
 % Options defaults: Other
 defopts.DiffMaxChange = 'Inf  % maximal variable change(s), can be Nx1-vector';
 defopts.DiffMinChange = '0    % minimal variable change(s), can be Nx1-vector';
 defopts.WarnOnEqualFunctionValues = ...
     'yes  % ''no''==''off''==0, ''on''==''yes''==1 ';
-defopts.LBounds = '-Inf % lower bounds, scalar or Nx1-vector'; 
-defopts.UBounds = 'Inf  % upper bounds, scalar or Nx1-vector'; 
+defopts.LBounds = '-Inf % lower bounds, scalar or Nx1-vector';
+defopts.UBounds = 'Inf  % upper bounds, scalar or Nx1-vector';
 defopts.EvalParallel = 'no   % objective function FUN accepts NxM matrix, with M>1?';
 defopts.EvalInitialX = 'yes  % evaluation of initial solution';
 defopts.Restarts     = '0    % number of restarts ';
 defopts.IncPopSize   = '2    % multiplier for population size before each restart';
 
-defopts.PopSize      = '(4 + floor(3*log(N)))  % population size, lambda'; 
+defopts.PopSize      = '(4 + floor(3*log(N)))  % population size, lambda';
 defopts.ParentNumber = 'floor(popsize/2)       % AKA mu, popsize equals lambda';
 defopts.RecombinationWeights = 'superlinear decrease % or linear, or equal';
-defopts.DiagonalOnly = '0*(1+100*N/sqrt(popsize))+(N>=1000)  % C is diagonal for given iterations, 1==always'; 
-defopts.Noise.on = '0  % uncertainty handling is off by default'; 
+defopts.DiagonalOnly = '0*(1+100*N/sqrt(popsize))+(N>=1000)  % C is diagonal for given iterations, 1==always';
+defopts.Noise.on = '0  % uncertainty handling is off by default';
 defopts.Noise.reevals  = '1*ceil(0.05*lambda)  % nb. of re-evaluated for uncertainty measurement';
 defopts.Noise.theta = '0.5  % threshold to invoke uncertainty treatment'; % smaller: more likely to diverge
-defopts.Noise.cum = '0.3  % cumulation constant for uncertainty'; 
+defopts.Noise.cum = '0.3  % cumulation constant for uncertainty';
 defopts.Noise.cutoff = '2*lambda/3  % rank change cutoff for summation';
 defopts.Noise.alphasigma  = '1+2/(N+10)  % factor for increasing sigma'; % smaller: slower adaptation
 defopts.Noise.epsilon  = '1e-7  % additional relative perturbation before reevaluation';
-defopts.Noise.minmaxevals = '[1 inf]  % min and max value of 2nd arg to fitfun, start value is 5th arg to cmaes'; 
-defopts.Noise.alphaevals  = '1+2/(N+10)  % factor for increasing 2nd arg to fitfun'; 
+defopts.Noise.minmaxevals = '[1 inf]  % min and max value of 2nd arg to fitfun, start value is 5th arg to cmaes';
+defopts.Noise.alphaevals  = '1+2/(N+10)  % factor for increasing 2nd arg to fitfun';
 defopts.Noise.callback = '[]  % callback function when uncertainty threshold is exceeded';
-% defopts.TPA = 0; 
-defopts.CMA.cs = '(mueff+2)/(N+mueff+3)  % cumulation constant for step-size'; 
-   %qqq cs = (mueff^0.5)/(N^0.5+mueff^0.5) % the short time horizon version
+% defopts.TPA = 0;
+defopts.CMA.cs = '(mueff+2)/(N+mueff+3)  % cumulation constant for step-size';
+%qqq cs = (mueff^0.5)/(N^0.5+mueff^0.5) % the short time horizon version
 defopts.CMA.damps = '1 + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs  % damping for step-size';
-% defopts.CMA.ccum = '4/(N+4)  % cumulation constant for covariance matrix'; 
+% defopts.CMA.ccum = '4/(N+4)  % cumulation constant for covariance matrix';
 defopts.CMA.ccum = '(4 + mueff/N) / (N+4 + 2*mueff/N)  % cumulation constant for pc';
-defopts.CMA.ccov1 = '2 / ((N+1.3)^2+mueff)  % learning rate for rank-one update'; 
-defopts.CMA.ccovmu = '2 * (mueff-2+1/mueff) / ((N+2)^2+mueff) % learning rate for rank-mu update'; 
-defopts.CMA.on     = 'yes'; 
-defopts.CMA.active = '0  % active CMA 1: neg. updates with pos. def. check, 2: neg. updates'; 
+defopts.CMA.ccov1 = '2 / ((N+1.3)^2+mueff)  % learning rate for rank-one update';
+defopts.CMA.ccovmu = '2 * (mueff-2+1/mueff) / ((N+2)^2+mueff) % learning rate for rank-mu update';
+defopts.CMA.on     = 'yes';
+defopts.CMA.active = '0  % active CMA 1: neg. updates with pos. def. check, 2: neg. updates';
 
 flg_future_setting = 0;  % testing for possible future variant(s)
-if flg_future_setting    
-  disp('in the future')
+if flg_future_setting
+    disp('in the future')
 
-  % damps setting from Brockhoff et al 2010
-  %   this damps diverges with popsize 400:
-  %   cmaeshtml('benchmarkszero', ones(20,1)*2, 5, o, 15);
-  defopts.CMA.damps = '2*mueff/lambda + 0.3 + cs  % damping for step-size';  % cs: for large mueff
-  % how about:
-  % defopts.CMA.damps = '2*mueff/lambda + 0.3 + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs  % damping for step-size';
+    % damps setting from Brockhoff et al 2010
+    %   this damps diverges with popsize 400:
+    %   cmaeshtml('benchmarkszero', ones(20,1)*2, 5, o, 15);
+    defopts.CMA.damps = '2*mueff/lambda + 0.3 + cs  % damping for step-size';  % cs: for large mueff
+                                                                               % how about:
+                                                                               % defopts.CMA.damps = '2*mueff/lambda + 0.3 + 2*max(0,sqrt((mueff-1)/(N+1))-1) + cs  % damping for step-size';
 
-  % ccum adjusted for large mueff, better on schefelmult? 
-  % TODO: this should also depend on diagonal option!?  
-  defopts.CMA.ccum = '(4 + mueff/N) / (N+4 + 2*mueff/N)  % cumulation constant for pc';
+    % ccum adjusted for large mueff, better on schefelmult?
+    % TODO: this should also depend on diagonal option!?
+    defopts.CMA.ccum = '(4 + mueff/N) / (N+4 + 2*mueff/N)  % cumulation constant for pc';
 
-  defopts.CMA.active = '1  % active CMA 1: neg. updates with pos. def. check, 2: neg. updates'; 
+    defopts.CMA.active = '1  % active CMA 1: neg. updates with pos. def. check, 2: neg. updates';
 end
-  
-defopts.Resume   = 'no   % resume former run from SaveFile'; 
-defopts.Science  = 'on  % off==do some additional (minor) problem capturing, NOT IN USE'; 
+
+defopts.Resume   = 'no   % resume former run from SaveFile';
+defopts.Science  = 'on  % off==do some additional (minor) problem capturing, NOT IN USE';
 defopts.ReadSignals = 'on  % from file signals.par for termination, yet a stumb';
 defopts.Seed = 'sum(100*clock)  % evaluated if it is a string';
 defopts.DispFinal  = 'on   % display messages like initial and final message';
 defopts.DispModulo = '100  % [0:Inf], disp messages after every i-th iteration';
 defopts.SaveVariables = 'on   % [on|final|off][-v6] save variables to .mat file';
-defopts.SaveFilename = 'variablescmaes.mat  % save all variables, see SaveVariables'; 
+defopts.SaveFilename = 'variablescmaes.mat  % save all variables, see SaveVariables';
 defopts.LogModulo = '1    % [0:Inf] if >1 record data less frequently after gen=100';
 defopts.LogTime   = '25   % [0:100] max. percentage of time for recording data';
-defopts.LogFilenamePrefix = 'outcmaes  % files for output data'; 
+defopts.LogFilenamePrefix = 'outcmaes  % files for output data';
 defopts.LogPlot = 'off    % plot while running using output data files';
 
-%qqqkkk 
-%defopts.varopt1 = ''; % 'for temporary and hacking purposes'; 
-%defopts.varopt2 = ''; % 'for temporary and hacking purposes'; 
+%qqqkkk
+%defopts.varopt1 = ''; % 'for temporary and hacking purposes';
+%defopts.varopt2 = ''; % 'for temporary and hacking purposes';
 defopts.UserData = 'for saving data/comments associated with the run';
 defopts.UserDat2 = ''; 'for saving data/comments associated with the run';
 
 % ---------------------- Handling Input Parameters ----------------------
 
 if nargin < 1 || isequal(fitfun, 'defaults') % pass default options
-  if nargin < 1
-    disp('Default options returned (type "help cmaes" for help).');
-  end
-  xmin = defopts;
-  if nargin > 1 % supplement second argument with default options
-    xmin = getoptions(xstart, defopts);
-  end
-  return;
+    if nargin < 1
+        disp('Default options returned (type "help cmaes" for help).');
+    end
+    xmin = defopts;
+    if nargin > 1 % supplement second argument with default options
+        xmin = getoptions(xstart, defopts);
+    end
+    return
 end
 
 if isequal(fitfun, 'displayoptions')
- names = fieldnames(defopts); 
- for name = names'
-   disp([name{:} repmat(' ', 1, 20-length(name{:})) ': ''' defopts.(name{:}) '''']); 
- end
- return; 
+    names = fieldnames(defopts);
+    for name = names'
+        disp([name{:} repmat(' ', 1, 20-length(name{:})) ': ''' defopts.(name{:}) '''']);
+    end
+    return
 end
 
 input.fitfun = fitfun; % record used input
 if isempty(fitfun)
-  % fitfun = definput.fitfun; 
-  % warning(['Objective function not determined, ''' fitfun ''' used']);
-  error(['Objective function not determined']);
+    % fitfun = definput.fitfun;
+    % warning(['Objective function not determined, ''' fitfun ''' used']);
+    error(['Objective function not determined']);
 end
 if ~ischar(fitfun)
-  error('first argument FUN must be a string');
+    error('first argument FUN must be a string');
 end
 
 
-if nargin < 2 
-  xstart = [];
+if nargin < 2
+    xstart = [];
 end
 
 input.xstart = xstart;
 if isempty(xstart)
-  % xstart = definput.xstart;  % objective variables initial point
-  % warning('Initial search point, and problem dimension, not determined');
-  error('Initial search point, and problem dimension, not determined');
+    % xstart = definput.xstart;  % objective variables initial point
+    % warning('Initial search point, and problem dimension, not determined');
+    error('Initial search point, and problem dimension, not determined');
 end
 
-if nargin < 3 
-  insigma = [];
+if nargin < 3
+    insigma = [];
 end
 if isa(insigma, 'struct')
-  error(['Third argument SIGMA must be (or eval to) a scalar '...
-	   'or a column vector of size(X0,1)']);
+    error(['Third argument SIGMA must be (or eval to) a scalar '...
+           'or a column vector of size(X0,1)']);
 end
 input.sigma = insigma;
 if isempty(insigma)
-  if all(size(myeval(xstart)) > 1)
-    insigma = std(xstart, 0, 2); 
-    if any(insigma == 0)
-      error(['Initial search volume is zero, choose SIGMA or X0 appropriate']);
+    if all(size(myeval(xstart)) > 1)
+        insigma = std(xstart, 0, 2);
+        if any(insigma == 0)
+            error(['Initial search volume is zero, choose SIGMA or X0 appropriate']);
+        end
+    else
+        % will be captured later
+        % error(['Initial step sizes (SIGMA) not determined']);
     end
-  else
-    % will be captured later
-    % error(['Initial step sizes (SIGMA) not determined']);
-  end
 end
 
 % Compose options opts
 if nargin < 4 || isempty(inopts) % no input options available
-  inopts = []; 
-  opts = defopts;
+    inopts = [];
+    opts = defopts;
 else
-  opts = getoptions(inopts, defopts);
+    opts = getoptions(inopts, defopts);
 end
 i = strfind(opts.SaveFilename, ' '); % remove everything after white space
 if ~isempty(i)
-  opts.SaveFilename = opts.SaveFilename(1:i(1)-1);
+    opts.SaveFilename = opts.SaveFilename(1:i(1)-1);
 end
 
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
-counteval = 0; countevalNaN = 0; 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+counteval = 0; countevalNaN = 0;
 irun = 0;
 while irun <= myeval(opts.Restarts) % for-loop does not work with resume
-  irun = irun + 1; 
+    irun = irun + 1;
 
-% ------------------------ Initialization -------------------------------
+    % ------------------------ Initialization -------------------------------
 
-% Handle resuming of old run
-flgresume = myevalbool(opts.Resume);
-xmean = myeval(xstart); 
-if all(size(xmean) > 1)
-   xmean = mean(xmean, 2); % in case if xstart is a population
-elseif size(xmean, 2) > 1
-  xmean = xmean';
-end 
-if ~flgresume % not resuming a former run
-  % Assign settings from input parameters and options for myeval...
-  N = size(xmean, 1); numberofvariables = N; 
-  lambda0 = floor(myeval(opts.PopSize) * myeval(opts.IncPopSize)^(irun-1)); 
-  % lambda0 = floor(myeval(opts.PopSize) * 3^floor((irun-1)/2)); 
-  popsize = lambda0;
-  lambda = lambda0;
-  insigma = myeval(insigma);
-  if all(size(insigma) == [N 2]) 
-    insigma = 0.5 * (insigma(:,2) - insigma(:,1));
-  end
-else % flgresume is true, do resume former run
-  tmp = whos('-file', opts.SaveFilename);
-  for i = 1:length(tmp)
-    if strcmp(tmp(i).name, 'localopts');
-      error('Saved variables include variable "localopts", please remove');
+    % Handle resuming of old run
+    flgresume = myevalbool(opts.Resume);
+    xmean = myeval(xstart);
+    if all(size(xmean) > 1)
+        xmean = mean(xmean, 2); % in case if xstart is a population
+    elseif size(xmean, 2) > 1
+        xmean = xmean';
     end
-  end
-  local.opts = opts; % keep stopping and display options
-  local.varargin = varargin;
-  load(opts.SaveFilename); 
-  varargin = local.varargin;
-  flgresume = 1;
+    if ~flgresume % not resuming a former run
+                  % Assign settings from input parameters and options for myeval...
+        N = size(xmean, 1); numberofvariables = N;
+        lambda0 = floor(myeval(opts.PopSize) * myeval(opts.IncPopSize)^(irun-1));
+        % lambda0 = floor(myeval(opts.PopSize) * 3^floor((irun-1)/2));
+        popsize = lambda0;
+        lambda = lambda0;
+        insigma = myeval(insigma);
+        if all(size(insigma) == [N 2])
+            insigma = 0.5 * (insigma(:,2) - insigma(:,1));
+        end
+    else % flgresume is true, do resume former run
+        tmp = whos('-file', opts.SaveFilename);
+        for i = 1:length(tmp)
+            if strcmp(tmp(i).name, 'localopts')
+                error('Saved variables include variable "localopts", please remove');
+            end
+        end
+        local.opts = opts; % keep stopping and display options
+        local.varargin = varargin;
+        load(opts.SaveFilename);
+        varargin = local.varargin;
+        flgresume = 1;
 
-  % Overwrite old stopping and display options
-  opts.StopFitness = local.opts.StopFitness; 
-  %%opts.MaxFunEvals = local.opts.MaxFunEvals;
-  %%opts.MaxIter = local.opts.MaxIter; 
-  opts.StopFunEvals = local.opts.StopFunEvals; 
-  opts.StopIter = local.opts.StopIter;  
-  opts.TolX = local.opts.TolX;
-  opts.TolUpX = local.opts.TolUpX;
-  opts.TolFun = local.opts.TolFun;
-  opts.TolHistFun = local.opts.TolHistFun;
-  opts.StopOnStagnation = local.opts.StopOnStagnation; 
-  opts.StopOnWarnings = local.opts.StopOnWarnings; 
-  opts.ReadSignals = local.opts.ReadSignals; 
-  opts.DispFinal = local.opts.DispFinal;
-  opts.LogPlot = local.opts.LogPlot;
-  opts.DispModulo = local.opts.DispModulo;
-  opts.SaveVariables = local.opts.SaveVariables;
-  opts.LogModulo = local.opts.LogModulo;
-  opts.LogTime = local.opts.LogTime;
-  clear local; % otherwise local would be overwritten during load
-end
-  
-%--------------------------------------------------------------
-% Evaluate options
-stopFitness = myeval(opts.StopFitness); 
-stopMaxFunEvals = myeval(opts.MaxFunEvals);  
-stopMaxIter = myeval(opts.MaxIter);  
-stopFunEvals = myeval(opts.StopFunEvals);  
-stopIter = myeval(opts.StopIter);  
-stopTolX = myeval(opts.TolX);
-stopTolUpX = myeval(opts.TolUpX);
-stopTolFun = myeval(opts.TolFun);
-stopTolHistFun = myeval(opts.TolHistFun);
-stopOnStagnation = myevalbool(opts.StopOnStagnation); 
-stopOnWarnings = myevalbool(opts.StopOnWarnings); 
-flgreadsignals = myevalbool(opts.ReadSignals);
-flgWarnOnEqualFunctionValues = myevalbool(opts.WarnOnEqualFunctionValues);
-flgEvalParallel = myevalbool(opts.EvalParallel);
-stopOnEqualFunctionValues = myeval(opts.StopOnEqualFunctionValues);
-arrEqualFunvals = zeros(1,10+N);
-flgDiagonalOnly = myeval(opts.DiagonalOnly); 
-flgActiveCMA = myeval(opts.CMA.active); 
-noiseHandling = myevalbool(opts.Noise.on);
-noiseMinMaxEvals = myeval(opts.Noise.minmaxevals);
-noiseAlphaEvals = myeval(opts.Noise.alphaevals);
-noiseCallback = myeval(opts.Noise.callback); 
-flgdisplay = myevalbool(opts.DispFinal);
-flgplotting = myevalbool(opts.LogPlot);
-verbosemodulo = myeval(opts.DispModulo);
-flgscience = myevalbool(opts.Science);
-flgsaving = [];
-strsaving = [];
-if strfind(opts.SaveVariables, '-v6') 
-  i = strfind(opts.SaveVariables, '%');
-  if isempty(i) || i == 0 || strfind(opts.SaveVariables, '-v6') < i
-    strsaving = '-v6';
-    flgsaving = 1;
-    flgsavingfinal = 1;
-  end
-end
-if strncmp('final', opts.SaveVariables, 5)
-  flgsaving = 0;
-  flgsavingfinal = 1;
-end
-if isempty(flgsaving)
-  flgsaving = myevalbool(opts.SaveVariables);
-  flgsavingfinal = flgsaving;
-end
-savemodulo = myeval(opts.LogModulo);
-savetime = myeval(opts.LogTime);
-
-i = strfind(opts.LogFilenamePrefix, ' '); % remove everything after white space
-if ~isempty(i)
-  opts.LogFilenamePrefix = opts.LogFilenamePrefix(1:i(1)-1);
-end
-
-% TODO here silent option? set disp, save and log options to 0 
-
-%--------------------------------------------------------------
-
-if (isfinite(stopFunEvals) || isfinite(stopIter)) && ~flgsaving
-  warning('To resume later the saving option needs to be set');
-end
-
-
-% Do more checking and initialization 
-if flgresume % resume is on
-  time.t0 = clock;
-  if flgdisplay
-    disp(['  resumed from ' opts.SaveFilename ]); 
-  end
-  if counteval >= stopMaxFunEvals 
-    error(['MaxFunEvals exceeded, use StopFunEvals as stopping ' ...
-	  'criterion before resume']);
-  end
-  if countiter >= stopMaxIter 
-    error(['MaxIter exceeded, use StopIter as stopping criterion ' ...
-	  'before resume']);
-  end
-  
-else % flgresume
-  % xmean = mean(myeval(xstart), 2); % evaluate xstart again, because of irun
-  maxdx = myeval(opts.DiffMaxChange); % maximal sensible variable change
-  mindx = myeval(opts.DiffMinChange); % minimal sensible variable change 
-				      % can both also be defined as Nx1 vectors
-  lbounds = myeval(opts.LBounds);		     
-  ubounds = myeval(opts.UBounds);
-  if length(lbounds) == 1
-    lbounds = repmat(lbounds, N, 1);
-  end
-  if length(ubounds) == 1
-    ubounds = repmat(ubounds, N, 1);
-  end
-  if isempty(insigma) % last chance to set insigma
-    if all(lbounds > -Inf) && all(ubounds < Inf)
-      if any(lbounds>=ubounds)
-	error('upper bound must be greater than lower bound');
-      end
-      insigma = 0.3*(ubounds-lbounds);
-      stopTolX = myeval(opts.TolX);  % reevaluate these
-      stopTolUpX = myeval(opts.TolUpX);
-    else
-      error(['Initial step sizes (SIGMA) not determined']);
+        % Overwrite old stopping and display options
+        opts.StopFitness = local.opts.StopFitness;
+        %%opts.MaxFunEvals = local.opts.MaxFunEvals;
+        %%opts.MaxIter = local.opts.MaxIter;
+        opts.StopFunEvals = local.opts.StopFunEvals;
+        opts.StopIter = local.opts.StopIter;
+        opts.TolX = local.opts.TolX;
+        opts.TolUpX = local.opts.TolUpX;
+        opts.TolFun = local.opts.TolFun;
+        opts.TolHistFun = local.opts.TolHistFun;
+        opts.StopOnStagnation = local.opts.StopOnStagnation;
+        opts.StopOnWarnings = local.opts.StopOnWarnings;
+        opts.ReadSignals = local.opts.ReadSignals;
+        opts.DispFinal = local.opts.DispFinal;
+        opts.LogPlot = local.opts.LogPlot;
+        opts.DispModulo = local.opts.DispModulo;
+        opts.SaveVariables = local.opts.SaveVariables;
+        opts.LogModulo = local.opts.LogModulo;
+        opts.LogTime = local.opts.LogTime;
+        clear local; % otherwise local would be overwritten during load
     end
-  end
 
-  % Check all vector sizes
-  if size(xmean, 2) > 1 || size(xmean,1) ~= N
-    error(['intial search point should be a column vector of size ' ...
-	   num2str(N)]);
-  elseif ~(all(size(insigma) == [1 1]) || all(size(insigma) == [N 1]))
-    error(['input parameter SIGMA should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  elseif size(stopTolX, 2) > 1 || ~ismember(size(stopTolX, 1), [1 N])
-    error(['option TolX should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  elseif size(stopTolUpX, 2) > 1 || ~ismember(size(stopTolUpX, 1), [1 N])
-    error(['option TolUpX should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  elseif size(maxdx, 2) > 1 || ~ismember(size(maxdx, 1), [1 N])
-    error(['option DiffMaxChange should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  elseif size(mindx, 2) > 1 || ~ismember(size(mindx, 1), [1 N])
-    error(['option DiffMinChange should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  elseif size(lbounds, 2) > 1 || ~ismember(size(lbounds, 1), [1 N])
-    error(['option lbounds should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  elseif size(ubounds, 2) > 1 || ~ismember(size(ubounds, 1), [1 N])
-    error(['option ubounds should be (or eval to) a scalar '...
-	   'or a column vector of size ' num2str(N)] );
-  end
-  
-  % Initialize dynamic internal state parameters
-  if any(insigma <= 0) 
-    error(['Initial search volume (SIGMA) must be greater than zero']);
-  end
-  if max(insigma)/min(insigma) > 1e6
-    error(['Initial search volume (SIGMA) badly conditioned']);
-  end
-  sigma = max(insigma);              % overall standard deviation
-  pc = zeros(N,1); ps = zeros(N,1);  % evolution paths for C and sigma
+    %--------------------------------------------------------------
+    % Evaluate options
+    stopFitness = myeval(opts.StopFitness);
+    stopMaxFunEvals = myeval(opts.MaxFunEvals);
+    stopMaxIter = myeval(opts.MaxIter);
+    stopFunEvals = myeval(opts.StopFunEvals);
+    stopIter = myeval(opts.StopIter);
+    stopTolX = myeval(opts.TolX);
+    stopTolUpX = myeval(opts.TolUpX);
+    stopTolFun = myeval(opts.TolFun);
+    stopTolHistFun = myeval(opts.TolHistFun);
+    stopOnStagnation = myevalbool(opts.StopOnStagnation);
+    stopOnWarnings = myevalbool(opts.StopOnWarnings);
+    flgreadsignals = myevalbool(opts.ReadSignals);
+    flgWarnOnEqualFunctionValues = myevalbool(opts.WarnOnEqualFunctionValues);
+    flgEvalParallel = myevalbool(opts.EvalParallel);
+    stopOnEqualFunctionValues = myeval(opts.StopOnEqualFunctionValues);
+    arrEqualFunvals = zeros(1,10+N);
+    flgDiagonalOnly = myeval(opts.DiagonalOnly);
+    flgActiveCMA = myeval(opts.CMA.active);
+    noiseHandling = myevalbool(opts.Noise.on);
+    noiseMinMaxEvals = myeval(opts.Noise.minmaxevals);
+    noiseAlphaEvals = myeval(opts.Noise.alphaevals);
+    noiseCallback = myeval(opts.Noise.callback);
+    flgdisplay = myevalbool(opts.DispFinal);
+    flgplotting = myevalbool(opts.LogPlot);
+    verbosemodulo = myeval(opts.DispModulo);
+    flgscience = myevalbool(opts.Science);
+    flgsaving = [];
+    strsaving = [];
+    if strfind(opts.SaveVariables, '-v6')
+        i = strfind(opts.SaveVariables, '%');
+        if isempty(i) || i == 0 || strfind(opts.SaveVariables, '-v6') < i
+            strsaving = '-v6';
+            flgsaving = 1;
+            flgsavingfinal = 1;
+        end
+    end
+    if strncmp('final', opts.SaveVariables, 5)
+        flgsaving = 0;
+        flgsavingfinal = 1;
+    end
+    if isempty(flgsaving)
+        flgsaving = myevalbool(opts.SaveVariables);
+        flgsavingfinal = flgsaving;
+    end
+    savemodulo = myeval(opts.LogModulo);
+    savetime = myeval(opts.LogTime);
 
-  if length(insigma) == 1
-    insigma = insigma * ones(N,1) ;
-  end
-  diagD = insigma/max(insigma);      % diagonal matrix D defines the scaling
-  diagC = diagD.^2; 
-  if flgDiagonalOnly ~= 1            % use at some point full covariance matrix
-    B = eye(N,N);                      % B defines the coordinate system
-    BD = B.*repmat(diagD',N,1);        % B*D for speed up only
-    C = diag(diagC);                   % covariance matrix == BD*(BD)'
-  end
-  if flgDiagonalOnly
-    B = 1; 
-  end
+    i = strfind(opts.LogFilenamePrefix, ' '); % remove everything after white space
+    if ~isempty(i)
+        opts.LogFilenamePrefix = opts.LogFilenamePrefix(1:i(1)-1);
+    end
 
-  fitness.hist=NaN*ones(1,10+ceil(3*10*N/lambda)); % history of fitness values
-  fitness.histsel=NaN*ones(1,10+ceil(3*10*N/lambda)); % history of fitness values
-  fitness.histbest=[]; % history of fitness values
-  fitness.histmedian=[]; % history of fitness values
+    % TODO here silent option? set disp, save and log options to 0
 
-  % Initialize boundary handling
-  bnd.isactive = any(lbounds > -Inf) || any(ubounds < Inf); 
-  if bnd.isactive
-    if any(lbounds>ubounds)
-      error('lower bound found to be greater than upper bound');
-    end
-    [xmean ti] = xintobounds(xmean, lbounds, ubounds); % just in case
-    if any(ti)
-      warning('Initial point was out of bounds, corrected');
-    end
-    bnd.weights = zeros(N,1);         % weights for bound penalty
-    % scaling is better in axis-parallel case, worse in rotated
-    bnd.flgscale = 0; % scaling will be omitted if zero 
-    if bnd.flgscale ~= 0 
-      bnd.scale = diagC/mean(diagC);
-    else
-      bnd.scale = ones(N,1);
-    end
-    
-    idx = (lbounds > -Inf) | (ubounds < Inf);
-    if length(idx) == 1
-      idx = idx * ones(N,1);
-    end
-    bnd.isbounded = zeros(N,1);
-    bnd.isbounded(find(idx)) = 1; 
-    maxdx = min(maxdx, (ubounds - lbounds)/2);
-    if any(sigma*sqrt(diagC) > maxdx)
-      fac = min(maxdx ./ sqrt(diagC))/sigma;
-      sigma = min(maxdx ./ sqrt(diagC));
-      warning(['Initial SIGMA multiplied by the factor ' num2str(fac) ...
-	       ', because it was larger than half' ...
-	       ' of one of the boundary intervals']);
-    end
-    idx = (lbounds > -Inf) & (ubounds < Inf);
-    dd = diagC;
-    if any(5*sigma*sqrt(dd(idx)) < ubounds(idx) - lbounds(idx))
-      warning(['Initial SIGMA is, in at least one coordinate, ' ...
-	       'much smaller than the '...
-	       'given boundary intervals. For reasonable ' ...
-	       'global search performance SIGMA should be ' ...
-	       'between 0.2 and 0.5 of the bounded interval in ' ...
-	       'each coordinate. If all coordinates have ' ... 
-	       'lower and upper bounds SIGMA can be empty']);
-    end
-    bnd.dfithist = 1;              % delta fit for setting weights
-    bnd.aridxpoints = [];          % remember complete outside points
-    bnd.arfitness = [];            % and their fitness
-    bnd.validfitval = 0;
-    bnd.iniphase = 1;
-  end
+    %--------------------------------------------------------------
 
-  % ooo initial feval, for output only
-  if irun == 1 
-    out.solutions.bestever.x = xmean;
-    out.solutions.bestever.f = Inf;  % for simpler comparison below
-    out.solutions.bestever.evals = counteval;
-    bestever = out.solutions.bestever;
-  end
-  if myevalbool(opts.EvalInitialX)
-    fitness.hist(1)=feval(fitfun, xmean, varargin{:}); 
-    fitness.histsel(1)=fitness.hist(1);
-    counteval = counteval + 1;
-    if fitness.hist(1) < out.solutions.bestever.f 
-	out.solutions.bestever.x = xmean;
-	out.solutions.bestever.f = fitness.hist(1);
-	out.solutions.bestever.evals = counteval;
-	bestever = out.solutions.bestever;
+    if (isfinite(stopFunEvals) || isfinite(stopIter)) && ~flgsaving
+        warning('To resume later the saving option needs to be set');
     end
-  else
-    fitness.hist(1)=NaN; 
-    fitness.histsel(1)=NaN; 
-  end
-    
-  % initialize random number generator
+
+
+    % Do more checking and initialization
+    if flgresume % resume is on
+        time.t0 = clock;
+        if flgdisplay
+            disp(['  resumed from ' opts.SaveFilename ]);
+        end
+        if counteval >= stopMaxFunEvals
+            error(['MaxFunEvals exceeded, use StopFunEvals as stopping ' ...
+                   'criterion before resume']);
+        end
+        if countiter >= stopMaxIter
+            error(['MaxIter exceeded, use StopIter as stopping criterion ' ...
+                   'before resume']);
+        end
+
+    else % flgresume
+         % xmean = mean(myeval(xstart), 2); % evaluate xstart again, because of irun
+        maxdx = myeval(opts.DiffMaxChange); % maximal sensible variable change
+        mindx = myeval(opts.DiffMinChange); % minimal sensible variable change
+                                            % can both also be defined as Nx1 vectors
+        lbounds = myeval(opts.LBounds);
+        ubounds = myeval(opts.UBounds);
+        if length(lbounds) == 1
+            lbounds = repmat(lbounds, N, 1);
+        end
+        if length(ubounds) == 1
+            ubounds = repmat(ubounds, N, 1);
+        end
+        if isempty(insigma) % last chance to set insigma
+            if all(lbounds > -Inf) && all(ubounds < Inf)
+                if any(lbounds>=ubounds)
+                    error('upper bound must be greater than lower bound');
+                end
+                insigma = 0.3*(ubounds-lbounds);
+                stopTolX = myeval(opts.TolX);  % reevaluate these
+                stopTolUpX = myeval(opts.TolUpX);
+            else
+                error(['Initial step sizes (SIGMA) not determined']);
+            end
+        end
+
+        % Check all vector sizes
+        if size(xmean, 2) > 1 || size(xmean,1) ~= N
+            error(['intial search point should be a column vector of size ' ...
+                   num2str(N)]);
+        elseif ~(all(size(insigma) == [1 1]) || all(size(insigma) == [N 1]))
+            error(['input parameter SIGMA should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        elseif size(stopTolX, 2) > 1 || ~ismember(size(stopTolX, 1), [1 N])
+            error(['option TolX should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        elseif size(stopTolUpX, 2) > 1 || ~ismember(size(stopTolUpX, 1), [1 N])
+            error(['option TolUpX should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        elseif size(maxdx, 2) > 1 || ~ismember(size(maxdx, 1), [1 N])
+            error(['option DiffMaxChange should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        elseif size(mindx, 2) > 1 || ~ismember(size(mindx, 1), [1 N])
+            error(['option DiffMinChange should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        elseif size(lbounds, 2) > 1 || ~ismember(size(lbounds, 1), [1 N])
+            error(['option lbounds should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        elseif size(ubounds, 2) > 1 || ~ismember(size(ubounds, 1), [1 N])
+            error(['option ubounds should be (or eval to) a scalar '...
+                   'or a column vector of size ' num2str(N)] );
+        end
+
+        % Initialize dynamic internal state parameters
+        if any(insigma <= 0)
+            error(['Initial search volume (SIGMA) must be greater than zero']);
+        end
+        if max(insigma)/min(insigma) > 1e6
+            error(['Initial search volume (SIGMA) badly conditioned']);
+        end
+        sigma = max(insigma);              % overall standard deviation
+        pc = zeros(N,1); ps = zeros(N,1);  % evolution paths for C and sigma
+
+        if length(insigma) == 1
+            insigma = insigma * ones(N,1) ;
+        end
+        diagD = insigma/max(insigma);      % diagonal matrix D defines the scaling
+        diagC = diagD.^2;
+        if flgDiagonalOnly ~= 1            % use at some point full covariance matrix
+            B = eye(N,N);                      % B defines the coordinate system
+            BD = B.*repmat(diagD',N,1);        % B*D for speed up only
+            C = diag(diagC);                   % covariance matrix == BD*(BD)'
+        end
+        if flgDiagonalOnly
+            B = 1;
+        end
+
+        fitness.hist=NaN*ones(1,10+ceil(3*10*N/lambda)); % history of fitness values
+        fitness.histsel=NaN*ones(1,10+ceil(3*10*N/lambda)); % history of fitness values
+        fitness.histbest=[]; % history of fitness values
+        fitness.histmedian=[]; % history of fitness values
+
+        % Initialize boundary handling
+        bnd.isactive = any(lbounds > -Inf) || any(ubounds < Inf);
+        if bnd.isactive
+            if any(lbounds>ubounds)
+                error('lower bound found to be greater than upper bound');
+            end
+            [xmean, ti] = xintobounds(xmean, lbounds, ubounds); % just in case
+            if any(ti)
+                warning('Initial point was out of bounds, corrected');
+            end
+            bnd.weights = zeros(N,1);         % weights for bound penalty
+                                              % scaling is better in axis-parallel case, worse in rotated
+            bnd.flgscale = 0; % scaling will be omitted if zero
+            if bnd.flgscale ~= 0
+                bnd.scale = diagC/mean(diagC);
+            else
+                bnd.scale = ones(N,1);
+            end
+
+            idx = (lbounds > -Inf) | (ubounds < Inf);
+            if length(idx) == 1
+                idx = idx * ones(N,1);
+            end
+            bnd.isbounded = zeros(N,1);
+            bnd.isbounded(find(idx)) = 1;
+            maxdx = min(maxdx, (ubounds - lbounds)/2);
+            if any(sigma*sqrt(diagC) > maxdx)
+                fac = min(maxdx ./ sqrt(diagC))/sigma;
+                sigma = min(maxdx ./ sqrt(diagC));
+                warning(['Initial SIGMA multiplied by the factor ' num2str(fac) ...
+                         ', because it was larger than half' ...
+                         ' of one of the boundary intervals']);
+            end
+            idx = (lbounds > -Inf) & (ubounds < Inf);
+            dd = diagC;
+            if any(5*sigma*sqrt(dd(idx)) < ubounds(idx) - lbounds(idx))
+                warning(['Initial SIGMA is, in at least one coordinate, ' ...
+                         'much smaller than the '...
+                         'given boundary intervals. For reasonable ' ...
+                         'global search performance SIGMA should be ' ...
+                         'between 0.2 and 0.5 of the bounded interval in ' ...
+                         'each coordinate. If all coordinates have ' ...
+                         'lower and upper bounds SIGMA can be empty']);
+            end
+            bnd.dfithist = 1;              % delta fit for setting weights
+            bnd.aridxpoints = [];          % remember complete outside points
+            bnd.arfitness = [];            % and their fitness
+            bnd.validfitval = 0;
+            bnd.iniphase = 1;
+        end
+
+        % ooo initial feval, for output only
+        if irun == 1
+            out.solutions.bestever.x = xmean;
+            out.solutions.bestever.f = Inf;  % for simpler comparison below
+            out.solutions.bestever.evals = counteval;
+            bestever = out.solutions.bestever;
+        end
+        if myevalbool(opts.EvalInitialX)
+            fitness.hist(1)=feval(fitfun, xmean, varargin{:});
+            fitness.histsel(1)=fitness.hist(1);
+            counteval = counteval + 1;
+            if fitness.hist(1) < out.solutions.bestever.f
+                out.solutions.bestever.x = xmean;
+                out.solutions.bestever.f = fitness.hist(1);
+                out.solutions.bestever.evals = counteval;
+                bestever = out.solutions.bestever;
+            end
+        else
+            fitness.hist(1)=NaN;
+            fitness.histsel(1)=NaN;
+        end
+
+        % initialize random number generator
 % $$$   if ischar(opts.Seed)
 % $$$     randn('state', eval(opts.Seed));     % random number generator state
 % $$$   else
 % $$$     randn('state', opts.Seed);
 % $$$   end
-  %qqq
+%qqq
 %  load(opts.SaveFilename, 'startseed');
 %  randn('state', startseed);
 %  disp(['SEED RELOADED FROM ' opts.SaveFilename]);
 %  startseed = randn('state');         % for retrieving in saved variables
 
-  % Initialize further constants
-  chiN=N^0.5*(1-1/(4*N)+1/(21*N^2));  % expectation of 
-				      %   ||N(0,I)|| == norm(randn(N,1))
-  
-  countiter = 0;
-  % Initialize records and output
-  if irun == 1
-    time.t0 = clock;
-    
-    % TODO: keep also median solution? 
-    out.evals = counteval;  % should be first entry
-    out.stopflag = {};
+        % Initialize further constants
+        chiN=N^0.5*(1-1/(4*N)+1/(21*N^2));  % expectation of
+                                            %   ||N(0,I)|| == norm(randn(N,1))
 
-    outiter = 0;
+        countiter = 0;
+        % Initialize records and output
+        if irun == 1
+            time.t0 = clock;
 
-    % Write headers to output data files 
-    filenameprefix = opts.LogFilenamePrefix; 
-    if savemodulo && savetime
-      filenames = {};
-      filenames(end+1) = {'axlen'};
-      filenames(end+1) = {'fit'};
-      filenames(end+1) = {'stddev'};
-      filenames(end+1) = {'xmean'};
-      filenames(end+1) = {'xrecentbest'};
-      str = [' (startseed=' num2str(startseed(2)) ...
-             ', ' num2str(clock, '%d/%02d/%d %d:%d:%2.2f') ')'];
-      for namecell = filenames(:)'
-        name = namecell{:};
+            % TODO: keep also median solution?
+            out.evals = counteval;  % should be first entry
+            out.stopflag = {};
 
-	[fid, err] = fopen(['./' filenameprefix name '.dat'], 'w');
-	if fid < 1 % err ~= 0 
-	  warning(['could not open ' filenameprefix name '.dat']);
-	  filenames(find(strcmp(filenames,name))) = [];
-	else
-%	  fprintf(fid, '%s\n', ...
-%	      ['<CMAES-OUTPUT version="' cmaVersion '">']);
-%	  fprintf(fid, ['  <NAME>' name '</NAME>\n']);
-%	  fprintf(fid, ['  <DATE>' date() '</DATE>\n']);
-%	  fprintf(fid, '  <PARAMETERS>\n');
-%	  fprintf(fid, ['    dimension=' num2str(N) '\n']);
-%	  fprintf(fid, '  </PARAMETERS>\n');
-	  % different cases for DATA columns annotations here
-%	  fprintf(fid, '  <DATA');
-	  if strcmp(name, 'axlen')
-	     fprintf(fid, ['%%  columns="iteration, evaluation, sigma, ' ...
-		 'max axis length, min axis length, ' ...
-		 'all principal axes lengths (sorted square roots ' ...
-                  'of eigenvalues of C)"' str]);
-	  elseif strcmp(name, 'fit')
-	    fprintf(fid, ['%%  columns="iteration, evaluation, sigma, axis ratio, bestever,' ...
-		' best, median, worst fitness function value,' ...
-		' further objective values of best"' str]);
-	  elseif strcmp(name, 'stddev')
-	    fprintf(fid, ['%%  columns=["iteration, evaluation, sigma, void, void, ' ...
-		'stds==sigma*sqrt(diag(C))"' str]);
-	  elseif strcmp(name, 'xmean')
-	    fprintf(fid, ['%%  columns="iteration, evaluation, void, ' ...
-                          'void, void, xmean"' str]);
-	  elseif strcmp(name, 'xrecentbest')
-	    fprintf(fid, ['%%  columns="iteration, evaluation, fitness, ' ...
-                          'void, void, xrecentbest"' str]);
-	  end
-	  fprintf(fid, '\n'); % DATA
-	  if strcmp(name, 'xmean')
-	    fprintf(fid, '%ld %ld 0 0 0 ', 0, counteval); 
-	    % fprintf(fid, '%ld %ld 0 0 %e ', countiter, counteval, fmean); 
-%qqq	    fprintf(fid, msprintf('%e ', genophenotransform(out.genopheno, xmean)) + '\n'); 
-	    fprintf(fid, '%e ', xmean);
-            fprintf(fid, '\n'); 
-	  end
-	  fclose(fid); 
-          clear fid; % preventing 
-	end
-      end % for files
-    end % savemodulo
-  end % irun == 1
-  
-end % else flgresume 
+            outiter = 0;
 
-% -------------------- Generation Loop --------------------------------
-stopflag = {};
-while isempty(stopflag)
-  % set internal parameters
-  if countiter == 0 || lambda ~= lambda_last
-    if countiter > 0 && floor(log10(lambda)) ~= floor(log10(lambda_last)) ...
-          && flgdisplay
-      disp(['  lambda = ' num2str(lambda)]);
-      lambda_hist(:,end+1) = [countiter+1; lambda];
-    else
-      lambda_hist = [countiter+1; lambda]; 
-    end
-    lambda_last = lambda;
-    % Strategy internal parameter setting: Selection  
-    mu = myeval(opts.ParentNumber); % number of parents/points for recombination
-    if strncmp(lower(opts.RecombinationWeights), 'equal', 3)
-      weights = ones(mu,1); % (mu_I,lambda)-CMA-ES
-    elseif strncmp(lower(opts.RecombinationWeights), 'linear', 3)
-      weights = mu+0.5-(1:mu)'; 
-    elseif strncmp(lower(opts.RecombinationWeights), 'superlinear', 3)
-      weights = log(mu+0.5)-log(1:mu)'; % muXone array for weighted recombination
-                                        % qqq mu can be non-integer and
-                                        % should become ceil(mu-0.5) (minor correction)
-    else
-      error(['Recombination weights to be "' opts.RecombinationWeights ...
-             '" is not implemented']);
-    end
-    mueff=sum(weights)^2/sum(weights.^2); % variance-effective size of mu
-    weights = weights/sum(weights);     % normalize recombination weights array
-    if mueff == lambda
-      error(['Combination of values for PopSize, ParentNumber and ' ...
-             ' and RecombinationWeights is not reasonable']);
-    end
-    
-    % Strategy internal parameter setting: Adaptation
-    cc = myeval(opts.CMA.ccum); % time constant for cumulation for covariance matrix
-    cs = myeval(opts.CMA.cs); 
+            % Write headers to output data files
+            filenameprefix = opts.LogFilenamePrefix;
+            if savemodulo && savetime
+                filenames = {};
+                filenames(end+1) = {'axlen'};
+                filenames(end+1) = {'fit'};
+                filenames(end+1) = {'stddev'};
+                filenames(end+1) = {'xmean'};
+                filenames(end+1) = {'xrecentbest'};
+                str = [' (startseed=' num2str(startseed(2)) ...
+                       ', ' num2str(clock, '%d/%02d/%d %d:%d:%2.2f') ')'];
+                for namecell = filenames(:)'
+                    name = namecell{:};
 
-    % old way TODO: remove this at some point
-    % mucov = mueff;   % size of mu used for calculating learning rate ccov
-    % ccov = (1/mucov) * 2/(N+1.41)^2 ... % learning rate for covariance matrix
-    %        + (1-1/mucov) * min(1,(2*mucov-1)/((N+2)^2+mucov)); 
+                    [fid, err] = fopen(['./' filenameprefix name '.dat'], 'w');
+                    if fid < 1 % err ~= 0
+                        warning(['could not open ' filenameprefix name '.dat']);
+                        filenames(find(strcmp(filenames,name))) = [];
+                    else
+                        %         fprintf(fid, '%s\n', ...
+                        %             ['<CMAES-OUTPUT version="' cmaVersion '">']);
+                        %         fprintf(fid, ['  <NAME>' name '</NAME>\n']);
+                        %         fprintf(fid, ['  <DATE>' date() '</DATE>\n']);
+                        %         fprintf(fid, '  <PARAMETERS>\n');
+                        %         fprintf(fid, ['    dimension=' num2str(N) '\n']);
+                        %         fprintf(fid, '  </PARAMETERS>\n');
+                        % different cases for DATA columns annotations here
+                        %         fprintf(fid, '  <DATA');
+                        if strcmp(name, 'axlen')
+                            fprintf(fid, ['%%  columns="iteration, evaluation, sigma, ' ...
+                                          'max axis length, min axis length, ' ...
+                                          'all principal axes lengths (sorted square roots ' ...
+                                          'of eigenvalues of C)"' str]);
+                        elseif strcmp(name, 'fit')
+                            fprintf(fid, ['%%  columns="iteration, evaluation, sigma, axis ratio, bestever,' ...
+                                          ' best, median, worst fitness function value,' ...
+                                          ' further objective values of best"' str]);
+                        elseif strcmp(name, 'stddev')
+                            fprintf(fid, ['%%  columns=["iteration, evaluation, sigma, void, void, ' ...
+                                          'stds==sigma*sqrt(diag(C))"' str]);
+                        elseif strcmp(name, 'xmean')
+                            fprintf(fid, ['%%  columns="iteration, evaluation, void, ' ...
+                                          'void, void, xmean"' str]);
+                        elseif strcmp(name, 'xrecentbest')
+                            fprintf(fid, ['%%  columns="iteration, evaluation, fitness, ' ...
+                                          'void, void, xrecentbest"' str]);
+                        end
+                        fprintf(fid, '\n'); % DATA
+                        if strcmp(name, 'xmean')
+                            fprintf(fid, '%ld %ld 0 0 0 ', 0, counteval);
+                            % fprintf(fid, '%ld %ld 0 0 %e ', countiter, counteval, fmean);
+                            %qqq        fprintf(fid, msprintf('%e ', genophenotransform(out.genopheno, xmean)) + '\n');
+                            fprintf(fid, '%e ', xmean);
+                            fprintf(fid, '\n');
+                        end
+                        fclose(fid);
+                        clear fid; % preventing
+                    end
+                end % for files
+            end % savemodulo
+        end % irun == 1
 
-    % new way
-    if myevalbool(opts.CMA.on) 
-      ccov1 = myeval(opts.CMA.ccov1); 
-      ccovmu = min(1-ccov1, myeval(opts.CMA.ccovmu));
-    else
-      ccov1 = 0;
-      ccovmu = 0;
-    end
-    
-    % flgDiagonalOnly = -lambda*4*1/ccov; % for ccov==1 it is not needed
-    % 0 : C will never be diagonal anymore
-    % 1 : C will always be diagonal
-    % >1: C is diagonal for first iterations, set to 0 afterwards
-    if flgDiagonalOnly < 1
-      flgDiagonalOnly = 0; 
-    end
-    if flgDiagonalOnly
-      ccov1_sep = min(1, ccov1 * (N+1.5) / 3); 
-      ccovmu_sep = min(1-ccov1_sep, ccovmu * (N+1.5) / 3); 
-    elseif N > 98 && flgdisplay && countiter == 0
-      disp('consider option DiagonalOnly for high-dimensional problems');
-    end
+    end % else flgresume
 
-    % ||ps|| is close to sqrt(mueff/N) for mueff large on linear fitness
-    %damps = ... % damping for step size control, usually close to one 
-    %    (1 + 2*max(0,sqrt((mueff-1)/(N+1))-1)) ... % limit sigma increase
-    %    * max(0.3, ... % reduce damps, if max. iteration number is small
-    %          1 - N/min(stopMaxIter,stopMaxFunEvals/lambda)) + cs; 
-    damps = myeval(opts.CMA.damps); 
-    if noiseHandling
-      noiseReevals = min(myeval(opts.Noise.reevals), lambda); 
-      noiseAlpha = myeval(opts.Noise.alphasigma); 
-      noiseEpsilon = myeval(opts.Noise.epsilon); 
-      noiseTheta = myeval(opts.Noise.theta); 
-      noisecum = myeval(opts.Noise.cum);
-      noiseCutOff = myeval(opts.Noise.cutoff);  % arguably of minor relevance
-    else
-      noiseReevals = 0; % more convenient in later coding
-    end
+    % -------------------- Generation Loop --------------------------------
+    stopflag = {};
+    while isempty(stopflag)
+        % set internal parameters
+        if countiter == 0 || lambda ~= lambda_last
+            if countiter > 0 && floor(log10(lambda)) ~= floor(log10(lambda_last)) ...
+                    && flgdisplay
+                disp(['  lambda = ' num2str(lambda)]);
+                lambda_hist(:,end+1) = [countiter+1; lambda];
+            else
+                lambda_hist = [countiter+1; lambda];
+            end
+            lambda_last = lambda;
+            % Strategy internal parameter setting: Selection
+            mu = myeval(opts.ParentNumber); % number of parents/points for recombination
+            if strncmp(lower(opts.RecombinationWeights), 'equal', 3)
+                weights = ones(mu,1); % (mu_I,lambda)-CMA-ES
+            elseif strncmp(lower(opts.RecombinationWeights), 'linear', 3)
+                weights = mu+0.5-(1:mu)';
+            elseif strncmp(lower(opts.RecombinationWeights), 'superlinear', 3)
+                weights = log(mu+0.5)-log(1:mu)'; % muXone array for weighted recombination
+                                                  % qqq mu can be non-integer and
+                                                  % should become ceil(mu-0.5) (minor correction)
+            else
+                error(['Recombination weights to be "' opts.RecombinationWeights ...
+                       '" is not implemented']);
+            end
+            mueff=sum(weights)^2/sum(weights.^2); % variance-effective size of mu
+            weights = weights/sum(weights);     % normalize recombination weights array
+            if mueff == lambda
+                error(['Combination of values for PopSize, ParentNumber and ' ...
+                       ' and RecombinationWeights is not reasonable']);
+            end
 
-    %qqq hacking of a different parameter setting, e.g. for ccov or damps,
-    %  can be done here, but is not necessary anymore, see opts.CMA. 
-    % ccov1 = 0.0*ccov1; disp(['CAVE: ccov1=' num2str(ccov1)]);
-    % ccovmu = 0.0*ccovmu; disp(['CAVE: ccovmu=' num2str(ccovmu)]);
-    % damps = inf*damps; disp(['CAVE: damps=' num2str(damps)]);
-    % cc = 1; disp(['CAVE: cc=' num2str(cc)]);
+            % Strategy internal parameter setting: Adaptation
+            cc = myeval(opts.CMA.ccum); % time constant for cumulation for covariance matrix
+            cs = myeval(opts.CMA.cs);
 
-  end    
+            % old way TODO: remove this at some point
+            % mucov = mueff;   % size of mu used for calculating learning rate ccov
+            % ccov = (1/mucov) * 2/(N+1.41)^2 ... % learning rate for covariance matrix
+            %        + (1-1/mucov) * min(1,(2*mucov-1)/((N+2)^2+mucov));
 
-  % Display initial message
-  if countiter == 0 && flgdisplay 
-    if mu == 1
-      strw = '100';
-    elseif mu < 8
-      strw = [sprintf('%.0f', 100*weights(1)) ... 
-              sprintf(' %.0f', 100*weights(2:end)')];
-    else
-      strw = [sprintf('%.2g ', 100*weights(1:2)') ...
-              sprintf('%.2g', 100*weights(3)') '...' ...
-              sprintf(' %.2g', 100*weights(end-1:end)') ']%, '];      
-    end
-    if irun > 1
-      strrun = [', run ' num2str(irun)];
-    else
-      strrun = '';
-    end
-    disp(['  n=' num2str(N) ': (' num2str(mu) ',' ...
-          num2str(lambda) ')-CMA-ES(w=[' ...
-          strw ']%, ' ...
-          'mu_eff=' num2str(mueff,'%.1f') ...
-          ') on function ' ...
-          (fitfun) strrun]);
-    if flgDiagonalOnly == 1
-      disp('    C is diagonal');
-    elseif flgDiagonalOnly
-      disp(['    C is diagonal for ' num2str(floor(flgDiagonalOnly)) ' iterations']);
-    end
-  end
+            % new way
+            if myevalbool(opts.CMA.on)
+                ccov1 = myeval(opts.CMA.ccov1);
+                ccovmu = min(1-ccov1, myeval(opts.CMA.ccovmu));
+            else
+                ccov1 = 0;
+                ccovmu = 0;
+            end
 
-  flush;
+            % flgDiagonalOnly = -lambda*4*1/ccov; % for ccov==1 it is not needed
+            % 0 : C will never be diagonal anymore
+            % 1 : C will always be diagonal
+            % >1: C is diagonal for first iterations, set to 0 afterwards
+            if flgDiagonalOnly < 1
+                flgDiagonalOnly = 0;
+            end
+            if flgDiagonalOnly
+                ccov1_sep = min(1, ccov1 * (N+1.5) / 3);
+                ccovmu_sep = min(1-ccov1_sep, ccovmu * (N+1.5) / 3);
+            elseif N > 98 && flgdisplay && countiter == 0
+                disp('consider option DiagonalOnly for high-dimensional problems');
+            end
 
-  countiter = countiter + 1; 
+            % ||ps|| is close to sqrt(mueff/N) for mueff large on linear fitness
+            %damps = ... % damping for step size control, usually close to one
+            %    (1 + 2*max(0,sqrt((mueff-1)/(N+1))-1)) ... % limit sigma increase
+            %    * max(0.3, ... % reduce damps, if max. iteration number is small
+            %          1 - N/min(stopMaxIter,stopMaxFunEvals/lambda)) + cs;
+            damps = myeval(opts.CMA.damps);
+            if noiseHandling
+                noiseReevals = min(myeval(opts.Noise.reevals), lambda);
+                noiseAlpha = myeval(opts.Noise.alphasigma);
+                noiseEpsilon = myeval(opts.Noise.epsilon);
+                noiseTheta = myeval(opts.Noise.theta);
+                noisecum = myeval(opts.Noise.cum);
+                noiseCutOff = myeval(opts.Noise.cutoff);  % arguably of minor relevance
+            else
+                noiseReevals = 0; % more convenient in later coding
+            end
 
-  % Generate and evaluate lambda offspring
- 
-  fitness.raw = repmat(NaN, 1, lambda + noiseReevals);
+            %qqq hacking of a different parameter setting, e.g. for ccov or damps,
+            %  can be done here, but is not necessary anymore, see opts.CMA.
+            % ccov1 = 0.0*ccov1; disp(['CAVE: ccov1=' num2str(ccov1)]);
+            % ccovmu = 0.0*ccovmu; disp(['CAVE: ccovmu=' num2str(ccovmu)]);
+            % damps = inf*damps; disp(['CAVE: damps=' num2str(damps)]);
+            % cc = 1; disp(['CAVE: cc=' num2str(cc)]);
 
-  % parallel evaluation
-  if flgEvalParallel
-      arz = randn(N,lambda);
-
-      if ~flgDiagonalOnly
-        arx = repmat(xmean, 1, lambda) + sigma * (BD * arz); % Eq. (1)
-      else
-        arx = repmat(xmean, 1, lambda) + repmat(sigma * diagD, 1, lambda) .* arz; 
-      end
-
-      if noiseHandling 
-        if noiseEpsilon == 0
-          arx = [arx arx(:,1:noiseReevals)]; 
-        elseif flgDiagonalOnly
-          arx = [arx arx(:,1:noiseReevals) + ...
-                 repmat(noiseEpsilon * sigma * diagD, 1, noiseReevals) ...
-                 .* randn(N,noiseReevals)]; 
-        else 
-          arx = [arx arx(:,1:noiseReevals) + ...
-                 noiseEpsilon * sigma * ...
-                 (BD * randn(N,noiseReevals))]; 
         end
-      end
 
-      % You may handle constraints here. You may either resample
-      % arz(:,k) and/or multiply it with a factor between -1 and 1
-      % (the latter will decrease the overall step size) and
-      % recalculate arx accordingly. Do not change arx or arz in any
-      % other way.
- 
-      if ~bnd.isactive
-        arxvalid = arx;
-      else
-        arxvalid = xintobounds(arx, lbounds, ubounds);
-      end
-      % You may handle constraints here.  You may copy and alter
-      % (columns of) arxvalid(:,k) only for the evaluation of the
-      % fitness function. arx and arxvalid should not be changed.
-      fitness.raw = feval(fitfun, arxvalid, varargin{:}); 
-      countevalNaN = countevalNaN + sum(isnan(fitness.raw));
-      counteval = counteval + sum(~isnan(fitness.raw)); 
-  end
+        % Display initial message
+        if countiter == 0 && flgdisplay
+            if mu == 1
+                strw = '100';
+            elseif mu < 8
+                strw = [sprintf('%.0f', 100*weights(1)) ...
+                        sprintf(' %.0f', 100*weights(2:end)')];
+            else
+                strw = [sprintf('%.2g ', 100*weights(1:2)') ...
+                        sprintf('%.2g', 100*weights(3)') '...' ...
+                        sprintf(' %.2g', 100*weights(end-1:end)') ']%, '];
+            end
+            if irun > 1
+                strrun = [', run ' num2str(irun)];
+            else
+                strrun = '';
+            end
+            disp(['  n=' num2str(N) ': (' num2str(mu) ',' ...
+                  num2str(lambda) ')-CMA-ES(w=[' ...
+                  strw ']%, ' ...
+                  'mu_eff=' num2str(mueff,'%.1f') ...
+                  ') on function ' ...
+                  (fitfun) strrun]);
+            if flgDiagonalOnly == 1
+                disp('    C is diagonal');
+            elseif flgDiagonalOnly
+                disp(['    C is diagonal for ' num2str(floor(flgDiagonalOnly)) ' iterations']);
+            end
+        end
 
-  % non-parallel evaluation and remaining NaN-values
-  % set also the reevaluated solution to NaN
-  fitness.raw(lambda + find(isnan(fitness.raw(1:noiseReevals)))) = NaN;  
-  for k=find(isnan(fitness.raw)), 
-    % fitness.raw(k) = NaN; 
-    tries = 0;
-    % Resample, until fitness is not NaN
-    while isnan(fitness.raw(k))
-      if k <= lambda  % regular samples (not the re-evaluation-samples)
-        arz(:,k) = randn(N,1); % (re)sample
+        flush;
 
-        if flgDiagonalOnly  
-          arx(:,k) = xmean + sigma * diagD .* arz(:,k);              % Eq. (1)
+        countiter = countiter + 1;
+
+        % Generate and evaluate lambda offspring
+
+        fitness.raw = repmat(NaN, 1, lambda + noiseReevals);
+
+        % parallel evaluation
+        if flgEvalParallel
+            arz = randn(N,lambda);
+
+            if ~flgDiagonalOnly
+                arx = repmat(xmean, 1, lambda) + sigma * (BD * arz); % Eq. (1)
+            else
+                arx = repmat(xmean, 1, lambda) + repmat(sigma * diagD, 1, lambda) .* arz;
+            end
+
+            if noiseHandling
+                if noiseEpsilon == 0
+                    arx = [arx arx(:,1:noiseReevals)];
+                elseif flgDiagonalOnly
+                    arx = [arx arx(:,1:noiseReevals) + ...
+                           repmat(noiseEpsilon * sigma * diagD, 1, noiseReevals) ...
+                           .* randn(N,noiseReevals)];
+                else
+                    arx = [arx arx(:,1:noiseReevals) + ...
+                           noiseEpsilon * sigma * ...
+                           (BD * randn(N,noiseReevals))];
+                end
+            end
+
+            % You may handle constraints here. You may either resample
+            % arz(:,k) and/or multiply it with a factor between -1 and 1
+            % (the latter will decrease the overall step size) and
+            % recalculate arx accordingly. Do not change arx or arz in any
+            % other way.
+
+            if ~bnd.isactive
+                arxvalid = arx;
+            else
+                arxvalid = xintobounds(arx, lbounds, ubounds);
+            end
+            % You may handle constraints here.  You may copy and alter
+            % (columns of) arxvalid(:,k) only for the evaluation of the
+            % fitness function. arx and arxvalid should not be changed.
+            fitness.raw = feval(fitfun, arxvalid, varargin{:});
+            countevalNaN = countevalNaN + sum(isnan(fitness.raw));
+            counteval = counteval + sum(~isnan(fitness.raw));
+        end
+
+        % non-parallel evaluation and remaining NaN-values
+        % set also the reevaluated solution to NaN
+        fitness.raw(lambda + find(isnan(fitness.raw(1:noiseReevals)))) = NaN;
+        for k=find(isnan(fitness.raw))
+            % fitness.raw(k) = NaN;
+            tries = 0;
+            % Resample, until fitness is not NaN
+            while isnan(fitness.raw(k))
+                if k <= lambda  % regular samples (not the re-evaluation-samples)
+                    arz(:,k) = randn(N,1); % (re)sample
+
+                    if flgDiagonalOnly
+                        arx(:,k) = xmean + sigma * diagD .* arz(:,k);              % Eq. (1)
+                    else
+                        arx(:,k) = xmean + sigma * (BD * arz(:,k));                % Eq. (1)
+                    end
+                else % re-evaluation solution with index > lambda
+                    if flgDiagonalOnly
+                        arx(:,k) = arx(:,k-lambda) + (noiseEpsilon * sigma) * diagD .* randn(N,1);
+                    else
+                        arx(:,k) = arx(:,k-lambda) + (noiseEpsilon * sigma) * (BD * randn(N,1));
+                    end
+                end
+
+                % You may handle constraints here. You may either resample
+                % arz(:,k) and/or multiply it with a factor between -1 and 1
+                % (the latter will decrease the overall step size) and
+                % recalculate arx accordingly. Do not change arx or arz in any
+                % other way.
+
+                if ~bnd.isactive
+                    arxvalid(:,k) = arx(:,k);
+                else
+                    arxvalid(:,k) = xintobounds(arx(:,k), lbounds, ubounds);
+                end
+                % You may handle constraints here.  You may copy and alter
+                % (columns of) arxvalid(:,k) only for the evaluation of the
+                % fitness function. arx should not be changed.
+                fitness.raw(k) = feval(fitfun, arxvalid(:,k), varargin{:});
+                tries = tries + 1;
+                if isnan(fitness.raw(k))
+                    countevalNaN = countevalNaN + 1;
+                end
+                if mod(tries, 100) == 0
+                    warning([num2str(tries) ...
+                             ' NaN objective function values at evaluation ' ...
+                             num2str(counteval)]);
+                end
+            end
+            counteval = counteval + 1; % retries due to NaN are not counted
+        end
+
+        fitness.sel = fitness.raw;
+
+        % ----- handle boundaries -----
+        if 1 < 3 && bnd.isactive
+            % Get delta fitness values
+            val = myprctile(fitness.raw, [25 75]);
+            % more precise would be exp(mean(log(diagC)))
+            val = (val(2) - val(1)) / N / mean(diagC) / sigma^2;
+            %val = (myprctile(fitness.raw, 75) - myprctile(fitness.raw, 25)) ...
+            %    / N / mean(diagC) / sigma^2;
+            % Catch non-sensible values
+            if ~isfinite(val)
+                warning('Non-finite fitness range');
+                val = max(bnd.dfithist);
+            elseif val == 0 % happens if all points are out of bounds
+                val = min(bnd.dfithist(bnd.dfithist>0));  % seems not to make sense, given all solutions are out of bounds
+            elseif bnd.validfitval == 0 % flag that first sensible val was found
+                bnd.dfithist = [];
+                bnd.validfitval = 1;
+            end
+
+            % Store delta fitness values
+            if length(bnd.dfithist) < 20+(3*N)/lambda
+                bnd.dfithist = [bnd.dfithist val];
+            else
+                bnd.dfithist = [bnd.dfithist(2:end) val];
+            end
+
+            [tx, ti]  = xintobounds(xmean, lbounds, ubounds);
+
+            % Set initial weights
+            if bnd.iniphase
+                if any(ti)
+                    bnd.weights(find(bnd.isbounded)) = 2.0002 * median(bnd.dfithist);
+                    if bnd.flgscale == 0 % scale only initial weights then
+                        dd = diagC;
+                        idx = find(bnd.isbounded);
+                        dd = dd(idx) / mean(dd); %  remove mean scaling
+                        bnd.weights(idx) = bnd.weights(idx) ./ dd;
+                    end
+                    if bnd.validfitval && countiter > 2
+                        bnd.iniphase = 0;
+                    end
+                end
+            end
+
+            % Increase weights
+            if  1 < 3 && any(ti) % any coordinate of xmean out of bounds
+                                 % judge distance of xmean to boundary
+                tx = xmean - tx;
+                idx = (ti ~= 0 & abs(tx) > 3*max(1,sqrt(N)/mueff) ...
+                       * sigma*sqrt(diagC)) ;
+                % only increase if xmean is moving away
+                idx = idx & (sign(tx) == sign(xmean - xold));
+                if ~isempty(idx) % increase
+                                 % the factor became 1.2 instead of 1.1, because
+                                 % changed from max to min in version 3.52
+                    bnd.weights(idx) = 1.2^(min(1, mueff/10/N)) * bnd.weights(idx);
+                end
+            end
+
+            % Calculate scaling biased to unity, product is one
+            if bnd.flgscale ~= 0
+                bnd.scale = exp(0.9*(log(diagC)-mean(log(diagC))));
+            end
+
+            % Assigned penalized fitness
+            bnd.arpenalty = (bnd.weights ./ bnd.scale)' * (arxvalid - arx).^2;
+
+            fitness.sel = fitness.raw + bnd.arpenalty;
+
+        end % handle boundaries
+            % ----- end handle boundaries -----
+
+            % compute noise measurement and reduce fitness arrays to size lambda
+            if noiseHandling
+                [noiseS] = local_noisemeasurement(fitness.sel(1:lambda), ...
+                                                  fitness.sel(lambda+(1:noiseReevals)), ...
+                                                  noiseReevals, noiseTheta, noiseCutOff);
+                if countiter == 1 % TODO: improve this very rude way of initialization
+                    noiseSS = 0;
+                    noiseN = 0;  % counter for mean
+                end
+                noiseSS = noiseSS + noisecum * (noiseS - noiseSS);
+
+                % noise-handling could be done here, but the original sigma is still needed
+                % disp([noiseS noiseSS noisecum])
+
+                fitness.rawar12 = fitness.raw; % just documentary
+                fitness.selar12 = fitness.sel; % just documentary
+                                               % qqq refine fitness based on both values
+                if 11 < 3  % TODO: in case of outliers this mean is counterproductive
+                           % median out of three would be ok
+                    fitness.raw(1:noiseReevals) = ... % not so raw anymore
+                        (fitness.raw(1:noiseReevals) + fitness.raw(lambda+(1:noiseReevals))) / 2;
+                    fitness.sel(1:noiseReevals) = ...
+                        (fitness.sel(1:noiseReevals) + fitness.sel(lambda+(1:noiseReevals))) / 2;
+                end
+                fitness.raw = fitness.raw(1:lambda);
+                fitness.sel = fitness.sel(1:lambda);
+            end
+
+            % Sort by fitness
+            [fitness.raw, fitness.idx] = sort(fitness.raw);
+            [fitness.sel, fitness.idxsel] = sort(fitness.sel);  % minimization
+            fitness.hist(2:end) = fitness.hist(1:end-1);    % record short history of
+            fitness.hist(1) = fitness.raw(1);               % best fitness values
+            if length(fitness.histbest) < 120+ceil(30*N/lambda) || ...
+                    (mod(countiter, 5) == 0  && length(fitness.histbest) < 2e4)  % 20 percent of 1e5 gen.
+                fitness.histbest = [fitness.raw(1) fitness.histbest];          % best fitness values
+                fitness.histmedian = [median(fitness.raw) fitness.histmedian]; % median fitness values
+            else
+                fitness.histbest(2:end) = fitness.histbest(1:end-1);
+                fitness.histmedian(2:end) = fitness.histmedian(1:end-1);
+                fitness.histbest(1) = fitness.raw(1);           % best fitness values
+                fitness.histmedian(1) = median(fitness.raw);    % median fitness values
+            end
+            fitness.histsel(2:end) = fitness.histsel(1:end-1); % record short history of
+            fitness.histsel(1) = fitness.sel(1);               % best sel fitness values
+
+            % Calculate new xmean, this is selection and recombination
+            xold = xmean; % for speed up of Eq. (2) and (3)
+            xmean = arx(:,fitness.idxsel(1:mu))*weights;
+            zmean = arz(:,fitness.idxsel(1:mu))*weights;%==D^-1*B'*(xmean-xold)/sigma
+            if mu == 1
+                fmean = fitness.sel(1);
+            else
+                fmean = NaN; % [] does not work in the latter assignment
+                             % fmean = feval(fitfun, xintobounds(xmean, lbounds, ubounds), varargin{:});
+                             % counteval = counteval + 1;
+            end
+
+            % Cumulation: update evolution paths
+            ps = (1-cs)*ps + sqrt(cs*(2-cs)*mueff) * (B*zmean);          % Eq. (4)
+            hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.4 + 2/(N+1);
+            if flg_future_setting
+                hsig = sum(ps.^2) / (1-(1-cs)^(2*countiter)) / N < 2 + 4/(N+1); % just simplified
+            end
+            %  hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.4 + 2/(N+1);
+            %  hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.5 + 1/(N-0.5);
+            %  hsig = norm(ps) < 1.5 * sqrt(N);
+            %  hsig = 1;
+
+            pc = (1-cc)*pc ...
+                 + hsig*(sqrt(cc*(2-cc)*mueff)/sigma) * (xmean-xold);     % Eq. (2)
+            if hsig == 0
+                % disp([num2str(countiter) ' ' num2str(counteval) ' pc update stalled']);
+            end
+
+            % Adapt covariance matrix
+            neg.ccov = 0;  % TODO: move parameter setting upwards at some point
+            if ccov1 + ccovmu > 0                                                    % Eq. (3)
+                if flgDiagonalOnly % internal linear(?) complexity
+                    diagC = (1-ccov1_sep-ccovmu_sep+(1-hsig)*ccov1_sep*cc*(2-cc)) * diagC ... % regard old matrix
+                            + ccov1_sep * pc.^2 ...               % plus rank one update
+                            + ccovmu_sep ...                      % plus rank mu update
+                            * (diagC .* (arz(:,fitness.idxsel(1:mu)).^2 * weights));
+                    %             * (repmat(diagC,1,mu) .* arz(:,fitness.idxsel(1:mu)).^2 * weights);
+                    diagD = sqrt(diagC); % replaces eig(C)
+                else
+                    arpos = (arx(:,fitness.idxsel(1:mu))-repmat(xold,1,mu)) / sigma;
+                    % "active" CMA update: negative update, in case controlling pos. definiteness
+                    if flgActiveCMA > 0
+                        % set parameters
+                        neg.mu = mu;
+                        neg.mueff = mueff;
+                        if flgActiveCMA > 10  % flat weights with mu=lambda/2
+                            neg.mu = floor(lambda/2);
+                            neg.mueff = neg.mu;
+                        end
+                        % neg.mu = ceil(min([N, lambda/4, mueff]));  neg.mueff = mu; % i.e. neg.mu <= N
+                        % Parameter study: in 3-D lambda=50,100, 10-D lambda=200,400, 30-D lambda=1000,2000 a
+                        % three times larger neg.ccov does not work.
+                        %   increasing all ccov rates three times does work (probably because of the factor (1-ccovmu))
+                        %   in 30-D to looks fine
+
+                        neg.ccov = (1 - ccovmu) * 0.25 * neg.mueff / ((N+2)^1.5 + 2*neg.mueff);
+                        neg.minresidualvariance = 0.66;  % keep at least 0.66 in all directions, small popsize are most critical
+                        neg.alphaold = 0.5;  % where to make up for the variance loss, 0.5 means no idea what to do
+                                             % 1 is slightly more robust and gives a better "guaranty" for pos. def.,
+                                             % but does it make sense from the learning perspective for large ccovmu?
+
+                        neg.ccovfinal = neg.ccov;
+
+                        % prepare vectors, compute negative updating matrix Cneg and checking matrix Ccheck
+                        arzneg = arz(:,fitness.idxsel(lambda:-1:lambda - neg.mu + 1));
+                        % i-th longest becomes i-th shortest
+                        % TODO: this is not in compliance with the paper Hansen&Ros2010,
+                        %       where simply arnorms = arnorms(end:-1:1) ?
+                        [arnorms, idxnorms] = sort(sqrt(sum(arzneg.^2, 1)));
+                        [ignore, idxnorms] = sort(idxnorms);  % inverse index
+                        arnormfacs = arnorms(end:-1:1) ./ arnorms;
+                        % arnormfacs = arnorms(randperm(neg.mu)) ./ arnorms;
+                        arnorms = arnorms(end:-1:1); % for the record
+                        if flgActiveCMA < 20
+                            arzneg = arzneg .* repmat(arnormfacs(idxnorms), N, 1);  % E x*x' is N
+                                                                                    % arzneg = sqrt(N) * arzneg ./ repmat(sqrt(sum(arzneg.^2, 1)), N, 1);  % E x*x' is N
+                        end
+                        if flgActiveCMA < 10 && neg.mu == mu  % weighted sum
+                            if mod(flgActiveCMA, 10) == 1 % TODO: prevent this with a less tight but more efficient check (see below)
+                                Ccheck = arzneg * diag(weights) * arzneg';  % in order to check the largest EV
+                            end
+                            artmp = BD * arzneg;
+                            Cneg = artmp * diag(weights) * artmp';
+                        else  % simple sum
+                            if mod(flgActiveCMA, 10) == 1
+                                Ccheck = (1/neg.mu) * arzneg*arzneg';  % in order to check largest EV
+                            end
+                            artmp = BD * arzneg;
+                            Cneg = (1/neg.mu) * artmp*artmp';
+
+                        end
+
+                        % check pos.def. and set learning rate neg.ccov accordingly,
+                        % this check makes the original choice of neg.ccov extremly failsafe
+                        % still assuming C == BD*BD', which is only approxim. correct
+                        if mod(flgActiveCMA, 10) == 1 && 1 - neg.ccov * arnorms(idxnorms).^2 * weights < neg.minresidualvariance
+                            % TODO: the simple and cheap way would be to set
+                            %    fac = 1 - ccovmu - ccov1 OR 1 - mueff/lambda and
+                            %    neg.ccov = fac*(1 - neg.minresidualvariance) / (arnorms(idxnorms).^2 * weights)
+                            % this is the more sophisticated way:
+                            % maxeigenval = eigs(arzneg * arzneg', 1, 'lm', eigsopts);  % not faster
+                            maxeigenval = max(eig(Ccheck));  % norm is much slower, because (norm()==max(svd())
+                                                             %disp([countiter log10([neg.ccov, maxeigenval, arnorms(idxnorms).^2 * weights, max(arnorms)^2]), ...
+                                                             %          neg.ccov * arnorms(idxnorms).^2 * weights])
+                                                             % pause
+                                                             % remove less than ??34*(1-cmu)%?? of variance in any direction
+                                                             %     1-ccovmu is the variance left from the old C
+                            neg.ccovfinal = min(neg.ccov, (1-ccovmu)*(1-neg.minresidualvariance)/maxeigenval);
+                            % -ccov1 removed to avoid error message??
+                            if neg.ccovfinal < neg.ccov
+                                disp(['active CMA at iteration ' num2str(countiter) ...
+                                      ': max EV ==', num2str([maxeigenval, neg.ccov, neg.ccovfinal])]);
+                            end
+                        end
+                        % xmean = xold;  % the distribution does not degenerate!?
+                        % update C
+                        C = (1-ccov1-ccovmu+neg.alphaold*neg.ccovfinal+(1-hsig)*ccov1*cc*(2-cc)) * C ... % regard old matrix
+                            + ccov1 * pc*pc' ...     % plus rank one update
+                            + (ccovmu + (1-neg.alphaold)*neg.ccovfinal) ...  % plus rank mu update
+                            * arpos * (repmat(weights,1,N) .* arpos') ...
+                            - neg.ccovfinal * Cneg;                        % minus rank mu update
+                    else  % no active (negative) update
+                        C = (1-ccov1-ccovmu+(1-hsig)*ccov1*cc*(2-cc)) * C ... % regard old matrix
+                            + ccov1 * pc*pc' ...     % plus rank one update
+                            + ccovmu ...             % plus rank mu update
+                            * arpos * (repmat(weights,1,N) .* arpos');
+                        % is now O(mu*N^2 + mu*N), was O(mu*N^2 + mu^2*N) when using diag(weights)
+                        %   for mu=30*N it is now 10 times faster, overall 3 times faster
+                    end
+                    diagC = diag(C);
+                end
+            end
+
+            % the following is de-preciated and will be removed in future
+            % better setting for cc makes this hack obsolete
+            if 11 < 2 && ~flgscience
+                % remove momentum in ps, if ps is large and fitness is getting worse.
+                % this should rarely happen.
+                % this might very well be counterproductive in dynamic environments
+                if sum(ps.^2)/N > 1.5 + 10*(2/N)^.5 && ...
+                        fitness.histsel(1) > max(fitness.histsel(2:3))
+                    ps = ps * sqrt(N*(1+max(0,log(sum(ps.^2)/N))) / sum(ps.^2));
+                    if flgdisplay
+                        disp(['Momentum in ps removed at [niter neval]=' ...
+                              num2str([countiter counteval]) ']']);
+                    end
+                end
+            end
+
+            % Adapt sigma
+            if flg_future_setting  % according to a suggestion from Dirk Arnold (2000)
+                                   % exp(1) is still not reasonably small enough
+                sigma = sigma * exp(min(1, (sum(ps.^2)/N - 1)/2 * cs/damps));            % Eq. (5)
+            else
+                % exp(1) is still not reasonably small enough
+                sigma = sigma * exp(min(1, (sqrt(sum(ps.^2))/chiN - 1) * cs/damps));             % Eq. (5)
+            end
+            % disp([countiter norm(ps)/chiN]);
+
+            if 11 < 3   % testing with optimal step-size
+                if countiter == 1
+                    disp('*********** sigma set to const * ||x|| ******************');
+                end
+                sigma = 0.04 * mueff * sqrt(sum(xmean.^2)) / N; % 20D,lam=1000:25e3
+                sigma = 0.3 * mueff * sqrt(sum(xmean.^2)) / N; % 20D,lam=(40,1000):17e3
+                                                               %      75e3 with def (1.5)
+                                                               %      35e3 with damps=0.25
+            end
+            if 11 < 3
+                if countiter == 1
+                    disp('*********** xmean set to const ******************');
+                end
+                xmean = ones(N,1);
+            end
+
+            % Update B and D from C
+
+            if ~flgDiagonalOnly && (ccov1+ccovmu+neg.ccov) > 0 && mod(countiter, 1/(ccov1+ccovmu+neg.ccov)/N/10) < 1
+                C=triu(C)+triu(C,1)'; % enforce symmetry to prevent complex numbers
+                [B,tmp] = eig(C);     % eigen decomposition, B==normalized eigenvectors
+                                      % effort: approx. 15*N matrix-vector multiplications
+                diagD = diag(tmp);
+
+                if any(~isfinite(diagD))
+                    clear idx; % prevents error under octave
+                    save(['tmp' opts.SaveFilename]);
+                    error(['function eig returned non-finited eigenvalues, cond(C)=' ...
+                           num2str(cond(C)) ]);
+                end
+                if any(any(~isfinite(B)))
+                    clear idx; % prevents error under octave
+                    save(['tmp' opts.SaveFilename]);
+                    error(['function eig returned non-finited eigenvectors, cond(C)=' ...
+                           num2str(cond(C)) ]);
+                end
+
+                % limit condition of C to 1e14 + 1
+                if min(diagD) <= 0
+                    if stopOnWarnings
+                        stopflag(end+1) = {'warnconditioncov'};
+                    else
+                        warning(['Iteration ' num2str(countiter) ...
+                                 ': Eigenvalue (smaller) zero']);
+                        diagD(diagD<0) = 0;
+                        tmp = max(diagD)/1e14;
+                        C = C + tmp*eye(N,N); diagD = diagD + tmp*ones(N,1);
+                    end
+                end
+                if max(diagD) > 1e14*min(diagD)
+                    if stopOnWarnings
+                        stopflag(end+1) = {'warnconditioncov'};
+                    else
+                        warning(['Iteration ' num2str(countiter) ': condition of C ' ...
+                                 'at upper limit' ]);
+                        tmp = max(diagD)/1e14 - min(diagD);
+                        C = C + tmp*eye(N,N); diagD = diagD + tmp*ones(N,1);
+                    end
+                end
+
+                diagC = diag(C);
+                diagD = sqrt(diagD); % D contains standard deviations now
+                                     % diagD = diagD / prod(diagD)^(1/N);  C = C / prod(diagD)^(2/N);
+                BD = B.*repmat(diagD',N,1); % O(n^2)
+            end % if mod
+
+            % Align/rescale order of magnitude of scales of sigma and C for nicer output
+            % not a very usual case
+            if 1 < 2 && sigma > 1e10*max(diagD)
+                fac = sigma / max(diagD);
+                sigma = sigma/fac;
+                pc = fac * pc;
+                diagD = fac * diagD;
+                if ~flgDiagonalOnly
+                    C = fac^2 * C; % disp(fac);
+                    BD = B.*repmat(diagD',N,1); % O(n^2), but repmat might be inefficient todo?
+                end
+                diagC = fac^2 * diagC;
+            end
+
+            if flgDiagonalOnly > 1 && countiter > flgDiagonalOnly
+                % full covariance matrix from now on
+                flgDiagonalOnly = 0;
+                B = eye(N,N);
+                BD = diag(diagD);
+                C = diag(diagC); % is better, because correlations are spurious anyway
+            end
+
+            if noiseHandling
+                if countiter == 1  % assign firstvarargin for noise treatment e.g. as #reevaluations
+                    if ~isempty(varargin) && length(varargin{1}) == 1 && isnumeric(varargin{1})
+                        if irun == 1
+                            firstvarargin = varargin{1};
+                        else
+                            varargin{1} =  firstvarargin;  % reset varargin{1}
+                        end
+                    else
+                        firstvarargin = 0;
+                    end
+                end
+                if noiseSS < 0 && noiseMinMaxEvals(2) > noiseMinMaxEvals(1) && firstvarargin
+                    varargin{1} = max(noiseMinMaxEvals(1), varargin{1} / noiseAlphaEvals^(1/4));  % still experimental
+                elseif noiseSS > 0
+                    if ~isempty(noiseCallback)  % to be removed?
+                        res = feval(noiseCallback); % should also work without output argument!?
+                        if ~isempty(res) && res > 1 % TODO: decide for interface of callback
+                                                    %       also a dynamic popsize could be done here
+                            sigma = sigma * noiseAlpha;
+                        end
+                    else
+                        if noiseMinMaxEvals(2) > noiseMinMaxEvals(1) && firstvarargin
+                            varargin{1} = min(noiseMinMaxEvals(2), varargin{1} * noiseAlphaEvals);
+                        end
+
+                        sigma = sigma * noiseAlpha;
+                        % lambda = ceil(0.1 * sqrt(lambda) + lambda);
+                        % TODO: find smallest increase of lambda with log-linear
+                        %       convergence in iterations
+                    end
+                    % qqq experimental: take a mean to estimate the true optimum
+                    noiseN = noiseN + 1;
+                    if noiseN == 1
+                        noiseX = xmean;
+                    else
+                        noiseX = noiseX + (3/noiseN) * (xmean - noiseX);
+                    end
+                end
+            end
+
+            % ----- numerical error management -----
+            % Adjust maximal coordinate axis deviations
+            if any(sigma*sqrt(diagC) > maxdx)
+                sigma = min(maxdx ./ sqrt(diagC));
+                %warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ...
+                %         'deviation at upper limit of ' num2str(maxdx)]);
+                % stopflag(end+1) = {'maxcoorddev'};
+            end
+            % Adjust minimal coordinate axis deviations
+            if any(sigma*sqrt(diagC) < mindx)
+                sigma = max(mindx ./ sqrt(diagC)) * exp(0.05+cs/damps);
+                %warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ...
+                %         'deviation at lower limit of ' num2str(mindx)]);
+                % stopflag(end+1) = {'mincoorddev'};;
+            end
+            % Adjust too low coordinate axis deviations
+            if any(xmean == xmean + 0.2*sigma*sqrt(diagC))
+                if stopOnWarnings
+                    stopflag(end+1) = {'warnnoeffectcoord'};
+                else
+                    warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ...
+                             'deviation too low' ]);
+                    if flgDiagonalOnly
+                        diagC = diagC + (ccov1_sep+ccovmu_sep) * (diagC .* ...
+                                                                  (xmean == xmean + 0.2*sigma*sqrt(diagC)));
+                    else
+                        C = C + (ccov1+ccovmu) * diag(diagC .* ...
+                                                      (xmean == xmean + 0.2*sigma*sqrt(diagC)));
+                    end
+                    sigma = sigma * exp(0.05+cs/damps);
+                end
+            end
+            % Adjust step size in case of (numerical) precision problem
+            if flgDiagonalOnly
+                tmp = 0.1*sigma*diagD;
+            else
+                tmp = 0.1*sigma*BD(:,1+floor(mod(countiter,N)));
+            end
+            if all(xmean == xmean + tmp)
+                i = 1+floor(mod(countiter,N));
+                if stopOnWarnings
+                    stopflag(end+1) = {'warnnoeffectaxis'};
+                else
+                    warning(['Iteration ' num2str(countiter) ...
+                             ': main axis standard deviation ' ...
+                             num2str(sigma*diagD(i)) ' has no effect' ]);
+                    sigma = sigma * exp(0.2+cs/damps);
+                end
+            end
+            % Adjust step size in case of equal function values (flat fitness)
+            % isequalfuncvalues = 0;
+            if fitness.sel(1) == fitness.sel(1+ceil(0.1+lambda/4))
+                % isequalfuncvalues = 1;
+                if stopOnEqualFunctionValues
+                    arrEqualFunvals = [countiter arrEqualFunvals(1:end-1)];
+                    % stop if this happens in more than 33%
+                    if arrEqualFunvals(end) > countiter - 3 * length(arrEqualFunvals)
+                        stopflag(end+1) = {'equalfunvals'};
+                    end
+                else
+                    if flgWarnOnEqualFunctionValues
+                        warning(['Iteration ' num2str(countiter) ...
+                                 ': equal function values f=' num2str(fitness.sel(1)) ...
+                                 ' at maximal main axis sigma ' ...
+                                 num2str(sigma*max(diagD))]);
+                    end
+                    sigma = sigma * exp(0.2+cs/damps);
+                end
+            end
+            % Adjust step size in case of equal function values
+            if countiter > 2 && myrange([fitness.hist fitness.sel(1)]) == 0
+                if stopOnWarnings
+                    stopflag(end+1) = {'warnequalfunvalhist'};
+                else
+                    warning(['Iteration ' num2str(countiter) ...
+                             ': equal function values in history at maximal main ' ...
+                             'axis sigma ' num2str(sigma*max(diagD))]);
+                    sigma = sigma * exp(0.2+cs/damps);
+                end
+            end
+
+            % ----- end numerical error management -----
+
+            % Keep overall best solution
+            out.evals = counteval;
+            out.solutions.evals = counteval;
+            out.solutions.mean.x = xmean;
+            out.solutions.mean.f = fmean;
+            out.solutions.mean.evals = counteval;
+            out.solutions.recentbest.x = arxvalid(:, fitness.idx(1));
+            out.solutions.recentbest.f = fitness.raw(1);
+            out.solutions.recentbest.evals = counteval + fitness.idx(1) - lambda;
+            out.solutions.recentworst.x = arxvalid(:, fitness.idx(end));
+            out.solutions.recentworst.f = fitness.raw(end);
+            out.solutions.recentworst.evals = counteval + fitness.idx(end) - lambda;
+            if fitness.hist(1) < out.solutions.bestever.f
+                out.solutions.bestever.x = arxvalid(:, fitness.idx(1));
+                out.solutions.bestever.f = fitness.hist(1);
+                out.solutions.bestever.evals = counteval + fitness.idx(1) - lambda;
+                bestever = out.solutions.bestever;
+            end
+
+            % Set stop flag
+            if fitness.raw(1) <= stopFitness, stopflag(end+1) = {'fitness'}; end
+            if counteval >= stopMaxFunEvals, stopflag(end+1) = {'maxfunevals'}; end
+            if countiter >= stopMaxIter, stopflag(end+1) = {'maxiter'}; end
+            if all(sigma*(max(abs(pc), sqrt(diagC))) < stopTolX)
+                stopflag(end+1) = {'tolx'};
+            end
+            if any(sigma*sqrt(diagC) > stopTolUpX)
+                stopflag(end+1) = {'tolupx'};
+            end
+            if sigma*max(diagD) == 0  % should never happen
+                stopflag(end+1) = {'bug'};
+            end
+            if countiter > 2 && myrange([fitness.sel fitness.hist]) <= stopTolFun
+                stopflag(end+1) = {'tolfun'};
+            end
+            if countiter >= length(fitness.hist) && myrange(fitness.hist) <= stopTolHistFun
+                stopflag(end+1) = {'tolhistfun'};
+            end
+            l = floor(length(fitness.histbest)/3);
+            if 1 < 2 && stopOnStagnation && ...  % leads sometimes early stop on ftablet, fcigtab
+                    countiter > N * (5+100/lambda) && ...
+                    length(fitness.histbest) > 100 && ...
+                    median(fitness.histmedian(1:l)) >= median(fitness.histmedian(end-l:end)) && ...
+                    median(fitness.histbest(1:l)) >= median(fitness.histbest(end-l:end))
+                stopflag(end+1) = {'stagnation'};
+            end
+
+            if counteval >= stopFunEvals || countiter >= stopIter
+                stopflag(end+1) = {'stoptoresume'};
+                if length(stopflag) == 1 && flgsaving == 0
+                    error('To resume later the saving option needs to be set');
+                end
+            end
+            % read stopping message from file signals.par
+            if flgreadsignals
+                fid = fopen('./signals.par', 'rt');  % can be performance critical
+                while fid > 0
+                    strline = fgetl(fid); %fgets(fid, 300);
+                    if strline < 0 % fgets and fgetl returns -1 at end of file
+                        break
+                    end
+                    % 'stop filename' sets stopflag to manual
+                    str = sscanf(strline, ' %s %s', 2);
+                    if strcmp(str, ['stop' opts.LogFilenamePrefix])
+                        stopflag(end+1) = {'manual'};
+                        break
+                    end
+                    % 'skip filename run 3' skips a run, but not the last
+                    str = sscanf(strline, ' %s %s %s', 3);
+                    if strcmp(str, ['skip' opts.LogFilenamePrefix 'run'])
+                        i = strfind(strline, 'run');
+                        if irun == sscanf(strline(i+3:end), ' %d ', 1) && irun <= myeval(opts.Restarts)
+                            stopflag(end+1) = {'skipped'};
+                        end
+                    end
+                end % while, break
+                if fid > 0
+                    fclose(fid);
+                    clear fid; % prevents strange error under octave
+                end
+            end
+
+            out.stopflag = stopflag;
+
+            % ----- output generation -----
+            if verbosemodulo > 0 && isfinite(verbosemodulo)
+                if countiter == 1 || mod(countiter, 10*verbosemodulo) < 1
+                    disp(['Iterat, #Fevals:   Function Value    (median,worst) ' ...
+                          '|Axis Ratio|' ...
+                          'idx:Min SD idx:Max SD']);
+                end
+                if mod(countiter, verbosemodulo) < 1 ...
+                        || (verbosemodulo > 0 && isfinite(verbosemodulo) && ...
+                            (countiter < 3 || ~isempty(stopflag)))
+                    [minstd, minstdidx] = min(sigma*sqrt(diagC));
+                    [maxstd, maxstdidx] = max(sigma*sqrt(diagC));
+                    % format display nicely
+                    disp([repmat(' ',1,4-floor(log10(countiter))) ...
+                          num2str(countiter) ' , ' ...
+                          repmat(' ',1,5-floor(log10(counteval))) ...
+                          num2str(counteval) ' : ' ...
+                          num2str(fitness.hist(1), '%.13e') ...
+                          ' +(' num2str(median(fitness.raw)-fitness.hist(1), '%.0e ') ...
+                          ',' num2str(max(fitness.raw)-fitness.hist(1), '%.0e ') ...
+                          ') | ' ...
+                          num2str(max(diagD)/min(diagD), '%4.2e') ' | ' ...
+                          repmat(' ',1,1-floor(log10(minstdidx))) num2str(minstdidx) ':' ...
+                          num2str(minstd, ' %.1e') ' ' ...
+                          repmat(' ',1,1-floor(log10(maxstdidx))) num2str(maxstdidx) ':' ...
+                          num2str(maxstd, ' %.1e')]);
+                end
+            end
+
+            % measure time for recording data
+            if countiter < 3
+                time.c = 0.05;
+                time.nonoutput = 0;
+                time.recording = 0;
+                time.saving  = 0.15; % first saving after 3 seconds of 100 iterations
+                time.plotting = 0;
+            elseif countiter > 300
+                % set backward horizon, must be long enough to cover infrequent plotting etc
+                % time.c = min(1, time.nonoutput/3 + 1e-9);
+                time.c = max(1e-5, 0.1/sqrt(countiter)); % mean over all or 1e-5
+            end
+            % get average time per iteration
+            time.t1 = clock;
+            time.act = max(0,etime(time.t1, time.t0));
+            time.nonoutput = (1-time.c) * time.nonoutput ...
+                + time.c * time.act;
+
+            time.recording = (1-time.c) * time.recording;  % per iteration
+            time.saving  = (1-time.c) * time.saving;
+            time.plotting = (1-time.c) * time.plotting;
+
+            % record output data, concerning time issues
+            if savemodulo && savetime && (countiter < 1e2 || ~isempty(stopflag) || ...
+                                          countiter >= outiter + savemodulo)
+                outiter = countiter;
+                % Save output data to files
+                for namecell = filenames(:)'
+                    name = namecell{:};
+
+                    [fid, err] = fopen(['./' filenameprefix name '.dat'], 'a');
+                    if fid < 1 % err ~= 0
+                        warning(['could not open ' filenameprefix name '.dat']);
+                    else
+                        if strcmp(name, 'axlen')
+                            fprintf(fid, '%d %d %e %e %e ', countiter, counteval, sigma, ...
+                                    max(diagD), min(diagD));
+                            fprintf(fid, '%e ', sort(diagD));
+                            fprintf(fid, '\n');
+                        elseif strcmp(name, 'disp') % TODO
+                        elseif strcmp(name, 'fit')
+                            fprintf(fid, '%ld %ld %e %e %25.18e %25.18e %25.18e %25.18e', ...
+                                    countiter, counteval, sigma, max(diagD)/min(diagD), ...
+                                    out.solutions.bestever.f, ...
+                                    fitness.raw(1), median(fitness.raw), fitness.raw(end));
+                            if ~isempty(varargin) && length(varargin{1}) == 1 && isnumeric(varargin{1}) && varargin{1} ~= 0
+                                fprintf(fid, ' %f', varargin{1});
+                            end
+                            fprintf(fid, '\n');
+                        elseif strcmp(name, 'stddev')
+                            fprintf(fid, '%ld %ld %e 0 0 ', countiter, counteval, sigma);
+                            fprintf(fid, '%e ', sigma*sqrt(diagC));
+                            fprintf(fid, '\n');
+                        elseif strcmp(name, 'xmean')
+                            if isnan(fmean)
+                                fprintf(fid, '%ld %ld 0 0 0 ', countiter, counteval);
+                            else
+                                fprintf(fid, '%ld %ld 0 0 %e ', countiter, counteval, fmean);
+                            end
+                            fprintf(fid, '%e ', xmean);
+                            fprintf(fid, '\n');
+                        elseif strcmp(name, 'xrecentbest')
+                            % TODO: fitness is inconsistent with x-value
+                            fprintf(fid, '%ld %ld %25.18e 0 0 ', countiter, counteval, fitness.raw(1));
+                            fprintf(fid, '%e ', arx(:,fitness.idx(1)));
+                            fprintf(fid, '\n');
+                        end
+                        fclose(fid);
+                    end
+                end
+
+                % get average time for recording data
+                time.t2 = clock;
+                time.recording = time.recording + time.c * max(0,etime(time.t2, time.t1));
+
+                % plot
+                if flgplotting && countiter > 1
+                    if countiter == 2
+                        iterplotted = 0;
+                    end
+                    if ~isempty(stopflag) || ...
+                            ((time.nonoutput+time.recording) * (countiter - iterplotted) > 1 && ...
+                             time.plotting < 0.05 * (time.nonoutput+time.recording))
+                        local_plotcmaesdat(324, filenameprefix);
+                        iterplotted = countiter;
+                        %  outplot(out); % outplot defined below
+                        if time.plotting == 0  % disregard opening of the window
+                            time.plotting = time.nonoutput+time.recording;
+                        else
+                            time.plotting = time.plotting + time.c * max(0,etime(clock, time.t2));
+                        end
+                    end
+                end
+                if countiter > 100 + 20 && savemodulo && ...
+                        time.recording * countiter > 0.1 && ...  % absolute time larger 0.1 second
+                        time.recording > savetime * (time.nonoutput+time.recording) / 100
+                    savemodulo = floor(1.1 * savemodulo) + 1;
+                    % disp('++savemodulo'); %qqq
+                end
+            end % if output
+
+            % save everything
+            time.t3 = clock;
+            if ~isempty(stopflag) || time.saving < 0.05 * time.nonoutput || countiter == 100
+                xmin = arxvalid(:, fitness.idx(1));
+                fmin = fitness.raw(1);
+                if flgsaving && countiter > 2
+                    clear idx; % prevents error under octave
+                               % -v6 : non-compressed non-unicode for version 6 and earlier
+                    if ~isempty(strsaving) && ~isoctave
+                        save('-mat', strsaving, opts.SaveFilename); % for inspection and possible restart
+                    else
+                        save('-mat', opts.SaveFilename); % for inspection and possible restart
+                    end
+                    time.saving = time.saving + time.c * max(0,etime(clock, time.t3));
+                end
+            end
+            time.t0 = clock;
+
+            % ----- end output generation -----
+
+    end % while, end generation loop
+
+        % -------------------- Final Procedures -------------------------------
+
+        % Evaluate xmean and return best recent point in xmin
+        fmin = fitness.raw(1);
+        xmin = arxvalid(:, fitness.idx(1)); % Return best point of last generation.
+        if length(stopflag) > sum(strcmp(stopflag, 'stoptoresume')) % final stopping
+            out.solutions.mean.f = ...
+                feval(fitfun, xintobounds(xmean, lbounds, ubounds), varargin{:});
+            counteval = counteval + 1;
+            out.solutions.mean.evals = counteval;
+            if out.solutions.mean.f < fitness.raw(1)
+                fmin = out.solutions.mean.f;
+                xmin = xintobounds(xmean, lbounds, ubounds); % Return xmean as best point
+            end
+            if out.solutions.mean.f < out.solutions.bestever.f
+                out.solutions.bestever = out.solutions.mean; % Return xmean as bestever point
+                out.solutions.bestever.x = xintobounds(xmean, lbounds, ubounds);
+                bestever = out.solutions.bestever;
+            end
+        end
+
+        % Save everything and display final message
+        if flgsavingfinal
+            clear idx; % prevents error under octave
+            if ~isempty(strsaving) && ~isoctave
+                save('-mat', strsaving, opts.SaveFilename); % for inspection and possible restart
+            else
+                save('-mat', opts.SaveFilename);    % for inspection and possible restart
+            end
+            message = [' (saved to ' opts.SaveFilename ')'];
         else
-          arx(:,k) = xmean + sigma * (BD * arz(:,k));                % Eq. (1)
-        end
-      else % re-evaluation solution with index > lambda
-        if flgDiagonalOnly  
-          arx(:,k) = arx(:,k-lambda) + (noiseEpsilon * sigma) * diagD .* randn(N,1);
-        else
-          arx(:,k) = arx(:,k-lambda) + (noiseEpsilon * sigma) * (BD * randn(N,1));
-        end
-      end
-      
-      % You may handle constraints here. You may either resample
-      % arz(:,k) and/or multiply it with a factor between -1 and 1
-      % (the latter will decrease the overall step size) and
-      % recalculate arx accordingly. Do not change arx or arz in any
-      % other way.
- 
-      if ~bnd.isactive
-        arxvalid(:,k) = arx(:,k);
-      else
-        arxvalid(:,k) = xintobounds(arx(:,k), lbounds, ubounds);
-      end
-      % You may handle constraints here.  You may copy and alter
-      % (columns of) arxvalid(:,k) only for the evaluation of the
-      % fitness function. arx should not be changed.
-      fitness.raw(k) = feval(fitfun, arxvalid(:,k), varargin{:}); 
-      tries = tries + 1;
-      if isnan(fitness.raw(k))
-	countevalNaN = countevalNaN + 1;
-      end
-      if mod(tries, 100) == 0
-	warning([num2str(tries) ...
-                 ' NaN objective function values at evaluation ' ...
-                 num2str(counteval)]);
-      end
-    end
-    counteval = counteval + 1; % retries due to NaN are not counted
-  end
-
-  fitness.sel = fitness.raw; 
-
-  % ----- handle boundaries -----
-  if 1 < 3 && bnd.isactive
-    % Get delta fitness values
-    val = myprctile(fitness.raw, [25 75]);
-    % more precise would be exp(mean(log(diagC)))
-    val = (val(2) - val(1)) / N / mean(diagC) / sigma^2;
-    %val = (myprctile(fitness.raw, 75) - myprctile(fitness.raw, 25)) ...
-    %    / N / mean(diagC) / sigma^2;
-    % Catch non-sensible values 
-    if ~isfinite(val)
-      warning('Non-finite fitness range');
-      val = max(bnd.dfithist);  
-    elseif val == 0 % happens if all points are out of bounds
-      val = min(bnd.dfithist(bnd.dfithist>0));  % seems not to make sense, given all solutions are out of bounds
-    elseif bnd.validfitval == 0 % flag that first sensible val was found
-      bnd.dfithist = [];
-      bnd.validfitval = 1;
-    end
-
-    % Store delta fitness values
-    if length(bnd.dfithist) < 20+(3*N)/lambda
-      bnd.dfithist = [bnd.dfithist val];
-    else
-      bnd.dfithist = [bnd.dfithist(2:end) val];
-    end
-
-    [tx ti]  = xintobounds(xmean, lbounds, ubounds);
-
-    % Set initial weights
-    if bnd.iniphase 
-      if any(ti) 
-        bnd.weights(find(bnd.isbounded)) = 2.0002 * median(bnd.dfithist);
-	if bnd.flgscale == 0 % scale only initial weights then
-	  dd = diagC; 
-	  idx = find(bnd.isbounded); 
-	  dd = dd(idx) / mean(dd); %  remove mean scaling
-	  bnd.weights(idx) = bnd.weights(idx) ./ dd; 
-	end
-	if bnd.validfitval && countiter > 2
-          bnd.iniphase = 0;
-	end
-      end
-    end
-
-    % Increase weights
-    if  1 < 3 && any(ti) % any coordinate of xmean out of bounds
-      % judge distance of xmean to boundary
-      tx = xmean - tx;
-      idx = (ti ~= 0 & abs(tx) > 3*max(1,sqrt(N)/mueff) ... 
-	     * sigma*sqrt(diagC)) ;
-      % only increase if xmean is moving away
-      idx = idx & (sign(tx) == sign(xmean - xold));
-      if ~isempty(idx) % increase
-        % the factor became 1.2 instead of 1.1, because
-        % changed from max to min in version 3.52
-        bnd.weights(idx) = 1.2^(min(1, mueff/10/N)) * bnd.weights(idx); 
-      end
-    end
-
-    % Calculate scaling biased to unity, product is one
-    if bnd.flgscale ~= 0 
-      bnd.scale = exp(0.9*(log(diagC)-mean(log(diagC)))); 
-    end
-
-    % Assigned penalized fitness
-    bnd.arpenalty = (bnd.weights ./ bnd.scale)' * (arxvalid - arx).^2; 
-
-    fitness.sel = fitness.raw + bnd.arpenalty;
-
-  end % handle boundaries
-  % ----- end handle boundaries -----
-  
-  % compute noise measurement and reduce fitness arrays to size lambda
-  if noiseHandling 
-    [noiseS] = local_noisemeasurement(fitness.sel(1:lambda), ...
-                                      fitness.sel(lambda+(1:noiseReevals)), ...
-                                      noiseReevals, noiseTheta, noiseCutOff); 
-    if countiter == 1 % TODO: improve this very rude way of initialization
-      noiseSS = 0;
-      noiseN = 0;  % counter for mean
-    end
-    noiseSS = noiseSS + noisecum * (noiseS - noiseSS); 
-
-    % noise-handling could be done here, but the original sigma is still needed
-    % disp([noiseS noiseSS noisecum])
-
-    fitness.rawar12 = fitness.raw; % just documentary
-    fitness.selar12 = fitness.sel; % just documentary
-    % qqq refine fitness based on both values
-    if 11 < 3  % TODO: in case of outliers this mean is counterproductive 
-               % median out of three would be ok 
-      fitness.raw(1:noiseReevals) = ... % not so raw anymore
-          (fitness.raw(1:noiseReevals) + fitness.raw(lambda+(1:noiseReevals))) / 2; 
-      fitness.sel(1:noiseReevals) = ... 
-          (fitness.sel(1:noiseReevals) + fitness.sel(lambda+(1:noiseReevals))) / 2; 
-    end      
-    fitness.raw = fitness.raw(1:lambda); 
-    fitness.sel = fitness.sel(1:lambda); 
-  end
-  
-  % Sort by fitness 
-  [fitness.raw, fitness.idx] = sort(fitness.raw); 
-  [fitness.sel, fitness.idxsel] = sort(fitness.sel);  % minimization
-  fitness.hist(2:end) = fitness.hist(1:end-1);    % record short history of
-  fitness.hist(1) = fitness.raw(1);               % best fitness values
-  if length(fitness.histbest) < 120+ceil(30*N/lambda) || ...
-       (mod(countiter, 5) == 0  && length(fitness.histbest) < 2e4)  % 20 percent of 1e5 gen.
-    fitness.histbest = [fitness.raw(1) fitness.histbest];          % best fitness values
-    fitness.histmedian = [median(fitness.raw) fitness.histmedian]; % median fitness values
-  else
-    fitness.histbest(2:end) = fitness.histbest(1:end-1); 
-    fitness.histmedian(2:end) = fitness.histmedian(1:end-1); 
-    fitness.histbest(1) = fitness.raw(1);           % best fitness values
-    fitness.histmedian(1) = median(fitness.raw);    % median fitness values
-  end
-  fitness.histsel(2:end) = fitness.histsel(1:end-1); % record short history of
-  fitness.histsel(1) = fitness.sel(1);               % best sel fitness values
-
-  % Calculate new xmean, this is selection and recombination 
-  xold = xmean; % for speed up of Eq. (2) and (3)
-  xmean = arx(:,fitness.idxsel(1:mu))*weights; 
-  zmean = arz(:,fitness.idxsel(1:mu))*weights;%==D^-1*B'*(xmean-xold)/sigma
-  if mu == 1
-    fmean = fitness.sel(1);
-  else
-    fmean = NaN; % [] does not work in the latter assignment
-    % fmean = feval(fitfun, xintobounds(xmean, lbounds, ubounds), varargin{:});
-    % counteval = counteval + 1;
-  end
-  
-  % Cumulation: update evolution paths
-  ps = (1-cs)*ps + sqrt(cs*(2-cs)*mueff) * (B*zmean);          % Eq. (4)
-  hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.4 + 2/(N+1);
-  if flg_future_setting
-    hsig = sum(ps.^2) / (1-(1-cs)^(2*countiter)) / N < 2 + 4/(N+1); % just simplified
-  end
-%  hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.4 + 2/(N+1);
-%  hsig = norm(ps)/sqrt(1-(1-cs)^(2*countiter))/chiN < 1.5 + 1/(N-0.5);
-%  hsig = norm(ps) < 1.5 * sqrt(N);
-%  hsig = 1;
-
-  pc = (1-cc)*pc ...
-        + hsig*(sqrt(cc*(2-cc)*mueff)/sigma) * (xmean-xold);     % Eq. (2)
-  if hsig == 0
-    % disp([num2str(countiter) ' ' num2str(counteval) ' pc update stalled']);
-  end
-
-  % Adapt covariance matrix
-  neg.ccov = 0;  % TODO: move parameter setting upwards at some point
-  if ccov1 + ccovmu > 0                                                    % Eq. (3)
-    if flgDiagonalOnly % internal linear(?) complexity
-      diagC = (1-ccov1_sep-ccovmu_sep+(1-hsig)*ccov1_sep*cc*(2-cc)) * diagC ... % regard old matrix 
-          + ccov1_sep * pc.^2 ...               % plus rank one update
-          + ccovmu_sep ...                      % plus rank mu update
-            * (diagC .* (arz(:,fitness.idxsel(1:mu)).^2 * weights));
-%             * (repmat(diagC,1,mu) .* arz(:,fitness.idxsel(1:mu)).^2 * weights);
-      diagD = sqrt(diagC); % replaces eig(C)
-    else
-      arpos = (arx(:,fitness.idxsel(1:mu))-repmat(xold,1,mu)) / sigma;
-      % "active" CMA update: negative update, in case controlling pos. definiteness 
-      if flgActiveCMA > 0
-        % set parameters
-        neg.mu = mu;  
-        neg.mueff = mueff;
-        if flgActiveCMA > 10  % flat weights with mu=lambda/2
-          neg.mu = floor(lambda/2);  
-          neg.mueff = neg.mu;
-        end
-        % neg.mu = ceil(min([N, lambda/4, mueff]));  neg.mueff = mu; % i.e. neg.mu <= N 
-        % Parameter study: in 3-D lambda=50,100, 10-D lambda=200,400, 30-D lambda=1000,2000 a 
-        % three times larger neg.ccov does not work. 
-        %   increasing all ccov rates three times does work (probably because of the factor (1-ccovmu))
-        %   in 30-D to looks fine
-
-        neg.ccov = (1 - ccovmu) * 0.25 * neg.mueff / ((N+2)^1.5 + 2*neg.mueff);
-        neg.minresidualvariance = 0.66;  % keep at least 0.66 in all directions, small popsize are most critical
-        neg.alphaold = 0.5;  % where to make up for the variance loss, 0.5 means no idea what to do
-                             % 1 is slightly more robust and gives a better "guaranty" for pos. def., 
-                             % but does it make sense from the learning perspective for large ccovmu? 
-
-        neg.ccovfinal = neg.ccov;
-
-        % prepare vectors, compute negative updating matrix Cneg and checking matrix Ccheck
-        arzneg = arz(:,fitness.idxsel(lambda:-1:lambda - neg.mu + 1));
-        % i-th longest becomes i-th shortest
-        % TODO: this is not in compliance with the paper Hansen&Ros2010, 
-        %       where simply arnorms = arnorms(end:-1:1) ? 
-        [arnorms idxnorms] = sort(sqrt(sum(arzneg.^2, 1))); 
-        [ignore idxnorms] = sort(idxnorms);  % inverse index 
-        arnormfacs = arnorms(end:-1:1) ./ arnorms; 
-        % arnormfacs = arnorms(randperm(neg.mu)) ./ arnorms;
-        arnorms = arnorms(end:-1:1); % for the record
-        if flgActiveCMA < 20
-          arzneg = arzneg .* repmat(arnormfacs(idxnorms), N, 1);  % E x*x' is N
-          % arzneg = sqrt(N) * arzneg ./ repmat(sqrt(sum(arzneg.^2, 1)), N, 1);  % E x*x' is N
-        end
-        if flgActiveCMA < 10 && neg.mu == mu  % weighted sum
-          if mod(flgActiveCMA, 10) == 1 % TODO: prevent this with a less tight but more efficient check (see below) 
-            Ccheck = arzneg * diag(weights) * arzneg';  % in order to check the largest EV
-          end
-          artmp = BD * arzneg;
-          Cneg = artmp * diag(weights) * artmp';
-        else  % simple sum
-          if mod(flgActiveCMA, 10) == 1
-            Ccheck = (1/neg.mu) * arzneg*arzneg';  % in order to check largest EV
-          end
-          artmp = BD * arzneg;
-          Cneg = (1/neg.mu) * artmp*artmp';
-
+            message = [];
         end
 
-        % check pos.def. and set learning rate neg.ccov accordingly, 
-        % this check makes the original choice of neg.ccov extremly failsafe 
-        % still assuming C == BD*BD', which is only approxim. correct 
-        if mod(flgActiveCMA, 10) == 1 && 1 - neg.ccov * arnorms(idxnorms).^2 * weights < neg.minresidualvariance
-          % TODO: the simple and cheap way would be to set
-          %    fac = 1 - ccovmu - ccov1 OR 1 - mueff/lambda and
-          %    neg.ccov = fac*(1 - neg.minresidualvariance) / (arnorms(idxnorms).^2 * weights)
-          % this is the more sophisticated way: 
-          % maxeigenval = eigs(arzneg * arzneg', 1, 'lm', eigsopts);  % not faster
-          maxeigenval = max(eig(Ccheck));  % norm is much slower, because (norm()==max(svd())
-          %disp([countiter log10([neg.ccov, maxeigenval, arnorms(idxnorms).^2 * weights, max(arnorms)^2]), ...
-           %          neg.ccov * arnorms(idxnorms).^2 * weights])
-          % pause
-          % remove less than ??34*(1-cmu)%?? of variance in any direction
-          %     1-ccovmu is the variance left from the old C
-          neg.ccovfinal = min(neg.ccov, (1-ccovmu)*(1-neg.minresidualvariance)/maxeigenval); 
-                                        % -ccov1 removed to avoid error message??
-          if neg.ccovfinal < neg.ccov
-            disp(['active CMA at iteration ' num2str(countiter) ...
-                 ': max EV ==', num2str([maxeigenval, neg.ccov, neg.ccovfinal])]);
-          end
+        if flgdisplay
+            disp(['#Fevals:   f(returned x)   |    bestever.f     | stopflag' ...
+                  message]);
+            if isoctave
+                strstop = stopflag(:);
+            else
+                strcat(stopflag(:), '.');
+            end
+            strstop = stopflag(:); %strcat(stopflag(:), '.');
+            disp([repmat(' ',1,6-floor(log10(counteval))) ...
+                  num2str(counteval, '%6.0f') ': ' num2str(fmin, '%.11e') ' | ' ...
+                  num2str(out.solutions.bestever.f, '%.11e') ' | ' ...
+                  strstop{1:end}]);
+            if N < 102
+                disp(['mean solution:' sprintf(' %+.1e', xmean)]);
+                disp(['std deviation:' sprintf('  %.1e', sigma*sqrt(diagC))]);
+                disp(sprintf('use plotcmaesdat.m for plotting the output at any time (option LogModulo must not be zero)'));
+            end
+            if exist('sfile', 'var')
+                disp(['Results saved in ' sfile]);
+            end
         end
-        % xmean = xold;  % the distribution does not degenerate!? 
-        % update C
-        C = (1-ccov1-ccovmu+neg.alphaold*neg.ccovfinal+(1-hsig)*ccov1*cc*(2-cc)) * C ... % regard old matrix 
-            + ccov1 * pc*pc' ...     % plus rank one update
-            + (ccovmu + (1-neg.alphaold)*neg.ccovfinal) ...  % plus rank mu update
-              * arpos * (repmat(weights,1,N) .* arpos') ...
-              - neg.ccovfinal * Cneg;                        % minus rank mu update
-      else  % no active (negative) update
-        C = (1-ccov1-ccovmu+(1-hsig)*ccov1*cc*(2-cc)) * C ... % regard old matrix 
-            + ccov1 * pc*pc' ...     % plus rank one update
-            + ccovmu ...             % plus rank mu update
-              * arpos * (repmat(weights,1,N) .* arpos');
-        % is now O(mu*N^2 + mu*N), was O(mu*N^2 + mu^2*N) when using diag(weights)
-        %   for mu=30*N it is now 10 times faster, overall 3 times faster
-      end
-      diagC = diag(C);
-    end
-  end
-  
-  % the following is de-preciated and will be removed in future
-  % better setting for cc makes this hack obsolete
-  if 11 < 2 && ~flgscience  
-    % remove momentum in ps, if ps is large and fitness is getting worse.
-    % this should rarely happen. 
-    % this might very well be counterproductive in dynamic environments
-    if sum(ps.^2)/N > 1.5 + 10*(2/N)^.5 && ...
-        fitness.histsel(1) > max(fitness.histsel(2:3))
-      ps = ps * sqrt(N*(1+max(0,log(sum(ps.^2)/N))) / sum(ps.^2));
-      if flgdisplay
-        disp(['Momentum in ps removed at [niter neval]=' ...
-              num2str([countiter counteval]) ']']);
-      end
-    end
-  end
 
-  % Adapt sigma
-  if flg_future_setting  % according to a suggestion from Dirk Arnold (2000)
-    % exp(1) is still not reasonably small enough
-    sigma = sigma * exp(min(1, (sum(ps.^2)/N - 1)/2 * cs/damps));            % Eq. (5)
-  else
-    % exp(1) is still not reasonably small enough
-    sigma = sigma * exp(min(1, (sqrt(sum(ps.^2))/chiN - 1) * cs/damps));             % Eq. (5)
-  end
-  % disp([countiter norm(ps)/chiN]);
-  
-  if 11 < 3   % testing with optimal step-size
-      if countiter == 1
-          disp('*********** sigma set to const * ||x|| ******************');
-      end
-      sigma = 0.04 * mueff * sqrt(sum(xmean.^2)) / N; % 20D,lam=1000:25e3
-      sigma = 0.3 * mueff * sqrt(sum(xmean.^2)) / N; % 20D,lam=(40,1000):17e3
-                                                     %      75e3 with def (1.5)
-                                                     %      35e3 with damps=0.25
-  end
-  if 11 < 3 
-          if countiter == 1
-              disp('*********** xmean set to const ******************');
-          end
-      xmean = ones(N,1);
-  end
-  
-  % Update B and D from C
-
-  if ~flgDiagonalOnly && (ccov1+ccovmu+neg.ccov) > 0 && mod(countiter, 1/(ccov1+ccovmu+neg.ccov)/N/10) < 1
-    C=triu(C)+triu(C,1)'; % enforce symmetry to prevent complex numbers
-    [B,tmp] = eig(C);     % eigen decomposition, B==normalized eigenvectors
-                          % effort: approx. 15*N matrix-vector multiplications
-    diagD = diag(tmp); 
-
-    if any(~isfinite(diagD))
-      clear idx; % prevents error under octave 
-      save(['tmp' opts.SaveFilename]);
-      error(['function eig returned non-finited eigenvalues, cond(C)=' ...
-	     num2str(cond(C)) ]);
-    end
-    if any(any(~isfinite(B)))
-      clear idx; % prevents error under octave
-      save(['tmp' opts.SaveFilename]);
-      error(['function eig returned non-finited eigenvectors, cond(C)=' ...
-	     num2str(cond(C)) ]);
-    end
-
-    % limit condition of C to 1e14 + 1
-    if min(diagD) <= 0
-	if stopOnWarnings
-	  stopflag(end+1) = {'warnconditioncov'};
-	else
-	  warning(['Iteration ' num2str(countiter) ...
-		   ': Eigenvalue (smaller) zero']);
-	  diagD(diagD<0) = 0;
-	  tmp = max(diagD)/1e14;
-	  C = C + tmp*eye(N,N); diagD = diagD + tmp*ones(N,1); 
-	end
-    end
-    if max(diagD) > 1e14*min(diagD) 
-	if stopOnWarnings
-	  stopflag(end+1) = {'warnconditioncov'};
-	else
-	  warning(['Iteration ' num2str(countiter) ': condition of C ' ...
-		   'at upper limit' ]);
-	  tmp = max(diagD)/1e14 - min(diagD);
-	  C = C + tmp*eye(N,N); diagD = diagD + tmp*ones(N,1); 
-	end
-    end
-
-    diagC = diag(C); 
-    diagD = sqrt(diagD); % D contains standard deviations now
-    % diagD = diagD / prod(diagD)^(1/N);  C = C / prod(diagD)^(2/N);
-    BD = B.*repmat(diagD',N,1); % O(n^2)
-  end % if mod
-
-  % Align/rescale order of magnitude of scales of sigma and C for nicer output
-  % not a very usual case
-  if 1 < 2 && sigma > 1e10*max(diagD)
-    fac = sigma / max(diagD);
-    sigma = sigma/fac;
-    pc = fac * pc;
-    diagD = fac * diagD; 
-    if ~flgDiagonalOnly
-      C = fac^2 * C; % disp(fac);
-      BD = B.*repmat(diagD',N,1); % O(n^2), but repmat might be inefficient todo?
-    end
-    diagC = fac^2 * diagC; 
-  end
-
-  if flgDiagonalOnly > 1 && countiter > flgDiagonalOnly 
-    % full covariance matrix from now on 
-    flgDiagonalOnly = 0; 
-    B = eye(N,N);
-    BD = diag(diagD);
-    C = diag(diagC); % is better, because correlations are spurious anyway
-  end
-
-  if noiseHandling 
-   if countiter == 1  % assign firstvarargin for noise treatment e.g. as #reevaluations
-     if ~isempty(varargin) && length(varargin{1}) == 1 && isnumeric(varargin{1})
-       if irun == 1
-         firstvarargin = varargin{1};
-       else
-         varargin{1} =  firstvarargin;  % reset varargin{1}
-       end
-     else
-       firstvarargin = 0;
-     end
-   end
-   if noiseSS < 0 && noiseMinMaxEvals(2) > noiseMinMaxEvals(1) && firstvarargin
-     varargin{1} = max(noiseMinMaxEvals(1), varargin{1} / noiseAlphaEvals^(1/4));  % still experimental
-   elseif noiseSS > 0
-    if ~isempty(noiseCallback)  % to be removed? 
-      res = feval(noiseCallback); % should also work without output argument!?
-      if ~isempty(res) && res > 1 % TODO: decide for interface of callback
-                                  %       also a dynamic popsize could be done here 
-        sigma = sigma * noiseAlpha;
-      end
-    else
-      if noiseMinMaxEvals(2) > noiseMinMaxEvals(1) && firstvarargin
-        varargin{1} = min(noiseMinMaxEvals(2), varargin{1} * noiseAlphaEvals);
-      end
-    
-      sigma = sigma * noiseAlpha; 
-      % lambda = ceil(0.1 * sqrt(lambda) + lambda);
-      % TODO: find smallest increase of lambda with log-linear
-      %       convergence in iterations
-    end
-    % qqq experimental: take a mean to estimate the true optimum
-    noiseN = noiseN + 1;
-    if noiseN == 1
-      noiseX = xmean; 
-    else
-      noiseX = noiseX + (3/noiseN) * (xmean - noiseX); 
-    end
-   end
-  end
-
-  % ----- numerical error management -----
-  % Adjust maximal coordinate axis deviations
-  if any(sigma*sqrt(diagC) > maxdx)
-    sigma = min(maxdx ./ sqrt(diagC));
-    %warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ...
-    %         'deviation at upper limit of ' num2str(maxdx)]);
-    % stopflag(end+1) = {'maxcoorddev'};
-  end
-  % Adjust minimal coordinate axis deviations
-  if any(sigma*sqrt(diagC) < mindx)
-    sigma = max(mindx ./ sqrt(diagC)) * exp(0.05+cs/damps); 
-    %warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ...
-    %         'deviation at lower limit of ' num2str(mindx)]);
-    % stopflag(end+1) = {'mincoorddev'};;
-  end
-  % Adjust too low coordinate axis deviations
-  if any(xmean == xmean + 0.2*sigma*sqrt(diagC)) 
-    if stopOnWarnings
-      stopflag(end+1) = {'warnnoeffectcoord'};
-    else
-      warning(['Iteration ' num2str(countiter) ': coordinate axis std ' ...
-                'deviation too low' ]);
-      if flgDiagonalOnly
-        diagC = diagC + (ccov1_sep+ccovmu_sep) * (diagC .* ...
-                                                  (xmean == xmean + 0.2*sigma*sqrt(diagC)));
-      else
-        C = C + (ccov1+ccovmu) * diag(diagC .* ...
-                                      (xmean == xmean + 0.2*sigma*sqrt(diagC)));
-      end
-      sigma = sigma * exp(0.05+cs/damps); 
-    end
-  end
-  % Adjust step size in case of (numerical) precision problem 
-  if flgDiagonalOnly
-    tmp = 0.1*sigma*diagD; 
-  else
-    tmp = 0.1*sigma*BD(:,1+floor(mod(countiter,N)));
-  end
-  if all(xmean == xmean + tmp)
-    i = 1+floor(mod(countiter,N));
-    if stopOnWarnings
-	stopflag(end+1) = {'warnnoeffectaxis'};
-    else
-      warning(['Iteration ' num2str(countiter) ...
-	       ': main axis standard deviation ' ...
-	       num2str(sigma*diagD(i)) ' has no effect' ]);
-	sigma = sigma * exp(0.2+cs/damps); 
-    end
-  end
-  % Adjust step size in case of equal function values (flat fitness)
-  % isequalfuncvalues = 0; 
-  if fitness.sel(1) == fitness.sel(1+ceil(0.1+lambda/4))
-    % isequalfuncvalues = 1; 
-    if stopOnEqualFunctionValues
-      arrEqualFunvals = [countiter arrEqualFunvals(1:end-1)];
-      % stop if this happens in more than 33%
-      if arrEqualFunvals(end) > countiter - 3 * length(arrEqualFunvals)
-        stopflag(end+1) = {'equalfunvals'}; 
-      end
-    else
-      if flgWarnOnEqualFunctionValues
-        warning(['Iteration ' num2str(countiter) ...
-		 ': equal function values f=' num2str(fitness.sel(1)) ...
-		 ' at maximal main axis sigma ' ...
-        num2str(sigma*max(diagD))]);
-      end
-      sigma = sigma * exp(0.2+cs/damps); 
-    end
-  end
-  % Adjust step size in case of equal function values
-  if countiter > 2 && myrange([fitness.hist fitness.sel(1)]) == 0  
-    if stopOnWarnings
-	stopflag(end+1) = {'warnequalfunvalhist'};
-    else
-      warning(['Iteration ' num2str(countiter) ...
-	       ': equal function values in history at maximal main ' ...
-	       'axis sigma ' num2str(sigma*max(diagD))]);
-	sigma = sigma * exp(0.2+cs/damps); 
-    end
-  end
-    
-  % ----- end numerical error management -----
-  
-  % Keep overall best solution
-  out.evals = counteval;
-  out.solutions.evals = counteval;
-  out.solutions.mean.x = xmean;
-  out.solutions.mean.f = fmean;
-  out.solutions.mean.evals = counteval;
-  out.solutions.recentbest.x = arxvalid(:, fitness.idx(1));
-  out.solutions.recentbest.f = fitness.raw(1);
-  out.solutions.recentbest.evals = counteval + fitness.idx(1) - lambda;
-  out.solutions.recentworst.x = arxvalid(:, fitness.idx(end));
-  out.solutions.recentworst.f = fitness.raw(end);
-  out.solutions.recentworst.evals = counteval + fitness.idx(end) - lambda;
-  if fitness.hist(1) < out.solutions.bestever.f
-    out.solutions.bestever.x = arxvalid(:, fitness.idx(1));
-    out.solutions.bestever.f = fitness.hist(1);
-    out.solutions.bestever.evals = counteval + fitness.idx(1) - lambda;
-    bestever = out.solutions.bestever;
-  end
-
-  % Set stop flag
-  if fitness.raw(1) <= stopFitness, stopflag(end+1) = {'fitness'}; end
-  if counteval >= stopMaxFunEvals, stopflag(end+1) = {'maxfunevals'}; end
-  if countiter >= stopMaxIter, stopflag(end+1) = {'maxiter'}; end
-  if all(sigma*(max(abs(pc), sqrt(diagC))) < stopTolX) 
-    stopflag(end+1) = {'tolx'};
-  end
-  if any(sigma*sqrt(diagC) > stopTolUpX) 
-    stopflag(end+1) = {'tolupx'};
-  end
-  if sigma*max(diagD) == 0  % should never happen
-    stopflag(end+1) = {'bug'};
-  end
-  if countiter > 2 && myrange([fitness.sel fitness.hist]) <= stopTolFun 
-    stopflag(end+1) = {'tolfun'};
-  end
-  if countiter >= length(fitness.hist) && myrange(fitness.hist) <= stopTolHistFun 
-    stopflag(end+1) = {'tolhistfun'};
-  end
-  l = floor(length(fitness.histbest)/3);
-  if 1 < 2 && stopOnStagnation && ...  % leads sometimes early stop on ftablet, fcigtab
-      countiter > N * (5+100/lambda) && ...  
-      length(fitness.histbest) > 100 && ... 
-      median(fitness.histmedian(1:l)) >= median(fitness.histmedian(end-l:end)) && ...
-      median(fitness.histbest(1:l)) >= median(fitness.histbest(end-l:end))
-    stopflag(end+1) = {'stagnation'};
-  end
-
-  if counteval >= stopFunEvals || countiter >= stopIter
-    stopflag(end+1) = {'stoptoresume'};
-    if length(stopflag) == 1 && flgsaving == 0
-      error('To resume later the saving option needs to be set');
-    end
-  end
-  % read stopping message from file signals.par 
-  if flgreadsignals
-    fid = fopen('./signals.par', 'rt');  % can be performance critical 
-    while fid > 0
-      strline = fgetl(fid); %fgets(fid, 300);
-      if strline < 0 % fgets and fgetl returns -1 at end of file
-        break;
-      end
-      % 'stop filename' sets stopflag to manual
-      str = sscanf(strline, ' %s %s', 2);
-      if strcmp(str, ['stop' opts.LogFilenamePrefix]) 
-        stopflag(end+1) = {'manual'};
-        break;
-      end
-      % 'skip filename run 3' skips a run, but not the last
-      str = sscanf(strline, ' %s %s %s', 3);
-      if strcmp(str, ['skip' opts.LogFilenamePrefix 'run'])
-        i = strfind(strline, 'run');
-        if irun == sscanf(strline(i+3:end), ' %d ', 1) && irun <= myeval(opts.Restarts)
-          stopflag(end+1) = {'skipped'};
-        end      
-      end
-    end % while, break 
-    if fid > 0
-      fclose(fid);
-      clear fid; % prevents strange error under octave
-    end
-  end
-  
-  out.stopflag = stopflag;
-
-  % ----- output generation -----
-  if verbosemodulo > 0 && isfinite(verbosemodulo)
-    if countiter == 1 || mod(countiter, 10*verbosemodulo) < 1 
-      disp(['Iterat, #Fevals:   Function Value    (median,worst) ' ...
-	    '|Axis Ratio|' ...
-	    'idx:Min SD idx:Max SD']); 
-    end
-    if mod(countiter, verbosemodulo) < 1 ...
-	  || (verbosemodulo > 0 && isfinite(verbosemodulo) && ...
-	      (countiter < 3 || ~isempty(stopflag)))
-      [minstd minstdidx] = min(sigma*sqrt(diagC));
-      [maxstd maxstdidx] = max(sigma*sqrt(diagC));
-      % format display nicely
-      disp([repmat(' ',1,4-floor(log10(countiter))) ...
-	    num2str(countiter) ' , ' ...
-	    repmat(' ',1,5-floor(log10(counteval))) ...
-	    num2str(counteval) ' : ' ...
-            num2str(fitness.hist(1), '%.13e') ...
-	    ' +(' num2str(median(fitness.raw)-fitness.hist(1), '%.0e ') ...
-	    ',' num2str(max(fitness.raw)-fitness.hist(1), '%.0e ') ...
-	    ') | ' ...
-	    num2str(max(diagD)/min(diagD), '%4.2e') ' | ' ...
-	    repmat(' ',1,1-floor(log10(minstdidx))) num2str(minstdidx) ':' ...
-	    num2str(minstd, ' %.1e') ' ' ...
-	    repmat(' ',1,1-floor(log10(maxstdidx))) num2str(maxstdidx) ':' ...
-	    num2str(maxstd, ' %.1e')]);
-    end
-  end
-
-  % measure time for recording data
-  if countiter < 3 
-    time.c = 0.05;
-    time.nonoutput = 0;
-    time.recording = 0;
-    time.saving  = 0.15; % first saving after 3 seconds of 100 iterations
-    time.plotting = 0;
-  elseif countiter > 300
-    % set backward horizon, must be long enough to cover infrequent plotting etc
-    % time.c = min(1, time.nonoutput/3 + 1e-9); 
-    time.c = max(1e-5, 0.1/sqrt(countiter)); % mean over all or 1e-5
-  end
-  % get average time per iteration
-  time.t1 = clock;
-  time.act = max(0,etime(time.t1, time.t0));
-  time.nonoutput = (1-time.c) * time.nonoutput ...
-      + time.c * time.act; 
-
-  time.recording = (1-time.c) * time.recording;  % per iteration
-  time.saving  = (1-time.c) * time.saving;
-  time.plotting = (1-time.c) * time.plotting;
-  
-  % record output data, concerning time issues
-  if savemodulo && savetime && (countiter < 1e2 || ~isempty(stopflag) || ...
-	countiter >= outiter + savemodulo)
-    outiter = countiter; 
-      % Save output data to files  
-      for namecell = filenames(:)'
-        name = namecell{:};
-
-	[fid, err] = fopen(['./' filenameprefix name '.dat'], 'a');
-	if fid < 1 % err ~= 0 
-	  warning(['could not open ' filenameprefix name '.dat']);
-	else
-	  if strcmp(name, 'axlen')
-	    fprintf(fid, '%d %d %e %e %e ', countiter, counteval, sigma, ...
-		max(diagD), min(diagD)); 
-            fprintf(fid, '%e ', sort(diagD)); 
-            fprintf(fid, '\n');
-	  elseif strcmp(name, 'disp') % TODO
-	  elseif strcmp(name, 'fit')
-	    fprintf(fid, '%ld %ld %e %e %25.18e %25.18e %25.18e %25.18e', ...
-                    countiter, counteval, sigma, max(diagD)/min(diagD), ...
-                    out.solutions.bestever.f, ...
-                    fitness.raw(1), median(fitness.raw), fitness.raw(end)); 
-            if ~isempty(varargin) && length(varargin{1}) == 1 && isnumeric(varargin{1}) && varargin{1} ~= 0
-              fprintf(fid, ' %f', varargin{1});
-            end                    
-	    fprintf(fid, '\n');
-	  elseif strcmp(name, 'stddev')
-	    fprintf(fid, '%ld %ld %e 0 0 ', countiter, counteval, sigma); 
-	    fprintf(fid, '%e ', sigma*sqrt(diagC)); 
-            fprintf(fid, '\n');
-	  elseif strcmp(name, 'xmean')
-	    if isnan(fmean)
-	      fprintf(fid, '%ld %ld 0 0 0 ', countiter, counteval); 
-	    else
-	      fprintf(fid, '%ld %ld 0 0 %e ', countiter, counteval, fmean); 
-	    end
-	    fprintf(fid, '%e ', xmean); 
-            fprintf(fid, '\n');
-	  elseif strcmp(name, 'xrecentbest')
-            % TODO: fitness is inconsistent with x-value
-	    fprintf(fid, '%ld %ld %25.18e 0 0 ', countiter, counteval, fitness.raw(1)); 
-	    fprintf(fid, '%e ', arx(:,fitness.idx(1))); 
-            fprintf(fid, '\n');
-	  end
-	  fclose(fid); 
-	end
-      end
-
-    % get average time for recording data
-    time.t2 = clock;
-    time.recording = time.recording + time.c * max(0,etime(time.t2, time.t1)); 
-    
-    % plot
-    if flgplotting && countiter > 1
-      if countiter == 2
-        iterplotted = 0;
-      end
-      if ~isempty(stopflag) || ... 
-        ((time.nonoutput+time.recording) * (countiter - iterplotted) > 1 && ...
-          time.plotting < 0.05 * (time.nonoutput+time.recording))
-        local_plotcmaesdat(324, filenameprefix);
-        iterplotted = countiter;  
-        %  outplot(out); % outplot defined below
-        if time.plotting == 0  % disregard opening of the window
-          time.plotting = time.nonoutput+time.recording;
-        else
-          time.plotting = time.plotting + time.c * max(0,etime(clock, time.t2)); 
+        out.arstopflags{irun} = stopflag;
+        if any(strcmp(stopflag, 'fitness')) ...
+                || any(strcmp(stopflag, 'maxfunevals')) ...
+                || any(strcmp(stopflag, 'stoptoresume')) ...
+                || any(strcmp(stopflag, 'manual'))
+            break
         end
-      end
-    end
-    if countiter > 100 + 20 && savemodulo && ...
-          time.recording * countiter > 0.1 && ...  % absolute time larger 0.1 second
-	  time.recording > savetime * (time.nonoutput+time.recording) / 100 
-      savemodulo = floor(1.1 * savemodulo) + 1;
-      % disp('++savemodulo'); %qqq
-    end
-  end % if output
-
-  % save everything
-  time.t3 = clock;
-  if ~isempty(stopflag) || time.saving < 0.05 * time.nonoutput || countiter == 100
-    xmin = arxvalid(:, fitness.idx(1));
-    fmin = fitness.raw(1);
-    if flgsaving && countiter > 2
-      clear idx; % prevents error under octave
-      % -v6 : non-compressed non-unicode for version 6 and earlier
-      if ~isempty(strsaving) && ~isoctave
-	save('-mat', strsaving, opts.SaveFilename); % for inspection and possible restart	
-      else 
-	save('-mat', opts.SaveFilename); % for inspection and possible restart
-      end
-      time.saving = time.saving + time.c * max(0,etime(clock, time.t3)); 
-    end
-  end
-  time.t0 = clock;
-
-  % ----- end output generation -----
-
-end % while, end generation loop
-
-% -------------------- Final Procedures -------------------------------
-
-% Evaluate xmean and return best recent point in xmin
-fmin = fitness.raw(1);
-xmin = arxvalid(:, fitness.idx(1)); % Return best point of last generation.
-if length(stopflag) > sum(strcmp(stopflag, 'stoptoresume')) % final stopping
-  out.solutions.mean.f = ...
-      feval(fitfun, xintobounds(xmean, lbounds, ubounds), varargin{:});
-  counteval = counteval + 1;
-  out.solutions.mean.evals = counteval;
-  if out.solutions.mean.f < fitness.raw(1)
-    fmin = out.solutions.mean.f;
-    xmin = xintobounds(xmean, lbounds, ubounds); % Return xmean as best point
-  end
-  if out.solutions.mean.f < out.solutions.bestever.f
-    out.solutions.bestever = out.solutions.mean; % Return xmean as bestever point
-    out.solutions.bestever.x = xintobounds(xmean, lbounds, ubounds); 
-    bestever = out.solutions.bestever;
-  end
-end
-
-% Save everything and display final message
-if flgsavingfinal
-  clear idx; % prevents error under octave
-  if ~isempty(strsaving) && ~isoctave
-    save('-mat', strsaving, opts.SaveFilename); % for inspection and possible restart	
-  else 
-    save('-mat', opts.SaveFilename);    % for inspection and possible restart
-  end
-  message = [' (saved to ' opts.SaveFilename ')'];
-else
-  message = [];
-end
-
-if flgdisplay
-  disp(['#Fevals:   f(returned x)   |    bestever.f     | stopflag' ...
-        message]);
-  if isoctave
-    strstop = stopflag(:); 
-  else
-      strcat(stopflag(:), '.');
-  end
-  strstop = stopflag(:); %strcat(stopflag(:), '.');
-  disp([repmat(' ',1,6-floor(log10(counteval))) ...
-        num2str(counteval, '%6.0f') ': ' num2str(fmin, '%.11e') ' | ' ...
-        num2str(out.solutions.bestever.f, '%.11e') ' | ' ...
-	strstop{1:end}]);
-  if N < 102
-     disp(['mean solution:' sprintf(' %+.1e', xmean)]);
-     disp(['std deviation:' sprintf('  %.1e', sigma*sqrt(diagC))]);
-     disp(sprintf('use plotcmaesdat.m for plotting the output at any time (option LogModulo must not be zero)'));
-  end
-  if exist('sfile', 'var') 
-    disp(['Results saved in ' sfile]); 
-  end
-end
-
-  out.arstopflags{irun} = stopflag;
-  if any(strcmp(stopflag, 'fitness')) ...
-	|| any(strcmp(stopflag, 'maxfunevals')) ...
-	|| any(strcmp(stopflag, 'stoptoresume')) ...
-	|| any(strcmp(stopflag, 'manual'))
-    break; 
-  end
 end % while irun <= Restarts
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function [x, idx] = xintobounds(x, lbounds, ubounds)
 %
 % x can be a column vector or a matrix consisting of column vectors
 %
-  if ~isempty(lbounds)
+if ~isempty(lbounds)
     if length(lbounds) == 1
-      idx = x < lbounds;
-      x(idx) = lbounds;
+        idx = x < lbounds;
+        x(idx) = lbounds;
     else
-      arbounds = repmat(lbounds, 1, size(x,2));
-      idx = x < arbounds;
-      x(idx) = arbounds(idx);
+        arbounds = repmat(lbounds, 1, size(x,2));
+        idx = x < arbounds;
+        x(idx) = arbounds(idx);
     end
-  else
+else
     idx = 0;
-  end
-  if ~isempty(ubounds)
+end
+if ~isempty(ubounds)
     if length(ubounds) == 1
-      idx2 = x > ubounds;
-      x(idx2) = ubounds;
+        idx2 = x > ubounds;
+        x(idx2) = ubounds;
     else
-      arbounds = repmat(ubounds, 1, size(x,2));
-      idx2 = x > arbounds;
-      x(idx2) = arbounds(idx2);
+        arbounds = repmat(ubounds, 1, size(x,2));
+        idx2 = x > arbounds;
+        x(idx2) = arbounds(idx2);
     end
-  else
+else
     idx2 = 0;
-  end
-  idx = idx2-idx; 
-  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+end
+idx = idx2-idx;
+
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function opts=getoptions(inopts, defopts)
 % OPTS = GETOPTIONS(INOPTS, DEFOPTS) handles an arbitrary number of
 % optional arguments to a function. The given arguments are collected
@@ -1812,7 +1812,7 @@ function opts=getoptions(inopts, defopts)
 %     defopts.ParentNumber = 50;
 %     defopts.MaxIterations = 1e6;
 %     defopts.MaxSigma = 1;
-%  
+%
 %     % merge default options with input options
 %     opts = getoptions(inopts, defopts);
 %
@@ -1823,148 +1823,148 @@ function opts=getoptions(inopts, defopts)
 %         % do whatever
 %       end
 %     end
-%   
+%
 %   For calling the function myfunction with default options:
 %   myfunction(argument1, []);
 %   For calling the function myfunction with modified options:
 %   opt.pop = 100; % redefine PopulationSize option
 %   opt.PAR = 10;  % redefine ParentNumber option
-%   opt.maxiter = 2; % opt.max=2 is ambiguous and would result in an error 
+%   opt.maxiter = 2; % opt.max=2 is ambiguous and would result in an error
 %   myfunction(argument1, opt);
 
 %
 % 04/07/19: Entries can be structs itself leading to a recursive
-%           call to getoptions. 
+%           call to getoptions.
 %
 
 if nargin < 2 || isempty(defopts) % no default options available
-  opts=inopts;
-  return;
+    opts=inopts;
+    return
 elseif isempty(inopts) % empty inopts invoke default options
-  opts = defopts;
-  return;
-elseif ~isstruct(defopts) % handle a single option value
-  if isempty(inopts) 
     opts = defopts;
-  elseif ~isstruct(inopts)
-    opts = inopts;
-  else
-    error('Input options are a struct, while default options are not');
-  end
-  return;
+    return
+elseif ~isstruct(defopts) % handle a single option value
+    if isempty(inopts)
+        opts = defopts;
+    elseif ~isstruct(inopts)
+        opts = inopts;
+    else
+        error('Input options are a struct, while default options are not');
+    end
+    return
 elseif ~isstruct(inopts) % no valid input options
-  error('The options need to be a struct or empty');
+    error('The options need to be a struct or empty');
 end
 
-  opts = defopts; % start from defopts 
-  % if necessary overwrite opts fields by inopts values
-  defnames = fieldnames(defopts);
-  idxmatched = []; % indices of defopts that already matched
-  for name = fieldnames(inopts)'
+opts = defopts; % start from defopts
+                % if necessary overwrite opts fields by inopts values
+defnames = fieldnames(defopts);
+idxmatched = []; % indices of defopts that already matched
+for name = fieldnames(inopts)'
     name = name{1}; % name of i-th inopts-field
     if isoctave
-      for i = 1:size(defnames, 1)
-	idx(i) = strncmp(lower(defnames(i)), lower(name), length(name));
-      end
+        for i = 1:size(defnames, 1)
+            idx(i) = strncmp(lower(defnames(i)), lower(name), length(name));
+        end
     else
-	idx = strncmpi(defnames, name, length(name));
+        idx = strncmpi(defnames, name, length(name));
     end
     if sum(idx) > 1
-      error(['option "' name '" is not an unambigous abbreviation. ' ...
-	     'Use opts=RMFIELD(opts, ''' name, ...
-	     ''') to remove the field from the struct.']);
+        error(['option "' name '" is not an unambigous abbreviation. ' ...
+               'Use opts=RMFIELD(opts, ''' name, ...
+               ''') to remove the field from the struct.']);
     end
     if sum(idx) == 1
-      defname  = defnames{find(idx)}; 
-      if ismember(find(idx), idxmatched)
-	error(['input options match more than ones with "' ...
-	       defname '". ' ...
-	       'Use opts=RMFIELD(opts, ''' name, ...
-	       ''') to remove the field from the struct.']);
-      end
-      idxmatched = [idxmatched find(idx)];
-      val = getfield(inopts, name);
-      % next line can replace previous line from MATLAB version 6.5.0 on and in octave
-      % val = inopts.(name);
-      if isstruct(val) % valid syntax only from version 6.5.0
-	opts = setfield(opts, defname, ...
-	    getoptions(val, getfield(defopts, defname))); 
-      elseif isstruct(getfield(defopts, defname)) 
-      % next three lines can replace previous three lines from MATLAB 
-      % version 6.5.0 on
-      %   opts.(defname) = ...
-      %      getoptions(val, defopts.(defname)); 
-      % elseif isstruct(defopts.(defname)) 
-	warning(['option "' name '" disregarded (must be struct)']); 
-      elseif ~isempty(val) % empty value: do nothing, i.e. stick to default
-	opts = setfield(opts, defnames{find(idx)}, val);
-	% next line can replace previous line from MATLAB version 6.5.0 on
-	% opts.(defname) = inopts.(name); 
-      end
+        defname  = defnames{find(idx)};
+        if ismember(find(idx), idxmatched)
+            error(['input options match more than ones with "' ...
+                   defname '". ' ...
+                   'Use opts=RMFIELD(opts, ''' name, ...
+                   ''') to remove the field from the struct.']);
+        end
+        idxmatched = [idxmatched find(idx)];
+        val = getfield(inopts, name);
+        % next line can replace previous line from MATLAB version 6.5.0 on and in octave
+        % val = inopts.(name);
+        if isstruct(val) % valid syntax only from version 6.5.0
+            opts = setfield(opts, defname, ...
+                                  getoptions(val, getfield(defopts, defname)));
+        elseif isstruct(getfield(defopts, defname))
+            % next three lines can replace previous three lines from MATLAB
+            % version 6.5.0 on
+            %   opts.(defname) = ...
+            %      getoptions(val, defopts.(defname));
+            % elseif isstruct(defopts.(defname))
+            warning(['option "' name '" disregarded (must be struct)']);
+        elseif ~isempty(val) % empty value: do nothing, i.e. stick to default
+            opts = setfield(opts, defnames{find(idx)}, val);
+            % next line can replace previous line from MATLAB version 6.5.0 on
+            % opts.(defname) = inopts.(name);
+        end
     else
-      warning(['option "' name '" disregarded (unknown field name)']);
+        warning(['option "' name '" disregarded (unknown field name)']);
     end
-  end
+end
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function res=myeval(s)
-  if ischar(s)
+if ischar(s)
     res = evalin('caller', s);
-  else
+else
     res = s;
-  end
-  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
-function res=myevalbool(s)
-  if ~ischar(s) % s may not and cannot be empty
-    res = s;
-  else % evaluation string s
-    if strncmpi(lower(s), 'yes', 3) || strncmpi(s, 'on', 2) ...
-	  || strncmpi(s, 'true', 4) || strncmp(s, '1 ', 2)
-      res = 1;
-    elseif strncmpi(s, 'no', 2) || strncmpi(s, 'off', 3) ...
-	  || strncmpi(s, 'false', 5) || strncmp(s, '0 ', 2)
-      res = 0;
-    else
-      try res = evalin('caller', s); catch
-	error(['String value "' s '" cannot be evaluated']);
-      end
-      try res ~= 0; catch
-	error(['String value "' s '" cannot be evaluated reasonably']);
-      end
-    end
-  end
-  
+end
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
+function res=myevalbool(s)
+if ~ischar(s) % s may not and cannot be empty
+    res = s;
+else % evaluation string s
+    if strncmpi(lower(s), 'yes', 3) || strncmpi(s, 'on', 2) ...
+            || strncmpi(s, 'true', 4) || strncmp(s, '1 ', 2)
+        res = 1;
+    elseif strncmpi(s, 'no', 2) || strncmpi(s, 'off', 3) ...
+            || strncmpi(s, 'false', 5) || strncmp(s, '0 ', 2)
+        res = 0;
+    else
+        try res = evalin('caller', s); catch
+            error(['String value "' s '" cannot be evaluated']);
+        end
+        try res ~= 0; catch
+            error(['String value "' s '" cannot be evaluated reasonably']);
+        end
+    end
+end
+
+
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function res = isoctave
 % any hack to find out whether we are running octave
-  s = version;
-  res = 0;
-  if exist('fflush', 'builtin') && eval(s(1)) < 7
+s = version;
+res = 0;
+if exist('fflush', 'builtin') && eval(s(1)) < 7
     res = 1;
-  end
+end
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function flush
-  if isoctave
+if isoctave
     feval('fflush', stdout);
-  end
+end
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 % ----- replacements for statistic toolbox functions ------------
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function res=myrange(x)
-  res = max(x) - min(x);
-  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+res = max(x) - min(x);
+
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 function res = myprctile(inar, perc, idx)
 %
 % Computes the percentiles in vector perc from vector inar
@@ -1975,105 +1975,105 @@ function res = myprctile(inar, perc, idx)
 N = length(inar);
 flgtranspose = 0;
 
-% sizes 
+% sizes
 if size(perc,1) > 1
-  perc = perc';
-  flgtranspose = 1;
-  if size(perc,1) > 1
-    error('perc must not be a matrix');
-  end
+    perc = perc';
+    flgtranspose = 1;
+    if size(perc,1) > 1
+        error('perc must not be a matrix');
+    end
 end
 if size(inar, 1) > 1 && size(inar,2) > 1
-  error('data inar must not be a matrix');
+    error('data inar must not be a matrix');
 end
- 
+
 % sort inar
 if nargin < 3 || isempty(idx)
-  [sar idx] = sort(inar);
+    [sar, idx] = sort(inar);
 else
-  sar = inar(idx);
+    sar = inar(idx);
 end
 
 res = [];
 for p = perc
-  if p <= 100*(0.5/N)
-    res(end+1) = sar(1);
-  elseif p >= 100*((N-0.5)/N)
-    res(end+1) = sar(N);
-  else
-    % find largest index smaller than required percentile
-    availablepercentiles = 100*((1:N)-0.5)/N;
-    i = max(find(p > availablepercentiles));
-    % interpolate linearly
-    res(end+1) = sar(i) ...
-	+ (sar(i+1)-sar(i))*(p - availablepercentiles(i)) ...
-	/ (availablepercentiles(i+1) - availablepercentiles(i));
+    if p <= 100*(0.5/N)
+        res(end+1) = sar(1);
+    elseif p >= 100*((N-0.5)/N)
+        res(end+1) = sar(N);
+    else
+        % find largest index smaller than required percentile
+        availablepercentiles = 100*((1:N)-0.5)/N;
+        i = max(find(p > availablepercentiles));
+        % interpolate linearly
+        res(end+1) = sar(i) ...
+            + (sar(i+1)-sar(i))*(p - availablepercentiles(i)) ...
+            / (availablepercentiles(i+1) - availablepercentiles(i));
 
-  end
+    end
 end
 
 if flgtranspose
-  res = res';
+    res = res';
 end
 
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 
 
 
-function [s ranks rankDelta] = local_noisemeasurement(arf1, arf2, lamreev, theta, cutlimit)
+function [s, ranks, rankDelta] = local_noisemeasurement(arf1, arf2, lamreev, theta, cutlimit)
 % function [s ranks rankDelta] = noisemeasurement(arf1, arf2, lamreev, theta)
 %
-% Input: 
-%   arf1, arf2 : two arrays of function values. arf1 is of size 1xlambda, 
-%       arf2 may be of size 1xlamreev or 1xlambda. The first lamreev values 
-%       in arf2 are (re-)evaluations of the respective solutions, i.e. 
+% Input:
+%   arf1, arf2 : two arrays of function values. arf1 is of size 1xlambda,
+%       arf2 may be of size 1xlamreev or 1xlambda. The first lamreev values
+%       in arf2 are (re-)evaluations of the respective solutions, i.e.
 %       arf1(1) and arf2(1) are two evaluations of "the first" solution.
-%    lamreev: number of reevaluated individuals in arf2 
-%    theta : parameter theta for the rank change limit, between 0 and 1, 
-%       typically between 0.2 and 0.7. 
-%    cutlimit (optional): output s is computed as a mean of rankchange minus 
-%       threshold, where rankchange is <=2*(lambda-1). cutlimit limits 
-%       abs(rankchange minus threshold) in this calculation to cutlimit. 
-%       cutlimit=1 evaluates basically the sign only. cutlimit=2 could be 
-%       the rank change with one solution (both evaluations of it). 
-% 
-% Output: 
+%    lamreev: number of reevaluated individuals in arf2
+%    theta : parameter theta for the rank change limit, between 0 and 1,
+%       typically between 0.2 and 0.7.
+%    cutlimit (optional): output s is computed as a mean of rankchange minus
+%       threshold, where rankchange is <=2*(lambda-1). cutlimit limits
+%       abs(rankchange minus threshold) in this calculation to cutlimit.
+%       cutlimit=1 evaluates basically the sign only. cutlimit=2 could be
+%       the rank change with one solution (both evaluations of it).
+%
+% Output:
 %   s : noise measurement, s>0 means the noise measure is above the
 %       acceptance threshold
-%   ranks : 2xlambda array, corresponding to [arf1; arf2], of ranks 
+%   ranks : 2xlambda array, corresponding to [arf1; arf2], of ranks
 %       of arf1 and arf2 in the set [arf1 arf2], values are in [1:2*lambda]
 %   rankDelta: 1xlambda array of rank movements of arf2 compared to
 %       arf1.  rankDelta(i) agrees with the number of values from
 %       the set [arf1 arf2] that lie between arf1(i) and arf2(i).
 %
 % Note: equal function values might lead to somewhat spurious results.
-%       For this case a revision is advisable. 
+%       For this case a revision is advisable.
 
 %%% verify input argument sizes
 if size(arf1,1) ~= 1
-  error('arf1 must be an 1xlambda array');
+    error('arf1 must be an 1xlambda array');
 elseif size(arf2,1) ~= 1
-  error('arf2 must be an 1xsomething array');
+    error('arf2 must be an 1xsomething array');
 elseif size(arf1,2) < size(arf2,2)  % not really necessary, but saver
-  error('arf2 must not be smaller than arf1 in length');
+    error('arf2 must not be smaller than arf1 in length');
 end
 lam = size(arf1, 2);
 if size(arf1,2) ~= size(arf2,2)
-   arf2(end+1:lam) = arf1((size(arf2,2)+1):lam);
+    arf2(end+1:lam) = arf1((size(arf2,2)+1):lam);
 end
 if nargin < 5
-  cutlimit = inf;
+    cutlimit = inf;
 end
 
 %%% capture unusual values
 if any(diff(arf1) == 0)
-  % this will presumably interpreted as rank change, because
-  % sort(ones(...)) returns 1,2,3,...
-  warning([num2str(sum(diff(arf1)==0)) ' equal function values']);
+    % this will presumably interpreted as rank change, because
+    % sort(ones(...)) returns 1,2,3,...
+    warning([num2str(sum(diff(arf1)==0)) ' equal function values']);
 end
 
 %%% compute rank changes into rankDelta
@@ -2086,12 +2086,12 @@ rankDelta = ranks(1,:) - ranks(2,:) - sign(ranks(1,:) - ranks(2,:));
 
 %%% compute rank change limits using both ranks(1,...) and ranks(2,...)
 for i = 1:lamreev
-  sumlim(i) = ...
-      0.5 * (...
-          myprctile(abs((1:2*lam-1) - (ranks(1,i) - (ranks(1,i)>ranks(2,i)))), ...
-                    theta*50) ...      
-          + myprctile(abs((1:2*lam-1) - (ranks(2,i) - (ranks(2,i)>ranks(1,i)))), ...
-                      theta*50)); 
+    sumlim(i) = ...
+        0.5 * (...
+            myprctile(abs((1:2*lam-1) - (ranks(1,i) - (ranks(1,i)>ranks(2,i)))), ...
+                      theta*50) ...
+            + myprctile(abs((1:2*lam-1) - (ranks(2,i) - (ranks(2,i)>ranks(1,i)))), ...
+                        theta*50));
 end
 
 %%% compute measurement
@@ -2101,235 +2101,235 @@ end
 s = abs(rankDelta(1:lamreev)) - max(1, sumlim); % lives roughly in 0..2*lambda
 
 % cut-off limit
-idx = abs(s) > cutlimit; 
+idx = abs(s) > cutlimit;
 s(idx) = sign(s(idx)) * cutlimit;
 s = mean(s);
 
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
+% ---------------------------------------------------------------
 % just a "local" copy of plotcmaesdat.m, with manual_mode set to zero
 function local_plotcmaesdat(figNb, filenameprefix, filenameextension, objectvarname)
 % PLOTCMAESDAT;
 % PLOTCMAES(FIGURENUMBER_iBEGIN_iEND, FILENAMEPREFIX, FILENAMEEXTENSION, OBJECTVARNAME);
-%   plots output from CMA-ES, e.g. cmaes.m, Java class CMAEvolutionStrategy... 
-%   mod(figNb,100)==1 plots versus iterations. 
+%   plots output from CMA-ES, e.g. cmaes.m, Java class CMAEvolutionStrategy...
+%   mod(figNb,100)==1 plots versus iterations.
 %
-% PLOTCMAES([101 300]) plots versus iteration, from iteration 300. 
-% PLOTCMAES([100 150 800]) plots versus function evaluations, between iteration 150 and 800. 
+% PLOTCMAES([101 300]) plots versus iteration, from iteration 300.
+% PLOTCMAES([100 150 800]) plots versus function evaluations, between iteration 150 and 800.
 %
-% Upper left subplot: blue/red: function value of the best solution in the 
+% Upper left subplot: blue/red: function value of the best solution in the
 %   recent population, cyan: same function value minus best
-%   ever seen function value, green: sigma, red: ratio between 
+%   ever seen function value, green: sigma, red: ratio between
 %   longest and shortest principal axis length which is equivalent
-%   to sqrt(cond(C)). 
+%   to sqrt(cond(C)).
 % Upper right plot: time evolution of the distribution mean (default) or
-%   the recent best solution vector. 
-% Lower left: principal axes lengths of the distribution ellipsoid, 
-%   equivalent with the sqrt(eig(C)) square root eigenvalues of C. 
-% Lower right: magenta: minimal and maximal "true" standard deviation 
-%   (with sigma included) in the coordinates, other colors: sqrt(diag(C)) 
+%   the recent best solution vector.
+% Lower left: principal axes lengths of the distribution ellipsoid,
+%   equivalent with the sqrt(eig(C)) square root eigenvalues of C.
+% Lower right: magenta: minimal and maximal "true" standard deviation
+%   (with sigma included) in the coordinates, other colors: sqrt(diag(C))
 %   of all diagonal elements of C, if C is diagonal they equal to the
-%   lower left. 
+%   lower left.
 %
-% Files [FILENAMEPREFIX name FILENAMEEXTENSION] are used, where 
+% Files [FILENAMEPREFIX name FILENAMEEXTENSION] are used, where
 %   name = axlen, OBJECTVARNAME (xmean|xrecentbest), fit, or stddev.
 %
 
 manual_mode = 0;
 
-  if nargin < 1 || isempty(figNb)
+if nargin < 1 || isempty(figNb)
     figNb = 325;
-  end
-  if nargin < 2 || isempty(filenameprefix)
+end
+if nargin < 2 || isempty(filenameprefix)
     filenameprefix = 'outcmaes';
-  end
-  if nargin < 3 || isempty(filenameextension)
+end
+if nargin < 3 || isempty(filenameextension)
     filenameextension = '.dat';
-  end
-  if nargin < 4 || isempty(objectvarname)
-    objectvarname = 'xmean';    
+end
+if nargin < 4 || isempty(objectvarname)
+    objectvarname = 'xmean';
     objectvarname = 'xrecentbest';
-  end
-  % load data
-  d.x = load([filenameprefix objectvarname filenameextension]); 
-  % d.x = load([filenameprefix 'xmean' filenameextension]); 
-  % d.x = load([filenameprefix 'xrecentbest' filenameextension]); 
-  d.f = load([filenameprefix 'fit' filenameextension]); 
-  d.std = load([filenameprefix 'stddev' filenameextension]);
-  d.D = load([filenameprefix 'axlen' filenameextension]);
+end
+% load data
+d.x = load([filenameprefix objectvarname filenameextension]);
+% d.x = load([filenameprefix 'xmean' filenameextension]);
+% d.x = load([filenameprefix 'xrecentbest' filenameextension]);
+d.f = load([filenameprefix 'fit' filenameextension]);
+d.std = load([filenameprefix 'stddev' filenameextension]);
+d.D = load([filenameprefix 'axlen' filenameextension]);
 
-  % interpret entries in figNb for cutting out some data
-  if length(figNb) > 1
+% interpret entries in figNb for cutting out some data
+if length(figNb) > 1
     iend = inf;
     istart = figNb(2);
     if length(figNb) > 2
-      iend = figNb(3);
+        iend = figNb(3);
     end
     figNb = figNb(1);
     d.x = d.x(d.x(:,1) >= istart & d.x(:,1) <= iend, :);
     d.f = d.f(d.f(:,1) >= istart & d.f(:,1) <= iend, :);
     d.std = d.std(d.std(:,1) >= istart & d.std(:,1) <= iend, :);
     d.D = d.D(d.D(:,1) >= istart & d.D(:,1) <= iend, :);
-  end
+end
 
-  % decide for x-axis
-  iabscissa = 2; % 1== versus iterations, 2==versus fevals
-  if mod(figNb,100) == 1
+% decide for x-axis
+iabscissa = 2; % 1== versus iterations, 2==versus fevals
+if mod(figNb,100) == 1
     iabscissa = 1; % a short hack
-  end
-  if iabscissa == 1
-    xlab ='iterations'; 
-  elseif iabscissa == 2
-    xlab = 'function evaluations'; 
-  end
+end
+if iabscissa == 1
+    xlab ='iterations';
+elseif iabscissa == 2
+    xlab = 'function evaluations';
+end
 
-  if size(d.x, 2) < 1000
+if size(d.x, 2) < 1000
     minxend = 1.03*d.x(end, iabscissa);
-  else
+else
     minxend = 0;
-  end
+end
 
-  % set up figure window
-  if manual_mode
+% set up figure window
+if manual_mode
     figure(figNb);  % just create and raise the figure window
-  else
-    if 1 < 3 && evalin('caller', 'iterplotted') == 0 && evalin('caller', 'irun') == 1 
-      figure(figNb);  % incomment this, if figure raise in the beginning is not desired
+else
+    if 1 < 3 && evalin('caller', 'iterplotted') == 0 && evalin('caller', 'irun') == 1
+        figure(figNb);  % incomment this, if figure raise in the beginning is not desired
     elseif ismember(figNb, findobj('Type', 'figure'))
-      set(0, 'CurrentFigure', figNb);  % prevents raise of existing figure window
+        set(0, 'CurrentFigure', figNb);  % prevents raise of existing figure window
     else
-      figure(figNb);
+        figure(figNb);
     end
-  end
+end
 
-  % plot fitness etc
-  foffset = 1e-99;
-  dfit = d.f(:,6)-min(d.f(:,6)); 
-  [ignore idxbest] = min(dfit);
-  dfit(dfit<1e-98) = NaN;
-  subplot(2,2,1); hold off; 
-  dd = abs(d.f(:,7:8)) + foffset; 
-  dd(d.f(:,7:8)==0) = NaN;
-  semilogy(d.f(:,iabscissa), dd, '-k'); hold on;
-  % additional fitness data, for example constraints values
-  if size(d.f,2) > 8
+% plot fitness etc
+foffset = 1e-99;
+dfit = d.f(:,6)-min(d.f(:,6));
+[ignore, idxbest] = min(dfit);
+dfit(dfit<1e-98) = NaN;
+subplot(2,2,1); hold off;
+dd = abs(d.f(:,7:8)) + foffset;
+dd(d.f(:,7:8)==0) = NaN;
+semilogy(d.f(:,iabscissa), dd, '-k'); hold on;
+% additional fitness data, for example constraints values
+if size(d.f,2) > 8
     dd = abs(d.f(:,9:end)) + 10*foffset;  % a hack
-    % dd(d.f(:,9:end)==0) = NaN; 
-    semilogy(d.f(:,iabscissa), dd, '-m'); hold on; 
+                                          % dd(d.f(:,9:end)==0) = NaN;
+    semilogy(d.f(:,iabscissa), dd, '-m'); hold on;
     if size(d.f,2) > 12
-      semilogy(d.f(:,iabscissa),abs(d.f(:,[7 8 11 13]))+foffset,'-k'); hold on;
+        semilogy(d.f(:,iabscissa),abs(d.f(:,[7 8 11 13]))+foffset,'-k'); hold on;
     end
-  end
+end
 
-  idx = find(d.f(:,6)>1e-98);  % positive values
-  if ~isempty(idx)  % otherwise non-log plot gets hold
-    semilogy(d.f(idx,iabscissa), d.f(idx,6)+foffset, '.b'); hold on; 
-  end
-  idx = find(d.f(:,6) < -1e-98);  % negative values
-  if ~isempty(idx)
-    semilogy(d.f(idx, iabscissa), abs(d.f(idx,6))+foffset,'.r'); hold on; 
-  end
-  semilogy(d.f(:,iabscissa),abs(d.f(:,6))+foffset,'-b'); hold on;
-  semilogy(d.f(:,iabscissa),dfit,'-c'); hold on;
-  semilogy(d.f(:,iabscissa),(d.f(:,4)),'-r'); hold on; % AR
-  semilogy(d.std(:,iabscissa), [max(d.std(:,6:end)')' ...
-                      min(d.std(:,6:end)')'], '-m'); % max,min std
-  maxval = max(d.std(end,6:end));
-  minval = min(d.std(end,6:end));
-  text(d.std(end,iabscissa), maxval, sprintf('%.0e', maxval));
-  text(d.std(end,iabscissa), minval, sprintf('%.0e', minval));
+idx = find(d.f(:,6)>1e-98);  % positive values
+if ~isempty(idx)  % otherwise non-log plot gets hold
+    semilogy(d.f(idx,iabscissa), d.f(idx,6)+foffset, '.b'); hold on;
+end
+idx = find(d.f(:,6) < -1e-98);  % negative values
+if ~isempty(idx)
+    semilogy(d.f(idx, iabscissa), abs(d.f(idx,6))+foffset,'.r'); hold on;
+end
+semilogy(d.f(:,iabscissa),abs(d.f(:,6))+foffset,'-b'); hold on;
+semilogy(d.f(:,iabscissa),dfit,'-c'); hold on;
+semilogy(d.f(:,iabscissa),(d.f(:,4)),'-r'); hold on; % AR
+semilogy(d.std(:,iabscissa), [max(d.std(:,6:end)')' ...
+                    min(d.std(:,6:end)')'], '-m'); % max,min std
+maxval = max(d.std(end,6:end));
+minval = min(d.std(end,6:end));
+text(d.std(end,iabscissa), maxval, sprintf('%.0e', maxval));
+text(d.std(end,iabscissa), minval, sprintf('%.0e', minval));
 
-  semilogy(d.std(:,iabscissa),(d.std(:,3)),'-g'); % sigma
-  % plot best f
-  semilogy(d.f(idxbest,iabscissa),min(dfit),'*c'); hold on;
-  semilogy(d.f(idxbest,iabscissa),abs(d.f(idxbest,6))+foffset,'*r'); hold on;
+semilogy(d.std(:,iabscissa),(d.std(:,3)),'-g'); % sigma
+                                                % plot best f
+semilogy(d.f(idxbest,iabscissa),min(dfit),'*c'); hold on;
+semilogy(d.f(idxbest,iabscissa),abs(d.f(idxbest,6))+foffset,'*r'); hold on;
 
-  ax = axis;
-  ax(2) = max(minxend, ax(2)); 
-  axis(ax);
-  
-  yannote = 10^(log10(ax(3)) + 0.05*(log10(ax(4))-log10(ax(3)))); 
-  text(ax(1), yannote, ...
-       [ 'f=' num2str(d.f(end,6), '%.15g') ]);
+ax = axis;
+ax(2) = max(minxend, ax(2));
+axis(ax);
 
-  title('blue:abs(f), cyan:f-min(f), green:sigma, red:axis ratio');
-  grid on; 
+yannote = 10^(log10(ax(3)) + 0.05*(log10(ax(4))-log10(ax(3))));
+text(ax(1), yannote, ...
+     [ 'f=' num2str(d.f(end,6), '%.15g') ]);
 
-  subplot(2,2,2); hold off; 
-  plot(d.x(:,iabscissa), d.x(:,6:end),'-'); hold on;
-  ax = axis;
-  ax(2) = max(minxend, ax(2)); 
-  axis(ax); 
+title('blue:abs(f), cyan:f-min(f), green:sigma, red:axis ratio');
+grid on;
 
-  % add some annotation lines
-  [ignore idx] = sort(d.x(end,6:end));
-  % choose no more than 25 indices 
-  idxs = round(linspace(1, size(d.x,2)-5, min(size(d.x,2)-5, 25))); 
-  yy = repmat(NaN, 2, size(d.x,2)-5);
-  yy(1,:) = d.x(end, 6:end);
-  yy(2,idx(idxs)) = linspace(ax(3), ax(4), length(idxs));
-  plot([d.x(end,iabscissa) ax(2)], yy, '-'); 
-  plot(repmat(d.x(end,iabscissa),2), [ax(3) ax(4)], 'k-');
-  for i = idx(idxs)
+subplot(2,2,2); hold off;
+plot(d.x(:,iabscissa), d.x(:,6:end),'-'); hold on;
+ax = axis;
+ax(2) = max(minxend, ax(2));
+axis(ax);
+
+% add some annotation lines
+[ignore idx] = sort(d.x(end,6:end));
+% choose no more than 25 indices
+idxs = round(linspace(1, size(d.x,2)-5, min(size(d.x,2)-5, 25)));
+yy = repmat(NaN, 2, size(d.x,2)-5);
+yy(1,:) = d.x(end, 6:end);
+yy(2,idx(idxs)) = linspace(ax(3), ax(4), length(idxs));
+plot([d.x(end,iabscissa) ax(2)], yy, '-');
+plot(repmat(d.x(end,iabscissa),2), [ax(3) ax(4)], 'k-');
+for i = idx(idxs)
     text(ax(2), yy(2,i), ...
          ['x(' num2str(i) ')=' num2str(yy(1,i))]);
-  end
-  
-  lam = 'NA'; 
-  if size(d.x, 1) > 1 && d.x(end, 1) > d.x(end-1, 1)
+end
+
+lam = 'NA';
+if size(d.x, 1) > 1 && d.x(end, 1) > d.x(end-1, 1)
     lam = num2str((d.x(end, 2) - d.x(end-1, 2)) / (d.x(end, 1) - d.x(end-1, 1)));
-  end
-  title(['Object Variables (' num2str(size(d.x, 2)-5) ...
-            '-D, popsize~' lam ')']);grid on;
+end
+title(['Object Variables (' num2str(size(d.x, 2)-5) ...
+       '-D, popsize~' lam ')']);grid on;
 
-  subplot(2,2,3); hold off; semilogy(d.D(:,iabscissa), d.D(:,6:end), '-');
-  ax = axis;
-  ax(2) = max(minxend, ax(2)); 
-  axis(ax);
-  title('Principal Axes Lengths');grid on;
-  xlabel(xlab); 
+subplot(2,2,3); hold off; semilogy(d.D(:,iabscissa), d.D(:,6:end), '-');
+ax = axis;
+ax(2) = max(minxend, ax(2));
+axis(ax);
+title('Principal Axes Lengths');grid on;
+xlabel(xlab);
 
-  subplot(2,2,4); hold off; 
-  % semilogy(d.std(:,iabscissa), d.std(:,6:end), 'k-'); hold on; 
-  % remove sigma from stds
-  d.std(:,6:end) = d.std(:,6:end) ./ (d.std(:,3) * ones(1,size(d.std,2)-5));
-  semilogy(d.std(:,iabscissa), d.std(:,6:end), '-'); hold on; 
-  if 11 < 3  % max and min std
+subplot(2,2,4); hold off;
+% semilogy(d.std(:,iabscissa), d.std(:,6:end), 'k-'); hold on;
+% remove sigma from stds
+d.std(:,6:end) = d.std(:,6:end) ./ (d.std(:,3) * ones(1,size(d.std,2)-5));
+semilogy(d.std(:,iabscissa), d.std(:,6:end), '-'); hold on;
+if 11 < 3  % max and min std
     semilogy(d.std(:,iabscissa), [d.std(:,3).*max(d.std(:,6:end)')' ...
                         d.std(:,3).*min(d.std(:,6:end)')'], '-m', 'linewidth', 2);
     maxval = max(d.std(end,6:end));
     minval = min(d.std(end,6:end));
     text(d.std(end,iabscissa), d.std(end,3)*maxval, sprintf('max=%.0e', maxval));
     text(d.std(end,iabscissa), d.std(end,3)*minval, sprintf('min=%.0e', minval));
-  end
-  ax = axis;
-  ax(2) = max(minxend, ax(2)); 
-  axis(ax);
-  % add some annotation lines
-  [ignore idx] = sort(d.std(end,6:end));
-  % choose no more than 25 indices 
-  idxs = round(linspace(1, size(d.x,2)-5, min(size(d.x,2)-5, 25))); 
-  yy = repmat(NaN, 2, size(d.std,2)-5);
-  yy(1,:) = d.std(end, 6:end);
-  yy(2,idx(idxs)) = logspace(log10(ax(3)), log10(ax(4)), length(idxs));
-  semilogy([d.std(end,iabscissa) ax(2)], yy, '-'); 
-  semilogy(repmat(d.std(end,iabscissa),2), [ax(3) ax(4)], 'k-');
-  for i = idx(idxs)
+end
+ax = axis;
+ax(2) = max(minxend, ax(2));
+axis(ax);
+% add some annotation lines
+[ignore, idx] = sort(d.std(end,6:end));
+% choose no more than 25 indices
+idxs = round(linspace(1, size(d.x,2)-5, min(size(d.x,2)-5, 25)));
+yy = repmat(NaN, 2, size(d.std,2)-5);
+yy(1,:) = d.std(end, 6:end);
+yy(2,idx(idxs)) = logspace(log10(ax(3)), log10(ax(4)), length(idxs));
+semilogy([d.std(end,iabscissa) ax(2)], yy, '-');
+semilogy(repmat(d.std(end,iabscissa),2), [ax(3) ax(4)], 'k-');
+for i = idx(idxs)
     text(ax(2), yy(2,i), [' ' num2str(i)]);
-  end
-  title('Standard Deviations in Coordinates divided by sigma');grid on;
-  xlabel(xlab);
+end
+title('Standard Deviations in Coordinates divided by sigma');grid on;
+xlabel(xlab);
 
-  if figNb ~= 324
+if figNb ~= 324
     % zoom on;  % does not work in Octave
-  end
-  drawnow;
+end
+drawnow;
 
-% ---------------------------------------------------------------  
-% --------------- TEST OBJECTIVE FUNCTIONS ----------------------  
-% ---------------------------------------------------------------  
+% ---------------------------------------------------------------
+% --------------- TEST OBJECTIVE FUNCTIONS ----------------------
+% ---------------------------------------------------------------
 
 %%% Unimodal functions
 
@@ -2337,652 +2337,652 @@ function f=fjens1(x)
 %
 % use population size about 2*N
 %
-  f = sum((x>0) .* x.^1, 1);
-  if any(any(x<0))
+f = sum((x>0) .* x.^1, 1);
+if any(any(x<0))
     idx = sum(x < 0, 1) > 0;
     f(idx) = 1e3;
-%    f = f + 1e3 * sum(x<0, 1);
-%    f = f + 10 * sum((x<0) .* x.^2, 1);
+    %    f = f + 1e3 * sum(x<0, 1);
+    %    f = f + 10 * sum((x<0) .* x.^2, 1);
     f(idx) = f(idx) + 1e-3*abs(randn(1,sum(idx)));
-%    f(idx) = NaN;
-  end
+    %    f(idx) = NaN;
+end
 
 function f=fsphere(x)
-  f = sum(x.^2,1);
+f = sum(x.^2,1);
 
 function f=fmax(x)
-  f = max(abs(x), [], 1);
+f = max(abs(x), [], 1);
 
 function f=fssphere(x)
-  f=sqrt(sum(x.^2, 1));
+f=sqrt(sum(x.^2, 1));
 
-%  lb = -0.512; ub = 512; 
-%  xfeas = x; 
+%  lb = -0.512; ub = 512;
+%  xfeas = x;
 %  xfeas(x<lb) = lb;
-%  xfeas(x>ub) = ub; 
+%  xfeas(x>ub) = ub;
 %  f=sum(xfeas.^2, 1);
-%  f = f + 1e-9 * sum((xfeas-x).^2); 
-  
+%  f = f + 1e-9 * sum((xfeas-x).^2);
+
 function f=fspherenoise(x, Nevals)
-  if nargin < 2 || isempty(Nevals)
+if nargin < 2 || isempty(Nevals)
     Nevals = 1;
-  end
-  [N,popsi] = size(x);
+end
+[N,popsi] = size(x);
 %  x = x .* (1 +  0.3e-0 * randn(N, popsi)/(2*N)); % actuator noise
-  fsum = 10.^(0*(0:N-1)/(N-1)) * x.^2; 
+fsum = 10.^(0*(0:N-1)/(N-1)) * x.^2;
 %  f = 0*rand(1,1) ...
 %      + fsum ...
 %      + fsum .* (2*randn(1,popsi) ./ randn(1,popsi).^0 / (2*N)) ...
-%      + 1*fsum.^0.9 .* 2*randn(1,popsi) / (2*N); % 
+%      + 1*fsum.^0.9 .* 2*randn(1,popsi) / (2*N); %
 
 %  f = fsum .* exp(0.1*randn(1,popsi));
-  f = fsum .* (1 + (10/(N+10)/sqrt(Nevals))*randn(1,popsi));
+f = fsum .* (1 + (10/(N+10)/sqrt(Nevals))*randn(1,popsi));
 %  f = fsum .* (1 + (0.1/N)*randn(1,popsi)./randn(1,popsi).^1);
 
-  idx = rand(1,popsi) < 0.0;
-  if sum(idx) > 0
+idx = rand(1,popsi) < 0.0;
+if sum(idx) > 0
     f(idx) = f(idx) + 1e3*exp(randn(1,sum(idx)));
-  end
-  
+end
+
 function f=fmixranks(x)
-  N = size(x,1);
-  f=(10.^(0*(0:(N-1))/(N-1))*x.^2).^0.5;
-  if size(x, 2) > 1 % compute ranks, if it is a population 
+N = size(x,1);
+f=(10.^(0*(0:(N-1))/(N-1))*x.^2).^0.5;
+if size(x, 2) > 1 % compute ranks, if it is a population
     [ignore, idx] = sort(f);
     [ignore, ranks] = sort(idx);
     k = 9; % number of solutions randomly permuted, lambda/2-1
            % works still quite well (two time slower)
     for i = k+1:k-0:size(x,2)
-      idx(i-k+(1:k)) = idx(i-k+randperm(k)); 
+        idx(i-k+(1:k)) = idx(i-k+randperm(k));
     end
     %disp([ranks' f'])
     [ignore, ranks] = sort(idx);
     %disp([ranks' f'])
     %pause
     f = ranks+1e-9*randn(1,1);
-  end
-  
+end
+
 function f = fsphereoneax(x)
-  f = x(1)^2;
-  f = mean(x)^2;
-  
+f = x(1)^2;
+f = mean(x)^2;
+
 function f=frandsphere(x)
-  N = size(x,1);
-  idx = ceil(N*rand(7,1));
-  f=sum(x(idx).^2);
+N = size(x,1);
+idx = ceil(N*rand(7,1));
+f=sum(x(idx).^2);
 
 function f=fspherelb0(x, M) % lbound at zero for 1:M needed
-  if nargin < 2 M = 0; end
-  N = size(x,1);
-  % M active bounds, f_i = 1 for x = 0
-  f = -M + sum((x(1:M) + 1).^2);
-  f = f + sum(x(M+1:N).^2);
-  
+if nargin < 2 M = 0; end
+N = size(x,1);
+% M active bounds, f_i = 1 for x = 0
+f = -M + sum((x(1:M) + 1).^2);
+f = f + sum(x(M+1:N).^2);
+
 function f=fspherehull(x)
-  % Patton, Dexter, Goodman, Punch
-  % in -500..500
-  % spherical ridge through zeros(N,1)
-  % worst case start point seems x = 2*100*sqrt(N)
-  % and small step size
-  N = size(x,1);
-  f = norm(x) + (norm(x-100*sqrt(N)) - 100*N)^2;
-  
+% Patton, Dexter, Goodman, Punch
+% in -500..500
+% spherical ridge through zeros(N,1)
+% worst case start point seems x = 2*100*sqrt(N)
+% and small step size
+N = size(x,1);
+f = norm(x) + (norm(x-100*sqrt(N)) - 100*N)^2;
+
 function f=fellilb0(x, idxM, scal) % lbound at zero for 1:M needed
-  N = size(x,1);
-  if nargin < 3 || isempty(scal)
+N = size(x,1);
+if nargin < 3 || isempty(scal)
     scal = 100;
-  end
-  scale=scal.^((0:N-1)/(N-1));
-  if nargin < 2 || isempty(idxM)
+end
+scale=scal.^((0:N-1)/(N-1));
+if nargin < 2 || isempty(idxM)
     idxM = 1:N;
-  end
-  %scale(N) = 1e0;
-  % M active bounds
-  xopt = 0.1;
-  x(idxM) = x(idxM) + xopt;
-  f = scale.^2*x.^2;
-  f = f - sum((xopt*scale(idxM)).^2); 
+end
+%scale(N) = 1e0;
+% M active bounds
+xopt = 0.1;
+x(idxM) = x(idxM) + xopt;
+f = scale.^2*x.^2;
+f = f - sum((xopt*scale(idxM)).^2);
 %  f = exp(f) - 1;
 %  f = log10(f+1e-19) + 19;
 
-  f = f + 1e-19;
-  
+f = f + 1e-19;
+
 function f=fcornersphere(x)
-  w = ones(size(x,1));
-  w(1) = 2.5; w(2)=2.5;
-  idx = x < 0;
-  f = sum(x(idx).^2);
-  idx = x > 0;
-  f = f + 2^2*sum(w(idx).*x(idx).^2);
-  
+w = ones(size(x,1));
+w(1) = 2.5; w(2)=2.5;
+idx = x < 0;
+f = sum(x(idx).^2);
+idx = x > 0;
+f = f + 2^2*sum(w(idx).*x(idx).^2);
+
 function f=fsectorsphere(x, scal)
 %
 % This is deceptive for cumulative sigma control CSA in large dimension:
 % The strategy (initially) diverges for N=50 and popsize = 150.  (Even
 % for cs==1 this can be observed for larger settings of N and
-% popsize.) The reason is obvious from the function topology. 
+% popsize.) The reason is obvious from the function topology.
 % Divergence can be avoided by setting boundaries or adding a
-% penalty for large ||x||. Then, convergence can be observed again. 
+% penalty for large ||x||. Then, convergence can be observed again.
 % Conclusion: for popsize>N cumulative sigma control is not completely
 % reasonable, but I do not know better alternatives. In particular:
-% TPA takes longer to converge than CSA when the latter still works. 
+% TPA takes longer to converge than CSA when the latter still works.
 %
-  if nargin < 2 || isempty (scal)
+if nargin < 2 || isempty (scal)
     scal = 1e3;
-  end
-  f=sum(x.^2,1);
-  idx = x<0;
-  f = f + (scal^2 - 1) * sum((idx.*x).^2,1);
-  if 11 < 3
+end
+f=sum(x.^2,1);
+idx = x<0;
+f = f + (scal^2 - 1) * sum((idx.*x).^2,1);
+if 11 < 3
     idxpen = find(f>1e9);
     if ~isempty(idxpen)
-      f(idxpen) = f(idxpen) + 1e8*sum(x(:,idxpen).^2,1);
+        f(idxpen) = f(idxpen) + 1e8*sum(x(:,idxpen).^2,1);
     end
-  end
-  
+end
+
 function f=fstepsphere(x, scal)
-  if nargin < 2 || isempty (scal)
+if nargin < 2 || isempty (scal)
     scal = 1e0;
-  end
-  N = size(x,1);
-  f=1e-11+sum(scal.^((0:N-1)/(N-1))*floor(x+0.5).^2);
-  f=1e-11+sum(floor(scal.^((0:N-1)/(N-1))'.*x+0.5).^2);
+end
+N = size(x,1);
+f=1e-11+sum(scal.^((0:N-1)/(N-1))*floor(x+0.5).^2);
+f=1e-11+sum(floor(scal.^((0:N-1)/(N-1))'.*x+0.5).^2);
 %  f=1e-11+sum(floor(x+0.5).^2);
 
 function f=fstep(x)
-  % in -5.12..5.12 (bounded)
-  N = size(x,1);
-  f=1e-11+6*N+sum(floor(x));
+% in -5.12..5.12 (bounded)
+N = size(x,1);
+f=1e-11+6*N+sum(floor(x));
 
 function f=flnorm(x, scal, e)
 if nargin < 2 || isempty(scal)
-  scal = 1;
+    scal = 1;
 end
 if nargin < 3 || isempty(e)
-  e = 1;
+    e = 1;
 end
 if e==inf
-  f = max(abs(x));
+    f = max(abs(x));
 else
-  N = size(x,1);
-  scale = scal.^((0:N-1)/(N-1))';
-  f=sum(abs(scale.*x).^e);
+    N = size(x,1);
+    scale = scal.^((0:N-1)/(N-1))';
+    f=sum(abs(scale.*x).^e);
 end
 
-function f=fneumaier3(x) 
-  % in -n^2..n^2
-  % x^*-i = i(n+1-i)
-  N = size(x,1);
+function f=fneumaier3(x)
+% in -n^2..n^2
+% x^*-i = i(n+1-i)
+N = size(x,1);
 %  f = N*(N+4)*(N-1)/6 + sum((x-1).^2) - sum(x(1:N-1).*x(2:N));
-  f = sum((x-1).^2) - sum(x(1:N-1).*x(2:N));
+f = sum((x-1).^2) - sum(x(1:N-1).*x(2:N));
 
 function f = fmaxmindist(y)
-  % y in [-1,1], y(1:2) is first point on a plane, y(3:4) second etc
-  % points best
-  %   5    1.4142
-  %   8    1.03527618 
-  %  10    0.842535997 
-  %  20    0.5997   
-  pop = size(y,2);
-  N = size(y,1)/2;
-  f = []; 
-  for ipop = 1:pop
+% y in [-1,1], y(1:2) is first point on a plane, y(3:4) second etc
+% points best
+%   5    1.4142
+%   8    1.03527618
+%  10    0.842535997
+%  20    0.5997
+pop = size(y,2);
+N = size(y,1)/2;
+f = [];
+for ipop = 1:pop
     if any(abs(y(:,ipop)) > 1)
-      f(ipop) = NaN; 
+        f(ipop) = NaN;
     else
-      x = reshape(y(:,ipop), [2, N]);
-      f(ipop) = inf;
-      for i = 1:N
-        f(ipop) = min(f(ipop), min(sqrt(sum((x(:,[1:i-1 i+1:N]) - repmat(x(:,i), 1, N-1)).^2, 1))));
-      end
+        x = reshape(y(:,ipop), [2, N]);
+        f(ipop) = inf;
+        for i = 1:N
+            f(ipop) = min(f(ipop), min(sqrt(sum((x(:,[1:i-1 i+1:N]) - repmat(x(:,i), 1, N-1)).^2, 1))));
+        end
     end
-  end
-  f = -f;
+end
+f = -f;
 
 function f=fchangingsphere(x)
-  N = size(x,1);
-  global scale_G; global count_G; if isempty(count_G) count_G=-1; end
-  count_G = count_G+1;
-  if mod(count_G,10) == 0
+N = size(x,1);
+global scale_G; global count_G; if isempty(count_G) count_G=-1; end
+count_G = count_G+1;
+if mod(count_G,10) == 0
     scale_G = 10.^(2*rand(1,N));
-  end
-  %disp(scale(1));
-  f = scale_G*x.^2;
-  
+end
+%disp(scale(1));
+f = scale_G*x.^2;
+
 function f= flogsphere(x)
- f = 1-exp(-sum(x.^2));
-  
+f = 1-exp(-sum(x.^2));
+
 function f= fexpsphere(x)
- f = exp(sum(x.^2)) - 1;
-  
+f = exp(sum(x.^2)) - 1;
+
 function f=fbaluja(x)
-  % in [-0.16 0.16]
-  y = x(1);
-  for i = 2:length(x)
+% in [-0.16 0.16]
+y = x(1);
+for i = 2:length(x)
     y(i) = x(i) + y(i-1);
-  end
-  f = 1e5 - 1/(1e-5 + sum(abs(y)));
+end
+f = 1e5 - 1/(1e-5 + sum(abs(y)));
 
 function f=fschwefel(x)
-  f = 0;
-  for i = 1:size(x,1),
+f = 0;
+for i = 1:size(x,1)
     f = f+sum(x(1:i))^2;
-  end
+end
 
 function f=fcigar(x, ar)
-  if nargin < 2 || isempty(ar)
+if nargin < 2 || isempty(ar)
     ar = 1e3;
-  end
-  f = x(1,:).^2 + ar^2*sum(x(2:end,:).^2,1);
-  
+end
+f = x(1,:).^2 + ar^2*sum(x(2:end,:).^2,1);
+
 function f=fcigtab(x)
-  f = x(1,:).^2 + 1e8*x(end,:).^2 + 1e4*sum(x(2:(end-1),:).^2, 1);
-  
+f = x(1,:).^2 + 1e8*x(end,:).^2 + 1e4*sum(x(2:(end-1),:).^2, 1);
+
 function f=ftablet(x)
-  f = 1e6*x(1,:).^2 + sum(x(2:end,:).^2, 1);
+f = 1e6*x(1,:).^2 + sum(x(2:end,:).^2, 1);
 
 function f=felli(x, lgscal, expon, expon2)
-  % lgscal: log10(axis ratio)
-  % expon: x_i^expon, sphere==2
-  N = size(x,1); if N < 2 error('dimension must be greater one'); end
+% lgscal: log10(axis ratio)
+% expon: x_i^expon, sphere==2
+N = size(x,1); if N < 2 error('dimension must be greater one'); end
 
 %  x = x - repmat(-0.5+(1:N)',1,size(x,2)); % optimum in 1:N
-  if nargin < 2 || isempty(lgscal), lgscal = 3; end
-  if nargin < 3 || isempty(expon), expon = 2; end
-  if nargin < 4 || isempty(expon2), expon2 = 1; end
+if nargin < 2 || isempty(lgscal), lgscal = 3; end
+if nargin < 3 || isempty(expon), expon = 2; end
+if nargin < 4 || isempty(expon2), expon2 = 1; end
 
-  f=((10^(lgscal*expon)).^((0:N-1)/(N-1)) * abs(x).^expon).^(1/expon2);
+f=((10^(lgscal*expon)).^((0:N-1)/(N-1)) * abs(x).^expon).^(1/expon2);
 %  if rand(1,1) > 0.015
 %    f = NaN;
 %  end
 %  f = f + randn(size(f));
 
 function f=fellitest(x)
-  beta = 0.9;
-  N = size(x,1);
-  f = (1e6.^((0:(N-1))/(N-1))).^beta * (x.^2).^beta; 
+beta = 0.9;
+N = size(x,1);
+f = (1e6.^((0:(N-1))/(N-1))).^beta * (x.^2).^beta;
+
 
-  
 function f=fellii(x, scal)
-  N = size(x,1); if N < 2 error('dimension must be greater one'); end
-  if nargin < 2
+N = size(x,1); if N < 2 error('dimension must be greater one'); end
+if nargin < 2
     scal = 1;
-  end
-  f= (scal*(1:N)).^2 * (x).^2;
+end
+f= (scal*(1:N)).^2 * (x).^2;
 
 function f=fellirot(x)
-  N = size(x,1);
-  global ORTHOGONALCOORSYSTEM_G
-  if isempty(ORTHOGONALCOORSYSTEM_G) ...
-	|| length(ORTHOGONALCOORSYSTEM_G) < N ...
-	|| isempty(ORTHOGONALCOORSYSTEM_G{N})
+N = size(x,1);
+global ORTHOGONALCOORSYSTEM_G
+if isempty(ORTHOGONALCOORSYSTEM_G) ...
+        || length(ORTHOGONALCOORSYSTEM_G) < N ...
+        || isempty(ORTHOGONALCOORSYSTEM_G{N})
     coordinatesystem(N);
-  end
-  f = felli(ORTHOGONALCOORSYSTEM_G{N}*x);
-  
+end
+f = felli(ORTHOGONALCOORSYSTEM_G{N}*x);
+
 function f=frot(x, fun, varargin)
-  N = size(x,1);
-  global ORTHOGONALCOORSYSTEM_G
-  if isempty(ORTHOGONALCOORSYSTEM_G) ...
-	|| length(ORTHOGONALCOORSYSTEM_G) < N ...
-	|| isempty(ORTHOGONALCOORSYSTEM_G{N})
+N = size(x,1);
+global ORTHOGONALCOORSYSTEM_G
+if isempty(ORTHOGONALCOORSYSTEM_G) ...
+        || length(ORTHOGONALCOORSYSTEM_G) < N ...
+        || isempty(ORTHOGONALCOORSYSTEM_G{N})
     coordinatesystem(N);
-  end
-  f = feval(fun, ORTHOGONALCOORSYSTEM_G{N}*x, varargin{:});
-  
+end
+f = feval(fun, ORTHOGONALCOORSYSTEM_G{N}*x, varargin{:});
+
 function coordinatesystem(N)
-  if nargin < 1 || isempty(N)
+if nargin < 1 || isempty(N)
     arN = 2:30;
-  else
+else
     arN = N;
-  end
-  global ORTHOGONALCOORSYSTEM_G
-  ORTHOGONALCOORSYSTEM_G{1} = 1; 
-  for N = arN
+end
+global ORTHOGONALCOORSYSTEM_G
+ORTHOGONALCOORSYSTEM_G{1} = 1;
+for N = arN
     ar = randn(N,N);
-    for i = 1:N 
-      for j = 1:i-1
-	ar(:,i) = ar(:,i) - ar(:,i)'*ar(:,j) * ar(:,j);
-      end
-      ar(:,i) = ar(:,i) / norm(ar(:,i));
+    for i = 1:N
+        for j = 1:i-1
+            ar(:,i) = ar(:,i) - ar(:,i)'*ar(:,j) * ar(:,j);
+        end
+        ar(:,i) = ar(:,i) / norm(ar(:,i));
     end
-    ORTHOGONALCOORSYSTEM_G{N} = ar; 
-  end
+    ORTHOGONALCOORSYSTEM_G{N} = ar;
+end
 
 function f=fplane(x)
-  f=x(1);
+f=x(1);
 
 function f=ftwoaxes(x)
-  f = sum(x(1:floor(end/2),:).^2, 1) + 1e6*sum(x(floor(1+end/2):end,:).^2, 1);
+f = sum(x(1:floor(end/2),:).^2, 1) + 1e6*sum(x(floor(1+end/2):end,:).^2, 1);
 
 function f=fparabR(x)
-  f = -x(1,:) + 100*sum(x(2:end,:).^2,1);
+f = -x(1,:) + 100*sum(x(2:end,:).^2,1);
 
 function f=fsharpR(x)
-  f = abs(-x(1, :)).^2 + 100 * sqrt(sum(x(2:end,:).^2, 1));
-  
+f = abs(-x(1, :)).^2 + 100 * sqrt(sum(x(2:end,:).^2, 1));
+
 function f=frosen(x)
-  if size(x,1) < 2 error('dimension must be greater one'); end
-  N = size(x,1); 
-  popsi = size(x,2); 
-  f = 1e2*sum((x(1:end-1,:).^2 - x(2:end,:)).^2,1) + sum((x(1:end-1,:)-1).^2,1);
-  % f = f + f^0.9 .* (2*randn(1,popsi) ./ randn(1,popsi).^0 / (2*N)); 
+if size(x,1) < 2, error('dimension must be greater one'); end
+N = size(x,1);
+popsi = size(x,2);
+f = 1e2*sum((x(1:end-1,:).^2 - x(2:end,:)).^2,1) + sum((x(1:end-1,:)-1).^2,1);
+% f = f + f^0.9 .* (2*randn(1,popsi) ./ randn(1,popsi).^0 / (2*N));
 
 function f=frosenlin(x)
-  if size(x,1) < 2 error('dimension must be greater one'); end
+if size(x,1) < 2 error('dimension must be greater one'); end
 
-  x_org = x;
-  x(x>30) = 30;
-  x(x<-30) = -30;
+x_org = x;
+x(x>30) = 30;
+x(x<-30) = -30;
 
-  f = 1e2*sum(-(x(1:end-1,:).^2 - x(2:end,:)),1) + ...
-      sum((x(1:end-1,:)-1).^2,1);
+f = 1e2*sum(-(x(1:end-1,:).^2 - x(2:end,:)),1) + ...
+    sum((x(1:end-1,:)-1).^2,1);
 
-  f = f + sum((x-x_org).^2,1);
-%  f(any(abs(x)>30,1)) = NaN; 
+f = f + sum((x-x_org).^2,1);
+%  f(any(abs(x)>30,1)) = NaN;
 
 function f=frosenrot(x)
-  N = size(x,1);
-  global ORTHOGONALCOORSYSTEM_G
-  if isempty(ORTHOGONALCOORSYSTEM_G) ...
-	|| length(ORTHOGONALCOORSYSTEM_G) < N ...
-	|| isempty(ORTHOGONALCOORSYSTEM_G{N})
+N = size(x,1);
+global ORTHOGONALCOORSYSTEM_G
+if isempty(ORTHOGONALCOORSYSTEM_G) ...
+        || length(ORTHOGONALCOORSYSTEM_G) < N ...
+        || isempty(ORTHOGONALCOORSYSTEM_G{N})
     coordinatesystem(N);
-  end
-  f = frosen(ORTHOGONALCOORSYSTEM_G{N}*x);
+end
+f = frosen(ORTHOGONALCOORSYSTEM_G{N}*x);
 
 function f=frosenmodif(x)
-  f = 74 + 100*(x(2)-x(1)^2)^2 + (1-x(1))^2 ...
-      - 400*exp(-sum((x+1).^2)/2/0.05);
-  
+f = 74 + 100*(x(2)-x(1)^2)^2 + (1-x(1))^2 ...
+    - 400*exp(-sum((x+1).^2)/2/0.05);
+
 function f=fschwefelrosen1(x)
-  % in [-10 10] 
-  f=sum((x.^2-x(1)).^2 + (x-1).^2);
-  
+% in [-10 10]
+f=sum((x.^2-x(1)).^2 + (x-1).^2);
+
 function f=fschwefelrosen2(x)
-  % in [-10 10] 
-  f=sum((x(2:end).^2-x(1)).^2 + (x(2:end)-1).^2);
+% in [-10 10]
+f=sum((x(2:end).^2-x(1)).^2 + (x(2:end)-1).^2);
 
 function f=fdiffpow(x)
-  [N popsi] = size(x); if N < 2 error('dimension must be greater one'); end
+[N, popsi] = size(x); if N < 2 error('dimension must be greater one'); end
 
-  f = sum(abs(x).^repmat(2+10*(0:N-1)'/(N-1), 1, popsi), 1);
-  f = sqrt(f); 
+f = sum(abs(x).^repmat(2+10*(0:N-1)'/(N-1), 1, popsi), 1);
+f = sqrt(f);
 
 function f=fabsprod(x)
-  f = sum(abs(x),1) + prod(abs(x),1);
+f = sum(abs(x),1) + prod(abs(x),1);
 
 function f=ffloor(x)
-  f = sum(floor(x+0.5).^2,1); 
+f = sum(floor(x+0.5).^2,1);
 
 function f=fmaxx(x)
-  f = max(abs(x), [], 1);
+f = max(abs(x), [], 1);
 
-%%% Multimodal functions 
+%%% Multimodal functions
 
 function f=fbirastrigin(x)
-% todo: the volume needs to be a constant 
-  N = size(x,1); 
-  idx = (sum(x, 1) < 0.5*N); % global optimum
-  f = zeros(1,size(x,2));
-  f(idx) = 10*(N-sum(cos(2*pi*x(:,idx)),1)) + sum(x(:,idx).^2,1); 
-  idx = ~idx;
-  f(idx) = 0.1 + 10*(N-sum(cos(2*pi*(x(:,idx)-2)),1)) + sum((x(:,idx)-2).^2,1); 
+% todo: the volume needs to be a constant
+N = size(x,1);
+idx = (sum(x, 1) < 0.5*N); % global optimum
+f = zeros(1,size(x,2));
+f(idx) = 10*(N-sum(cos(2*pi*x(:,idx)),1)) + sum(x(:,idx).^2,1);
+idx = ~idx;
+f(idx) = 0.1 + 10*(N-sum(cos(2*pi*(x(:,idx)-2)),1)) + sum((x(:,idx)-2).^2,1);
 
 function f=fackley(x)
-  % -32.768..32.768
-  % Adding a penalty outside the interval is recommended,  
-  % because for large step sizes, fackley imposes like frand
-  % 
-  N = size(x,1); 
-  f = 20-20*exp(-0.2*sqrt(sum(x.^2)/N)); 
-  f = f + (exp(1) - exp(sum(cos(2*pi*x))/N));
-  % add penalty outside the search interval
-  f = f + sum((x(x>32.768)-32.768).^2) + sum((x(x<-32.768)+32.768).^2);
-  
+% -32.768..32.768
+% Adding a penalty outside the interval is recommended,
+% because for large step sizes, fackley imposes like frand
+%
+N = size(x,1);
+f = 20-20*exp(-0.2*sqrt(sum(x.^2)/N));
+f = f + (exp(1) - exp(sum(cos(2*pi*x))/N));
+% add penalty outside the search interval
+f = f + sum((x(x>32.768)-32.768).^2) + sum((x(x<-32.768)+32.768).^2);
+
 function f = fbohachevsky(x)
- % -15..15
-  f = sum(x(1:end-1).^2 + 2 * x(2:end).^2 - 0.3 * cos(3*pi*x(1:end-1)) ...
-	  - 0.4 * cos(4*pi*x(2:end)) + 0.7);
-  
+% -15..15
+f = sum(x(1:end-1).^2 + 2 * x(2:end).^2 - 0.3 * cos(3*pi*x(1:end-1)) ...
+        - 0.4 * cos(4*pi*x(2:end)) + 0.7);
+
 function f=fconcentric(x)
-  % in  +-600
-  s = sum(x.^2);
-  f = s^0.25 * (sin(50*s^0.1)^2 + 1);
+% in  +-600
+s = sum(x.^2);
+f = s^0.25 * (sin(50*s^0.1)^2 + 1);
 
 function f=fgriewank(x)
-  % in [-600 600]
-  [N, P] = size(x);
-  f = 1 - prod(cos(x'./sqrt(1:N))) + sum(x.^2)/4e3;
-  scale = repmat(sqrt(1:N)', 1, P);
-  f = 1 - prod(cos(x./scale), 1) + sum(x.^2, 1)/4e3;
-  % f = f + 1e4*sum(x(abs(x)>5).^2);
-  % if sum(x(abs(x)>5).^2) > 0
-  %   f = 1e4 * sum(x(abs(x)>5).^2) + 1e8 * sum(x(x>5)).^2;
-  % end
+% in [-600 600]
+[N, P] = size(x);
+f = 1 - prod(cos(x'./sqrt(1:N))) + sum(x.^2)/4e3;
+scale = repmat(sqrt(1:N)', 1, P);
+f = 1 - prod(cos(x./scale), 1) + sum(x.^2, 1)/4e3;
+% f = f + 1e4*sum(x(abs(x)>5).^2);
+% if sum(x(abs(x)>5).^2) > 0
+%   f = 1e4 * sum(x(abs(x)>5).^2) + 1e8 * sum(x(x>5)).^2;
+% end
 
 function f=fgriewrosen(x)
 % F13 or F8F2
-  [N, P] = size(x);
-  scale = repmat(sqrt(1:N)', 1, P);
-  y = [x(2:end,:); x(1,:)];
-  x = 100 * (x.^2 - y) + (x - 1).^2;  % Rosenbrock part
-  f = 1 - prod(cos(x./scale), 1) + sum(x.^2, 1)/4e3;
-  f = sum(1 - cos(x) + x.^2/4e3, 1);
+[N, P] = size(x);
+scale = repmat(sqrt(1:N)', 1, P);
+y = [x(2:end,:); x(1,:)];
+x = 100 * (x.^2 - y) + (x - 1).^2;  % Rosenbrock part
+f = 1 - prod(cos(x./scale), 1) + sum(x.^2, 1)/4e3;
+f = sum(1 - cos(x) + x.^2/4e3, 1);
 
 function f=fspallpseudorastrigin(x, scal, skewfac, skewstart, amplitude)
 % by default multi-modal about between -30 and 30
-  if nargin < 5 || isempty(amplitude)
+if nargin < 5 || isempty(amplitude)
     amplitude = 40;
-  end
-  if nargin < 4 || isempty(skewstart)
+end
+if nargin < 4 || isempty(skewstart)
     skewstart = 0;
-  end
-  if nargin < 3 || isempty(skewfac)
+end
+if nargin < 3 || isempty(skewfac)
     skewfac = 1;
-  end
-  if nargin < 2 || isempty(scal)
+end
+if nargin < 2 || isempty(scal)
     scal = 1;
-  end
-  N = size(x,1); 
-  scale = 1;
-  if N > 1
-    scale=scal.^((0:N-1)'/(N-1)); 
-  end
-  % simple version: 
-  % f = amplitude*(N - sum(cos(2*pi*(scale.*x)))) + sum((scale.*x).^2);
+end
+N = size(x,1);
+scale = 1;
+if N > 1
+    scale=scal.^((0:N-1)'/(N-1));
+end
+% simple version:
+% f = amplitude*(N - sum(cos(2*pi*(scale.*x)))) + sum((scale.*x).^2);
 
-  % skew version: 
-  y = repmat(scale, 1, size(x,2)) .* x;
-  idx = find(x > skewstart);
-  if ~isempty(idx)
+% skew version:
+y = repmat(scale, 1, size(x,2)) .* x;
+idx = find(x > skewstart);
+if ~isempty(idx)
     y(idx) =  skewfac*y(idx);
-  end
-  f = amplitude * (0*N-prod(cos((2*pi)^0*y),1)) + 0.05 * sum(y.^2,1) ...
-      + randn(1,1);
+end
+f = amplitude * (0*N-prod(cos((2*pi)^0*y),1)) + 0.05 * sum(y.^2,1) ...
+    + randn(1,1);
 
 function f=frastrigin(x, scal, skewfac, skewstart, amplitude)
 % by default multi-modal about between -30 and 30
-  if nargin < 5 || isempty(amplitude)
+if nargin < 5 || isempty(amplitude)
     amplitude = 10;
-  end
-  if nargin < 4 || isempty(skewstart)
+end
+if nargin < 4 || isempty(skewstart)
     skewstart = 0;
-  end
-  if nargin < 3 || isempty(skewfac)
+end
+if nargin < 3 || isempty(skewfac)
     skewfac = 1;
-  end
-  if nargin < 2 || isempty(scal)
+end
+if nargin < 2 || isempty(scal)
     scal = 1;
-  end
-  N = size(x,1); 
-  scale = 1;
-  if N > 1
-    scale=scal.^((0:N-1)'/(N-1)); 
-  end
-  % simple version: 
-  % f = amplitude*(N - sum(cos(2*pi*(scale.*x)))) + sum((scale.*x).^2);
+end
+N = size(x,1);
+scale = 1;
+if N > 1
+    scale=scal.^((0:N-1)'/(N-1));
+end
+% simple version:
+% f = amplitude*(N - sum(cos(2*pi*(scale.*x)))) + sum((scale.*x).^2);
 
-  % skew version: 
-  y = repmat(scale, 1, size(x,2)) .* x;
-  idx = find(x > skewstart);
-  % idx = intersect(idx, 2:2:10); 
-  if ~isempty(idx)
+% skew version:
+y = repmat(scale, 1, size(x,2)) .* x;
+idx = find(x > skewstart);
+% idx = intersect(idx, 2:2:10);
+if ~isempty(idx)
     y(idx) =  skewfac*y(idx);
-  end
-  f = amplitude * (N-sum(cos(2*pi*y),1)) + sum(y.^2,1);
-  
+end
+f = amplitude * (N-sum(cos(2*pi*y),1)) + sum(y.^2,1);
+
 function f=frastriginmax(x)
-  N = size(x,1);
-  f = (N/20)*807.06580387678 - (10 * (N-sum(cos(2*pi*x),1)) + sum(x.^2,1));
-  f(any(abs(x) > 5.12)) = 1e2*N;
+N = size(x,1);
+f = (N/20)*807.06580387678 - (10 * (N-sum(cos(2*pi*x),1)) + sum(x.^2,1));
+f(any(abs(x) > 5.12)) = 1e2*N;
 
 function f = fschaffer(x)
- % -100..100
-  N = size(x,1);
-  s = x(1:N-1,:).^2 + x(2:N,:).^2;
-  f = sum(s.^0.25 .* (sin(50*s.^0.1).^2+1), 1);
+% -100..100
+N = size(x,1);
+s = x(1:N-1,:).^2 + x(2:N,:).^2;
+f = sum(s.^0.25 .* (sin(50*s.^0.1).^2+1), 1);
 
 function f=fschwefelmult(x)
-  % -500..500
-  % 
-  N = size(x,1); 
-  f = - sum(x.*sin(sqrt(abs(x))), 1);
-  f = 418.9829*N - 1.27275661e-5*N - sum(x.*sin(sqrt(abs(x))), 1);
-  % penalty term 
-  f = f + 1e4*sum((abs(x)>500) .* (abs(x)-500).^2, 1);
-  
+% -500..500
+%
+N = size(x,1);
+f = - sum(x.*sin(sqrt(abs(x))), 1);
+f = 418.9829*N - 1.27275661e-5*N - sum(x.*sin(sqrt(abs(x))), 1);
+% penalty term
+f = f + 1e4*sum((abs(x)>500) .* (abs(x)-500).^2, 1);
+
 function f=ftwomax(x)
-  % Boundaries at +/-5
-  N = size(x,1); 
-  f = -abs(sum(x)) + 5*N;
+% Boundaries at +/-5
+N = size(x,1);
+f = -abs(sum(x)) + 5*N;
 
 function f=ftwomaxtwo(x)
-  % Boundaries at +/-10
-  N = size(x,1); 
-  f = abs(sum(x));
-  if f > 30
+% Boundaries at +/-10
+N = size(x,1);
+f = abs(sum(x));
+if f > 30
     f = f - 30;
-  end
-  f = -f;
-  
+end
+f = -f;
+
 function f=frand(x)
-  f=1./(1-rand(1, size(x,2))) - 1;
+f=1./(1-rand(1, size(x,2))) - 1;
 
 % CHANGES
 % 12/02/19: "future" setting of ccum, correcting for large mueff, is default now
 % 11/11/15: bug-fix: max value for ccovmu_sep setting corrected
-% 10/11/11: (3.52.beta) boundary handling: replace max with min in change 
-%           rate formula. Active CMA: check of pos.def. improved. 
-%           Plotting: value of lambda appears in the title. 
+% 10/11/11: (3.52.beta) boundary handling: replace max with min in change
+%           rate formula. Active CMA: check of pos.def. improved.
+%           Plotting: value of lambda appears in the title.
 % 10/04/03: (3.51.beta) active CMA cleaned up. Equal fitness detection
-%           looks into history now. 
+%           looks into history now.
 % 10/03/08: (3.50.beta) "active CMA" revised and bug-fix of ambiguous
-%           option Noise.alpha -> Noise.alphasigma. 
-% 09/10/12: (3.40.beta) a slightly modified version of "active CMA", 
+%           option Noise.alpha -> Noise.alphasigma.
+% 09/10/12: (3.40.beta) a slightly modified version of "active CMA",
 %           that is a negative covariance matrix update, use option
-%           CMA.active. In 10;30;90-D the gain on ftablet is a factor 
-%           of 1.6;2.5;4.4 (the scaling improves by sqrt(N)). On 
-%           Rosenbrock the gain is about 25%. On sharp ridge the 
-%           behavior is improved. Cigar is unchanged. 
-% 09/08/10: local plotcmaesdat remains in backround  
-% 09/08/10: bug-fix in time management for data writing, logtime was not 
-%        considered properly (usually not at all). 
-% 09/07/05: V3.24: stagnation termination added 
+%           CMA.active. In 10;30;90-D the gain on ftablet is a factor
+%           of 1.6;2.5;4.4 (the scaling improves by sqrt(N)). On
+%           Rosenbrock the gain is about 25%. On sharp ridge the
+%           behavior is improved. Cigar is unchanged.
+% 09/08/10: local plotcmaesdat remains in backround
+% 09/08/10: bug-fix in time management for data writing, logtime was not
+%        considered properly (usually not at all).
+% 09/07/05: V3.24: stagnation termination added
 % 08/09/27: V3.23: momentum alignment is out-commented and de-preciated
 % 08/09/25: V3.22: re-alignment of sigma and C was buggy
 % 08/07/15: V3.20, CMA-parameters are options now. ccov and mucov were replaced
 %        by ccov1 \approx ccov/mucov and ccovmu \approx (1-1/mucov)*ccov
-% 08/06/30: file name xrecent was change to xrecentbest (compatible with other 
+% 08/06/30: file name xrecent was change to xrecentbest (compatible with other
 %        versions)
-% 08/06/29: time stamp added to output files 
-% 08/06/28: bug fixed with resume option, commentary did not work 
+% 08/06/29: time stamp added to output files
+% 08/06/28: bug fixed with resume option, commentary did not work
 % 08/06/28: V3.10, uncertainty (noise) handling added (re-implemented), according
 %        to reference "A Method for Handling Uncertainty..." from below.
-% 08/06/28: bug fix: file xrecent was empty 
-% 08/06/01: diagonalonly clean up. >1 means some iterations. 
+% 08/06/28: bug fix: file xrecent was empty
+% 08/06/01: diagonalonly clean up. >1 means some iterations.
 % 08/05/05: output is written to file preventing an increasing data
-%        array and ease long runs. 
-% 08/03/27: DiagonalOnly<0 learns for -DiagonalOnly iterations only the 
-%        diagonal with a larger learning rate. 
-% 08/03 (2.60): option DiagonalOnly>=1 invokes a time- and space-linear  
-%        variant with only diagonal elements of the covariance matrix 
-%        updating.  This can be useful for large dimensions, say > 100. 
+%        array and ease long runs.
+% 08/03/27: DiagonalOnly<0 learns for -DiagonalOnly iterations only the
+%        diagonal with a larger learning rate.
+% 08/03 (2.60): option DiagonalOnly>=1 invokes a time- and space-linear
+%        variant with only diagonal elements of the covariance matrix
+%        updating.  This can be useful for large dimensions, say > 100.
 % 08/02: diag(weights) * ... replaced with repmat(weights,1,N) .* ...
-%        in C update, implies O(mu*N^2) instead of O(mu^2*N + mu*N^2). 
+%        in C update, implies O(mu*N^2) instead of O(mu^2*N + mu*N^2).
 % 07/09: tolhistfun as termination criterion added, "<" changed to
-%        "<=" also for TolFun to allow for stopping on zero difference. 
-%        Name tolfunhist clashes with option tolfun. 
-% 07/07: hsig threshold made slighly smaller for large dimension, 
-%        useful for lambda < lambda_default. 
+%        "<=" also for TolFun to allow for stopping on zero difference.
+%        Name tolfunhist clashes with option tolfun.
+% 07/07: hsig threshold made slighly smaller for large dimension,
+%        useful for lambda < lambda_default.
 % 07/06: boundary handling: scaling in the boundary handling
 %        is omitted now, see bnd.flgscale. This seems not to
 %        have a big impact. Using the scaling is worse on rotated
-%        functions, but better on separable ones. 
+%        functions, but better on separable ones.
 % 07/05: boundary handling: weight i is not incremented anymore
 %        if xmean(i) moves towards the feasible space. Increment
-%        factor changed to 1.2 instead of 1.1. 
+%        factor changed to 1.2 instead of 1.1.
 % 07/05: boundary handling code simplified not changing the algorithm
 % 07/04: bug removed for saving in octave
 % 06/11/10: more testing of outcome of eig, fixed max(D) to max(diag(D))
-% 06/10/21: conclusive final bestever assignment in the end 
+% 06/10/21: conclusive final bestever assignment in the end
 % 06/10/21: restart and incpopsize option implemented for restarts
-%        with increasing population size, version 2.50. 
+%        with increasing population size, version 2.50.
 % 06/09/16: output argument bestever inserted again for convenience and
 %        backward compatibility
-% 06/08: output argument out and struct out reorganized. 
+% 06/08: output argument out and struct out reorganized.
 % 06/01: Possible parallel evaluation included as option EvalParallel
 % 05/11: Compatibility to octave implemented, package octave-forge
-%   is needed. 
+%   is needed.
 % 05/09: Raise of figure and waiting for first plots improved
-% 05/01: Function coordinatesystem cleaned up. 
+% 05/01: Function coordinatesystem cleaned up.
 % 05/01: Function prctile, which requires the statistics toolbox,
-%        replaced by myprctile. 
-% 05/01: Option warnonequalfunctionvalues included. 
-% 04/12: Decrease of sigma removed. Problems on fsectorsphere can 
-%        be addressed better by adding search space boundaries. 
-% 04/12: Boundary handling simpyfied. 
-% 04/12: Bug when stopping criteria tolx or tolupx are vectors. 
-% 04/11: Three input parameters are obligatory now. 
-% 04/11: Bug in boundary handling removed: Boundary weights can decrease now. 
-% 04/11: Normalization for boundary weights scale changed. 
-% 04/11: VerboseModulo option bug removed. Documentation improved. 
+%        replaced by myprctile.
+% 05/01: Option warnonequalfunctionvalues included.
+% 04/12: Decrease of sigma removed. Problems on fsectorsphere can
+%        be addressed better by adding search space boundaries.
+% 04/12: Boundary handling simpyfied.
+% 04/12: Bug when stopping criteria tolx or tolupx are vectors.
+% 04/11: Three input parameters are obligatory now.
+% 04/11: Bug in boundary handling removed: Boundary weights can decrease now.
+% 04/11: Normalization for boundary weights scale changed.
+% 04/11: VerboseModulo option bug removed. Documentation improved.
 % 04/11: Condition for increasing boundary weights changed.
 % 04/10: Decrease of sigma when fitness is getting consistenly
 %        worse. Addresses the problems appearing on fsectorsphere for
 %        large population size.
-% 04/10: VerboseModulo option included. 
+% 04/10: VerboseModulo option included.
 % 04/10: Bug for condition for increasing boundary weights removed.
 % 04/07: tolx depends on initial sigma to achieve scale invariance
-%        for this stopping criterion. 
+%        for this stopping criterion.
 % 04/06: Objective function value NaN is not counted as function
-%        evaluation and invokes resampling of the search point. 
+%        evaluation and invokes resampling of the search point.
 % 04/06: Error handling for eigenvalue beeing zero (never happens
 %        with default parameter setting)
-% 04/05: damps further tuned for large mueff 
-%      o Details for stall of pc-adaptation added (variable hsig 
-%        introduced). 
+% 04/05: damps further tuned for large mueff
+%      o Details for stall of pc-adaptation added (variable hsig
+%        introduced).
 % 04/05: Bug in boundary handling removed: A large initial SIGMA was
 %        corrected not until *after* the first iteration, which could
 %        lead to a complete failure.
-% 04/05: Call of function range (works with stats toolbox only) 
-%        changed to myrange. 
+% 04/05: Call of function range (works with stats toolbox only)
+%        changed to myrange.
 % 04/04: Parameter cs depends on mueff now and damps \propto sqrt(mueff)
-%        instead of \propto mueff. 
+%        instead of \propto mueff.
 %      o Initial stall to adapt C (flginiphase) is removed and
 %        adaptation of pc is stalled for large norm(ps) instead.
-%      o Returned default options include documentation. 
+%      o Returned default options include documentation.
 %      o Resume part reorganized.
-% 04/03: Stopflag becomes cell-array. 
+% 04/03: Stopflag becomes cell-array.
 
 % ---------------------------------------------------------------
 % CMA-ES: Evolution Strategy with Covariance Matrix Adaptation for
 % nonlinear function minimization. To be used under the terms of the
 % GNU General Public License (http://www.gnu.org/copyleft/gpl.html).
-% Author (copyright): Nikolaus Hansen, 2001-2008. 
+% Author (copyright): Nikolaus Hansen, 2001-2008.
 % e-mail: nikolaus.hansen AT inria.fr
 % URL:http://www.bionik.tu-berlin.de/user/niko
-% References: See below. 
+% References: See below.
 % ---------------------------------------------------------------
 %
 % GENERAL PURPOSE: The CMA-ES (Evolution Strategy with Covariance
@@ -2999,7 +2999,7 @@ function f=frand(x)
 % expected to take at least 30*N^2 and up to 300*N^2 function
 % evaluations.
 %
-% SOME MORE COMMENTS: 
+% SOME MORE COMMENTS:
 % The adaptation of the covariance matrix (e.g. by the CMA) is
 % equivalent to a general linear transformation of the problem
 % coding. Nevertheless every problem specific knowlegde about the best
@@ -3022,13 +3022,13 @@ function f=frand(x)
 % ---------------------------------------------------------------
 %%% REFERENCES
 %
-% The equation numbers refer to 
+% The equation numbers refer to
 % Hansen, N. and S. Kern (2004). Evaluating the CMA Evolution
 % Strategy on Multimodal Test Functions.  Eighth International
 % Conference on Parallel Problem Solving from Nature PPSN VIII,
-% Proceedings, pp. 282-291, Berlin: Springer. 
+% Proceedings, pp. 282-291, Berlin: Springer.
 % (http://www.bionik.tu-berlin.de/user/niko/ppsn2004hansenkern.pdf)
-% 
+%
 % Further references:
 % Hansen, N. and A. Ostermeier (2001). Completely Derandomized
 % Self-Adaptation in Evolution Strategies. Evolutionary Computation,
@@ -3050,6 +3050,3 @@ function f=frand(x)
 % Optimization with an Application to Feedback Control of
 % Combustion. To appear in IEEE Transactions on Evolutionary
 % Computation.
-
-
-
diff --git a/matlab/optimization/csminit1.m b/matlab/optimization/csminit1.m
index 1a0795195..22391027e 100644
--- a/matlab/optimization/csminit1.m
+++ b/matlab/optimization/csminit1.m
@@ -1,7 +1,7 @@
 function [fhat,xhat,fcount,retcode] = csminit1(fcn,x0,penalty,f0,g0,badg,H0,Verbose,varargin)
 % [fhat,xhat,fcount,retcode] = csminit1(fcn,x0,penalty,f0,g0,badg,H0,Verbose,varargin)
-% 
-% Inputs: 
+%
+% Inputs:
 %   fcn:        [string]        string naming the objective function to be minimized
 %   x0:         [npar by 1]     initial value of the parameter vector
 %   penalty:    [scalar]        variable penalty in case of failure of objective function
@@ -20,7 +20,7 @@ function [fhat,xhat,fcount,retcode] = csminit1(fcn,x0,penalty,f0,g0,badg,H0,Verb
 %   retcode     [scalar]        0: normal step
 %                               1: zero gradient.
 %                               5: largest step still improves too fast.
-%                               2,4: back and forth adjustment of stepsize didn't finish.  
+%                               2,4: back and forth adjustment of stepsize didn't finish.
 %                               3: smallest stepsize still improves too slow
 %                               6: no improvement found
 %---------------------
@@ -33,12 +33,12 @@ function [fhat,xhat,fcount,retcode] = csminit1(fcn,x0,penalty,f0,g0,badg,H0,Verb
 %
 % Fixed 7/19/93 to flip eigenvalues of H to get better performance when
 % it's not psd.
-% 
+%
 % Original file downloaded from:
 % http://sims.princeton.edu/yftp/optimize/mfiles/csminit.m
-% 
+%
 % Copyright (C) 1993-2007 Christopher Sims
-% Copyright (C) 2008-2016 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -122,7 +122,7 @@ else
             disp_verbose(sprintf('Correct for low angle: %g',a),Verbose)
         end
     end
-        disp_verbose(sprintf('Predicted improvement: %18.9f',-dfhat/2),Verbose)
+    disp_verbose(sprintf('Predicted improvement: %18.9f',-dfhat/2),Verbose)
     %
     % Have OK dx, now adjust length of step (lambda) until min and
     % max improvement rate criteria are met.
@@ -145,7 +145,7 @@ else
         %ARGLIST
         %f = feval(fcn,dxtest,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13);
         % f = feval(fcn,x0+dx*lambda,P1,P2,P3,P4,P5,P6,P7,P8);
-            disp_verbose(sprintf('lambda = %10.5g; f = %20.7f',lambda,f ),Verbose)
+        disp_verbose(sprintf('lambda = %10.5g; f = %20.7f',lambda,f ),Verbose)
         %debug
         %disp(sprintf('Improvement too great? f0-f: %g, criterion: %g',f0-f,-(1-THETA)*dfhat*lambda))
         if f<fhat
@@ -183,7 +183,7 @@ else
                     if Verbose
                         lambda = -lambda*factor^6
                     else
-                        lambda = -lambda*factor^6;                        
+                        lambda = -lambda*factor^6;
                     end
                 else
                     if lambda < 0
@@ -216,7 +216,7 @@ else
                 end
             end
             lambda=lambda*factor;
-            if abs(lambda) > 1e20;
+            if abs(lambda) > 1e20
                 retcode = 5;
                 done =1;
             end
diff --git a/matlab/optimization/csminwel1.m b/matlab/optimization/csminwel1.m
index 52a018792..cfa869932 100644
--- a/matlab/optimization/csminwel1.m
+++ b/matlab/optimization/csminwel1.m
@@ -14,13 +14,13 @@ function [fh,xh,gh,H,itct,fcount,retcodeh] = csminwel1(fcn,x0,H0,grad,crit,nit,m
 %   epsilon: [scalar]       scalar double, numerical differentiation increment
 %   varargin:               Optional additional inputs that get handed off to fcn each
 %                           time it is called.
-% 
+%
 %        Note that if the program ends abnormally, it is possible to retrieve the current x,
 %        f, and H from the files g1.mat and H.mat that are written at each iteration and at each
 %        hessian update, respectively.  (When the routine hits certain kinds of difficulty, it
 %        writes g2.mat and g3.mat as well. If all were written at about the same time, any of them
 %        may be a decent starting point. One can also start from the one with best function value.)
-% 
+%
 % Outputs:
 %   fh:     [scalar]        function value at minimum
 %   xh:     [npar by 1]     parameter vector at minimum
@@ -30,19 +30,19 @@ function [fh,xh,gh,H,itct,fcount,retcodeh] = csminwel1(fcn,x0,H0,grad,crit,nit,m
 %   fcount  [scalar]        function iteration count upon termination
 %   retcodeh [scalar]       return code:
 %                               0: normal step
-%                               1: zero gradient 
+%                               1: zero gradient
 %                               2: back and forth on step length never finished
 %                               3: smallest step still improving too slow
 %                               4: back and forth on step length never finished
 %                               5: largest step still improving too fast
 %                               6: smallest step still improving too slow, reversed gradient
 %                               7: warning: possible inaccuracy in H matrix
-% 
+%
 % Original file downloaded from:
 % http://sims.princeton.edu/yftp/optimize/mfiles/csminwel.m
-% 
+%
 % Copyright (C) 1993-2007 Christopher Sims
-% Copyright (C) 2006-2015 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -59,7 +59,7 @@ function [fh,xh,gh,H,itct,fcount,retcodeh] = csminwel1(fcn,x0,H0,grad,crit,nit,m
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-% initialize variable penalty    
+% initialize variable penalty
 penalty = 1e8;
 fh = [];
 xh = [];
@@ -139,7 +139,7 @@ while ~done
         else
             if NumGrad
                 [g1, badg1]=get_num_grad(method,fcn,penalty,f1,x1,epsilon,varargin{:});
-            elseif ischar(grad),
+            elseif ischar(grad)
                 [g1, badg1] = grad(x1,varargin{:});
             else
                 [junk1,cost_flag,g1] = penalty_objective_function(x1,fcn,penalty,varargin{:});
@@ -166,7 +166,7 @@ while ~done
                 else
                     if NumGrad
                         [g2, badg2]=get_num_grad(method,fcn,penalty,f2,x2,epsilon,varargin{:});
-                    elseif ischar(grad),
+                    elseif ischar(grad)
                         [g2, badg2] = grad(x2,varargin{:});
                     else
                         [junk2,cost_flag,g2] = penalty_objective_function(x1,fcn,penalty,varargin{:});
@@ -193,12 +193,12 @@ while ~done
                         [f3, x3, fc, retcode3] = csminit1(fcn,x,penalty,f,gcliff,0,eye(nx),Verbose,varargin{:});
                         fcount = fcount+fc; % put by Jinill
                         if retcode3==2 || retcode3==4
-                            wall3=1; 
+                            wall3=1;
                             badg3=1;
                         else
                             if NumGrad
                                 [g3, badg3]=get_num_grad(method,fcn,penalty,f3,x3,epsilon,varargin{:});
-                            elseif ischar(grad),
+                            elseif ischar(grad)
                                 [g3, badg3] = grad(x3,varargin{:});
                             else
                                 [junk3,cost_flag,g3] = penalty_objective_function(x1,fcn,penalty,varargin{:});
@@ -258,7 +258,7 @@ while ~done
         if nogh
             if NumGrad
                 [gh, badgh]=get_num_grad(method,fcn,penalty,fh,xh,epsilon,varargin{:});
-            elseif ischar(grad),
+            elseif ischar(grad)
                 [gh, badgh] = grad(xh,varargin{:});
             else
                 [junkh,cost_flag,gh] = penalty_objective_function(x1,fcn,penalty,varargin{:});
@@ -302,7 +302,7 @@ while ~done
             error('Unaccounted Case, please contact the developers',Verbose)
         end
     end
-     
+
     f=fh;
     x=xh;
     g=gh;
@@ -312,18 +312,18 @@ end
 end
 
 function [g, badg]=get_num_grad(method,fcn,penalty,f0,x0,epsilon,varargin)
-    switch method
-      case 2
-        [g,badg] = numgrad2(fcn, f0, x0, penalty, epsilon, varargin{:});
-      case 3
-        [g,badg] = numgrad3(fcn, f0, x0, penalty, epsilon, varargin{:});
-      case 5
-        [g,badg] = numgrad5(fcn, f0, x0, penalty, epsilon, varargin{:});
-      case 13
-        [g,badg] = numgrad3_(fcn, f0, x0, penalty, epsilon, varargin{:});
-      case 15
-        [g,badg] = numgrad5_(fcn, f0, x0, penalty, epsilon, varargin{:});
-      otherwise
-        error('csminwel1: Unknown method for gradient evaluation!')
-    end
+switch method
+  case 2
+    [g,badg] = numgrad2(fcn, f0, x0, penalty, epsilon, varargin{:});
+  case 3
+    [g,badg] = numgrad3(fcn, f0, x0, penalty, epsilon, varargin{:});
+  case 5
+    [g,badg] = numgrad5(fcn, f0, x0, penalty, epsilon, varargin{:});
+  case 13
+    [g,badg] = numgrad3_(fcn, f0, x0, penalty, epsilon, varargin{:});
+  case 15
+    [g,badg] = numgrad5_(fcn, f0, x0, penalty, epsilon, varargin{:});
+  otherwise
+    error('csminwel1: Unknown method for gradient evaluation!')
+end
 end
\ No newline at end of file
diff --git a/matlab/optimization/dynare_minimize_objective.m b/matlab/optimization/dynare_minimize_objective.m
index 0aebc6b50..025d41189 100644
--- a/matlab/optimization/dynare_minimize_objective.m
+++ b/matlab/optimization/dynare_minimize_objective.m
@@ -8,12 +8,12 @@ function [opt_par_values,fval,exitflag,hessian_mat,options_,Scale,new_rat_hess_i
 %   minimizer_algorithm [scalar double, or string]          code of the optimizer algorithm, or string for the name of a user defined optimization routine (not shipped with dynare).
 %   options_            [matlab structure]                  Dynare options structure
 %   bounds              [n_params by 2] vector of doubles   2 row vectors containing lower and upper bound for parameters
-%   parameter_names     [n_params by 1] cell array          strings containing the parameters names   
+%   parameter_names     [n_params by 1] cell array          strings containing the parameters names
 %   prior_information   [matlab structure]                  Dynare prior information structure (bayestopt_) provided for algorithm 6
 %   Initial_Hessian     [n_params by n_params] matrix       initial hessian matrix provided for algorithm 6
 %   new_rat_hess_info   [matlab structure]                  step size info used by algorith 5
 %   varargin            [cell array]                        Input arguments for objective function
-%    
+%
 % OUTPUTS
 %   opt_par_values      [n_params by 1] vector of doubles   optimal parameter values minimizing the objective
 %   fval                [scalar double]                     value of the objective function at the minimum
@@ -21,12 +21,12 @@ function [opt_par_values,fval,exitflag,hessian_mat,options_,Scale,new_rat_hess_i
 %   hessian_mat         [n_params by n_params] matrix       hessian matrix at the mode returned by optimizer
 %   options_            [matlab structure]                  Dynare options structure (to return options set by algorithms 5)
 %   Scale               [scalar double]                     scaling parameter returned by algorith 6
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
-% 
-% Copyright (C) 2014-2016 Dynare Team
+%
+%
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -77,7 +77,7 @@ switch minimizer_algorithm
     if options_.silent_optimizer
         optim_options = optimset(optim_options,'display','off');
     end
-    if options_.analytic_derivation,
+    if options_.analytic_derivation
         optim_options = optimset(optim_options,'GradObj','on','TolX',1e-7);
     end
     [opt_par_values,fval,exitflag,output,lamdba,grad,hessian_mat] = ...
@@ -148,7 +148,7 @@ switch minimizer_algorithm
     if ~isempty(options_.optim_opt)
         eval(['optim_options = optimset(optim_options,' options_.optim_opt ');']);
     end
-    if options_.analytic_derivation,
+    if options_.analytic_derivation
         optim_options = optimset(optim_options,'GradObj','on');
     end
     if options_.silent_optimizer
@@ -188,16 +188,16 @@ switch minimizer_algorithm
               case 'verbosity'
                 Verbose = options_list{i,2};
               case 'SaveFiles'
-                Save_files = options_list{i,2};                
+                Save_files = options_list{i,2};
               otherwise
                 warning(['csminwel: Unknown option (' options_list{i,1} ')!'])
             end
         end
     end
     if options_.silent_optimizer
-        Save_files = 0; 
+        Save_files = 0;
         Verbose = 0;
-    end    
+    end
     % Set flag for analytical gradient.
     if options_.analytic_derivation
         analytic_grad=1;
@@ -232,23 +232,23 @@ switch minimizer_algorithm
                 if options_.analytic_derivation && flag~=0
                     error('newrat: analytic_derivation is incompatible with numerical Hessian. Using analytic Hessian')
                 else
-                    newratflag=flag; 
+                    newratflag=flag;
                 end
               case 'TolFun'
                 crit = options_list{i,2};
               case 'verbosity'
                 Verbose = options_list{i,2};
               case 'SaveFiles'
-                Save_files = options_list{i,2};                
+                Save_files = options_list{i,2};
               otherwise
                 warning(['newrat: Unknown option (' options_list{i,1} ')!'])
             end
         end
     end
     if options_.silent_optimizer
-        Save_files = 0; 
+        Save_files = 0;
         Verbose = 0;
-    end    
+    end
     hess_info.gstep=options_.gstep;
     hess_info.htol = 1.e-4;
     hess_info.h1=options_.gradient_epsilon*ones(n_params,1);
@@ -307,12 +307,15 @@ switch minimizer_algorithm
     end
     if options_.silent_optimizer
         simplexOptions.verbose = options_list{i,2};
-    end    
+    end
     [opt_par_values,fval,exitflag] = simplex_optimization_routine(objective_function,start_par_value,simplexOptions,parameter_names,varargin{:});
   case 9
     % Set defaults
     H0 = (bounds(:,2)-bounds(:,1))*0.2;
     H0(~isfinite(H0)) = 0.01;
+    while max(H0)/min(H0)>1e6 %make sure initial search volume (SIGMA) is not badly conditioned
+        H0(H0==max(H0))=0.9*H0(H0==max(H0));
+    end
     cmaesOptions = options_.cmaes;
     cmaesOptions.LBounds = bounds(:,1);
     cmaesOptions.UBounds = bounds(:,2);
@@ -336,14 +339,14 @@ switch minimizer_algorithm
                 end
               case 'SaveFiles'
                 if options_list{i,2}==0
-                  cmaesOptions.SaveVariables='off';
-                  cmaesOptions.LogModulo = '0';    % [0:Inf] if >1 record data less frequently after gen=100';
-                  cmaesOptions.LogTime   = '0';    % [0:100] max. percentage of time for recording data';
+                    cmaesOptions.SaveVariables='off';
+                    cmaesOptions.LogModulo = '0';    % [0:Inf] if >1 record data less frequently after gen=100';
+                    cmaesOptions.LogTime   = '0';    % [0:100] max. percentage of time for recording data';
                 end
               case 'CMAESResume'
-                  if options_list{i,2}==1
+                if options_list{i,2}==1
                     cmaesOptions.Resume = 'yes';
-                  end
+                end
               otherwise
                 warning(['cmaes: Unknown option (' options_list{i,1}  ')!'])
             end
@@ -355,7 +358,7 @@ switch minimizer_algorithm
         cmaesOptions.SaveVariables='off';
         cmaesOptions.LogModulo = '0';    % [0:Inf] if >1 record data less frequently after gen=100';
         cmaesOptions.LogTime   = '0';    % [0:100] max. percentage of time for recording data';
-    end    
+    end
     warning('off','CMAES:NonfinitenessRange');
     warning('off','CMAES:InitialSigma');
     [x, fval, COUNTEVAL, STOPFLAG, OUT, BESTEVER] = cmaes(func2str(objective_function),start_par_value,H0,cmaesOptions,varargin{:});
@@ -383,11 +386,11 @@ switch minimizer_algorithm
               case 'MaxFunEvals'
                 simpsaOptions.MAX_FUN_EVALS = options_list{i,2};
               case 'verbosity'
-                  if options_list{i,2} == 0
+                if options_list{i,2} == 0
                     simpsaOptions.DISPLAY = 'none';
-                  else
+                else
                     simpsaOptions.DISPLAY = 'iter';
-                  end                      
+                end
               otherwise
                 warning(['simpsa: Unknown option (' options_list{i,1}  ')!'])
             end
@@ -411,10 +414,10 @@ switch minimizer_algorithm
     if ~isempty(options_.optim_opt)
         options_list = read_key_value_string(options_.optim_opt);
         SupportedListOfOptions = {'CreationFcn', 'Display', 'DisplayInterval', 'FunctionTolerance', ...
-                                    'FunValCheck', 'HybridFcn', 'InertiaRange', 'InitialSwarmMatrix', 'InitialSwarmSpan', ...
-                                    'MaxIterations', 'MaxStallIterations', 'MaxStallTime', 'MaxTime', ...
-                                    'MinNeighborsFraction', 'ObjectiveLimit', 'OutputFcn', 'PlotFcn', 'SelfAdjustmentWeight', ...
-                                    'SocialAdjustmentWeight', 'SwarmSize', 'UseParallel', 'UseVectorized'};
+                            'FunValCheck', 'HybridFcn', 'InertiaRange', 'InitialSwarmMatrix', 'InitialSwarmSpan', ...
+                            'MaxIterations', 'MaxStallIterations', 'MaxStallTime', 'MaxTime', ...
+                            'MinNeighborsFraction', 'ObjectiveLimit', 'OutputFcn', 'PlotFcn', 'SelfAdjustmentWeight', ...
+                            'SocialAdjustmentWeight', 'SwarmSize', 'UseParallel', 'UseVectorized'};
         for i=1:rows(options_list)
             if ismember(options_list{i,1}, SupportedListOfOptions)
                 particleswarmOptions = optimoptions(particleswarmOptions, options_list{i,1}, options_list{i,2});
@@ -511,8 +514,8 @@ end
 end
 
 function [LB, UB]=set_bounds_to_finite_values(bounds, huge_number)
-    LB=bounds(:,1);
-    LB(isinf(LB))=-huge_number;
-    UB=bounds(:,2);
-    UB(isinf(UB))=huge_number;
+LB=bounds(:,1);
+LB(isinf(LB))=-huge_number;
+UB=bounds(:,2);
+UB(isinf(UB))=huge_number;
 end
diff --git a/matlab/optimization/gmhmaxlik.m b/matlab/optimization/gmhmaxlik.m
index 3710d8d65..4f1db628d 100644
--- a/matlab/optimization/gmhmaxlik.m
+++ b/matlab/optimization/gmhmaxlik.m
@@ -1,6 +1,6 @@
 function [PostMode, HessianMatrix, Scale, ModeValue] = gmhmaxlik(fun, xinit, Hinit, iscale, bounds, priorstd, gmhmaxlikOptions, OptimizationOptions, varargin)
 
-% Copyright (C) 2006-2015 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -16,10 +16,10 @@ function [PostMode, HessianMatrix, Scale, ModeValue] = gmhmaxlik(fun, xinit, Hin
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 % Set default options
 
-if ~isempty(Hinit);
+if ~isempty(Hinit)
     gmhmaxlikOptions.varinit = 'previous';
 else
     gmhmaxlikOptions.varinit = 'prior';
diff --git a/matlab/optimization/gmhmaxlik_core.m b/matlab/optimization/gmhmaxlik_core.m
index 2d7a3cb81..3e94d30ab 100644
--- a/matlab/optimization/gmhmaxlik_core.m
+++ b/matlab/optimization/gmhmaxlik_core.m
@@ -1,8 +1,8 @@
-function [PostMod,PostVar,Scale,PostMean] = gmhmaxlik_core(ObjFun,xparam1,mh_bounds,options,iScale,info,MeanPar,VarCov,varargin)  
+function [PostMod,PostVar,Scale,PostMean] = gmhmaxlik_core(ObjFun,xparam1,mh_bounds,options,iScale,info,MeanPar,VarCov,varargin)
 
-% (Dirty) Global minimization routine of (minus) a likelihood (or posterior density) function. 
-% 
-% INPUTS 
+% (Dirty) Global minimization routine of (minus) a likelihood (or posterior density) function.
+%
+% INPUTS
 %   o ObjFun     [char]     string specifying the name of the objective function.
 %   o xparam1    [double]   (p*1) vector of parameters to be estimated.
 %   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters.
@@ -10,29 +10,29 @@ function [PostMod,PostVar,Scale,PostMean] = gmhmaxlik_core(ObjFun,xparam1,mh_bou
 %   o iScale     [double]   scalar specifying the initial of the jumping distribution's scale parameter.
 %   o info       [char]     string, empty or equal to 'LastCall'.
 %   o MeanPar    [double]   (p*1) vector specifying the initial posterior mean.
-%   o VarCov     [double]   (p*p) matrix specifying the initial posterior covariance matrix. 
+%   o VarCov     [double]   (p*p) matrix specifying the initial posterior covariance matrix.
 %   o gend       [integer]  scalar specifying the number of observations ==> varargin{1}.
 %   o data       [double]   (T*n) matrix of data ==> varargin{2}.
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   o PostMod    [double]   (p*1) vector, evaluation of the posterior mode.
 %   o PostVar    [double]   (p*p) matrix, evaluation of the posterior covariance matrix.
-%   o Scale      [double]   scalar specifying the scale parameter that should be used in 
-%                           an eventual metropolis-hastings algorithm. 
-%   o PostMean   [double]   (p*1) vector, evaluation of the posterior mean.  
+%   o Scale      [double]   scalar specifying the scale parameter that should be used in
+%                           an eventual metropolis-hastings algorithm.
+%   o PostMean   [double]   (p*1) vector, evaluation of the posterior mean.
 %
-% ALGORITHM 
+% ALGORITHM
 %   Metropolis-Hastings with an constantly updated covariance matrix for
 %   the jump distribution. The posterior mean, variance and mode are
 %   updated (in step 2) with the following rules:
 %
-%   \[ 
-%       \mu_t = \mu_{t-1} + \frac{1}{t}\left(\theta_t-\mu_{t-1}\right) 
-%   \]    
+%   \[
+%       \mu_t = \mu_{t-1} + \frac{1}{t}\left(\theta_t-\mu_{t-1}\right)
+%   \]
 %
-%   \[ 
-%       \Sigma_t = \Sigma_{t-1} + \mu_{t-1}\mu_{t-1}'-\mu_{t}\mu_{t}' + 
-%                  \frac{1}{t}\left(\theta_t\theta_t'-\Sigma_{t-1}-\mu_{t-1}\mu_{t-1}'\right) 
+%   \[
+%       \Sigma_t = \Sigma_{t-1} + \mu_{t-1}\mu_{t-1}'-\mu_{t}\mu_{t}' +
+%                  \frac{1}{t}\left(\theta_t\theta_t'-\Sigma_{t-1}-\mu_{t-1}\mu_{t-1}'\right)
 %   \]
 %
 %   and
@@ -43,7 +43,7 @@ function [PostMod,PostVar,Scale,PostMean] = gmhmaxlik_core(ObjFun,xparam1,mh_bou
 %                         \theta_t, & \hbox{if } p(\theta_t|\mathcal Y) > p(\mathrm{mode}_{t-1}|\mathcal Y) \\
 %                         \mathrm{mode}_{t-1}, & \hbox{otherwise.}
 %                       \end{array}
-%                     \right. 
+%                     \right.
 %   \]
 %
 %   where $t$ is the iteration, $\mu_t$ the estimate of the posterior mean
@@ -51,12 +51,12 @@ function [PostMod,PostVar,Scale,PostMean] = gmhmaxlik_core(ObjFun,xparam1,mh_bou
 %   covariance matrix after $t$ iterations, $\mathrm{mode}_t$ is the
 %   evaluation of the posterior mode after $t$ iterations and
 %   $p(\theta_t|\mathcal Y)$ is the posterior density of parameters
-%   (specified by the user supplied function "fun").       
+%   (specified by the user supplied function "fun").
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2015 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -94,7 +94,7 @@ isux = 0; jsux = 0; test = 0;
 ix2 = ModePar;% initial condition!
 ilogpo2 = - feval(ObjFun,ix2,varargin{:});% initial posterior density
 mlogpo2 = ilogpo2;
-try 
+try
     dd = transpose(chol(CovJump));
 catch
     dd = eye(length(CovJump));
@@ -108,7 +108,7 @@ while j<=MaxNumberOfTuningSimulations
     end
     % I move if the proposal is enough likely...
     if logpo2 > -inf && log(rand) < logpo2 - ilogpo2
-        ix2 = proposal; 
+        ix2 = proposal;
         if logpo2 > mlogpo2
             ModePar = proposal;
             mlogpo2 = logpo2;
@@ -165,7 +165,7 @@ while j<= NumberOfIterations
         ilogpo2 = logpo2;
         isux = isux + 1;
         jsux = jsux + 1;
-    end% ... otherwise I don't move.    
+    end% ... otherwise I don't move.
     prtfrc = j/NumberOfIterations;
     if mod(j, 10)==0
         dyn_waitbar(prtfrc,hh,sprintf('Acceptance ratio: %f',isux/j));
@@ -184,7 +184,7 @@ PostMean = MeanPar;
 %% this is the last call to the routine, and I climb the hill (without
 %% updating the covariance matrix)...
 if strcmpi(info,'LastCall')
-    
+
     hh = dyn_waitbar(0,'Tuning of the scale parameter...');
     set(hh,'Name','Tuning of the scale parameter.'),
     j = 1; jj  = 1;
@@ -214,8 +214,8 @@ if strcmpi(info,'LastCall')
         if mod(j, 10)==0
             dyn_waitbar(prtfrc,hh,sprintf('Acceptance ratio [during last 1000]: %f [%f]',isux/j,jsux/jj));
         end
-        if j/1000 == round(j/1000) 
-            test1 = jsux/jj;  
+        if j/1000 == round(j/1000)
+            test1 = jsux/jj;
             cfactor = test1/AcceptanceTarget;
             iScale = iScale*cfactor;
             jsux = 0; jj = 0;
diff --git a/matlab/optimization/mr_gstep.m b/matlab/optimization/mr_gstep.m
index 605508d2c..0836a7a87 100644
--- a/matlab/optimization/mr_gstep.m
+++ b/matlab/optimization/mr_gstep.m
@@ -11,7 +11,7 @@ function [f0, x, ig] = mr_gstep(h1,x,bounds,func0,penalty,htol0,Verbose,Save_fil
 % varargin{6} --> BayesInfo
 % varargin{1} --> DynareResults
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,7 +29,7 @@ function [f0, x, ig] = mr_gstep(h1,x,bounds,func0,penalty,htol0,Verbose,Save_fil
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 n=size(x,1);
-if isempty(h1),
+if isempty(h1)
     h1=varargin{3}.gradient_epsilon*ones(n,1);
 end
 
@@ -39,7 +39,7 @@ if isempty(htol0)
 else
     htol = htol0;
 end
-if length(htol)==1,
+if length(htol)==1
     htol=htol*ones(n,1);
 end
 f0=penalty_objective_function(x,func0,penalty,varargin{:});
@@ -72,7 +72,7 @@ while i<n
         gg(i)=(f1(i)'-f_1(i)')./(2.*h1(i));
         hh(i) = 1/max(1.e-9,abs( (f1(i)+f_1(i)-2*f0)./(h1(i)*h1(i)) ));
         if gg(i)*(hh(i)*gg(i))/2 > htol(i)
-            [f0 x fc retcode] = csminit1(func0,x,penalty,f0,gg,0,diag(hh),Verbose,varargin{:});
+            [f0, x, fc, retcode] = csminit1(func0,x,penalty,f0,gg,0,diag(hh),Verbose,varargin{:});
             ig(i)=1;
             if Verbose
                 fprintf(['Done for param %s = %8.4f\n'],varargin{6}.name{i},x(i))
@@ -95,13 +95,11 @@ return
 function x = check_bounds(x,bounds)
 
 inx = find(x>=bounds(:,2));
-if ~isempty(inx),
+if ~isempty(inx)
     x(inx) = bounds(inx,2)-eps;
 end
 
 inx = find(x<=bounds(:,1));
-if ~isempty(inx),
+if ~isempty(inx)
     x(inx) = bounds(inx,1)+eps;
 end
-
-
diff --git a/matlab/optimization/mr_hessian.m b/matlab/optimization/mr_hessian.m
index eb1c0752e..b234df9b7 100644
--- a/matlab/optimization/mr_hessian.m
+++ b/matlab/optimization/mr_hessian.m
@@ -33,7 +33,7 @@ function [hessian_mat, gg, htol1, ihh, hh_mat0, hh1, hess_info] = mr_hessian(x,f
 %                           varargin{6} --> BayesInfo
 %                           varargin{7} --> Bounds
 %                           varargin{8} --> DynareResults
-% 
+%
 % Outputs
 %  - hessian_mat        hessian
 %  - gg                 Jacobian
@@ -44,7 +44,7 @@ function [hessian_mat, gg, htol1, ihh, hh_mat0, hh1, hess_info] = mr_hessian(x,f
 %  - hh1                updated hess_info.h1
 %  - hess_info          structure with updated step length
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ n=size(x,1);
 h2=varargin{7}.ub-varargin{7}.lb;
 hmax=varargin{7}.ub-x;
 hmax=min(hmax,x-varargin{7}.lb);
-if isempty(ff0),
+if isempty(ff0)
     outer_product_gradient=0;
 else
     outer_product_gradient=1;
@@ -109,7 +109,7 @@ while i<n
     while (abs(dx(it))<0.5*hess_info.htol || abs(dx(it))>(3*hess_info.htol)) && icount<10 && ic==0
         icount=icount+1;
         if abs(dx(it))<0.5*hess_info.htol
-            if abs(dx(it)) ~= 0,
+            if abs(dx(it)) ~= 0
                 hess_info.h1(i)=min(max(1.e-10,0.3*abs(x(i))), 0.9*hess_info.htol/abs(dx(it))*hess_info.h1(i));
             else
                 hess_info.h1(i)=2.1*hess_info.h1(i);
@@ -147,8 +147,8 @@ while i<n
         end
     end
     f1(:,i)=fx;
-    if outer_product_gradient,
-        if any(isnan(ffx)) || isempty(ffx),
+    if outer_product_gradient
+        if any(isnan(ffx)) || isempty(ffx)
             ff1=ones(size(ff0)).*fx/length(ff0);
         else
             ff1=ffx;
@@ -157,8 +157,8 @@ while i<n
     xh1(i)=x(i)-hess_info.h1(i);
     [fx,exit_flag,ffx]=penalty_objective_function(xh1,func,penalty,varargin{:});
     f_1(:,i)=fx;
-    if outer_product_gradient,
-        if any(isnan(ffx)) || isempty(ffx),
+    if outer_product_gradient
+        if any(isnan(ffx)) || isempty(ffx)
             ff_1=ones(size(ff0)).*fx/length(ff0);
         else
             ff_1=ffx;
@@ -180,7 +180,7 @@ xh_1=xh1;
 
 gg=(f1'-f_1')./(2.*hess_info.h1);
 
-if outer_product_gradient,
+if outer_product_gradient
     if hflag==2
         gg=(f1'-f_1')./(2.*hess_info.h1);
         hessian_mat = zeros(size(f0,1),n*n);
@@ -223,7 +223,7 @@ if outer_product_gradient,
     hh_mat=gga'*gga;  % rescaled outer product hessian
     hh_mat0=ggh'*ggh;  % outer product hessian
     A=diag(2.*hess_info.h1);  % rescaling matrix
-    % igg=inv(hh_mat);  % inverted rescaled outer product hessian
+                              % igg=inv(hh_mat);  % inverted rescaled outer product hessian
     ihh=A'*(hh_mat\A);  % inverted outer product hessian
     if hflag>0 && min(eig(reshape(hessian_mat,n,n)))>0
         hh0 = A*reshape(hessian_mat,n,n)*A';  %rescaled second order derivatives
@@ -244,12 +244,12 @@ if outer_product_gradient,
         igg=inv(A)'*ihh*inv(A);  % inverted rescaled outer product hessian with modified std's
         hh_mat=inv(igg);   % outer product rescaled hessian with modified std's
         hh_mat0=inv(A)'*hh_mat*inv(A);  % outer product hessian with modified std's
-        %     sd0=sqrt(1./diag(hh0));   %rescaled 'standard errors' using second order derivatives
-        %     sd=sqrt(diag(igg));  %rescaled 'standard errors' using outer product
-        %     igg=igg./(sd*sd').*(sd0*sd0');  %rescaled inverse outer product with 'true' std's
-        %     hh_mat=inv(igg);   % rescaled outer product hessian with 'true' std's
-        %     ihh=A'*igg*A;  % inverted outer product hessian
-        %     hh_mat0=inv(A)'*hh_mat*inv(A);  % outer product hessian with 'true' std's
+                                        %     sd0=sqrt(1./diag(hh0));   %rescaled 'standard errors' using second order derivatives
+                                        %     sd=sqrt(diag(igg));  %rescaled 'standard errors' using outer product
+                                        %     igg=igg./(sd*sd').*(sd0*sd0');  %rescaled inverse outer product with 'true' std's
+                                        %     hh_mat=inv(igg);   % rescaled outer product hessian with 'true' std's
+                                        %     ihh=A'*igg*A;  % inverted outer product hessian
+                                        %     hh_mat0=inv(A)'*hh_mat*inv(A);  % outer product hessian with 'true' std's
     end
     if hflag<2
         hessian_mat=hh_mat0(:);
diff --git a/matlab/optimization/newrat.m b/matlab/optimization/newrat.m
index 8085316d0..c554a22dc 100644
--- a/matlab/optimization/newrat.m
+++ b/matlab/optimization/newrat.m
@@ -11,14 +11,14 @@ function [xparam1, hh, gg, fval, igg, hess_info] = newrat(func0, x, bounds, anal
 %  - analytic_derivation    1 if analytic derivatives, 0 otherwise
 %  - ftol0                  termination criterion for function change
 %  - nit                    maximum number of iterations
-%  - flagg                  Indicator how to compute final Hessian (In each iteration, Hessian is computed with outer product gradient)  
+%  - flagg                  Indicator how to compute final Hessian (In each iteration, Hessian is computed with outer product gradient)
 %                           0: final Hessian computed with outer product gradient
-%                           1: final 'mixed' Hessian: diagonal elements computed with 
-%                               numerical second order derivatives with correlation structure 
+%                           1: final 'mixed' Hessian: diagonal elements computed with
+%                               numerical second order derivatives with correlation structure
 %                               as from outer product gradient
 %                           2: full numerical Hessian
 %  - Verbose                1 if explicit output is requested
-%  - Save_files             1 if intermediate output is to be saved 
+%  - Save_files             1 if intermediate output is to be saved
 %  - hess_info              structure storing the step sizes for
 %                           computation of Hessian
 %  - varargin               other inputs:
@@ -30,7 +30,7 @@ function [xparam1, hh, gg, fval, igg, hess_info] = newrat(func0, x, bounds, anal
 %                           varargin{6} --> BayesInfo
 %                           varargin{7} --> Bounds
 %                           varargin{8} --> DynareResults
-% 
+%
 % Outputs
 % - xparam1                 parameter vector at optimum
 % - hh                      hessian
@@ -39,7 +39,7 @@ function [xparam1, hh, gg, fval, igg, hess_info] = newrat(func0, x, bounds, anal
 % - igg                     inverted outer product hessian
 % - hess_info               structure with updated step length
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -56,7 +56,7 @@ function [xparam1, hh, gg, fval, igg, hess_info] = newrat(func0, x, bounds, anal
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-% initialize variable penalty    
+% initialize variable penalty
 penalty = 1e8;
 
 icount=0;
@@ -86,7 +86,7 @@ fval=fval0;
 outer_product_gradient=1;
 if isempty(hh)
     [dum, gg, htol0, igg, hhg, h1, hess_info]=mr_hessian(x,func0,penalty,flagit,htol,hess_info,varargin{:});
-    if isempty(dum),
+    if isempty(dum)
         outer_product_gradient=0;
         igg = 1e-4*eye(nx);
     else
@@ -154,7 +154,7 @@ while norm(gg)>gtol && check==0 && jit<nit
     if length(find(ig))<nx
         ggx=ggx*0;
         ggx(find(ig))=gg(find(ig));
-        if analytic_derivation,
+        if analytic_derivation
             hhx=hh;
         else
             hhx = reshape(dum,nx,nx);
@@ -195,26 +195,26 @@ while norm(gg)>gtol && check==0 && jit<nit
     if (fval0(icount)-fval)<ftol
         disp_verbose('No further improvement is possible!',Verbose)
         check=1;
-        if analytic_derivation,
+        if analytic_derivation
             [fvalx,exit_flag,gg,hh]=penalty_objective_function(xparam1,func0,penalty,varargin{:});
             hhg=hh;
             H = inv(hh);
         else
-        if flagit==2
-            hh=hh0;
-        elseif flagg>0
-            [dum, gg, htol0, igg, hhg, h1, hess_info]=mr_hessian(xparam1,func0,penalty,flagg,ftol0,hess_info,varargin{:});
-            if flagg==2
-                hh = reshape(dum,nx,nx);
-                ee=eig(hh);
-                if min(ee)<0
+            if flagit==2
+                hh=hh0;
+            elseif flagg>0
+                [dum, gg, htol0, igg, hhg, h1, hess_info]=mr_hessian(xparam1,func0,penalty,flagg,ftol0,hess_info,varargin{:});
+                if flagg==2
+                    hh = reshape(dum,nx,nx);
+                    ee=eig(hh);
+                    if min(ee)<0
+                        hh=hhg;
+                    end
+                else
                     hh=hhg;
                 end
-            else
-                hh=hhg;
             end
         end
-        end
         disp_verbose(['Actual dxnorm ',num2str(norm(x(:,end)-x(:,end-1)))],Verbose)
         disp_verbose(['FVAL          ',num2str(fval)],Verbose)
         disp_verbose(['Improvement   ',num2str(fval0(icount)-fval)],Verbose)
@@ -233,7 +233,7 @@ while norm(gg)>gtol && check==0 && jit<nit
         disp_verbose(['Ftol          ',num2str(ftol)],Verbose)
         disp_verbose(['Htol          ',num2str(max(htol0))],Verbose)
         htol=htol_base;
-        if norm(x(:,icount)-xparam1)>1.e-12 && analytic_derivation==0,
+        if norm(x(:,icount)-xparam1)>1.e-12 && analytic_derivation==0
             try
                 if Save_files
                     save('m1.mat','x','fval0','nig','-append')
@@ -244,7 +244,7 @@ while norm(gg)>gtol && check==0 && jit<nit
                 end
             end
             [dum, gg, htol0, igg, hhg, h1, hess_info]=mr_hessian(xparam1,func0,penalty,flagit,htol,hess_info,varargin{:});
-            if isempty(dum),
+            if isempty(dum)
                 outer_product_gradient=0;
             end
             if max(htol0)>htol
@@ -253,7 +253,7 @@ while norm(gg)>gtol && check==0 && jit<nit
                 disp_verbose('Tolerance has to be relaxed',Verbose)
                 skipline()
             end
-            if ~outer_product_gradient,
+            if ~outer_product_gradient
                 H = bfgsi1(H,gg-g(:,icount),xparam1-x(:,icount),Verbose,Save_files);
                 hh=inv(H);
                 hhg=hh;
@@ -270,7 +270,7 @@ while norm(gg)>gtol && check==0 && jit<nit
                 end
                 H = igg;
             end
-        elseif analytic_derivation,
+        elseif analytic_derivation
             [fvalx,exit_flag,gg,hh]=penalty_objective_function(xparam1,func0,penalty,varargin{:});
             hhg=hh;
             H = inv(hh);
@@ -311,7 +311,7 @@ if norm(gg)<=gtol
     disp_verbose(['Estimation ended:'],Verbose)
     disp_verbose(['Gradient norm < ', num2str(gtol)],Verbose)
 end
-if check==1,
+if check==1
     disp_verbose(['Estimation successful.'],Verbose)
 end
 
@@ -321,11 +321,11 @@ return
 function x = check_bounds(x,bounds)
 
 inx = find(x>=bounds(:,2));
-if ~isempty(inx),
+if ~isempty(inx)
     x(inx) = bounds(inx,2)-eps;
 end
 
 inx = find(x<=bounds(:,1));
-if ~isempty(inx),
+if ~isempty(inx)
     x(inx) = bounds(inx,1)+eps;
 end
diff --git a/matlab/optimization/penalty_objective_function.m b/matlab/optimization/penalty_objective_function.m
index c245800c2..e0c249251 100644
--- a/matlab/optimization/penalty_objective_function.m
+++ b/matlab/optimization/penalty_objective_function.m
@@ -2,13 +2,13 @@ function [fval, exit_flag, arg1, arg2] = penalty_objective_function(x, fcn, base
 
 % Encapsulates an objective function to be minimized, adding a penalty if necessary.
 %
-% INPUTS 
+% INPUTS
 % - x             [double]    n*1 vector of instrument values.
 % - fcn           [fhandle]   objective function.
 % - base_penalty  [double]    scalar, base of the penality (typically the value of the objective at the previous iteration).
 % - varagin       [cell]      additional parameters for fcn.
 %
-% OUTPUTS 
+% OUTPUTS
 % - fval          [double]    scalar, value of the objective function at x.
 % - exit_flag     [integer]   scalar, flag returned by fcn (third output).
 % - arg1, arg2                fourth and fifth output arguments of the objective function.
diff --git a/matlab/optimization/simplex_optimization_routine.m b/matlab/optimization/simplex_optimization_routine.m
index 58b3ff1b0..ccd81367e 100644
--- a/matlab/optimization/simplex_optimization_routine.m
+++ b/matlab/optimization/simplex_optimization_routine.m
@@ -7,7 +7,7 @@ function [x,fval,exitflag] = simplex_optimization_routine(objective_function,x,o
 %
 % The routine automatically restarts from the current solution while amelioration is possible.
 %
-% INPUTS 
+% INPUTS
 %  o objective_function     [string]                  Name of the objective function to be minimized.
 %  o x                      [double]                  n*1 vector, starting guess of the optimization routine.
 %  o options                [structure]               Options of this implementation of the simplex algorithm.
@@ -23,13 +23,13 @@ function [x,fval,exitflag] = simplex_optimization_routine(objective_function,x,o
 %     varargin{6} --> BayesInfo
 %     varargin{1} --> DynareResults
 %
-% OUTPUTS 
+% OUTPUTS
 %  o x                      [double]                  n*1 vector, estimate of the optimal inputs.
 %  o fval                   [double]                  scalar, value of the objective at the optimum.
 %  o exitflag               [integer]                 scalar equal to 0 or 1 (0 if the algorithm did not converge to
 %                                                     a minimum).
 
-% Copyright (C) 2010-2013 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -251,7 +251,7 @@ while (func_count < max_func_calls) && (iter_count < max_iterations) && (simplex
     fxr = feval(objective_function,x,varargin{:});
     func_count = func_count+1;
     if fxr < fv(1)% xr is better than previous best point v(:,1).
-        % Calculate the expansion point
+                  % Calculate the expansion point
         xe = xbar + rho*chi*(xbar-v(:,end));
         x  = xe;
         fxe = feval(objective_function,x,varargin{:});
@@ -396,7 +396,7 @@ while (func_count < max_func_calls) && (iter_count < max_iterations) && (simplex
         disp(['Crit. x:                  ' num2str(critX)])
         skipline()
     end
-    if verbose && max(abs(best_point-v(:,1)))>x_tolerance;
+    if verbose && max(abs(best_point-v(:,1)))>x_tolerance
         if verbose<2
             disp(['Simplex iteration number: ' int2str(simplex_iterations) '-' int2str(simplex_init) '-' int2str(simplex_algo_iterations)])
             disp(['Objective function value: ' num2str(fv(1))])
@@ -499,7 +499,7 @@ while (func_count < max_func_calls) && (iter_count < max_iterations) && (simplex
         else
             break
         end
-   end
+    end
 end% while loop.
 
 x(:) = v(:,1);
@@ -520,43 +520,43 @@ end
 
 
 function [v,fv,delta] = simplex_initialization(objective_function,point,point_score,delta,zero_delta,check_delta,varargin)
-    n = length(point);
-    v  = zeros(n,n+1);
-    v(:,1) = point;
-    fv = zeros(n+1,1);
-    fv(1) = point_score;
-    if length(delta)==1
-        delta = repmat(delta,n,1);
+n = length(point);
+v  = zeros(n,n+1);
+v(:,1) = point;
+fv = zeros(n+1,1);
+fv(1) = point_score;
+if length(delta)==1
+    delta = repmat(delta,n,1);
+end
+for j = 1:n
+    y = point;
+    if y(j) ~= 0
+        y(j) = (1 + delta(j))*y(j);
+    else
+        y(j) = zero_delta;
     end
-    for j = 1:n
-        y = point;
-        if y(j) ~= 0
-            y(j) = (1 + delta(j))*y(j);
-        else
-            y(j) = zero_delta;
-        end
-        v(:,j+1) = y;
-        x = y;
-        [fv(j+1),junk1,junk2,nopenalty_flag] = feval(objective_function,x,varargin{:});
-        if check_delta
-            while ~nopenalty_flag
-                if y(j)~=0
-                    delta(j) = delta(j)/1.1;
-                else
-                    zero_delta = zero_delta/1.1;
-                end
-                y = point;
-                if y(j) ~= 0
-                    y(j) = (1 + delta(j))*y(j);
-                else
-                    y(j) = zero_delta;
-                end
-                v(:,j+1) = y;
-                x = y;
-                [fv(j+1),junk1,junk2,nopenalty_flag] = feval(objective_function,x,varargin{:});
+    v(:,j+1) = y;
+    x = y;
+    [fv(j+1),junk1,junk2,nopenalty_flag] = feval(objective_function,x,varargin{:});
+    if check_delta
+        while ~nopenalty_flag
+            if y(j)~=0
+                delta(j) = delta(j)/1.1;
+            else
+                zero_delta = zero_delta/1.1;
             end
+            y = point;
+            if y(j) ~= 0
+                y(j) = (1 + delta(j))*y(j);
+            else
+                y(j) = zero_delta;
+            end
+            v(:,j+1) = y;
+            x = y;
+            [fv(j+1),junk1,junk2,nopenalty_flag] = feval(objective_function,x,varargin{:});
         end
     end
-    % Sort by increasing order of the objective function values.
-    [fv,sort_idx] = sort(fv);
-    v = v(:,sort_idx);
\ No newline at end of file
+end
+% Sort by increasing order of the objective function values.
+[fv,sort_idx] = sort(fv);
+v = v(:,sort_idx);
\ No newline at end of file
diff --git a/matlab/optimization/simpsa.m b/matlab/optimization/simpsa.m
index 260607a24..87b881a2c 100644
--- a/matlab/optimization/simpsa.m
+++ b/matlab/optimization/simpsa.m
@@ -1,8 +1,8 @@
 function [X,FVAL,EXITFLAG,OUTPUT] = simpsa(FUN,X0,LB,UB,OPTIONS,varargin)
 
-% Finds a minimum of a function of several variables using an algorithm 
-% that is based on the combination of the non-linear smplex and the simulated 
-% annealing algorithm (the SIMPSA algorithm, Cardoso et al., 1996). 
+% Finds a minimum of a function of several variables using an algorithm
+% that is based on the combination of the non-linear smplex and the simulated
+% annealing algorithm (the SIMPSA algorithm, Cardoso et al., 1996).
 % In this paper, the algorithm is shown to be adequate for the global optimi-
 % zation of an example set of unconstrained and constrained NLP functions.
 %
@@ -11,54 +11,54 @@ function [X,FVAL,EXITFLAG,OUTPUT] = simpsa(FUN,X0,LB,UB,OPTIONS,varargin)
 %        X
 %
 % Algorithm partly is based on paper of Cardoso et al, 1996.
-%                                                                             
-%   X=SIMPSA(FUN,X0) start at X0 and finds a minimum X to the function FUN. 
+%
+%   X=SIMPSA(FUN,X0) start at X0 and finds a minimum X to the function FUN.
 %   FUN accepts input X and returns a scalar function value F evaluated at X.
 %   X0 may be a scalar, vector, or matrix.
-%   
-%   X=SIMPSA(FUN,X0,LB,UB) defines a set of lower and upper bounds on the 
-%   design variables, X, so that a solution is found in the range 
-%   LB <= X <= UB. Use empty matrices for LB and UB if no bounds exist. 
-%   Set LB(i) = -Inf if X(i) is unbounded below; set UB(i) = Inf if X(i) is 
+%
+%   X=SIMPSA(FUN,X0,LB,UB) defines a set of lower and upper bounds on the
+%   design variables, X, so that a solution is found in the range
+%   LB <= X <= UB. Use empty matrices for LB and UB if no bounds exist.
+%   Set LB(i) = -Inf if X(i) is unbounded below; set UB(i) = Inf if X(i) is
 %   unbounded above.
-%   
+%
 %   X=SIMPSA(FUN,X0,LB,UB,OPTIONS) minimizes with the default optimization
-%   parameters replaced by values in the structure OPTIONS, an argument 
-%   created with the SIMPSASET function. See SIMPSASET for details. 
+%   parameters replaced by values in the structure OPTIONS, an argument
+%   created with the SIMPSASET function. See SIMPSASET for details.
 %   Used options are TEMP_START, TEMP_END, COOL_RATE, INITIAL_ACCEPTANCE_RATIO,
 %   MIN_COOLING_FACTOR, MAX_ITER_TEMP_FIRST, MAX_ITER_TEMP_LAST, MAX_ITER_TEMP,
 %   MAX_ITER_TOTAL, MAX_TIME, MAX_FUN_EVALS, TOLX, TOLFUN, DISPLAY and OUTPUT_FCN.
 %   Use OPTIONS = [] as a place holder if no options are set.
-%   
-%   X=SIMPSA(FUN,X0,LB,UB,OPTIONS,varargin) is used to supply a variable 
+%
+%   X=SIMPSA(FUN,X0,LB,UB,OPTIONS,varargin) is used to supply a variable
 %   number of input arguments to the objective function FUN.
-%   
-%   [X,FVAL]=SIMPSA(FUN,X0,...) returns the value of the objective 
+%
+%   [X,FVAL]=SIMPSA(FUN,X0,...) returns the value of the objective
 %   function FUN at the solution X.
-%   
-%   [X,FVAL,EXITFLAG]=SIMPSA(FUN,X0,...) returns an EXITFLAG that describes the 
-%   exit condition of SIMPSA. Possible values of EXITFLAG and the corresponding 
+%
+%   [X,FVAL,EXITFLAG]=SIMPSA(FUN,X0,...) returns an EXITFLAG that describes the
+%   exit condition of SIMPSA. Possible values of EXITFLAG and the corresponding
 %   exit conditions are:
-%   
+%
 %     1  Change in the objective function value less than the specified tolerance.
 %     2  Change in X less than the specified tolerance.
 %     0  Maximum number of function evaluations or iterations reached.
 %    -1  Maximum time exceeded.
-%   
-%   [X,FVAL,EXITFLAG,OUTPUT]=SIMPSA(FUN,X0,...) returns a structure OUTPUT with 
+%
+%   [X,FVAL,EXITFLAG,OUTPUT]=SIMPSA(FUN,X0,...) returns a structure OUTPUT with
 %   the number of iterations taken in OUTPUT.nITERATIONS, the number of function
 %   evaluations in OUTPUT.nFUN_EVALS, the temperature profile in OUTPUT.TEMPERATURE,
-%   the simplexes that were evaluated in OUTPUT.SIMPLEX and the best one in 
-%   OUTPUT.SIMPLEX_BEST, the costs associated with each simplex in OUTPUT.COSTS and 
-%   from the best simplex at that iteration in OUTPUT.COST_BEST, the amount of time 
+%   the simplexes that were evaluated in OUTPUT.SIMPLEX and the best one in
+%   OUTPUT.SIMPLEX_BEST, the costs associated with each simplex in OUTPUT.COSTS and
+%   from the best simplex at that iteration in OUTPUT.COST_BEST, the amount of time
 %   needed in OUTPUT.TIME and the options used in OUTPUT.OPTIONS.
-% 
+%
 %   See also SIMPSASET, SIMPSAGET
 
 
 % Copyright (C) 2005 Henning Schmidt, FCC, henning@fcc.chalmers.se
 % Copyright (C) 2006 Brecht Donckels, BIOMATH, brecht.donckels@ugent.be
-% Copyright (C) 2013 Dynare Team.
+% Copyright (C) 2013-2017 Dynare Team.
 %
 % This file is part of Dynare.
 %
@@ -77,11 +77,11 @@ function [X,FVAL,EXITFLAG,OUTPUT] = simpsa(FUN,X0,LB,UB,OPTIONS,varargin)
 
 % handle variable input arguments
 
-if nargin < 5,
+if nargin < 5
     OPTIONS = [];
-    if nargin < 4,
+    if nargin < 4
         UB = 1e5;
-        if nargin < 3,
+        if nargin < 3
             LB = -1e5;
         end
     end
@@ -89,22 +89,22 @@ end
 
 % check input arguments
 
-if ~ischar(FUN),
+if ~ischar(FUN)
     error('''FUN'' incorrectly specified in ''SIMPSA''');
 end
-if ~isfloat(X0),
+if ~isfloat(X0)
     error('''X0'' incorrectly specified in ''SIMPSA''');
 end
-if ~isfloat(LB),
+if ~isfloat(LB)
     error('''LB'' incorrectly specified in ''SIMPSA''');
 end
-if ~isfloat(UB),
+if ~isfloat(UB)
     error('''UB'' incorrectly specified in ''SIMPSA''');
 end
-if length(X0) ~= length(LB),
+if length(X0) ~= length(LB)
     error('''LB'' and ''X0'' have incompatible dimensions in ''SIMPSA''');
 end
-if length(X0) ~= length(UB),
+if length(X0) ~= length(UB)
     error('''UB'' and ''X0'' have incompatible dimensions in ''SIMPSA''');
 end
 
@@ -122,20 +122,20 @@ NDIM = length(X0);
 
 % set default options
 DEFAULT_OPTIONS = simpsaset('TEMP_START',[],...  % starting temperature (if none provided, an optimal one will be estimated)
-             'TEMP_END',.1,...                    % end temperature
-             'COOL_RATE',10,...                  % small values (<1) means slow convergence,large values (>1) means fast convergence
-             'INITIAL_ACCEPTANCE_RATIO',0.95,... % when initial temperature is estimated, this will be the initial acceptance ratio in the first round
-             'MIN_COOLING_FACTOR',0.9,...        % minimum cooling factor (<1)
-             'MAX_ITER_TEMP_FIRST',50,...        % number of iterations in the preliminary temperature loop
-             'MAX_ITER_TEMP_LAST',2000,...         % number of iterations in the last temperature loop (pure simplex)
-             'MAX_ITER_TEMP',10,...              % number of iterations in the remaining temperature loops
-             'MAX_ITER_TOTAL',2500,...           % maximum number of iterations tout court
-             'MAX_TIME',2500,...                 % maximum duration of optimization
-             'MAX_FUN_EVALS',20000,...            % maximum number of function evaluations
-             'TOLX',1e-6,...                     % maximum difference between best and worst function evaluation in simplex
-             'TOLFUN',1e-6,...                   % maximum difference between the coordinates of the vertices
-             'DISPLAY','iter',...                % 'iter' or 'none' indicating whether user wants feedback
-             'OUTPUT_FCN',[]);                   % string with output function name
+                            'TEMP_END',.1,...                    % end temperature
+                            'COOL_RATE',10,...                  % small values (<1) means slow convergence,large values (>1) means fast convergence
+                            'INITIAL_ACCEPTANCE_RATIO',0.95,... % when initial temperature is estimated, this will be the initial acceptance ratio in the first round
+                            'MIN_COOLING_FACTOR',0.9,...        % minimum cooling factor (<1)
+                            'MAX_ITER_TEMP_FIRST',50,...        % number of iterations in the preliminary temperature loop
+                            'MAX_ITER_TEMP_LAST',2000,...         % number of iterations in the last temperature loop (pure simplex)
+                            'MAX_ITER_TEMP',10,...              % number of iterations in the remaining temperature loops
+                            'MAX_ITER_TOTAL',2500,...           % maximum number of iterations tout court
+                            'MAX_TIME',2500,...                 % maximum duration of optimization
+                            'MAX_FUN_EVALS',20000,...            % maximum number of function evaluations
+                            'TOLX',1e-6,...                     % maximum difference between best and worst function evaluation in simplex
+                            'TOLFUN',1e-6,...                   % maximum difference between the coordinates of the vertices
+                            'DISPLAY','iter',...                % 'iter' or 'none' indicating whether user wants feedback
+                            'OUTPUT_FCN',[]);                   % string with output function name
 
 % update default options with supplied options
 
@@ -167,7 +167,7 @@ TEMP_LOOP_NUMBER = 1;
 % loop as described by Cardoso et al., 1996 (recommended)
 
 % therefore, the temperature is set to YBEST*1e5 in the first loop
-if isempty(OPTIONS.TEMP_START),
+if isempty(OPTIONS.TEMP_START)
     TEMP = abs(YBEST)*1e5;
 else
     TEMP = OPTIONS.TEMP_START;
@@ -195,51 +195,51 @@ nITERATIONS = 0;
 % temperature loop: run SIMPSA till stopping criterion is met
 % -----------------------------------------------------------
 
-while 1,
-    
+while 1
+
     % detect if termination criterium was met
     % ---------------------------------------
-    
+
     % if a termination criterium was met, the value of EXITFLAG should have changed
     % from its default value of -2 to -1, 0, 1 or 2
-    
-    if EXITFLAG ~= -2,
+
+    if EXITFLAG ~= -2
         break
     end
-    
+
     % set MAXITERTEMP: maximum number of iterations at current temperature
     % --------------------------------------------------------------------
-    
-    if TEMP_LOOP_NUMBER == 1,
+
+    if TEMP_LOOP_NUMBER == 1
         MAXITERTEMP = OPTIONS.MAX_ITER_TEMP_FIRST*NDIM;
-        % The initial temperature is estimated (is requested) as described in 
-        % Cardoso et al. (1996). Therefore, we need to store the number of 
-        % successful and unsuccessful moves, as well as the increase in cost 
+        % The initial temperature is estimated (is requested) as described in
+        % Cardoso et al. (1996). Therefore, we need to store the number of
+        % successful and unsuccessful moves, as well as the increase in cost
         % for the unsuccessful moves.
-        if isempty(OPTIONS.TEMP_START),
+        if isempty(OPTIONS.TEMP_START)
             [SUCCESSFUL_MOVES,UNSUCCESSFUL_MOVES,UNSUCCESSFUL_COSTS] = deal(0);
         end
-    elseif TEMP < OPTIONS.TEMP_END,
+    elseif TEMP < OPTIONS.TEMP_END
         TEMP = 0;
         MAXITERTEMP = OPTIONS.MAX_ITER_TEMP_LAST*NDIM;
     else
         MAXITERTEMP = OPTIONS.MAX_ITER_TEMP*NDIM;
     end
-    
+
     % construct initial simplex
     % -------------------------
-    
+
     % 1st vertex of initial simplex
     P(1,:) = PBEST;
     Y(1) = CALCULATE_COST(FUN,P(1,:),LB,UB,varargin{:});
-    
+
     % if output function given then run output function to plot intermediate result
-    if ~isempty(OPTIONS.OUTPUT_FCN),
+    if ~isempty(OPTIONS.OUTPUT_FCN)
         feval(OPTIONS.OUTPUT_FCN,transpose(P(1,:)),Y(1));
     end
-    
+
     % remaining vertices of simplex
-    for k = 1:NDIM,
+    for k = 1:NDIM
         % copy first vertex in new vertex
         P(k+1,:) = P(1,:);
         % alter new vertex
@@ -247,20 +247,20 @@ while 1,
         % calculate value of objective function at new vertex
         Y(k+1) = CALCULATE_COST(FUN,P(k+1,:),LB,UB,varargin{:});
     end
-    
+
     % store information on what step the algorithm just did
     ALGOSTEP = 'initial simplex';
-    
+
     % add NDIM+1 to number of function evaluations
     nFUN_EVALS = nFUN_EVALS + NDIM;
-    
+
     % note:
     %  dimensions of matrix P: (NDIM+1) x NDIM
     %  dimensions of vector Y: (NDIM+1) x 1
-    
+
     % give user feedback if requested
-    if strcmp(OPTIONS.DISPLAY,'iter'),
-        if nITERATIONS == 0,
+    if strcmp(OPTIONS.DISPLAY,'iter')
+        if nITERATIONS == 0
             disp(' Nr Iter  Nr Fun Eval    Min function       Best function        TEMP           Algorithm Step');
         else
             disp(sprintf('%5.0f      %5.0f       %12.6g     %15.6g      %12.6g       %s',nITERATIONS,nFUN_EVALS,Y(1),YBEST,TEMP,'best point'));
@@ -269,111 +269,111 @@ while 1,
 
     % run full metropolis cycle at current temperature
     % ------------------------------------------------
-    
+
     % initialize vector COSTS, needed to calculate new temperature using cooling
     % schedule as described by Cardoso et al. (1996)
     COSTS = zeros((NDIM+1)*MAXITERTEMP,1);
-    
+
     % initialize ITERTEMP to zero
-    
+
     ITERTEMP = 0;
-    
+
     % start
 
-    for ITERTEMP = 1:MAXITERTEMP,
-        
+    for ITERTEMP = 1:MAXITERTEMP
+
         % add one to number of iterations
         nITERATIONS = nITERATIONS + 1;
-        
+
         % Press and Teukolsky (1991) add a positive logarithmic distributed variable,
-        % proportional to the control temperature T to the function value associated with 
-        % every vertex of the simplex. Likewise,they subtract a similar random variable 
+        % proportional to the control temperature T to the function value associated with
+        % every vertex of the simplex. Likewise,they subtract a similar random variable
         % from the function value at every new replacement point.
         % Thus, if the replacement point corresponds to a lower cost, this method always
-        % accepts a true down hill step. If, on the other hand, the replacement point 
+        % accepts a true down hill step. If, on the other hand, the replacement point
         % corresponds to a higher cost, an uphill move may be accepted, depending on the
         % relative COSTS of the perturbed values.
         % (taken from Cardoso et al.,1996)
-        
+
         % add random fluctuations to function values of current vertices
         YFLUCT = Y+TEMP*abs(log(rand(NDIM+1,1)));
-        
+
         % reorder YFLUCT, Y and P so that the first row corresponds to the lowest YFLUCT value
         help = sortrows([YFLUCT,Y,P],1);
         YFLUCT = help(:,1);
         Y = help(:,2);
         P = help(:,3:end);
-        
+
         % store temperature at current iteration
         OUTPUT.TEMPERATURE(nITERATIONS) = TEMP;
 
         % store information about simplex at the current iteration
         OUTPUT.SIMPLEX(:,:,nITERATIONS) = P;
         OUTPUT.SIMPLEX_BEST(nITERATIONS,:) = PBEST;
-        
+
         % store cost function value of best vertex in current iteration
         OUTPUT.COSTS(nITERATIONS,:) = Y;
         OUTPUT.COST_BEST(nITERATIONS) = YBEST;
-        
-        if strcmp(OPTIONS.DISPLAY,'iter'),
+
+        if strcmp(OPTIONS.DISPLAY,'iter')
             disp(sprintf('%5.0f      %5.0f       %12.6g     %15.6g      %12.6g       %s',nITERATIONS,nFUN_EVALS,Y(1),YBEST,TEMP,ALGOSTEP));
         end
-        
+
         % if output function given then run output function to plot intermediate result
-        if ~isempty(OPTIONS.OUTPUT_FCN),
+        if ~isempty(OPTIONS.OUTPUT_FCN)
             feval(OPTIONS.OUTPUT_FCN,transpose(P(1,:)),Y(1));
         end
-        
+
         % end the optimization if one of the stopping criteria is met
-        %% 1. difference between best and worst function evaluation in simplex is smaller than TOLFUN 
+        %% 1. difference between best and worst function evaluation in simplex is smaller than TOLFUN
         %% 2. maximum difference between the coordinates of the vertices in simplex is less than TOLX
         %% 3. no convergence,but maximum number of iterations has been reached
         %% 4. no convergence,but maximum time has been reached
-            
-        if (abs(max(Y)-min(Y)) < OPTIONS.TOLFUN) && (TEMP_LOOP_NUMBER ~= 1),
-            if strcmp(OPTIONS.DISPLAY,'iter'),
+
+        if (abs(max(Y)-min(Y)) < OPTIONS.TOLFUN) && (TEMP_LOOP_NUMBER ~= 1)
+            if strcmp(OPTIONS.DISPLAY,'iter')
                 disp('Change in the objective function value less than the specified tolerance (TOLFUN).')
             end
             EXITFLAG = 1;
-            break;
+            break
         end
-        
-        if (max(max(abs(P(2:NDIM+1,:)-P(1:NDIM,:)))) < OPTIONS.TOLX) && (TEMP_LOOP_NUMBER ~= 1),
-            if strcmp(OPTIONS.DISPLAY,'iter'),
+
+        if (max(max(abs(P(2:NDIM+1,:)-P(1:NDIM,:)))) < OPTIONS.TOLX) && (TEMP_LOOP_NUMBER ~= 1)
+            if strcmp(OPTIONS.DISPLAY,'iter')
                 disp('Change in X less than the specified tolerance (TOLX).')
             end
             EXITFLAG = 2;
-            break;
+            break
         end
-        
-        if (nITERATIONS >= OPTIONS.MAX_ITER_TOTAL*NDIM) || (nFUN_EVALS >= OPTIONS.MAX_FUN_EVALS*NDIM*(NDIM+1)),
-            if strcmp(OPTIONS.DISPLAY,'iter'),
+
+        if (nITERATIONS >= OPTIONS.MAX_ITER_TOTAL*NDIM) || (nFUN_EVALS >= OPTIONS.MAX_FUN_EVALS*NDIM*(NDIM+1))
+            if strcmp(OPTIONS.DISPLAY,'iter')
                 disp('Maximum number of function evaluations or iterations reached.');
             end
             EXITFLAG = 0;
-            break;
+            break
         end
-        
-        if toc/60 > OPTIONS.MAX_TIME,
-            if strcmp(OPTIONS.DISPLAY,'iter'),
+
+        if toc/60 > OPTIONS.MAX_TIME
+            if strcmp(OPTIONS.DISPLAY,'iter')
                 disp('Exceeded maximum time.');
             end
             EXITFLAG = -1;
-            break;
+            break
         end
-        
+
         % begin a new iteration
-        
+
         %% first extrapolate by a factor -1 through the face of the simplex
         %% across from the high point,i.e.,reflect the simplex from the high point
         [YFTRY,YTRY,PTRY] = AMOTRY(FUN,P,-1,LB,UB,varargin{:});
-        
+
         %% check the result
-        if YFTRY <= YFLUCT(1),
+        if YFTRY <= YFLUCT(1)
             %% gives a result better than the best point,so try an additional
             %% extrapolation by a factor 2
             [YFTRYEXP,YTRYEXP,PTRYEXP] = AMOTRY(FUN,P,-2,LB,UB,varargin{:});
-            if YFTRYEXP < YFTRY,
+            if YFTRYEXP < YFTRY
                 P(end,:) = PTRYEXP;
                 Y(end) = YTRYEXP;
                 ALGOSTEP = 'reflection and expansion';
@@ -382,12 +382,12 @@ while 1,
                 Y(end) = YTRY;
                 ALGOSTEP = 'reflection';
             end
-        elseif YFTRY >= YFLUCT(NDIM),
+        elseif YFTRY >= YFLUCT(NDIM)
             %% the reflected point is worse than the second-highest, so look
             %% for an intermediate lower point, i.e., do a one-dimensional
             %% contraction
             [YFTRYCONTR,YTRYCONTR,PTRYCONTR] = AMOTRY(FUN,P,-0.5,LB,UB,varargin{:});
-            if YFTRYCONTR < YFLUCT(end),
+            if YFTRYCONTR < YFLUCT(end)
                 P(end,:) = PTRYCONTR;
                 Y(end) = YTRYCONTR;
                 ALGOSTEP = 'one dimensional contraction';
@@ -396,7 +396,7 @@ while 1,
                 %% around the lowest (best) point
                 X = ones(NDIM,NDIM)*diag(P(1,:));
                 P(2:end,:) = 0.5*(P(2:end,:)+X);
-                for k=2:NDIM,
+                for k=2:NDIM
                     Y(k) = CALCULATE_COST(FUN,P(k,:),LB,UB,varargin{:});
                 end
                 ALGOSTEP = 'multiple contraction';
@@ -407,15 +407,15 @@ while 1,
             Y(end) = YTRY;
             ALGOSTEP = 'reflection';
         end
-        
-        % the initial temperature is estimated in the first loop from 
-        % the number of successfull and unsuccesfull moves, and the average 
+
+        % the initial temperature is estimated in the first loop from
+        % the number of successfull and unsuccesfull moves, and the average
         % increase in cost associated with the unsuccessful moves
-        
-        if TEMP_LOOP_NUMBER == 1 && isempty(OPTIONS.TEMP_START),
-            if Y(1) > Y(end),
+
+        if TEMP_LOOP_NUMBER == 1 && isempty(OPTIONS.TEMP_START)
+            if Y(1) > Y(end)
                 SUCCESSFUL_MOVES = SUCCESSFUL_MOVES+1;
-            elseif Y(1) <= Y(end),
+            elseif Y(1) <= Y(end)
                 UNSUCCESSFUL_MOVES = UNSUCCESSFUL_MOVES+1;
                 UNSUCCESSFUL_COSTS = UNSUCCESSFUL_COSTS+(Y(end)-Y(1));
             end
@@ -424,28 +424,28 @@ while 1,
     end
 
     % stop if previous for loop was broken due to some stop criterion
-    if ITERTEMP < MAXITERTEMP,
-        break;
+    if ITERTEMP < MAXITERTEMP
+        break
     end
-    
+
     % store cost function values in COSTS vector
     COSTS((ITERTEMP-1)*NDIM+1:ITERTEMP*NDIM+1) = Y;
-    
-    % calculated initial temperature or recalculate temperature 
+
+    % calculated initial temperature or recalculate temperature
     % using cooling schedule as proposed by Cardoso et al. (1996)
     % -----------------------------------------------------------
-    
-    if TEMP_LOOP_NUMBER == 1 && isempty(OPTIONS.TEMP_START),
+
+    if TEMP_LOOP_NUMBER == 1 && isempty(OPTIONS.TEMP_START)
         TEMP = -(UNSUCCESSFUL_COSTS/(SUCCESSFUL_MOVES+UNSUCCESSFUL_MOVES))/log(((SUCCESSFUL_MOVES+UNSUCCESSFUL_MOVES)*OPTIONS.INITIAL_ACCEPTANCE_RATIO-SUCCESSFUL_MOVES)/UNSUCCESSFUL_MOVES);
-    elseif TEMP_LOOP_NUMBER ~= 0,
+    elseif TEMP_LOOP_NUMBER ~= 0
         STDEV_Y = std(COSTS);
         COOLING_FACTOR = 1/(1+TEMP*log(1+OPTIONS.COOL_RATE)/(3*STDEV_Y));
         TEMP = TEMP*min(OPTIONS.MIN_COOLING_FACTOR,COOLING_FACTOR);
     end
-    
+
     % add one to temperature loop number
     TEMP_LOOP_NUMBER = TEMP_LOOP_NUMBER+1;
-    
+
 end
 
 % return solution
@@ -476,8 +476,8 @@ return
 % ---------------
 
 function [YFTRY,YTRY,PTRY] = AMOTRY(FUN,P,fac,LB,UB,varargin)
-% Extrapolates by a factor fac through the face of the simplex across from 
-% the high point, tries it, and replaces the high point if the new point is 
+% Extrapolates by a factor fac through the face of the simplex across from
+% the high point, tries it, and replaces the high point if the new point is
 % better.
 
 global NDIM TEMP
@@ -502,14 +502,14 @@ function [YTRY] = CALCULATE_COST(FUN,PTRY,LB,UB,varargin)
 
 global YBEST PBEST NDIM nFUN_EVALS
 
-for i = 1:NDIM,
+for i = 1:NDIM
     % check lower bounds
-    if PTRY(i) < LB(i),
+    if PTRY(i) < LB(i)
         YTRY = 1e12+(LB(i)-PTRY(i))*1e6;
         return
     end
     % check upper bounds
-    if PTRY(i) > UB(i),
+    if PTRY(i) > UB(i)
         YTRY = 1e12+(PTRY(i)-UB(i))*1e6;
         return
     end
@@ -522,7 +522,7 @@ YTRY = feval(FUN,PTRY(:),varargin{:});
 nFUN_EVALS = nFUN_EVALS + 1;
 
 % save the best point ever
-if YTRY < YBEST,
+if YTRY < YBEST
     YBEST = YTRY;
     PBEST = PTRY;
 end
diff --git a/matlab/optimization/simpsaget.m b/matlab/optimization/simpsaget.m
index e482a3e00..96eb36dc9 100644
--- a/matlab/optimization/simpsaget.m
+++ b/matlab/optimization/simpsaget.m
@@ -18,7 +18,7 @@ function o = simpsaget(options,name,default,flag)
 %   See also SIMPSASET, SIMPSA
 
 % Copyright (C) 2006 Brecht Donckels, BIOMATH, brecht.donckels@ugent.be
-% Copyright (C) 2013-2016 Dynare Team.
+% Copyright (C) 2013-2017 Dynare Team.
 %
 % This file is part of Dynare.
 %
@@ -38,25 +38,25 @@ function o = simpsaget(options,name,default,flag)
 
 % undocumented usage for fast access with no error checking
 if (nargin == 4) && isequal(flag,'fast')
-   o = getknownfield(options,name,default);
-   return
+    o = getknownfield(options,name,default);
+    return
 end
 
 if nargin < 2
-  error('MATLAB:odeget:NotEnoughInputs','Not enough input arguments.');
+    error('MATLAB:odeget:NotEnoughInputs','Not enough input arguments.');
 end
 if nargin < 3
-  default = [];
+    default = [];
 end
 
 if ~isempty(options) && ~isa(options,'struct')
-  error('MATLAB:odeget:Arg1NotODESETstruct',...
-        'First argument must be an options structure created with ODESET.');
+    error('MATLAB:odeget:Arg1NotODESETstruct',...
+          'First argument must be an options structure created with ODESET.');
 end
 
 if isempty(options)
-  o = default;
-  return;
+    o = default;
+    return
 end
 
 Names = [
@@ -75,39 +75,39 @@ Names = [
     'TOLFUN                   '
     'DISPLAY                  '
     'OUTPUT_FCN               '
-    ];
+        ];
 
 names = lower(Names);
 
 lowName = lower(name);
 j = strmatch(lowName,names);
 if isempty(j)               % if no matches
-  error('MATLAB:odeget:InvalidPropName',...
-        ['Unrecognized property name ''%s''.  ' ...
-         'See ODESET for possibilities.'], name);
+    error('MATLAB:odeget:InvalidPropName',...
+          ['Unrecognized property name ''%s''.  ' ...
+           'See ODESET for possibilities.'], name);
 elseif length(j) > 1            % if more than one match
-  % Check for any exact matches (in case any names are subsets of others)
-  k = strmatch(lowName,names,'exact');
-  if length(k) == 1
-    j = k;
-  else
-    msg = sprintf('Ambiguous property name ''%s'' ', name);
-    msg = [msg '(' deblank(Names(j(1),:))];
-    for k = j(2:length(j))'
-      msg = [msg ', ' deblank(Names(k,:))];
+                                % Check for any exact matches (in case any names are subsets of others)
+    k = strmatch(lowName,names,'exact');
+    if length(k) == 1
+        j = k;
+    else
+        msg = sprintf('Ambiguous property name ''%s'' ', name);
+        msg = [msg '(' deblank(Names(j(1),:))];
+        for k = j(2:length(j))'
+            msg = [msg ', ' deblank(Names(k,:))];
+        end
+        msg = sprintf('%s).', msg);
+        error('MATLAB:odeget:AmbiguousPropName', msg);
     end
-    msg = sprintf('%s).', msg);
-    error('MATLAB:odeget:AmbiguousPropName', msg);
-  end
 end
 
 if any(strcmp(fieldnames(options),deblank(Names(j,:))))
-  o = options.(deblank(Names(j,:)));
-  if isempty(o)
-    o = default;
-  end
+    o = options.(deblank(Names(j,:)));
+    if isempty(o)
+        o = default;
+    end
 else
-  o = default;
+    o = default;
 end
 
 % --------------------------------------------------------------------------
@@ -115,11 +115,10 @@ function v = getknownfield(s, f, d)
 %GETKNOWNFIELD  Get field f from struct s, or else yield default d.
 
 if isfield(s,f)   % s could be empty.
-  v = subsref(s, struct('type','.','subs',f));
-  if isempty(v)
-    v = d;
-  end
+    v = subsref(s, struct('type','.','subs',f));
+    if isempty(v)
+        v = d;
+    end
 else
-  v = d;
+    v = d;
 end
-
diff --git a/matlab/optimization/simpsaset.m b/matlab/optimization/simpsaset.m
index ca687891a..1d63c7bdc 100644
--- a/matlab/optimization/simpsaset.m
+++ b/matlab/optimization/simpsaset.m
@@ -28,7 +28,7 @@ function options = simpsaset(varargin)
 
 % Copyright (C) 2005 Henning Schmidt, FCC, henning@fcc.chalmers.se
 % Copyright (C) 2006 Brecht Donckels, BIOMATH, brecht.donckels@ugent.be
-% Copyright (C) 2013 Dynare Team.
+% Copyright (C) 2013-2017 Dynare Team.
 %
 % This file is part of Dynare.
 %
@@ -64,7 +64,7 @@ if (nargin == 0) && (nargout == 0)
     fprintf('                      DISPLAY: [ ''iter'' or ''none'' {''iter''} ]\n');
     fprintf('                   OUTPUT_FCN: [ function_handle ]\n');
     fprintf('\n');
-return;
+    return
 end
 
 Names = [
@@ -83,7 +83,7 @@ Names = [
     'TOLFUN                   '
     'DISPLAY                  '
     'OUTPUT_FCN               '
-    ];
+        ];
 
 m = size(Names,1);
 names = lower(Names);
@@ -91,82 +91,82 @@ names = lower(Names);
 % Combine all leading options structures o1, o2, ... in odeset(o1,o2,...).
 options = [];
 for j = 1:m
-  options.(deblank(Names(j,:))) = [];
+    options.(deblank(Names(j,:))) = [];
 end
 i = 1;
 while i <= nargin
-  arg = varargin{i};
-  if ischar(arg)                         % arg is an option name
-    break;
-  end
-  if ~isempty(arg)                      % [] is a valid options argument
-    if ~isa(arg,'struct')
-      error('MATLAB:odeset:NoPropNameOrStruct',...
-            ['Expected argument %d to be a string property name ' ...
-                     'or an options structure\ncreated with SIMANSET.'], i);
+    arg = varargin{i};
+    if ischar(arg)                         % arg is an option name
+        break
     end
-    for j = 1:m
-      if any(strcmp(fieldnames(arg),deblank(Names(j,:))))
-        val = arg.(deblank(Names(j,:)));
-      else
-        val = [];
-      end
-      if ~isempty(val)
-        options.(deblank(Names(j,:))) = val;
-      end
+    if ~isempty(arg)                      % [] is a valid options argument
+        if ~isa(arg,'struct')
+            error('MATLAB:odeset:NoPropNameOrStruct',...
+                  ['Expected argument %d to be a string property name ' ...
+                   'or an options structure\ncreated with SIMANSET.'], i);
+        end
+        for j = 1:m
+            if any(strcmp(fieldnames(arg),deblank(Names(j,:))))
+                val = arg.(deblank(Names(j,:)));
+            else
+                val = [];
+            end
+            if ~isempty(val)
+                options.(deblank(Names(j,:))) = val;
+            end
+        end
     end
-  end
-  i = i + 1;
+    i = i + 1;
 end
 
 % A finite state machine to parse name-value pairs.
 if rem(nargin-i+1,2) ~= 0
-  error('MATLAB:odeset:ArgNameValueMismatch',...
-        'Arguments must occur in name-value pairs.');
+    error('MATLAB:odeset:ArgNameValueMismatch',...
+          'Arguments must occur in name-value pairs.');
 end
 expectval = 0;                          % start expecting a name, not a value
 while i <= nargin
-  arg = varargin{i};
-    
-  if ~expectval
-    if ~ischar(arg)
-      error('MATLAB:odeset:NoPropName',...
-            'Expected argument %d to be a string property name.', i);
-    end
-    
-    lowArg = lower(arg);
-    j = strmatch(lowArg,names);
-    if isempty(j)                       % if no matches
-      error('MATLAB:odeset:InvalidPropName',...
-            'Unrecognized property name ''%s''.', arg);
-    elseif length(j) > 1                % if more than one match
-      % Check for any exact matches (in case any names are subsets of others)
-      k = strmatch(lowArg,names,'exact');
-      if length(k) == 1
-        j = k;
-      else
-        msg = sprintf('Ambiguous property name ''%s'' ', arg);
-        msg = [msg '(' deblank(Names(j(1),:))];
-        for k = j(2:length(j))'
-          msg = [msg ', ' deblank(Names(k,:))];
+    arg = varargin{i};
+
+    if ~expectval
+        if ~ischar(arg)
+            error('MATLAB:odeset:NoPropName',...
+                  'Expected argument %d to be a string property name.', i);
         end
-        msg = sprintf('%s).', msg);
-        error('MATLAB:odeset:AmbiguousPropName', msg);
-      end
+
+        lowArg = lower(arg);
+        j = strmatch(lowArg,names);
+        if isempty(j)                       % if no matches
+            error('MATLAB:odeset:InvalidPropName',...
+                  'Unrecognized property name ''%s''.', arg);
+        elseif length(j) > 1                % if more than one match
+                                            % Check for any exact matches (in case any names are subsets of others)
+            k = strmatch(lowArg,names,'exact');
+            if length(k) == 1
+                j = k;
+            else
+                msg = sprintf('Ambiguous property name ''%s'' ', arg);
+                msg = [msg '(' deblank(Names(j(1),:))];
+                for k = j(2:length(j))'
+                    msg = [msg ', ' deblank(Names(k,:))];
+                end
+                msg = sprintf('%s).', msg);
+                error('MATLAB:odeset:AmbiguousPropName', msg);
+            end
+        end
+        expectval = 1;                      % we expect a value next
+
+    else
+        options.(deblank(Names(j,:))) = arg;
+        expectval = 0;
+
     end
-    expectval = 1;                      % we expect a value next
-    
-  else
-    options.(deblank(Names(j,:))) = arg;
-    expectval = 0;
-      
-  end
-  i = i + 1;
+    i = i + 1;
 end
 
 if expectval
-  error('MATLAB:odeset:NoValueForProp',...
-        'Expected value for property ''%s''.', arg);
+    error('MATLAB:odeset:NoValueForProp',...
+          'Expected value for property ''%s''.', arg);
 end
 
 end
diff --git a/matlab/optimization/simulated_annealing.m b/matlab/optimization/simulated_annealing.m
index 5b505b71d..7088685b3 100644
--- a/matlab/optimization/simulated_annealing.m
+++ b/matlab/optimization/simulated_annealing.m
@@ -5,7 +5,7 @@ function [xopt, fopt,exitflag, n_accepted_draws, n_total_draws, n_out_of_bounds_
 %
 % Implements the continuous simulated annealing global optimization
 % algorithm described in Corana et al. (1987)
-% 
+%
 %  A very quick (perhaps too quick) overview of SA:
 %     SA tries to find the global optimum of an N dimensional function.
 %  It moves both up and downhill and as the optimization process
@@ -49,17 +49,17 @@ function [xopt, fopt,exitflag, n_accepted_draws, n_total_draws, n_out_of_bounds_
 %    Note: The suggested values generally come from Corana et al. To
 %          drastically reduce runtime, see Goffe et al., pp. 90-1 for
 %          suggestions on choosing the appropriate RT and NT.
-% 
+%
 %    fcn - function to be optimized.
 %    x - The starting values for the variables of the function to be
 %        optimized. (N)
 %    optim:     Options structure with fields
-% 
+%
 %       optim.maximizer_indicator - Denotes whether the function should be maximized or
 %           minimized. A value =1 denotes maximization while a
 %           value =0 denotes minimization. Intermediate output (see verbosity)
 %           takes this into account.
-%       optim.RT - The temperature reduction factor 
+%       optim.RT - The temperature reduction factor
 %       optim.TolFun - Error tolerance for termination. If the final function
 %           values from the last neps temperatures differ from the
 %           corresponding value at the current temperature by less than
@@ -104,11 +104,11 @@ function [xopt, fopt,exitflag, n_accepted_draws, n_total_draws, n_out_of_bounds_
 %                               of all points are accepted, the input value is not very
 %                               important (i.e. is the value is off, SA adjusts VM to the
 %                               correct value)
-% 
-%    lb - The lower bound for the allowable solution variables. 
-%    ub - The upper bound for the allowable solution variables. 
+%
+%    lb - The lower bound for the allowable solution variables.
+%    ub - The upper bound for the allowable solution variables.
 %         If the algorithm chooses X(I) < LB(I) or X(I) > UB(I),
-%         I = 1, N, a point is from inside is randomly selected. 
+%         I = 1, N, a point is from inside is randomly selected.
 %         This focuses the algorithm on the region inside UB and LB.
 %         Unless the user wishes to concentrate the search to a par-
 %         ticular region, UB and LB should be set to very large positive
@@ -116,8 +116,8 @@ function [xopt, fopt,exitflag, n_accepted_draws, n_total_draws, n_out_of_bounds_
 %         vector X should be inside this region. Also note that LB and
 %         UB are fixed in position, while VM is centered on the last
 %         accepted trial set of variables that optimizes the function.
-% 
-% 
+%
+%
 % Input/Output Parameters:
 %
 %  Output Parameters:
@@ -142,28 +142,28 @@ function [xopt, fopt,exitflag, n_accepted_draws, n_total_draws, n_out_of_bounds_
 %    t:     On output, the final temperature.
 %    vm:    Final step length vector
 %
-% Algorithm: 
+% Algorithm:
 %  This routine implements the continuous simulated annealing global
 %  optimization algorithm described in Corana et al.'s article
 %  "Minimizing Multimodal Functions of Continuous Variables with the
 %  "Simulated Annealing" Algorithm" in the September 1987 (vol. 13,
 %  no. 3, pp. 262-280) issue of the ACM Transactions on Mathematical
 %  Software.
-% 
+%
 % For modifications to the algorithm and many details on its use,
 %  (particularly for econometric applications) see Goffe, Ferrier
 %  and Rogers, "Global Optimization of Statistical Functions with
 %  Simulated Annealing," Journal of Econometrics, vol. 60, no. 1/2,
 %  Jan./Feb. 1994, pp. 65-100.
-% 
+%
 %  Based on the Matlab code written by Thomas Werner (Bundesbank December
-%  2002), which in turn is based on the GAUSS version of Bill Goffe's simulated annealing 
+%  2002), which in turn is based on the GAUSS version of Bill Goffe's simulated annealing
 %  program for global optimization, written by E.G.Tsionas (9/4/95).
-% 
-% Copyright (C) 1995 E.G.Tsionas 
-% Copyright (C) 1995-2002 Thomas Werner 
+%
+% Copyright (C) 1995 E.G.Tsionas
+% Copyright (C) 1995-2002 Thomas Werner
 % Copyright (C) 2002-2015 Giovanni Lombardo
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -194,17 +194,17 @@ xopt=x;
 nacp=zeros(n,1);
 fstar=1e20*ones(optim.neps,1);
 %* If the initial temperature is not positive, notify the user and abort. *
-if(t<=0.0);
+if(t<=0.0)
     fprintf('\nThe initial temperature is not positive. Reset the variable t\n');
     exitflag=3;
-    return;
-end;
+    return
+end
 %*  If the initial value is out of bounds, notify the user and abort. *
-if(sum(x>ub)+sum(x<lb)>0);
+if(sum(x>ub)+sum(x<lb)>0)
     fprintf('\nInitial condition out of bounds\n');
     exitflag=2;
-    return;
-end;
+    return
+end
 %*  Evaluate the function with input x and return value as f. *
 f=feval(fcn,x,varargin{:});
 %*
@@ -212,98 +212,98 @@ f=feval(fcn,x,varargin{:});
 %  Note that all intermediate and final output switches the sign back
 %  to eliminate any possible confusion for the user.
 %*
-if(optim.maximizer_indicator==0);
+if(optim.maximizer_indicator==0)
     f=-f;
-end;
+end
 n_total_draws=n_total_draws+1;
 fopt=f;
 fstar(1)=f;
-if(optim.verbosity >1);
+if(optim.verbosity >1)
     disp '  ';
     disp(['initial x    ' num2str(x(:)')]);
-    if(optim.maximizer_indicator);
+    if(optim.maximizer_indicator)
         disp(['initial f    ' num2str(f)]);
     else
         disp(['initial f    ' num2str(-f)]);
-    end;
-end;
+    end
+end
 %  Start the main loop. Note that it terminates if (i) the algorithm
 %  succesfully optimizes the function or (ii) there are too many
 %  function evaluations (more than optim.MaxIter).
 
-while (1>0);
+while (1>0)
     nup=0;
     nrej=0;
     nnew=0;
     ndown=0;
     lnobds=0;
     m=1;
-    while m<=optim.nt;
+    while m<=optim.nt
         j=1;
-        while j<=optim.ns;
+        while j<=optim.ns
             h=1;
-            while h<=n;
+            while h<=n
                 %*  Generate xp, the trial value of x. Note use of vm to choose xp. *
                 i=1;
-                while i<=n;
-                    if(i==h);
+                while i<=n
+                    if(i==h)
                         xp(i)=x(i)+(rand(1,1)*2.0-1.0)*vm(i);
                     else
                         xp(i)=x(i);
-                    end;
+                    end
                     %*  If xp is out of bounds, select a point in bounds for the trial. *
-                    if((xp(i)<lb(i) || xp(i)>ub(i)));
+                    if((xp(i)<lb(i) || xp(i)>ub(i)))
                         xp(i)=lb(i)+(ub(i)-lb(i))*rand(1,1);
                         lnobds=lnobds+1;
                         n_out_of_bounds_draws=n_out_of_bounds_draws+1;
-                        if(optim.verbosity >=3);
+                        if(optim.verbosity >=3)
                             if exist('fp','var')
                                 print_current_invalid_try(optim.maximizer_indicator,xp,x,fp,f);
                             end
-                        end;
-                    end;
+                        end
+                    end
                     i=i+1;
-                end;
+                end
                 %*  Evaluate the function with the trial point xp and return as fp. *
                 % fp=feval(fcn,xp,listarg);
                 fp=feval(fcn,xp,varargin{:});
-                if(optim.maximizer_indicator==0);
+                if(optim.maximizer_indicator==0)
                     fp=-fp;
-                end;
+                end
                 n_total_draws=n_total_draws+1;
-                if(optim.verbosity >=3);
+                if(optim.verbosity >=3)
                     print_current_valid_try(optim.maximizer_indicator,xp,x,fp,f);
-                end;
+                end
                 %*  If too many function evaluations occur, terminate the algorithm. *
-                if(n_total_draws>=optim.MaxIter);
+                if(n_total_draws>=optim.MaxIter)
                     fprintf('Too many function evaluations; consider\n');
                     fprintf('increasing optim.MaxIter or optim.TolFun or decreasing\n');
                     fprintf('optim.nt or optim.rt. These results are likely to be poor\n');
-                    if(optim.maximizer_indicator==0);
+                    if(optim.maximizer_indicator==0)
                         fopt=-fopt;
-                    end;
+                    end
                     exitflag=1;
-                    return;
-                end;
+                    return
+                end
                 %*  Accept the new point if the function value increases. *
-                if(fp>=f);
-                    if(optim.verbosity >=3);
+                if(fp>=f)
+                    if(optim.verbosity >=3)
                         fprintf('point accepted\n');
-                    end;
+                    end
                     x=xp;
                     f=fp;
                     n_accepted_draws=n_accepted_draws+1;
                     nacp(h)=nacp(h)+1;
                     nup=nup+1;
                     %*  If greater than any other point, record as new optimum. *
-                    if(fp>fopt);
-                        if(optim.verbosity >=3);
+                    if(fp>fopt)
+                        if(optim.verbosity >=3)
                             fprintf('new optimum\n');
-                        end;
+                        end
                         xopt=xp;
                         fopt=fp;
                         nnew=nnew+1;
-                    end;
+                    end
                     %*
                     % If the point is lower, use the Metropolis criteria to decide on
                     % acceptance or rejection.
@@ -311,14 +311,14 @@ while (1>0);
                 else
                     p=exp((fp-f)/t);
                     pp=rand(1,1);
-                    if(pp<p);
-                        if(optim.verbosity >=3);
-                            if(optim.maximizer_indicator);
-                             fprintf('though lower, point accepted\n');
+                    if(pp<p)
+                        if(optim.verbosity >=3)
+                            if(optim.maximizer_indicator)
+                                fprintf('though lower, point accepted\n');
                             else
-                             fprintf('though higher, point accepted\n');
-                            end;
-                        end;
+                                fprintf('though higher, point accepted\n');
+                            end
+                        end
                         x=xp;
                         f=fp;
                         n_accepted_draws=n_accepted_draws+1;
@@ -326,87 +326,87 @@ while (1>0);
                         ndown=ndown+1;
                     else
                         nrej=nrej+1;
-                        if(optim.verbosity >=3);
-                            if(optim.maximizer_indicator);
+                        if(optim.verbosity >=3)
+                            if(optim.maximizer_indicator)
                                 fprintf('lower point rejected\n');
                             else
                                 fprintf('higher point rejected\n');
-                            end;
-                        end;
-                    end;
-                end;
+                            end
+                        end
+                    end
+                end
                 h=h+1;
-            end;
+            end
             j=j+1;
-        end;
+        end
         %*  Adjust vm so that approximately half of all evaluations are accepted. *
         i=1;
-        while i<=n;
+        while i<=n
             ratio=nacp(i)/optim.ns;
-            if(ratio>.6);
+            if(ratio>.6)
                 vm(i)=vm(i)*(1.+c(i)*(ratio-.6)/.4);
-            elseif(ratio<.4);
+            elseif(ratio<.4)
                 vm(i)=vm(i)/(1.+c(i)*((.4-ratio)/.4));
-            end;
-            if(vm(i)>(ub(i)-lb(i)));
+            end
+            if(vm(i)>(ub(i)-lb(i)))
                 vm(i)=ub(i)-lb(i);
-            end;
+            end
             i=i+1;
-        end;
-        if(optim.verbosity >=2);
+        end
+        if(optim.verbosity >=2)
             fprintf('intermediate results after step length adjustment\n');
             fprintf('new step length(vm)  %4.3f', vm(:)');
             fprintf('current optimal x    %4.3f', xopt(:)');
             fprintf('current x            %4.3f', x(:)');
-        end;
+        end
         nacp=zeros(n,1);
         m=m+1;
-    end;
-    if(optim.verbosity >=1);
+    end
+    if(optim.verbosity >=1)
         print_intermediate_statistics(optim.maximizer_indicator,t,xopt,vm,fopt,nup,ndown,nrej,lnobds,nnew);
-    end;
+    end
     %*  Check termination criteria. *
     quit=0;
     fstar(1)=f;
-    if((fopt-fstar(1))<=optim.TolFun);
+    if((fopt-fstar(1))<=optim.TolFun)
         quit=1;
-    end;
-    if(sum(abs(f-fstar)>optim.TolFun)>0);
+    end
+    if(sum(abs(f-fstar)>optim.TolFun)>0)
         quit=0;
-    end;
+    end
     %*  Terminate SA if appropriate. *
-    if(quit);
+    if(quit)
         exitflag=0;
-        if(optim.maximizer_indicator==0);
+        if(optim.maximizer_indicator==0)
             fopt=-fopt;
-        end;
-        if(optim.verbosity >=1);
+        end
+        if(optim.verbosity >=1)
             fprintf('SA achieved termination criteria.exitflag=0\n');
-        end;
-        return;        
-    end;
+        end
+        return
+    end
     %*  If termination criteria are not met, prepare for another loop. *
     t=optim.rt*t;
     i=optim.neps;
-    while i>=2;
+    while i>=2
         fstar(i)=fstar(i-1);
         i=i-1;
-    end;
+    end
     f=fopt;
     x=xopt;
     %*  Loop again. *
-end;
+end
 
 end
 
 function  print_current_invalid_try(max,xp,x,fp,f)
 fprintf('\n');
-    disp(['Current x    ' num2str(x(:)')]);
-if(max);
+disp(['Current x    ' num2str(x(:)')]);
+if(max)
     disp(['Current f    ' num2str(f)]);
 else
     disp(['Current f    ' num2str(-f)]);
-end;
+end
 disp(['Trial x      ' num2str(xp(:)')]);
 disp 'Point rejected since out of bounds';
 end
@@ -414,7 +414,7 @@ end
 function print_current_valid_try(max,xp,x,fp,f)
 
 disp(['Current x    ' num2str(x(:)')]);
-if(max);
+if(max)
     disp(['Current f   ' num2str(f)]);
     disp(['Trial x     ' num2str(xp(:)')]);
     disp(['Resulting f ' num2str(fp)]);
@@ -422,7 +422,7 @@ else
     disp(['Current f   ' num2str(-f)]);
     disp(['Trial x     ' num2str(xp(:)')]);
     disp(['Resulting f ' num2str(-fp)]);
-end;
+end
 end
 
 
diff --git a/matlab/optimization/solvopt.m b/matlab/optimization/solvopt.m
index 6d5693e86..c4a819a26 100644
--- a/matlab/optimization/solvopt.m
+++ b/matlab/optimization/solvopt.m
@@ -1,10 +1,10 @@
 function [x,f,exitflag,n_f_evals,n_grad_evals,n_constraint_evals,n_constraint_gradient_evals]=solvopt(x,fun,grad,func,gradc,optim,varargin)
 % [x,f,options]=solvopt(x,fun,grad,func,gradc,options,varargin)
-% 
-% The function SOLVOPT, developed by Alexei Kuntsevich and Franz Kappe,  
+%
+% The function SOLVOPT, developed by Alexei Kuntsevich and Franz Kappe,
 % performs a modified version of Shor's r-algorithm in
 % order to find a local minimum resp. maximum of a nonlinear function
-% defined on the n-dimensional Euclidean space or % a solution of a nonlinear 
+% defined on the n-dimensional Euclidean space or % a solution of a nonlinear
 % constrained problem:
 % min { f(x): g(x) (<)= 0, g(x) in R(m), x in R(n) }
 %
@@ -41,7 +41,7 @@ function [x,f,exitflag,n_f_evals,n_grad_evals,n_constraint_evals,n_constraint_gr
 %   *optim.LBGradientStep= lower bound for the stepsize used for the difference
 %        approximation of gradients (1e-12 by default, see more in the manual).
 %  (* ... changes should be done with care)
-% 
+%
 % Outputs:
 % x                     optimal parameter vector (row resp. column),
 % f                     optimum function value
@@ -51,15 +51,15 @@ function [x,f,exitflag,n_f_evals,n_grad_evals,n_constraint_evals,n_constraint_gr
 % n_grad_evals:         number of gradient evaluations,
 % n_constraint_evals:   number of constraint function evaluations,
 % n_constraint_gradient_evals   number of constraint gradient evaluations.
-% 
-% 
-% Algorithm: Kuntsevich, A.V., Kappel, F., SolvOpt - The solver for local nonlinear optimization problems 
-% (version 1.1, Matlab, C, FORTRAN). University of Graz, Graz, 1997. 
-% 
-% 
-% Copyright (C) 1997-2008, Alexei Kuntsevich and Franz Kappel 
+%
+%
+% Algorithm: Kuntsevich, A.V., Kappel, F., SolvOpt - The solver for local nonlinear optimization problems
+% (version 1.1, Matlab, C, FORTRAN). University of Graz, Graz, 1997.
+%
+%
+% Copyright (C) 1997-2008, Alexei Kuntsevich and Franz Kappel
 % Copyright (C) 2008-2015 Giovanni Lombardo
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -162,7 +162,7 @@ if isempty(func)
     constr=0;
 else
     constr=1;                  % Constrained problem
-    if isempty(gradc),
+    if isempty(gradc)
         appconstr=1;
     else
         appconstr=0;            % Exact gradients of constraints are supplied
@@ -201,7 +201,7 @@ end
 epsnorm=1.e-15;
 epsnorm2=1.e-30;    % epsilon & epsilon^2
 
-if constr, h1=-1;                  % NLP: restricted to minimization
+if constr, h1=-1                  % NLP: restricted to minimization
     cnteps=optim.TolXConstraint;                % Max. admissible residual
 else
     h1=sign(optim.minimizer_indicator);         % Minimize resp. maximize a function
@@ -217,10 +217,10 @@ ajp=20;
 ajpp=ajp;                        % Start value for the power
 ajs=1.15;                        % Base II
 knorms=0; gnorms=zeros(1,10);    % Gradient norms stored
-%---}
+                                 %---}
 
 %Display control ---{
-if optim.verbosity<=0, dispdata=0;
+if optim.verbosity<=0, dispdata=0
     if optim.verbosity==-1
         dispwarn=0;
     else
@@ -243,7 +243,7 @@ else
     des=3.3;
 end
 mxtc=3;                          % Number of trial cycles (steep wall detect)
-%---}
+                                 %---}
 termx=0; limxterm=50;              % Counter and limit for x-criterion
 
 ddx   =max(1e-11,optim.LBGradientStep);      % stepsize for gradient approximation
@@ -253,7 +253,7 @@ low_bound=-1+1e-4;                 % Lower bound cosine used to detect a ravine
 ZeroGrad=n*1.e-16;                 % Lower bound for a gradient norm
 
 nzero=0;                           % Zero-gradient events counter
-% Lower bound for values of variables taking into account
+                                   % Lower bound for values of variables taking into account
 lowxbound=max([optim.TolX,1e-3]);
 % Lower bound for function values to be considered as making difference
 lowfbound=optim.TolFun^2;
@@ -276,30 +276,79 @@ else
     f=feval(fun,x,varargin{:});
 end
 n_f_evals=n_f_evals+1;
-if isempty(f),      if dispwarn,disp(errmes);disp(error30);end
-    exitflag=-3; if trx, x=x';end, return
-elseif isnan(f),    if dispwarn,disp(errmes);disp(error31);disp(error6);end
-    exitflag=-3; if trx, x=x';end, return
-elseif abs(f)==Inf, if dispwarn,disp(errmes);disp(error32);disp(error6);end
-    exitflag=-3; if trx, x=x';end, return
+if isempty(f)
+    if dispwarn
+        disp(errmes)
+        disp(error30)
+    end
+    exitflag=-3;
+    if trx
+        x=x';
+    end
+    return
+elseif isnan(f)
+    if dispwarn
+        disp(errmes)
+        disp(error31)
+        disp(error6)
+    end
+    exitflag=-3;
+    if trx
+        x=x';
+    end
+    return
+elseif abs(f)==Inf
+    if dispwarn
+        disp(errmes)
+        disp(error32)
+        disp(error6)
+    end
+    exitflag=-3;
+    if trx
+        x=x';
+    end
+    return
 end
 xrec=x; frec=f;     % record point and function value
-% Constrained problem
-if constr,  fp=f; kless=0;
-    if trx,
+                    % Constrained problem
+if constr,  fp=f; kless=0
+    if trx
         fc=feval(func,x');
     else
         fc=feval(func,x);
     end
-    if isempty(fc),
-        if dispwarn,disp(errmes);disp(error50);end
-        exitflag=-5; if trx, x=x';end, return
-    elseif isnan(fc),
-        if dispwarn,disp(errmes);disp(error51);disp(error6);end
-        exitflag=-5; if trx, x=x';end, return
-    elseif abs(fc)==Inf,
-        if dispwarn,disp(errmes);disp(error52);disp(error6);end
-        exitflag=-5; if trx, x=x';end, return
+    if isempty(fc)
+        if dispwarn
+            disp(errmes)
+            disp(error50)
+        end
+        exitflag=-5;
+        if trx
+            x=x';
+        end
+        return
+    elseif isnan(fc)
+        if dispwarn
+            disp(errmes)
+            disp(error51)
+            disp(error6)
+        end
+        exitflag=-5;
+        if trx
+            x=x';
+        end
+        return
+    elseif abs(fc)==Inf
+        if dispwarn
+            disp(errmes)
+            disp(error52)
+            disp(error6)
+        end
+        exitflag=-5;
+        if trx
+            x=x';
+        end
+        return
     end
     n_constraint_evals=n_constraint_evals+1;
     PenCoef=1;                              % first rough approximation
@@ -318,13 +367,13 @@ if app
         if trx
             g=apprgrdn(x',fp,fun,deltax',1,varargin{:});
         else
-            g=apprgrdn(x ,fp,fun,deltax,1,varargin{:}); 
+            g=apprgrdn(x ,fp,fun,deltax,1,varargin{:});
         end
     else
         if trx
             g=apprgrdn(x',f,fun,deltax',1,varargin{:});
         else
-            g=apprgrdn(x ,f,fun,deltax,1,varargin{:}); 
+            g=apprgrdn(x ,f,fun,deltax,1,varargin{:});
         end
     end
     n_f_evals=n_f_evals+n;
@@ -332,114 +381,151 @@ else
     if trx
         g=feval(grad,x',varargin{:});
     else
-        g=feval(grad,x,varargin{:});   
+        g=feval(grad,x,varargin{:});
     end
     n_grad_evals=n_grad_evals+1;
 end
-if size(g,2)==1, g=g'; end, ng=norm(g);
-if size(g,2)~=n,    if dispwarn,disp(errmes);disp(error40);end
-    exitflag=-4; if trx, x=x';end, return
-elseif isnan(ng),   if dispwarn,disp(errmes);disp(error41);disp(error6);end
-    exitflag=-4; if trx, x=x';end, return
-elseif ng==Inf,     if dispwarn,disp(errmes);disp(error42);disp(error6);end
-    exitflag=-4; if trx, x=x';end, return
-elseif ng<ZeroGrad, if dispwarn,disp(errmes);disp(error43);disp(error6);end
-    exitflag=-4; if trx, x=x';end, return
+if size(g,2)==1, g=g'; end
+ng=norm(g);
+if size(g,2)~=n
+    if dispwarn
+        disp(errmes)
+        disp(error40)
+    end
+    exitflag=-4;
+    if trx
+        x=x';
+    end
+    return
+elseif isnan(ng)
+    if dispwarn
+        disp(errmes)
+        disp(error41)
+        disp(error6)
+    end
+    exitflag=-4;
+    if trx
+        x=x';
+    end
+    return
+elseif ng==Inf
+    if dispwarn
+        disp(errmes)
+        disp(error42)
+        disp(error6)
+    end
+    exitflag=-4;
+    if trx
+        x=x';
+    end
+    return
+elseif ng<ZeroGrad
+    if dispwarn
+        disp(errmes)
+        disp(error43)
+        disp(error6)
+    end
+    exitflag=-4;
+    if trx
+        x=x';
+    end
+    return
 end
 if constr
     if ~FP
-        if appconstr,
+        if appconstr
             deltax=sign(x); idx=find(deltax==0);
-            deltax(idx)=ones(size(idx));  
+            deltax(idx)=ones(size(idx));
             deltax=ddx*deltax;
             if trx
                 gc=apprgrdn(x',fc,func,deltax',0);
             else
-                gc=apprgrdn(x ,fc,func,deltax ,0); 
+                gc=apprgrdn(x ,fc,func,deltax ,0);
             end
             n_constraint_evals=n_constraint_evals+n;
         else
             if trx
                 gc=feval(gradc,x');
             else
-                gc=feval(gradc,x); 
+                gc=feval(gradc,x);
             end
             n_constraint_gradient_evals=n_constraint_gradient_evals+1;
         end
         if size(gc,2)==1
-            gc=gc'; 
+            gc=gc';
         end
         ngc=norm(gc);
-        if size(gc,2)~=n,
+        if size(gc,2)~=n
             if dispwarn
-                disp(errmes);
-                disp(error60);
+                disp(errmes)
+                disp(error60)
             end
-            exitflag=-6; 
+            exitflag=-6;
             if trx
                 x=x';
             end
             return
-        elseif isnan(ngc),
+        elseif isnan(ngc)
             if dispwarn
-                disp(errmes);
-                disp(error61);
-                disp(error6);
+                disp(errmes)
+                disp(error61)
+                disp(error6)
             end
-            exitflag=-6; 
+            exitflag=-6;
             if trx
                 x=x';
             end
             return
-        elseif ngc==Inf,
+        elseif ngc==Inf
             if dispwarn
-                disp(errmes);
-                disp(error62);
-                disp(error6);
+                disp(errmes)
+                disp(error62)
+                disp(error6)
             end
-            exitflag=-6; 
+            exitflag=-6;
             if trx
                 x=x';
             end
             return
-        elseif ngc<ZeroGrad,
+        elseif ngc<ZeroGrad
             if dispwarn
-                disp(errmes);
-                disp(error63);
+                disp(errmes)
+                disp(error63)
             end
-            exitflag=-6; 
+            exitflag=-6;
             if trx
                 x=x';
             end
             return
         end
         g=g+PenCoef*gc; ng=norm(g);
-    end, end
+    end
+end
 grec=g; nng=ng;
 % ----}
 % INITIAL STEPSIZE
 h=h1*sqrt(optim.TolX)*max(abs(x));     % smallest possible stepsize
-if abs(optim.minimizer_indicator)~=1,
+if abs(optim.minimizer_indicator)~=1
     h=h1*max(abs([optim.minimizer_indicator,h]));     % user-supplied stepsize
 else
     h=h1*max(1/log(ng+1.1),abs(h));    % calculated stepsize
 end
 
 % RESETTING LOOP ----{
-while 1,
+while 1
     kcheck=0;                        % Set checkpoint counter.
     kg=0;                            % stepsizes stored
     kj=0;                            % ravine jump counter
     B=eye(n);                        % re-set transf. matrix to identity
     fst=f; g1=g;  dx=0;
     % ----}
-    
+
     % MAIN ITERATIONS ----{
-    
-    while 1,
+
+    while 1
         k=k+1;kcheck=kcheck+1;
         laststep=dx;
-        
+
         % ADJUST GAMMA --{
         gamma=1+max([ajb^((ajp-kcheck)*n),2*optim.TolFun]);
         gamma=min([gamma,ajs^max([1,log10(nng+1)])]);
@@ -447,11 +533,21 @@ while 1,
         gt=g*B;   w=wdef;
         % JUMPING OVER A RAVINE ----{
         if (gt/norm(gt))*(g1'/norm(g1))<low_bound
-            if kj==2, xx=x;  end,  if kj==0, kd=4;  end,
+            if kj==2
+                xx=x;
+            end
+            if kj==0
+                kd=4
+            end
             kj=kj+1;  w=-.9; h=h*2;             % use large coef. of space dilation
-            if kj>2*kd,     kd=kd+1;  warnno=1;
-                if any(abs(x-xx)<epsnorm*abs(x)), % flat bottom is detected
-                    if dispwarn,disp(wrnmes);disp(warn08); end
+            if kj>2*kd
+                kd=kd+1;
+                warnno=1;
+                if any(abs(x-xx)<epsnorm*abs(x)) % flat bottom is detected
+                    if dispwarn
+                        disp(wrnmes)
+                        disp(warn08)
+                    end
                 end
             end
         else
@@ -465,8 +561,8 @@ while 1,
             z=z/nrmz;
             g1=gt+w*(z*gt')*z;  B=B+w*(B*z')*z;
         else
-            z=zeros(1,n); 
-            nrmz=0; 
+            z=zeros(1,n);
+            nrmz=0;
             g1=gt;
         end
         d1=norm(g1);  g0=(g1/d1)*B';
@@ -474,15 +570,18 @@ while 1,
         % RESETTING ----{
         if kcheck>1
             idx=find(abs(g)>ZeroGrad); numelem=size(idx,2);
-            if numelem>0, grbnd=epsnorm*numelem^2;
-                if all(abs(g1(idx))<=abs(g(idx))*grbnd) | nrmz==0
-                    if dispwarn,  disp(wrnmes);  disp(warn20); end
+            if numelem>0, grbnd=epsnorm*numelem^2
+                if all(abs(g1(idx))<=abs(g(idx))*grbnd) || nrmz==0
+                    if dispwarn
+                        disp(wrnmes)
+                        disp(warn20)
+                    end
                     if abs(fst-f)<abs(f)*.01
                         ajp=ajp-10*n;
                     else
-                        ajp=ajpp; 
+                        ajp=ajpp;
                     end
-                    h=h1*dx/3; 
+                    h=h1*dx/3;
                     k=k-1;
                     break
                 end
@@ -493,23 +592,26 @@ while 1,
         xopt=x;fopt=f;   k1=0;k2=0;ksm=0;kc=0;knan=0;  hp=h;
         if constr, Reset=0; end
         % 1-D SEARCH ----{
-        while 1,
+        while 1
             x1=x;f1=f;
-            if constr, FP1=FP; fp1=fp; end
+            if constr
+                FP1=FP;
+                fp1=fp;
+            end
             x=x+hp*g0;
             % FUNCTION VALUE
             if trx
                 f=feval(fun,x',varargin{:});
             else
-                f=feval(fun,x,varargin{:});  
+                f=feval(fun,x,varargin{:});
             end
             n_f_evals=n_f_evals+1;
             if h1*f==Inf
                 if dispwarn
-                    disp(errmes); 
-                    disp(error5); 
+                    disp(errmes)
+                    disp(error5)
                 end
-                exitflag=-7; 
+                exitflag=-7;
                 if trx
                     x=x';
                 end
@@ -522,15 +624,31 @@ while 1,
                     fc=feval(func,x);
                 end
                 n_constraint_evals=n_constraint_evals+1;
-                if  isnan(fc),
-                    if dispwarn,disp(errmes);disp(error51);disp(error6);end
-                    exitflag=-5; if trx, x=x';end, return
-                elseif abs(fc)==Inf,
-                    if dispwarn,disp(errmes);disp(error52);disp(error6);end
-                    exitflag=-5; if trx, x=x';end, return
+                if  isnan(fc)
+                    if dispwarn
+                        disp(errmes)
+                        disp(error51)
+                        disp(error6)
+                    end
+                    exitflag=-5;
+                    if trx
+                        x=x';
+                    end
+                    return
+                elseif abs(fc)==Inf
+                    if dispwarn
+                        disp(errmes)
+                        disp(error52)
+                        disp(error6)
+                    end
+                    exitflag=-5;
+                    if trx
+                        x=x';
+                    end
+                    return
                 end
                 if fc<=cnteps
-                    FP=1; 
+                    FP=1;
                     fc=0;
                 else
                     FP=0;
@@ -538,7 +656,7 @@ while 1,
                     if fp_rate<-epsnorm
                         if ~FP1
                             PenCoefNew=-15*fp_rate/norm(x-x1);
-                            if PenCoefNew>1.2*PenCoef,
+                            if PenCoefNew>1.2*PenCoef
                                 PenCoef=PenCoefNew; Reset=1; kless=0; f=f+PenCoef*fc; break
                             end
                         end
@@ -547,98 +665,123 @@ while 1,
                 f=f+PenCoef*fc;
             end
             if abs(f)==Inf || isnan(f)
-                if dispwarn, disp(wrnmes);
+                if dispwarn, disp(wrnmes)
                     if isnan(f)
-                        disp(error31); 
+                        disp(error31)
                     else
-                        disp(error32); 
+                        disp(error32)
                     end
                 end
                 if ksm || kc>=mxtc
-                    exitflag=-3; 
+                    exitflag=-3;
                     if trx
                         x=x';
                     end
                     return
                 else
                     k2=k2+1;
-                    k1=0; 
-                    hp=hp/dq; 
+                    k1=0;
+                    hp=hp/dq;
                     x=x1;
-                    f=f1; 
+                    f=f1;
                     knan=1;
                     if constr
-                        FP=FP1; 
-                        fp=fp1; 
+                        FP=FP1;
+                        fp=fp1;
                     end
                 end
                 % STEP SIZE IS ZERO TO THE EXTENT OF EPSNORM
-            elseif all(abs(x-x1)<abs(x)*epsnorm),
+            elseif all(abs(x-x1)<abs(x)*epsnorm)
                 stepvanish=stepvanish+1;
-                if stepvanish>=5,
+                if stepvanish>=5
                     exitflag=-14;
-                    if dispwarn, disp(termwarn1);
-                        disp(endwarn(4,:)); end
-                    if trx,x=x';end,  return
+                    if dispwarn
+                        disp(termwarn1)
+                        disp(endwarn(4,:))
+                    end
+                    if trx
+                        x=x';
+                    end
+                    return
                 else
-                    x=x1; 
-                    f=f1; 
-                    hp=hp*10; 
+                    x=x1;
+                    f=f1;
+                    hp=hp*10;
                     ksm=1;
                     if constr
-                        FP=FP1; 
-                        fp=fp1; 
+                        FP=FP1;
+                        fp=fp1;
                     end
                 end
                 % USE SMALLER STEP
             elseif h1*f<h1*gamma^sign(f1)*f1
-                if ksm,break,end,  k2=k2+1;k1=0; hp=hp/dq; x=x1;f=f1;
-                if constr, FP=FP1; fp=fp1; end
+                if ksm
+                    break
+                end
+                k2=k2+1;k1=0; hp=hp/dq; x=x1;f=f1;
+                if constr
+                    FP=FP1;
+                    fp=fp1;
+                end
                 if kc>=mxtc, break, end
                 % 1-D OPTIMIZER IS LEFT BEHIND
-            else   if h1*f<=h1*f1, break,  end
+            else
+                if h1*f<=h1*f1
+                    break
+                end
                 % USE LARGER STEP
-                k1=k1+1; if k2>0, kc=kc+1; end, k2=0;
-                if k1>=20,      hp=du20*hp;
-                elseif k1>=10,  hp=du10*hp;
-                elseif k1>=3,   hp=du03*hp;
+                k1=k1+1;
+                if k2>0
+                    kc=kc+1;
+                end
+                k2=0;
+                if k1>=20
+                    hp=du20*hp;
+                elseif k1>=10
+                    hp=du10*hp;
+                elseif k1>=3
+                    hp=du03*hp;
                 end
             end
         end
         % ----}  End of 1-D search
         % ADJUST THE TRIAL STEP SIZE ----{
         dx=norm(xopt-x);
-        if kg<kstore,  kg=kg+1;  end
-        if kg>=2,  nsteps(2:kg)=nsteps(1:kg-1); end
+        if kg<kstore
+            kg=kg+1;
+        end
+        if kg>=2
+            nsteps(2:kg)=nsteps(1:kg-1);
+        end
         nsteps(1)=dx/(abs(h)*norm(g0));
         kk=sum(nsteps(1:kg).*[kg:-1:1])/sum([kg:-1:1]);
         if     kk>des
             if kg==1
                 h=h*(kk-des+1);
             else
-                h=h*sqrt(kk-des+1); 
+                h=h*sqrt(kk-des+1);
             end
         elseif kk<des
             h=h*sqrt(kk/des);
         end
-        
+
         stepvanish=stepvanish+ksm;
         % ----}
         % COMPUTE THE GRADIENT ----{
-        if app,
+        if app
             deltax=sign(g0); idx=find(deltax==0);
             deltax(idx)=ones(size(idx));  deltax=h1*ddx*deltax;
             if constr
                 if trx
                     g=apprgrdn(x',fp,fun,deltax',1,varargin{:});
                 else
-                    g=apprgrdn(x ,fp,fun,deltax,1,varargin{:});    
+                    g=apprgrdn(x ,fp,fun,deltax,1,varargin{:});
                 end
             else
                 if trx
                     g=apprgrdn(x',f,fun,deltax',1,varargin{:});
                 else
-                    g=apprgrdn(x ,f,fun,deltax ,1,varargin{:});    
+                    g=apprgrdn(x ,f,fun,deltax ,1,varargin{:});
                 end
             end
             n_f_evals=n_f_evals+n;
@@ -646,19 +789,39 @@ while 1,
             if trx
                 g=feval(grad,x',varargin{:});
             else
-                g=feval(grad,x,varargin{:}); 
+                g=feval(grad,x,varargin{:});
             end
             n_grad_evals=n_grad_evals+1;
         end
-        if size(g,2)==1, g=g'; end,    ng=norm(g);
-        if isnan(ng),
-            if dispwarn, disp(errmes); disp(error41); end
-            exitflag=-4; if trx, x=x'; end, return
-        elseif ng==Inf,
-            if dispwarn,disp(errmes);disp(error42);end
-            exitflag=-4; if trx, x=x';end, return
-        elseif ng<ZeroGrad,
-            if dispwarn,disp(wrnmes);disp(warn1);end
+        if size(g,2)==1
+            g=g'
+        end
+        ng=norm(g);
+        if isnan(ng)
+            if dispwarn
+                disp(errmes)
+                disp(error41)
+            end
+            exitflag=-4;
+            if trx
+                x=x';
+            end
+            return
+        elseif ng==Inf
+            if dispwarn
+                disp(errmes)
+                disp(error42)
+            end
+            exitflag=-4;
+            if trx
+                x=x';
+            end
+            return
+        elseif ng<ZeroGrad
+            if dispwarn
+                disp(wrnmes)
+                disp(warn1)
+            end
             ng=ZeroGrad;
         end
         % Constraints:
@@ -666,52 +829,93 @@ while 1,
             if ~FP
                 if ng<.01*PenCoef
                     kless=kless+1;
-                    if kless>=20, PenCoef=PenCoef/10; Reset=1; kless=0; end
+                    if kless>=20
+                        PenCoef=PenCoef/10;
+                        Reset=1;
+                        kless=0;
+                    end
                 else
                     kless=0;
                 end
-                if appconstr,
+                if appconstr
                     deltax=sign(x); idx=find(deltax==0);
                     deltax(idx)=ones(size(idx));  deltax=ddx*deltax;
                     if trx
                         gc=apprgrdn(x',fc,func,deltax',0);
                     else
-                        gc=apprgrdn(x ,fc,func,deltax ,0); 
+                        gc=apprgrdn(x ,fc,func,deltax ,0);
                     end
                     n_constraint_evals=n_constraint_evals+n;
                 else
                     if trx
                         gc=feval(gradc,x');
                     else
-                        gc=feval(gradc,x ); 
+                        gc=feval(gradc,x );
                     end
                     n_constraint_gradient_evals=n_constraint_gradient_evals+1;
                 end
-                if size(gc,2)==1, gc=gc'; end, ngc=norm(gc);
-                if     isnan(ngc),
-                    if dispwarn,disp(errmes);disp(error61);end
-                    exitflag=-6; if trx, x=x';end, return
-                elseif ngc==Inf,
-                    if dispwarn,disp(errmes);disp(error62);end
-                    exitflag=-6; if trx, x=x';end, return
-                elseif ngc<ZeroGrad && ~appconstr,
-                    if dispwarn,disp(errmes);disp(error63);end
-                    exitflag=-6; if trx, x=x';end, return
+                if size(gc,2)==1
+                    gc=gc';
+                end
+                ngc=norm(gc);
+                if isnan(ngc)
+                    if dispwarn
+                        disp(errmes)
+                        disp(error61)
+                    end
+                    exitflag=-6;
+                    if trx
+                        x=x';
+                    end
+                    return
+                elseif ngc==Inf
+                    if dispwarn
+                        disp(errmes)
+                        disp(error62)
+                    end
+                    exitflag=-6;
+                    if trx
+                        x=x';
+                    end
+                    return
+                elseif ngc<ZeroGrad && ~appconstr
+                    if dispwarn
+                        disp(errmes)
+                        disp(error63)
+                    end
+                    exitflag=-6;
+                    if trx
+                        x=x';
+                    end
+                    return
                 end
                 g=g+PenCoef*gc; ng=norm(g);
-                if Reset, if dispwarn,  disp(wrnmes);  disp(warn21); end
+                if Reset
+                    if dispwarn
+                        disp(wrnmes)
+                        disp(warn21)
+                    end
                     h=h1*dx/3; k=k-1; nng=ng; break
                 end
-            end, end
-        if h1*f>h1*frec, frec=f; xrec=x; grec=g; end
+            end
+        end
+        if h1*f>h1*frec
+            frec=f;
+            xrec=x;
+            grec=g;
+        end
         % ----}
-        if ng>ZeroGrad,
-            if knorms<10,  knorms=knorms+1;  end
-            if knorms>=2,  gnorms(2:knorms)=gnorms(1:knorms-1); end
+        if ng>ZeroGrad
+            if knorms<10
+                knorms=knorms+1;
+            end
+            if knorms>=2
+                gnorms(2:knorms)=gnorms(1:knorms-1);
+            end
             gnorms(1)=ng;
             nng=(prod(gnorms(1:knorms)))^(1/knorms);
         end
-        
+
         % DISPLAY THE CURRENT VALUES ----{
         if k==ld
             disp('Iter.# ..... Function ... Step Value ... Gradient Norm ');
@@ -721,10 +925,20 @@ while 1,
         %----}
         % CHECK THE STOPPING CRITERIA ----{
         termflag=1;
-        if constr, if ~FP, termflag=0; end, end
-        if kcheck<=5, termflag=0; end
-        if knan, termflag=0; end
-        if kc>=mxtc, termflag=0; end
+        if constr
+            if ~FP
+                termflag=0;
+            end
+        end
+        if kcheck<=5
+            termflag=0;
+        end
+        if knan
+            termflag=0
+        end
+        if kc>=mxtc
+            termflag=0;
+        end
         % ARGUMENT
         if termflag
             idx=find(abs(x)>=lowxbound);
@@ -737,40 +951,48 @@ while 1,
                         ~constr
                     if any(abs(xrec(idx)-x(idx))> detxr * abs(x(idx)))
                         if dispwarn
-                            disp(wrnmes);
-                            disp(warn09);
+                            disp(wrnmes)
+                            disp(warn09)
                         end
-                        x=xrec; 
-                        f=frec; 
-                        g=grec; 
-                        ng=norm(g); 
+                        x=xrec;
+                        f=frec;
+                        g=grec;
+                        ng=norm(g);
                         krerun=krerun+1;
                         h=h1*max([dx,detxr*norm(x)])/krerun;
-                        warnno=2; 
+                        warnno=2;
                         break
                     else
                         h=h*10;
                     end
                 elseif  abs(f-frec)> optim.TolFun*abs(f)    && ...
                         norm(x-xrec)<optim.TolX*norm(x) && constr
-                    
+
                 elseif  abs(f-fopt)<=optim.TolFun*abs(f)  || ...
                         abs(f)<=lowfbound               || ...
                         (abs(f-fopt)<=optim.TolFun && termx>=limxterm )
                     if stopf
                         if dx<=laststep
-                            if warnno==1 && ng<sqrt(optim.TolFun), warnno=0; end
-                            if ~app, if any(abs(g)<=epsnorm2), warnno=3; end, end
+                            if warnno==1 && ng<sqrt(optim.TolFun)
+                                warnno=0;
+                            end
+                            if ~app
+                                if any(abs(g)<=epsnorm2)
+                                    warnno=3;
+                                end
+                            end
                             if warnno~=0
                                 exitflag=-warnno-10;
-                                if dispwarn, disp(termwarn1);
-                                    disp(endwarn(warnno,:));
-                                    if app, disp(appwarn); end
+                                if dispwarn, disp(termwarn1)
+                                    disp(endwarn(warnno,:))
+                                    if app
+                                        disp(appwarn);
+                                    end
                                 end
                             else
                                 exitflag=k;
                                 if dispwarn
-                                    disp(termwarn0); 
+                                    disp(termwarn0);
                                 end
                             end
                             if trx
@@ -783,11 +1005,18 @@ while 1,
                     end
                 elseif dx<1.e-12*max(norm(x),1) && termx>=limxterm
                     exitflag=-14;
-                    if dispwarn, disp(termwarn1); disp(endwarn(4,:));
-                        if app, disp(appwarn); end
+                    if dispwarn
+                        disp(termwarn1)
+                        disp(endwarn(4,:))
+                        if app
+                            disp(appwarn)
+                        end
                     end
                     x=xrec; f=frec;
-                    if trx,x=x';end,  return
+                    if trx
+                        x=x';
+                    end
+                    return
                 else
                     stopf=0;
                 end
@@ -795,57 +1024,67 @@ while 1,
         end
         % ITERATIONS LIMIT
         if(k==optim.MaxIter)
-            exitflag=-9; 
+            exitflag=-9;
             if trx
-                x=x'; 
-            end,
-            if dispwarn, disp(wrnmes);  disp(warn4); end
+                x=x';
+            end
+            if dispwarn
+                disp(wrnmes)
+                disp(warn4)
+            end
             return
         end
         % ----}
         % ZERO GRADIENT ----{
         if constr
-            if ng<=ZeroGrad,
-                if dispwarn,  disp(termwarn1);  disp(warn1); end
-                exitflag=-8; 
+            if ng<=ZeroGrad
+                if dispwarn
+                    disp(termwarn1)
+                    disp(warn1)
+                end
+                exitflag=-8;
                 if trx
                     x=x';
                 end
                 return
             end
         else
-            if ng<=ZeroGrad,        nzero=nzero+1;
-                if dispwarn, disp(wrnmes);  disp(warn1);  end
+            if ng<=ZeroGrad
+                nzero=nzero+1;
+                if dispwarn
+                    disp(wrnmes)
+                    disp(warn1)
+                end
                 if nzero>=3
-                    exitflag=-8; 
+                    exitflag=-8;
                     if trx
                         x=x';
                     end
                     return
                 end
                 g0=-h*g0/2;
-                for i=1:10,
+                for i=1:10
                     x=x+g0;
                     if trx
                         f=feval(fun,x',varargin{:});
                     else
-                        f=feval(fun,x,varargin{:}); 
+                        f=feval(fun,x,varargin{:});
                     end
                     n_f_evals=n_f_evals+1;
                     if abs(f)==Inf
                         if dispwarn
-                            disp(errmes);  
-                            disp(error32);  
+                            disp(errmes)
+                            disp(error32)
                         end
                         exitflag=-3;
                         if trx
                             x=x';
                         end
                         return
-                    elseif isnan(f),
+                    elseif isnan(f)
                         if dispwarn
-                            disp(errmes);  
-                            disp(error32);  
+                            disp(errmes)
+                            disp(error32)
                         end
                         exitflag=-3;
                         if trx
@@ -853,47 +1092,47 @@ while 1,
                         end
                         return
                     end
-                    if app,
-                        deltax=sign(g0); 
+                    if app
+                        deltax=sign(g0);
                         idx=find(deltax==0);
-                        deltax(idx)=ones(size(idx));  
+                        deltax(idx)=ones(size(idx));
                         deltax=h1*ddx*deltax;
-                        if trx  
+                        if trx
                             g=apprgrdn(x',f,fun,deltax',1,varargin{:});
                         else
                             g=apprgrdn(x,f,fun,deltax,1,varargin{:});
                         end
                         n_f_evals=n_f_evals+n;
                     else
-                        if trx  
+                        if trx
                             g=feval(grad,x',varargin{:});
                         else
-                            g=feval(grad,x,varargin{:});   
+                            g=feval(grad,x,varargin{:});
                         end
                         n_grad_evals=n_grad_evals+1;
                     end
                     if size(g,2)==1
-                        g=g'; 
+                        g=g';
                     end
                     ng=norm(g);
                     if ng==Inf
                         if dispwarn
-                            disp(errmes);  
-                            disp(error42); 
+                            disp(errmes)
+                            disp(error42)
                         end
-                        exitflag=-4; 
+                        exitflag=-4;
                         if trx
-                            x=x'; 
+                            x=x';
                         end
                         return
                     elseif isnan(ng)
                         if dispwarn
-                            disp(errmes);  
-                            disp(error41); 
+                            disp(errmes)
+                            disp(error41)
                         end
-                        exitflag=-4; 
+                        exitflag=-4;
                         if trx
-                            x=x'; 
+                            x=x';
                         end
                         return
                     end
@@ -901,41 +1140,54 @@ while 1,
                         break
                     end
                 end
-                if ng<=ZeroGrad,
+                if ng<=ZeroGrad
                     if dispwarn
-                        disp(termwarn1);  
-                        disp(warn1); 
+                        disp(termwarn1)
+                        disp(warn1)
                     end
-                    exitflag=-8; 
+                    exitflag=-8;
                     if trx
                         x=x';
                     end
                     return
                 end
-                h=h1*dx; 
+                h=h1*dx;
                 break
             end
         end
         % ----}
         % FUNCTION IS FLAT AT THE POINT ----{
         if ~constr && abs(f-fopt)<abs(fopt)*optim.TolFun && kcheck>5 && ng<1
-            idx=find(abs(g)<=epsnorm2); 
+            idx=find(abs(g)<=epsnorm2);
             ni=size(idx,2);
-            if ni>=1 && ni<=n/2 && kflat<=3, kflat=kflat+1;
-                if dispwarn,  disp(wrnmes); disp(warn31); end, warnno=1;
+            if ni>=1 && ni<=n/2 && kflat<=3
+                kflat=kflat+1;
+                if dispwarn
+                    disp(wrnmes)
+                    disp(warn31)
+                end
+                warnno=1;
                 x1=x; fm=f;
-                for j=idx, y=x(j); f2=fm;
-                    if y==0, x1(j)=1; elseif abs(y)<1, x1(j)=sign(y); else, x1(j)=y; end
-                    for i=1:20, x1(j)=x1(j)/1.15;
+                for j=idx
+                    y=x(j); f2=fm;
+                    if y==0
+                        x1(j)=1;
+                    elseif abs(y)<1
+                        x1(j)=sign(y);
+                    else
+                        x1(j)=y;
+                    end
+                    for i=1:20
+                        x1(j)=x1(j)/1.15;
                         if trx
                             f1=feval(fun,x1',varargin{:});
                         else
-                            f1=feval(fun,x1,varargin{:}); 
+                            f1=feval(fun,x1,varargin{:});
                         end
                         n_f_evals=n_f_evals+1;
-                        if abs(f1)~=Inf && ~isnan(f1),
+                        if abs(f1)~=Inf && ~isnan(f1)
                             if h1*f1>h1*fm
-                                y=x1(j); 
+                                y=x1(j);
                                 fm=f1;
                             elseif h1*f2>h1*f1
                                 break
@@ -948,36 +1200,36 @@ while 1,
                     x1(j)=y;
                 end
                 if h1*fm>h1*f
-                    if app,
+                    if app
                         deltax=h1*ddx*ones(size(deltax));
                         if trx
                             gt=apprgrdn(x1',fm,fun,deltax',1,varargin{:});
                         else
-                            gt=apprgrdn(x1 ,fm,fun,deltax ,1,varargin{:});    
+                            gt=apprgrdn(x1 ,fm,fun,deltax ,1,varargin{:});
                         end
                         n_f_evals=n_f_evals+n;
                     else
                         if trx
                             gt=feval(grad,x1',varargin{:});
                         else
-                            gt=feval(grad,x1,varargin{:}); 
+                            gt=feval(grad,x1,varargin{:});
                         end
                         n_grad_evals=n_grad_evals+1;
                     end
                     if size(gt,2)==1
-                        gt=gt'; 
+                        gt=gt';
                     end
                     ngt=norm(gt);
-                    if ~isnan(ngt) && ngt>epsnorm2,
+                    if ~isnan(ngt) && ngt>epsnorm2
                         if dispwarn
-                            disp(warn32); 
+                            disp(warn32)
                         end
                         optim.TolFun=optim.TolFun/5;
-                        x=x1; 
-                        g=gt; 
-                        ng=ngt; 
-                        f=fm; 
-                        h=h1*dx/3; 
+                        x=x1;
+                        g=gt;
+                        ng=ngt;
+                        f=fm;
+                        h=h1*dx/3;
                         break
                     end
                 end
@@ -986,6 +1238,6 @@ while 1,
         % ----}
     end % iterations
 end % restart
-% end of the function
-%
-end
\ No newline at end of file
+    % end of the function
+    %
+    end
\ No newline at end of file
diff --git a/matlab/optimize_prior.m b/matlab/optimize_prior.m
index cdb03ecff..adf4d9c0e 100644
--- a/matlab/optimize_prior.m
+++ b/matlab/optimize_prior.m
@@ -2,7 +2,7 @@ function optimize_prior(DynareOptions, ModelInfo, DynareResults, BayesInfo, Esti
 
 % This routine computes the mode of the prior density using an optimization algorithm.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,7 +34,7 @@ while look_for_admissible_initial_condition
             look_for_admissible_initial_condition = 0;
         end
     else
-        if iter == 2000;
+        if iter == 2000
             scale = scale/1.1;
             iter  = 0;
         else
diff --git a/matlab/options2cell.m b/matlab/options2cell.m
index 3ff8ef227..697c24b87 100644
--- a/matlab/options2cell.m
+++ b/matlab/options2cell.m
@@ -2,13 +2,13 @@ function c = options2cell(o)
 
 % Converts an option structure as a cell of NAME and VALUE pairs.
 %
-% INPUTS 
+% INPUTS
 %  o o       matlab's structure holding a set of options (each field name is the name of an option and the associated content is the value of the option).
 %
-% OUTPUTS 
+% OUTPUTS
 %  o c       matlab's cell row array of the form {NAME1, VALUE1, NAME2, VALUE2, NAME3, VALUE3, ...}.
 
-% Copyright (C) 2013 Dynare Team.
+% Copyright (C) 2013-2017 Dynare Team.
 %
 % This file is part of Dynare.
 %
@@ -27,10 +27,10 @@ function c = options2cell(o)
 
 s = fieldnames(o);
 c = {};
-j = 1; 
- 
+j = 1;
+
 for i=1:length(s)
-    c(j) = {s{i}}; 
-    c(j+1) = {o.(s{i})}; 
-    j = j+2; 
+    c(j) = {s{i}};
+    c(j+1) = {o.(s{i})};
+    j = j+2;
 end
\ No newline at end of file
diff --git a/matlab/osr.m b/matlab/osr.m
index d579c63ec..60039ac45 100644
--- a/matlab/osr.m
+++ b/matlab/osr.m
@@ -9,19 +9,19 @@ function osr_res = osr(var_list,params,i_var,W)
 %                                           optimal simple rule
 %   i_var       [n_osr_vars by 1 double]    indices of osr-variable in
 %                                           specified in optim_weights in declaration order
-%   W           [M_.endo_nbr by M_.endo_nbr sparse matrix] Weighting matrix for variance of endogenous variables             
-%    
+%   W           [M_.endo_nbr by M_.endo_nbr sparse matrix] Weighting matrix for variance of endogenous variables
+%
 % OUTPUTS
 %   osr_res:    [structure] results structure containing:
 %    - objective_function [scalar double]   value of the objective
 %                                               function at the optimum
-%    - optim_params       [structure]       parameter values at the optimum 
-% 
-%       
+%    - optim_params       [structure]       parameter values at the optimum
+%
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
-% Copyright (C) 2001-2016 Dynare Team
+%
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -38,7 +38,7 @@ function osr_res = osr(var_list,params,i_var,W)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-global M_ options_ oo_  
+global M_ options_ oo_
 
 options_.order = 1;
 
diff --git a/matlab/osr1.m b/matlab/osr1.m
index cf13da166..b73db2b24 100644
--- a/matlab/osr1.m
+++ b/matlab/osr1.m
@@ -9,14 +9,14 @@ function osr_res = osr1(i_params,i_var,weights)
 %   osr_res:    [structure] results structure containing:
 %    - objective_function [scalar double]   value of the objective
 %                                               function at the optimum
-%    - optim_params       [structure]       parameter values at the optimum 
-% 
+%    - optim_params       [structure]       parameter values at the optimum
+%
 % Algorithm:
-% 
+%
 %   Uses Newton-type optimizer csminwel to directly solve quadratic
 %   osr-problem
-% 
-% Copyright (C) 2005-2014 Dynare Team
+%
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -80,7 +80,7 @@ if isfield(options_.osr,'maxit') || isfield(options_.osr,'tolf')
                 options_.optim_opt=[options_.optim_opt,','];
             end
             options_.optim_opt=[options_.optim_opt,'''TolFun'',',num2str(options_.osr.tolf),''];
-        end  
+        end
     end
 end
 
@@ -101,17 +101,17 @@ i_var=unique(i_var);
 %% do initial checks
 [loss,info,exit_flag,vx]=osr_obj(t0,i_params,inv_order_var(i_var),weights(i_var,i_var));
 if info~=0
-   print_info(info, options_.noprint, options_);
-   else 
-       if ~options_.noprint
-           fprintf('\nOSR: Initial value of the objective function: %g \n\n',loss);
-       end
+    print_info(info, options_.noprint, options_);
+else
+    if ~options_.noprint
+        fprintf('\nOSR: Initial value of the objective function: %g \n\n',loss);
+    end
 end
-if ~options_.noprint && isinf(loss) 
-   fprintf('\nOSR: The initial value of the objective function is infinite.\n');
-   fprintf('\nOSR: Check whether the unconditional variance of a target variable is infinite\n');
-   fprintf('\nOSR: due to the presence of a unit root.\n');
-   error('OSR: Initial likelihood is infinite')
+if ~options_.noprint && isinf(loss)
+    fprintf('\nOSR: The initial value of the objective function is infinite.\n');
+    fprintf('\nOSR: Check whether the unconditional variance of a target variable is infinite\n');
+    fprintf('\nOSR: due to the presence of a unit root.\n');
+    error('OSR: Initial likelihood is infinite')
 end
 
 
@@ -120,17 +120,17 @@ if isequal(options_.osr.opt_algo,5)
 elseif isequal(options_.osr.opt_algo,6)
     error('OSR: OSR does not support opt_algo=6.')
 elseif isequal(options_.osr.opt_algo,10)
-    error('OSR: OSR does not support opt_algo=10.')    
+    error('OSR: OSR does not support opt_algo=10.')
 elseif isequal(options_.osr.opt_algo,11)
-    error('OSR: OSR does not support opt_algo=11.')    
+    error('OSR: OSR does not support opt_algo=11.')
 else
-    
-if ~isempty(M_.osr.param_bounds) && ~(ismember(options_.osr.opt_algo,[1,2,5,9]) || ischar(options_.osr.opt_algo))
-    error('OSR: OSR with bounds on parameters requires a constrained optimizer, i.e. 1,2,5, or 9.')    
-end
-%%do actual optimization
-[p, f, exitflag] = dynare_minimize_objective(str2func('osr_obj'),t0,options_.osr.opt_algo,options_,M_.osr.param_bounds,cellstr(M_.param_names(i_params,:)),[],[], i_params,...
-                inv_order_var(i_var),weights(i_var,i_var));
+
+    if ~isempty(M_.osr.param_bounds) && ~(ismember(options_.osr.opt_algo,[1,2,5,9]) || ischar(options_.osr.opt_algo))
+        error('OSR: OSR with bounds on parameters requires a constrained optimizer, i.e. 1,2,5, or 9.')
+    end
+    %%do actual optimization
+    [p, f, exitflag] = dynare_minimize_objective(str2func('osr_obj'),t0,options_.osr.opt_algo,options_,M_.osr.param_bounds,cellstr(M_.param_names(i_params,:)),[],[], i_params,...
+                                                 inv_order_var(i_var),weights(i_var,i_var));
 end
 
 osr_res.objective_function = f;
diff --git a/matlab/osr_obj.m b/matlab/osr_obj.m
index 67efbbbc0..76db1da69 100644
--- a/matlab/osr_obj.m
+++ b/matlab/osr_obj.m
@@ -17,7 +17,7 @@ function [loss,info,exit_flag,vx,junk]=osr_obj(x,i_params,i_var,weights)
 %
 % SPECIAL REQUIREMENTS
 %   none
-% Copyright (C) 2005-2016 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -51,14 +51,14 @@ it_ = M_.maximum_lag+1;
 
 if info(1)
     if info(1) == 3 || info(1) == 4 || info(1) == 5 || info(1)==6 ||info(1) == 19 ||...
-            info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
-            info(1) == 81 || info(1) == 84 ||  info(1) == 85
+                info(1) == 20 || info(1) == 21 || info(1) == 23 || info(1) == 26 || ...
+                info(1) == 81 || info(1) == 84 ||  info(1) == 85
         loss = 1e8;
         info(4)=info(2);
         return
     else
         loss = 1e8;
-        info(4)=0.1;        
+        info(4)=0.1;
         return
     end
 end
diff --git a/matlab/parallel/AnalyseComputationalEnvironment.m b/matlab/parallel/AnalyseComputationalEnvironment.m
index e5d2a87f5..d00ca1b69 100644
--- a/matlab/parallel/AnalyseComputationalEnvironment.m
+++ b/matlab/parallel/AnalyseComputationalEnvironment.m
@@ -1,657 +1,658 @@
-function [ErrorCode] = AnalyseComputationalEnvironment(DataInput, DataInputAdd)
-% PARALLEL CONTEXT
-% In a parallel context, this function is used to check the cluster defined by the user.
-% If no error happen the function returns 0. The function complies with
-% Windows/Linux operating systems and Matlab/Octave software.
-%
-%
-% INPUT/OUTPUT description:
-%
-%
-% DataInput
-%   is the strcture option_.parallel, with the follow fields:
-%
-%             Local         1 is on local machine, 0 remote
-%      ComputerName         the computer name.
-%            CPUnbr         the CPU's
-%          UserName         the user name for the ComputerName.
-%          Password         the password for the user name in ComputerName.
-%       RemoteDrive         Drive used for Remote computation (data exchange, etc): must be contain 'RemoteFolder'.
-%   RemoteDirectory         Folder in RemoteDrive used for Remote computation.
-%  MatlabOctavePath         Path to MATLAB or Octave executable.
-%        DynarePath         Path to matlab directory within the Dynare installation directory.
-%
-%   This information is typed by the user in the DYNARE configuration file and is parsed by the preprocessor,
-%   the goal of this function is to check if configuration is correct and if dynare
-%   can be executed successfully in parallel mode.
-%
-%
-% DataInputAdd
-%   it is the structure options_.parallel_info. Currently , only the string in the
-%   field RemoteTmpFolder (the temporary directory created/destroyed on remote
-%   computer) is used.
-
-if ispc, 
-    [tempo, MasterName]=system('hostname');
-    MasterName=deblank(MasterName);
-end
-
-RemoteTmpFolder=DataInputAdd.RemoteTmpFolder;
-dynareParallelMkDir(RemoteTmpFolder,DataInput);
-
-
-% The variable ErrorCode is initialized at 0. If there are non problems with
-% Local, ComputerName connections,... in general with parallel software execution,
-% the ErrorCode is unchanged, in the others cases 1, 2 , ... The values
-% table is below.
-%
-%
-%   Table for ErrorCode Values.
-%
-%   ErrorCode -> 0      Initial Value -> No Error Detected!!!
-%   ErrorCode -> 1 ...  When an error is detected, the values 1, 2, 3... are
-%   used to specify the type of error or warning.
-%
-%   Value 1:    The variable 'Local' has a bad value!
-%
-%   Value 2:    The variable 'CPUnbr' has a bad value. For more information
-%               see http://www.dynare.org/DynareWiki/ParallelDynare.
-%         2.1   [warning] The user asks to use more CPU's than those available.
-%         2.2   [warning] There are unused CPU's!
-%         2.3   [error] NumberOfThreadsPerJob is not a divisor of CPUnbr
-%
-%
-%   Value 3:    The remote computer is unreachable!!!
-%
-%   Value 4:    The fields user name and/or password are/is empty!
-%
-%   Value 5:    Remote Drive and/or Remote Folder do not exist!
-%
-%   Value 6:    It is impossible write/read files on the remote computer.
-%
-%   Value 7:    The values user and/or passwd are incorrect or the user has
-%               no permissions to execute a Matlab session. Or simply
-%               Matlab path (MatlabOctavePath) is incorrect!
-%
-%   Value 8:    Dynare path (DynarePath) is incorrect!
-%
-%   Value 9:    It is impossible delete remote computational temporary files!
-%
-%
-%
-%
-% Currently when errors are detected execution simply stops and users can
-% fix configuration errors according to the error type.
-
-% Copyright (C) 2009-2013 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/>.
-
-
-ErrorCode=0;
-
-
-for Node=1:length(DataInput) % To obtain a recoursive function remove the 'for'
-    % and use AnalyseComputationalEnvironment with differents input!
-    
-    
-    % Determine the operating system or software version when necessary
-    % for different command types.
-   
-    OScallerUnix=~ispc;
-    OScallerWindows=ispc;
-    OStargetUnix=strcmpi('unix',DataInput(Node).OperatingSystem);
-    if isempty(DataInput(Node).OperatingSystem),
-        OStargetUnix=OScallerUnix;
-    end
-    OStargetWindows=strcmpi('windows',DataInput(Node).OperatingSystem);
-    if isempty(DataInput(Node).OperatingSystem),
-        OStargetWindows=OScallerWindows;
-    end
-    
-    Environment= (OScallerUnix || OStargetUnix);
-    
-    skipline(2)
-    disp(['Testing computer -> ',DataInput(Node).ComputerName,' <- ...']);
-    skipline(2)
-    
-    % The function is composed by two main blocks, determined by the 'Local'
-    % variable.
-    
-    % This check can be removed ... according to the dynare parser
-    % strategy.
-    
-    if ((DataInput(Node).Local == 0) |(DataInput(Node).Local == 1))
-        % Continue it is Ok!
-        disp('Check on Local Variable ..... Ok!');
-        skipline()    
-    else
-        disp('The variable "Local" has a bad value!');
-        skipline()
-        disp('ErrorCode 1.');
-        skipline()
-        ErrorCode=1;
-        return
-    end
-    
-    %         %%%%%%%%%%  Local (No Network) Computing   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-    %         Here only the multi-core, or multi-processor avaiable on local
-    %         machine are involved in parallel computing. No network
-    %         comunications are required!
-    
-    
-    % In this case we need to check only the variable 'CPUnbr'.
-    
-    % We run the parallel code on local computer, so the others fields are automatically
-    % fixed by Dynare parser. Then the user can also fill them with wrong values.
-    
-    
-    %         %%%%%%%%%%  Cluster Computing   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-    %         Here we can have many computer with multi-core, or multi-processor avaiable on the
-    %         network and involved in parallel computing.
-    %         So in this case we need more sophisticated check.
-    
-    
-    if (DataInput(Node).Local == 0)
-        
-        % Now we verify if it is possibile to be connected with the
-        % remote computer.
-        
-        si1=[];
-        de1=[];
-        
-        if Environment
-            if OScallerWindows
-                [si1 de1]=system(['ping ', DataInput(Node).ComputerName]);
-            else
-                [si1 de1]=system(['ping ', DataInput(Node).ComputerName, ' -c 4']);
-            end
-        else
-            [si1 de1]=system(['ping ', DataInput(Node).ComputerName]);
-        end
-        
-        if (si1)
-            disp(['It is impossibile to ping to the computer with name "',DataInput(Node).ComputerName,'" using the network!'])
-            skipline()
-            disp('ErrorCode 3.')
-            ErrorCode=3;
-            skipline(2)
-        else
-            disp('Check on ComputerName Variable ..... Ok!')
-            skipline(2)
-        end
-        
-        
-        % Now we verify if user name and password are correct and if remote
-        % drive and remote folder exist on the remote computer and it is
-        % possible to exchange data with them.
-        
-        if Environment
-            % This check can be removed ... according to the dynare parser
-            % strategy.
-            
-            if (isempty(DataInput(Node).UserName))
-                disp('The fields UserName is empty!')
-                skipline()
-                disp('ErrorCode 4.')
-                skipline(2)
-                ErrorCode=4;
-                return
-            end
-            disp('Check on UserName Variable ..... Ok!')
-            skipline(2)
-            
-            % This check can be removed ... according to the dynare parser
-            % strategy.           
-                if (~isempty(DataInput(Node).Password))
-                    disp('[WARNING] The field Password should be empty under unix or mac!');
-                    skipline()
-                    disp(['Remove the string ',DataInput(Node).Password,' from this field!'])
-                    skipline()
-                    disp('ErrorCode 4.')
-                    skipline(2)
-                    ErrorCode=4;
-                else
-                    disp('Check on Password Variable ..... Ok!')
-                    skipline(2)
-                end
-        else
-            
-            % This check can be removed ... according to the dynare parser
-            % strategy.
-            
-            if (isempty(DataInput(Node).UserName)) || (isempty(DataInput(Node).Password))
-                disp('The fields UserName and/or Password are/is empty!');
-                skipline()
-                disp('ErrorCode 4.')
-                skipline(2)
-                ErrorCode=4;
-                return
-            end
-            disp('Check on UserName Variable ..... Ok!');
-            skipline()
-            disp('Check on Password Variable ..... Ok!');
-            skipline()
-        end
-        
-        % Now we very if RemoteDrive and/or RemoteDirectory exist on remote
-        % computer!
-        
-        if Environment
-            
-            % This check can be removed ... according to the dynare parser
-            % strategy.
-            
-            if  isempty(DataInput(Node).RemoteDirectory)
-                disp('The field RemoteDirectory is empty!')
-                skipline()
-                disp('ErrorCode 5.')
-                skipline()
-                ErrorCode=5;
-                return
-            end
-            
-            % This check can be removed ... according to the dynare parser
-            % strategy.
-            
-                if (~isempty(DataInput(Node).RemoteDrive))
-                    disp('[WARNING] The fields RemoteDrive should be empty under unix or mac!')
-                    skipline()
-                    disp(['remove the string ',DataInput(Node).RemoteDrive,' from this field!'])
-                    skipline()
-                    disp('ErrorCode 5.')
-                    skipline(2)
-                    ErrorCode=5;
-                end
-            
-            si2=[];
-            de2=[];
-            if ~isempty(DataInput(Node).Port),
-                ssh_token = ['-p ',DataInput(Node).Port];
-            else
-                ssh_token = '';
-            end
-            
-            [si2 de2]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' ls ',DataInput(Node).RemoteDirectory,'/',RemoteTmpFolder,'/']);
-            
-            if (si2)
-                disp ('Remote Directory does not exist or is not reachable!')
-                skipline()
-                disp('ErrorCode 5.')
-                skipline(2)
-                ErrorCode=5;
-                return
-            end
-            
-            disp('Check on RemoteDirectory Variable ..... Ok!')
-            skipline(2)
-            disp('Check on RemoteDrive Variable ..... Ok!')
-            skipline(2)
-            
-        else
-            % This check can be removed ... according to the dynare parser
-            % strategy.
-            
-            if (isempty(DataInput(Node).RemoteDrive)||isempty(DataInput(Node).RemoteDirectory))
-                disp('Remote RemoteDrive and/or RemoteDirectory is/are empty!')
-                skipline()
-                disp('ErrorCode 5.')
-                skipline(2)
-                ErrorCode=5;
-                return
-            end
-            
-            
-            si2=[];
-            de2=[];
-            [si2 de2]=system(['dir \\',DataInput(Node).ComputerName,'\',DataInput(Node).RemoteDrive,'$\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder]);
-            
-            if (si2)
-                disp ('Remote Directory does not exist or it is not reachable!')
-                skipline()
-                disp('ErrorCode 5.')
-                skipline(2)
-                ErrorCode=5;
-                return
-            end
-            
-            disp('Check on RemoteDirectory Variable ..... Ok!')
-            skipline(2)
-            disp('Check on RemoteDrive Variable ..... Ok!')
-            skipline(2)
-            
-        end
-        
-        
-        % Now we verify if it possible to exchange data with the remote
-        % computer:
-        
-        
-        % Build a command file to test the matlab execution and dynare path ...
-        
-        fid = fopen('Tracing.m', 'w+');
-        s1=(['fT = fopen(''MatlabOctaveIsOk.txt'',''w+'');\n']);
-        s2='fclose(fT);\n';
-        SBS=strfind(DataInput(Node).DynarePath,'\');
-        DPStr=DataInput(Node).DynarePath;
-        if isempty(SBS),
-            DPStrNew=DPStr;
-        else
-            DPStrNew=[DPStr(1:SBS(1)),'\'];
-            for j=2:length(SBS),
-                DPStrNew=[DPStrNew,DPStr(SBS(j-1)+1:SBS(j)),'\'];
-            end
-            DPStrNew=[DPStrNew,DPStr(SBS(end)+1:end)];
-        end
-        s3=['addpath(''',DPStrNew,'''),\n'];
-        s4=['try,\n  dynareroot = dynare_config();\n'];
-        s41=(['  fT = fopen(''DynareIsOk.txt'',''w+'');\n']);
-        s42='  fclose(fT);\n';
-        s5=['catch,\n'];
-        s51=(['  fT = fopen(''DynareFailed.txt'',''w+'');\n']);
-        s52='  fclose(fT);\n';
-        s6=['end,\n'];
-        s7=['if ismac,\n'];
-        s71=(['  fT = fopen(''IsMac.txt'',''w+'');\n']);
-        s72='  fclose(fT);\n';
-        s8=['end,\n'];
-        send='exit';
-        StrCommand=([s1,s2,s3,s4,s41,s42,s5,s51,s52,s6,s7,s71,s72,s8,send]);
-        
-        % Mettere controllo su NbW ...
-        % if isoctave
-        %     NbW = fprintf(fid,StrCommand, '%s');
-        % else
-        NbW = fprintf(fid,StrCommand, '%s');
-        % end
-        fclose(fid);
-        
-        dynareParallelSendFiles('Tracing.m', RemoteTmpFolder,DataInput(Node));
-        FindTracing = dynareParallelDir('Tracing.m', RemoteTmpFolder,DataInput(Node));
-        
-        delete ('Tracing.m');
-        
-        if (isempty(FindTracing))
-            disp('It is impossible to exchange data with Remote Drive and/or Remote Directory! ErrorCode 6.')
-            skipline()
-            disp('ErrorCode 6.')
-            skipline(2)
-            ErrorCode=6;
-            return
-        else
-            disp('Check on Exchange File with Remote Computer ..... Ok!')
-            skipline(2)
-        end
-        
-        
-        % Now we verify if it is possible execute a matlab/octave section on remote
-        % machine when the user is .UserName with password .Password and
-        % the path is MatlabOctavePath.
-        
-        if Environment,
-            if ~isempty(DataInput(Node).Port),
-                ssh_token = ['-p ',DataInput(Node).Port];
-            else
-                ssh_token = '';
-            end
-            if strfind([DataInput(Node).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' "cd ',DataInput(Node).RemoteDirectory,'/',RemoteTmpFolder,  '; ', DataInput(Node).MatlabOctavePath, ' Tracing.m;" &']);
-            else
-                system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' "cd ',DataInput(Node).RemoteDirectory,'/',RemoteTmpFolder,  '; ', DataInput(Node).MatlabOctavePath, ' -nosplash -nodesktop -minimize -r Tracing;" &']);
-            end
-        else
-            if ~strcmp(DataInput(Node).ComputerName,MasterName), % run on remote machine
-                if  strfind([DataInput(Node).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e -u ',DataInput(Node).UserName,' -p ',DataInput(Node).Password,' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' Tracing.m']);
-                else
-                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e -u ',DataInput(Node).UserName,' -p ',DataInput(Node).Password,' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' -nosplash -nodesktop -minimize -r Tracing']);
-                end
-            else % run on local machine via the network: user and passwd cannot be used!
-                if  strfind([DataInput(Node).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e ',' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' Tracing.m']);
-                else
-                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e ',' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' -nosplash -nodesktop -minimize -r Tracing']);
-                end
-            end
-                
-        end
-        
-        % Timer da fissare, nei valori di attesa!
-        
-        t1=fix(clock);
-        
-        if t1(5)+1>60;
-            t2=2;
-        else t2=t1(5)+1;
-        end
-        
-        Flag=0;
-        
-        while (1);
-            if Flag==0
-                disp('Try to run matlab/octave on remote machine ... ')
-                skipline()
-                disp('please wait ... ')
-                skipline()
-                Flag=1;
-            end
-            nt=fix(clock);
-            nt(5)-t2;
-            
-            if (~isempty (dynareParallelDir('MatlabOctaveIsOk.txt',RemoteTmpFolder,DataInput(Node)))) || ((nt(5)-t2)>0)
-                if ((nt(5)-t2)>0)
-                    ErrorCode=7;
-                end
-                break
-            end
-            
-        end
-        
-        if  (ErrorCode==7)
-            
-            disp ('It is not possible execute a matlab session on remote machine!')
-            skipline()
-            disp('ErrorCode 7.')
-            skipline(2)
-            ErrorCode=7;
-            dynareParallelRmDir(RemoteTmpFolder,DataInput(Node));
-            return
-        else
-            disp('Check on MatlabOctave Path and MatlabOctave Program Execution on remote machine ..... Ok!')
-            skipline(2)
-            
-            % Now we verify if the DynarePath is correct ...
-            disp('Check the Dynare path on remote machine ... ')
-            skipline()
-            disp('please wait ... ')
-            skipline(2)
-            pause(2)
-            
-            if isempty(dynareParallelDir('DynareIsOk.txt',RemoteTmpFolder,DataInput(Node)))
-                ErrorCode=8;
-            end
-            
-            if  (ErrorCode==8)
-                disp ('The DynarePath is incorrect!')
-                skipline()
-                disp('ErrorCode 8.')
-                skipline(2)
-                ErrorCode=8;
-                dynareParallelRmDir(RemoteTmpFolder,DataInput(Node));
-                return
-            else
-                disp('Check on Dynare Path remote machine ..... Ok!')
-            if isempty(dynareParallelDir('IsMac.txt',RemoteTmpFolder,DataInput(Node)))
-                RemoteEnvironment=Environment;
-            else
-                RemoteEnvironment=2;                
-            end
-                skipline(2)
-            end
-        end
-        
-        
-        % Now we verify if it is possible delete remote computational traces!
-        
-        dynareParallelRmDir(RemoteTmpFolder,DataInput(Node));
-        
-        si3=[];
-        
-        si3=dynareParallelDir('Tracing.m', RemoteTmpFolder,DataInput(Node));
-        
-        if (isempty(si3))
-            disp ('Check on Delete Remote Computational Traces ..... Ok!')
-            skipline(2)
-        else
-            disp ('It is impossible to delete temporary files on remote machine!')
-            skipline()
-            disp('ErrorCode 9.')
-            skipline(2)
-            ErrorCode=9;
-            return
-        end
-        
-        
-    end
-    % Now we check the variable 'CPUnbr'.
-    
-    % This check can be removed ... according to the dynare parser
-    % strategy.
-    
-    yn=isempty(DataInput(Node).CPUnbr);
-    
-    if yn==1
-        % The field is empty!
-        disp('The field "CPUnbr" is empty!')
-        skipline()
-        disp('ErrorCode 2.')
-        skipline(2)
-        ErrorCode=2;
-        return
-    end
-    
-    % This check can be removed ... according to the dynare parser
-    % strategy.
-    
-    
-    
-    % We look for the information on local computer hardware.
-    
-    si0=[];
-    de0=[];
-    
-    Environment1=Environment;
-    disp('Checking Hardware please wait ...');
-    if (DataInput(Node).Local == 1)
-        if Environment,
-            if ~ismac
-                [si0 de0]=system('grep processor /proc/cpuinfo');
-            else
-                [si0 de0]=system('sysctl -n hw.ncpu');
-                Environment1=2;
-            end
-        else
-            [si0 de0]=system(['psinfo \\']);
-        end
-    else
-        if Environment,
-            if ~isempty(DataInput(Node).Port),
-                ssh_token = ['-p ',DataInput(Node).Port];
-            else
-                ssh_token = '';
-            end
-            if OStargetUnix,
-                if RemoteEnvironment ==1 , 
-                    [si0 de0]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' grep processor /proc/cpuinfo']);
-                else % it is MAC
-                    [si0 de0]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' sysctl -n hw.ncpu']);
-                    Environment1=2;
-                end
-            else
-                [si0 de0]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' psinfo']);
-            end
-        else
-            [si0 de0]=system(['psinfo \\',DataInput(Node).ComputerName,' -u ',DataInput(Node).UserName,' -p ',DataInput(Node).Password]);
-        end
-    end
-    
-    
-    RealCPUnbr='';
-%    keyboard;
-    RealCPUnbr=GiveCPUnumber(de0,Environment1);
-    
-    % Questo controllo penso che si possa MIGLIORARE!!!!!
-    if  isempty (RealCPUnbr) && Environment1==0,
-        [si0 de0]=system(['psinfo \\',DataInput(Node).ComputerName]);
-    end        
-    RealCPUnbr=GiveCPUnumber(de0,Environment1);
-
-    if  isempty (RealCPUnbr)
-        % An error occurred when we try to know the Cpu/Cores
-        % numbers.
-        disp('It is impossible determine the number of Cpu/Processor avaiable on this machine!')
-        skipline()
-        disp('ErrorCode 2.')
-        skipline()
-        if Environment
-            disp('Check the command "$less /proc/cpuinfo" ... !')
-        else
-            disp('Check if the pstools are installed and are in machine path! And check the command "psinfo \\"')
-        end
-        skipline()
-        ErrorCode=2;
-        return
-    end
-    
-    
-    % Trasforming the input data provided in a form [n1:n2] in a single numerical
-    % value.
-    
-    
-    CPUnbrUser=length(DataInput(Node).CPUnbr);
-    maxCPUnbrUser=max(DataInput(Node).CPUnbr)+1;
-    
-    disp(['Hardware has ', num2str(RealCPUnbr),' Cpu/Cores!'])
-    disp(['User requires ',num2str(CPUnbrUser),' Cpu/Cores!'])
-    if  CPUnbrUser==RealCPUnbr,
-        % It is Ok!
-        disp('Check on CPUnbr Variable ..... Ok!')
-        skipline(3)
-    end
-    
-    if CPUnbrUser > RealCPUnbr
-        disp('Warning! The user asks to use more CPU''s than those available.')
-        skipline(2)
-        ErrorCode=2.1;
-    end
-    if CPUnbrUser < RealCPUnbr
-        disp('Warning! There are unused CPU''s!')
-        skipline(2)
-        ErrorCode=2.2;
-    end
-    
-    if mod(length(DataInput(Node).CPUnbr),DataInput(Node).NumberOfThreadsPerJob)
-        skipline()
-        disp(['NumberOfThreadsPerJob = ',int2str(DataInput(Node).NumberOfThreadsPerJob),' is not an exact divisor of number of CPUs = ',int2str(DataInput(Node).CPUnbr),'!'])
-        disp(['    You must re-set properly NumberOfThreadsPerJob of node ' int2str(Node) ' ' DataInput(Node).ComputerName])
-        disp('    in your configuration file')
-        skipline()
-        ErrorCode=2.3;
-    end
-    
-    disp(['Test for Cluster computation, computer ',DataInput(Node).ComputerName, ' ..... Passed!'])
-    skipline(2)    
+function [ErrorCode] = AnalyseComputationalEnvironment(DataInput, DataInputAdd)
+% PARALLEL CONTEXT
+% In a parallel context, this function is used to check the cluster defined by the user.
+% If no error happen the function returns 0. The function complies with
+% Windows/Linux operating systems and Matlab/Octave software.
+%
+%
+% INPUT/OUTPUT description:
+%
+%
+% DataInput
+%   is the strcture option_.parallel, with the follow fields:
+%
+%             Local         1 is on local machine, 0 remote
+%      ComputerName         the computer name.
+%            CPUnbr         the CPU's
+%          UserName         the user name for the ComputerName.
+%          Password         the password for the user name in ComputerName.
+%       RemoteDrive         Drive used for Remote computation (data exchange, etc): must be contain 'RemoteFolder'.
+%   RemoteDirectory         Folder in RemoteDrive used for Remote computation.
+%  MatlabOctavePath         Path to MATLAB or Octave executable.
+%        DynarePath         Path to matlab directory within the Dynare installation directory.
+%
+%   This information is typed by the user in the DYNARE configuration file and is parsed by the preprocessor,
+%   the goal of this function is to check if configuration is correct and if dynare
+%   can be executed successfully in parallel mode.
+%
+%
+% DataInputAdd
+%   it is the structure options_.parallel_info. Currently , only the string in the
+%   field RemoteTmpFolder (the temporary directory created/destroyed on remote
+%   computer) is used.
+
+if ispc
+    [tempo, MasterName]=system('hostname');
+    MasterName=deblank(MasterName);
+end
+
+RemoteTmpFolder=DataInputAdd.RemoteTmpFolder;
+dynareParallelMkDir(RemoteTmpFolder,DataInput);
+
+
+% The variable ErrorCode is initialized at 0. If there are non problems with
+% Local, ComputerName connections,... in general with parallel software execution,
+% the ErrorCode is unchanged, in the others cases 1, 2 , ... The values
+% table is below.
+%
+%
+%   Table for ErrorCode Values.
+%
+%   ErrorCode -> 0      Initial Value -> No Error Detected!!!
+%   ErrorCode -> 1 ...  When an error is detected, the values 1, 2, 3... are
+%   used to specify the type of error or warning.
+%
+%   Value 1:    The variable 'Local' has a bad value!
+%
+%   Value 2:    The variable 'CPUnbr' has a bad value. For more information
+%               see http://www.dynare.org/DynareWiki/ParallelDynare.
+%         2.1   [warning] The user asks to use more CPU's than those available.
+%         2.2   [warning] There are unused CPU's!
+%         2.3   [error] NumberOfThreadsPerJob is not a divisor of CPUnbr
+%
+%
+%   Value 3:    The remote computer is unreachable!!!
+%
+%   Value 4:    The fields user name and/or password are/is empty!
+%
+%   Value 5:    Remote Drive and/or Remote Folder do not exist!
+%
+%   Value 6:    It is impossible write/read files on the remote computer.
+%
+%   Value 7:    The values user and/or passwd are incorrect or the user has
+%               no permissions to execute a Matlab session. Or simply
+%               Matlab path (MatlabOctavePath) is incorrect!
+%
+%   Value 8:    Dynare path (DynarePath) is incorrect!
+%
+%   Value 9:    It is impossible delete remote computational temporary files!
+%
+%
+%
+%
+% Currently when errors are detected execution simply stops and users can
+% fix configuration errors according to the error type.
+
+% Copyright (C) 2009-2017 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/>.
+
+
+ErrorCode=0;
+
+
+for Node=1:length(DataInput) % To obtain a recoursive function remove the 'for'
+                             % and use AnalyseComputationalEnvironment with differents input!
+
+
+    % Determine the operating system or software version when necessary
+    % for different command types.
+
+    OScallerUnix=~ispc;
+    OScallerWindows=ispc;
+    OStargetUnix=strcmpi('unix',DataInput(Node).OperatingSystem);
+    if isempty(DataInput(Node).OperatingSystem)
+        OStargetUnix=OScallerUnix;
+    end
+    OStargetWindows=strcmpi('windows',DataInput(Node).OperatingSystem);
+    if isempty(DataInput(Node).OperatingSystem)
+        OStargetWindows=OScallerWindows;
+    end
+
+    Environment= (OScallerUnix || OStargetUnix);
+
+    skipline(2)
+    disp(['Testing computer -> ',DataInput(Node).ComputerName,' <- ...']);
+    skipline(2)
+
+    % The function is composed by two main blocks, determined by the 'Local'
+    % variable.
+
+    % This check can be removed ... according to the dynare parser
+    % strategy.
+
+    if ((DataInput(Node).Local == 0) |(DataInput(Node).Local == 1))
+        % Continue it is Ok!
+        disp('Check on Local Variable ..... Ok!');
+        skipline()
+    else
+        disp('The variable "Local" has a bad value!');
+        skipline()
+        disp('ErrorCode 1.');
+        skipline()
+        ErrorCode=1;
+        return
+    end
+
+    %         %%%%%%%%%%  Local (No Network) Computing   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    %         Here only the multi-core, or multi-processor avaiable on local
+    %         machine are involved in parallel computing. No network
+    %         comunications are required!
+
+
+    % In this case we need to check only the variable 'CPUnbr'.
+
+    % We run the parallel code on local computer, so the others fields are automatically
+    % fixed by Dynare parser. Then the user can also fill them with wrong values.
+
+
+    %         %%%%%%%%%%  Cluster Computing   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    %         Here we can have many computer with multi-core, or multi-processor avaiable on the
+    %         network and involved in parallel computing.
+    %         So in this case we need more sophisticated check.
+
+
+    if (DataInput(Node).Local == 0)
+
+        % Now we verify if it is possibile to be connected with the
+        % remote computer.
+
+        si1=[];
+        de1=[];
+
+        if Environment
+            if OScallerWindows
+                [si1 de1]=system(['ping ', DataInput(Node).ComputerName]);
+            else
+                [si1 de1]=system(['ping ', DataInput(Node).ComputerName, ' -c 4']);
+            end
+        else
+            [si1 de1]=system(['ping ', DataInput(Node).ComputerName]);
+        end
+
+        if (si1)
+            disp(['It is impossibile to ping to the computer with name "',DataInput(Node).ComputerName,'" using the network!'])
+            skipline()
+            disp('ErrorCode 3.')
+            ErrorCode=3;
+            skipline(2)
+        else
+            disp('Check on ComputerName Variable ..... Ok!')
+            skipline(2)
+        end
+
+
+        % Now we verify if user name and password are correct and if remote
+        % drive and remote folder exist on the remote computer and it is
+        % possible to exchange data with them.
+
+        if Environment
+            % This check can be removed ... according to the dynare parser
+            % strategy.
+
+            if (isempty(DataInput(Node).UserName))
+                disp('The fields UserName is empty!')
+                skipline()
+                disp('ErrorCode 4.')
+                skipline(2)
+                ErrorCode=4;
+                return
+            end
+            disp('Check on UserName Variable ..... Ok!')
+            skipline(2)
+
+            % This check can be removed ... according to the dynare parser
+            % strategy.
+            if (~isempty(DataInput(Node).Password))
+                disp('[WARNING] The field Password should be empty under unix or mac!');
+                skipline()
+                disp(['Remove the string ',DataInput(Node).Password,' from this field!'])
+                skipline()
+                disp('ErrorCode 4.')
+                skipline(2)
+                ErrorCode=4;
+            else
+                disp('Check on Password Variable ..... Ok!')
+                skipline(2)
+            end
+        else
+
+            % This check can be removed ... according to the dynare parser
+            % strategy.
+
+            if (isempty(DataInput(Node).UserName)) || (isempty(DataInput(Node).Password))
+                disp('The fields UserName and/or Password are/is empty!');
+                skipline()
+                disp('ErrorCode 4.')
+                skipline(2)
+                ErrorCode=4;
+                return
+            end
+            disp('Check on UserName Variable ..... Ok!');
+            skipline()
+            disp('Check on Password Variable ..... Ok!');
+            skipline()
+        end
+
+        % Now we very if RemoteDrive and/or RemoteDirectory exist on remote
+        % computer!
+
+        if Environment
+
+            % This check can be removed ... according to the dynare parser
+            % strategy.
+
+            if  isempty(DataInput(Node).RemoteDirectory)
+                disp('The field RemoteDirectory is empty!')
+                skipline()
+                disp('ErrorCode 5.')
+                skipline()
+                ErrorCode=5;
+                return
+            end
+
+            % This check can be removed ... according to the dynare parser
+            % strategy.
+
+            if (~isempty(DataInput(Node).RemoteDrive))
+                disp('[WARNING] The fields RemoteDrive should be empty under unix or mac!')
+                skipline()
+                disp(['remove the string ',DataInput(Node).RemoteDrive,' from this field!'])
+                skipline()
+                disp('ErrorCode 5.')
+                skipline(2)
+                ErrorCode=5;
+            end
+
+            si2=[];
+            de2=[];
+            if ~isempty(DataInput(Node).Port)
+                ssh_token = ['-p ',DataInput(Node).Port];
+            else
+                ssh_token = '';
+            end
+
+            [si2 de2]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' ls ',DataInput(Node).RemoteDirectory,'/',RemoteTmpFolder,'/']);
+
+            if (si2)
+                disp ('Remote Directory does not exist or is not reachable!')
+                skipline()
+                disp('ErrorCode 5.')
+                skipline(2)
+                ErrorCode=5;
+                return
+            end
+
+            disp('Check on RemoteDirectory Variable ..... Ok!')
+            skipline(2)
+            disp('Check on RemoteDrive Variable ..... Ok!')
+            skipline(2)
+
+        else
+            % This check can be removed ... according to the dynare parser
+            % strategy.
+
+            if (isempty(DataInput(Node).RemoteDrive)||isempty(DataInput(Node).RemoteDirectory))
+                disp('Remote RemoteDrive and/or RemoteDirectory is/are empty!')
+                skipline()
+                disp('ErrorCode 5.')
+                skipline(2)
+                ErrorCode=5;
+                return
+            end
+
+
+            si2=[];
+            de2=[];
+            [si2 de2]=system(['dir \\',DataInput(Node).ComputerName,'\',DataInput(Node).RemoteDrive,'$\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder]);
+
+            if (si2)
+                disp ('Remote Directory does not exist or it is not reachable!')
+                skipline()
+                disp('ErrorCode 5.')
+                skipline(2)
+                ErrorCode=5;
+                return
+            end
+
+            disp('Check on RemoteDirectory Variable ..... Ok!')
+            skipline(2)
+            disp('Check on RemoteDrive Variable ..... Ok!')
+            skipline(2)
+
+        end
+
+
+        % Now we verify if it possible to exchange data with the remote
+        % computer:
+
+
+        % Build a command file to test the matlab execution and dynare path ...
+
+        fid = fopen('Tracing.m', 'w+');
+        s1=(['fT = fopen(''MatlabOctaveIsOk.txt'',''w+'');\n']);
+        s2='fclose(fT);\n';
+        SBS=strfind(DataInput(Node).DynarePath,'\');
+        DPStr=DataInput(Node).DynarePath;
+        if isempty(SBS)
+            DPStrNew=DPStr;
+        else
+            DPStrNew=[DPStr(1:SBS(1)),'\'];
+            for j=2:length(SBS)
+                DPStrNew=[DPStrNew,DPStr(SBS(j-1)+1:SBS(j)),'\'];
+            end
+            DPStrNew=[DPStrNew,DPStr(SBS(end)+1:end)];
+        end
+        s3=['addpath(''',DPStrNew,'''),\n'];
+        s4=['try,\n  dynareroot = dynare_config();\n'];
+        s41=(['  fT = fopen(''DynareIsOk.txt'',''w+'');\n']);
+        s42='  fclose(fT);\n';
+        s5=['catch,\n'];
+        s51=(['  fT = fopen(''DynareFailed.txt'',''w+'');\n']);
+        s52='  fclose(fT);\n';
+        s6=['end,\n'];
+        s7=['if ismac,\n'];
+        s71=(['  fT = fopen(''IsMac.txt'',''w+'');\n']);
+        s72='  fclose(fT);\n';
+        s8=['end,\n'];
+        send='exit';
+        StrCommand=([s1,s2,s3,s4,s41,s42,s5,s51,s52,s6,s7,s71,s72,s8,send]);
+
+        % Mettere controllo su NbW ...
+        % if isoctave
+        %     NbW = fprintf(fid,StrCommand, '%s');
+        % else
+        NbW = fprintf(fid,StrCommand, '%s');
+        % end
+        fclose(fid);
+
+        dynareParallelSendFiles('Tracing.m', RemoteTmpFolder,DataInput(Node));
+        FindTracing = dynareParallelDir('Tracing.m', RemoteTmpFolder,DataInput(Node));
+
+        delete ('Tracing.m');
+
+        if (isempty(FindTracing))
+            disp('It is impossible to exchange data with Remote Drive and/or Remote Directory! ErrorCode 6.')
+            skipline()
+            disp('ErrorCode 6.')
+            skipline(2)
+            ErrorCode=6;
+            return
+        else
+            disp('Check on Exchange File with Remote Computer ..... Ok!')
+            skipline(2)
+        end
+
+
+        % Now we verify if it is possible execute a matlab/octave section on remote
+        % machine when the user is .UserName with password .Password and
+        % the path is MatlabOctavePath.
+
+        if Environment
+            if ~isempty(DataInput(Node).Port)
+                ssh_token = ['-p ',DataInput(Node).Port];
+            else
+                ssh_token = '';
+            end
+            if strfind([DataInput(Node).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' "cd ',DataInput(Node).RemoteDirectory,'/',RemoteTmpFolder,  '; ', DataInput(Node).MatlabOctavePath, ' Tracing.m;" &']);
+            else
+                system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' "cd ',DataInput(Node).RemoteDirectory,'/',RemoteTmpFolder,  '; ', DataInput(Node).MatlabOctavePath, ' -nosplash -nodesktop -minimize -r Tracing;" &']);
+            end
+        else
+            if ~strcmp(DataInput(Node).ComputerName,MasterName) % run on remote machine
+                if  strfind([DataInput(Node).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e -u ',DataInput(Node).UserName,' -p ',DataInput(Node).Password,' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' Tracing.m']);
+                else
+                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e -u ',DataInput(Node).UserName,' -p ',DataInput(Node).Password,' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' -nosplash -nodesktop -minimize -r Tracing']);
+                end
+            else % run on local machine via the network: user and passwd cannot be used!
+                if  strfind([DataInput(Node).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e ',' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' Tracing.m']);
+                else
+                    [NonServeS NenServeD]=system(['start /B psexec \\',DataInput(Node).ComputerName,' -e ',' -W ',DataInput(Node).RemoteDrive,':\',DataInput(Node).RemoteDirectory,'\',RemoteTmpFolder ' -low   ',DataInput(Node).MatlabOctavePath,' -nosplash -nodesktop -minimize -r Tracing']);
+                end
+            end
+
+        end
+
+        % Timer da fissare, nei valori di attesa!
+
+        t1=fix(clock);
+
+        if t1(5)+1>60
+            t2=2;
+        else
+            t2=t1(5)+1;
+        end
+
+        Flag=0;
+
+        while (1)
+            if Flag==0
+                disp('Try to run matlab/octave on remote machine ... ')
+                skipline()
+                disp('please wait ... ')
+                skipline()
+                Flag=1;
+            end
+            nt=fix(clock);
+            nt(5)-t2;
+
+            if (~isempty (dynareParallelDir('MatlabOctaveIsOk.txt',RemoteTmpFolder,DataInput(Node)))) || ((nt(5)-t2)>0)
+                if ((nt(5)-t2)>0)
+                    ErrorCode=7;
+                end
+                break
+            end
+
+        end
+
+        if  (ErrorCode==7)
+
+            disp ('It is not possible execute a matlab session on remote machine!')
+            skipline()
+            disp('ErrorCode 7.')
+            skipline(2)
+            ErrorCode=7;
+            dynareParallelRmDir(RemoteTmpFolder,DataInput(Node));
+            return
+        else
+            disp('Check on MatlabOctave Path and MatlabOctave Program Execution on remote machine ..... Ok!')
+            skipline(2)
+
+            % Now we verify if the DynarePath is correct ...
+            disp('Check the Dynare path on remote machine ... ')
+            skipline()
+            disp('please wait ... ')
+            skipline(2)
+            pause(2)
+
+            if isempty(dynareParallelDir('DynareIsOk.txt',RemoteTmpFolder,DataInput(Node)))
+                ErrorCode=8;
+            end
+
+            if  (ErrorCode==8)
+                disp ('The DynarePath is incorrect!')
+                skipline()
+                disp('ErrorCode 8.')
+                skipline(2)
+                ErrorCode=8;
+                dynareParallelRmDir(RemoteTmpFolder,DataInput(Node));
+                return
+            else
+                disp('Check on Dynare Path remote machine ..... Ok!')
+                if isempty(dynareParallelDir('IsMac.txt',RemoteTmpFolder,DataInput(Node)))
+                    RemoteEnvironment=Environment;
+                else
+                    RemoteEnvironment=2;
+                end
+                skipline(2)
+            end
+        end
+
+
+        % Now we verify if it is possible delete remote computational traces!
+
+        dynareParallelRmDir(RemoteTmpFolder,DataInput(Node));
+
+        si3=[];
+
+        si3=dynareParallelDir('Tracing.m', RemoteTmpFolder,DataInput(Node));
+
+        if (isempty(si3))
+            disp ('Check on Delete Remote Computational Traces ..... Ok!')
+            skipline(2)
+        else
+            disp ('It is impossible to delete temporary files on remote machine!')
+            skipline()
+            disp('ErrorCode 9.')
+            skipline(2)
+            ErrorCode=9;
+            return
+        end
+
+
+    end
+    % Now we check the variable 'CPUnbr'.
+
+    % This check can be removed ... according to the dynare parser
+    % strategy.
+
+    yn=isempty(DataInput(Node).CPUnbr);
+
+    if yn==1
+        % The field is empty!
+        disp('The field "CPUnbr" is empty!')
+        skipline()
+        disp('ErrorCode 2.')
+        skipline(2)
+        ErrorCode=2;
+        return
+    end
+
+    % This check can be removed ... according to the dynare parser
+    % strategy.
+
+
+
+    % We look for the information on local computer hardware.
+
+    si0=[];
+    de0=[];
+
+    Environment1=Environment;
+    disp('Checking Hardware please wait ...');
+    if (DataInput(Node).Local == 1)
+        if Environment
+            if ~ismac
+                [si0 de0]=system('grep processor /proc/cpuinfo');
+            else
+                [si0 de0]=system('sysctl -n hw.ncpu');
+                Environment1=2;
+            end
+        else
+            [si0 de0]=system(['psinfo \\']);
+        end
+    else
+        if Environment
+            if ~isempty(DataInput(Node).Port)
+                ssh_token = ['-p ',DataInput(Node).Port];
+            else
+                ssh_token = '';
+            end
+            if OStargetUnix
+                if RemoteEnvironment ==1
+                    [si0 de0]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' grep processor /proc/cpuinfo']);
+                else % it is MAC
+                    [si0 de0]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' sysctl -n hw.ncpu']);
+                    Environment1=2;
+                end
+            else
+                [si0 de0]=system(['ssh ',ssh_token,' ',DataInput(Node).UserName,'@',DataInput(Node).ComputerName,' psinfo']);
+            end
+        else
+            [si0 de0]=system(['psinfo \\',DataInput(Node).ComputerName,' -u ',DataInput(Node).UserName,' -p ',DataInput(Node).Password]);
+        end
+    end
+
+
+    RealCPUnbr='';
+    %    keyboard;
+    RealCPUnbr=GiveCPUnumber(de0,Environment1);
+
+    % Questo controllo penso che si possa MIGLIORARE!!!!!
+    if  isempty (RealCPUnbr) && Environment1==0
+        [si0 de0]=system(['psinfo \\',DataInput(Node).ComputerName]);
+    end
+    RealCPUnbr=GiveCPUnumber(de0,Environment1);
+
+    if  isempty (RealCPUnbr)
+        % An error occurred when we try to know the Cpu/Cores
+        % numbers.
+        disp('It is impossible determine the number of Cpu/Processor avaiable on this machine!')
+        skipline()
+        disp('ErrorCode 2.')
+        skipline()
+        if Environment
+            disp('Check the command "$less /proc/cpuinfo" ... !')
+        else
+            disp('Check if the pstools are installed and are in machine path! And check the command "psinfo \\"')
+        end
+        skipline()
+        ErrorCode=2;
+        return
+    end
+
+
+    % Trasforming the input data provided in a form [n1:n2] in a single numerical
+    % value.
+
+
+    CPUnbrUser=length(DataInput(Node).CPUnbr);
+    maxCPUnbrUser=max(DataInput(Node).CPUnbr)+1;
+
+    disp(['Hardware has ', num2str(RealCPUnbr),' Cpu/Cores!'])
+    disp(['User requires ',num2str(CPUnbrUser),' Cpu/Cores!'])
+    if  CPUnbrUser==RealCPUnbr
+        % It is Ok!
+        disp('Check on CPUnbr Variable ..... Ok!')
+        skipline(3)
+    end
+
+    if CPUnbrUser > RealCPUnbr
+        disp('Warning! The user asks to use more CPU''s than those available.')
+        skipline(2)
+        ErrorCode=2.1;
+    end
+    if CPUnbrUser < RealCPUnbr
+        disp('Warning! There are unused CPU''s!')
+        skipline(2)
+        ErrorCode=2.2;
+    end
+
+    if mod(length(DataInput(Node).CPUnbr),DataInput(Node).NumberOfThreadsPerJob)
+        skipline()
+        disp(['NumberOfThreadsPerJob = ',int2str(DataInput(Node).NumberOfThreadsPerJob),' is not an exact divisor of number of CPUs = ',int2str(DataInput(Node).CPUnbr),'!'])
+        disp(['    You must re-set properly NumberOfThreadsPerJob of node ' int2str(Node) ' ' DataInput(Node).ComputerName])
+        disp('    in your configuration file')
+        skipline()
+        ErrorCode=2.3;
+    end
+
+    disp(['Test for Cluster computation, computer ',DataInput(Node).ComputerName, ' ..... Passed!'])
+    skipline(2)
 end
\ No newline at end of file
diff --git a/matlab/parallel/CreateTimeString.m b/matlab/parallel/CreateTimeString.m
index 8b82b1cc6..e78f8836a 100644
--- a/matlab/parallel/CreateTimeString.m
+++ b/matlab/parallel/CreateTimeString.m
@@ -6,9 +6,9 @@ function [TiSt] = CreateTimeString()
 % None
 %
 %  OUTPUTS
-%  o TiSt    []   ...  
+%  o TiSt    []   ...
 %
-% Copyright (C) 2009-2010 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/parallel/GiveCPUnumber.m b/matlab/parallel/GiveCPUnumber.m
index 00b7fc451..cc2d45aa3 100644
--- a/matlab/parallel/GiveCPUnumber.m
+++ b/matlab/parallel/GiveCPUnumber.m
@@ -1,76 +1,76 @@
-function [nCPU]= GiveCPUnumber (ComputerInformations, Environment)
-% PARALLEL CONTEXT
-% In a parallel context this function return the CPUs or cores numer avaiable
-% on the computer used for run parallel code.
-%
-% INPUTS
-% an array contained several fields that describe the hardaware
-% software enviroments of a generic computer.
-%
-% OUTPUTS
-% The CPUs or Cores numbers of computer.
-%
-% SPECIAL REQUIREMENTS
-% none
-
-% Copyright (C) 2010-2013 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/>.
-
-
-nCPU='';
-
-if nargin < 2,
-% Determine a specific operating system or software version when necessary
-% for different command (sintax, name, ...).
-Environment=~ispc;
-end
-
-switch Environment
-  case 0          %WINDOWS OPERATING SYSTEM
-    
-    OffSet=27;
-
-    SringPosition=strfind(ComputerInformations, 'Processors:');
-    nCPU=ComputerInformations(SringPosition+OffSet);
-
-    % We check if there are Processors/Cores more than 9.
-
-
-    t0=ComputerInformations(SringPosition+OffSet+1);
-    t1=str2num(t0);
-    t1=isempty(t1);
-
-    % if t1 is 0 the machine have more than 9 CPU.
-
-    if t1==0
-        nCPU=strcat(nCPU,t0);
-    end
-
-    nCPU=str2num(nCPU);
-
-    return
-  case 1            %LIKE UNIX OPERATING SYSTEM
-    
-    % Da generalizzare a un numero di CPu maggiore di 9!!!
-
-    nCPU=str2num(ComputerInformations(length(ComputerInformations)-1))+1;
-
-  case 2            %MAC-OS OPERATING SYSTEM
-
-    nCPU=str2num(ComputerInformations);
-
-end
+function [nCPU]= GiveCPUnumber (ComputerInformations, Environment)
+% PARALLEL CONTEXT
+% In a parallel context this function return the CPUs or cores numer avaiable
+% on the computer used for run parallel code.
+%
+% INPUTS
+% an array contained several fields that describe the hardaware
+% software enviroments of a generic computer.
+%
+% OUTPUTS
+% The CPUs or Cores numbers of computer.
+%
+% SPECIAL REQUIREMENTS
+% none
+
+% Copyright (C) 2010-2017 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/>.
+
+
+nCPU='';
+
+if nargin < 2
+    % Determine a specific operating system or software version when necessary
+    % for different command (sintax, name, ...).
+    Environment=~ispc;
+end
+
+switch Environment
+  case 0          %WINDOWS OPERATING SYSTEM
+
+    OffSet=27;
+
+    SringPosition=strfind(ComputerInformations, 'Processors:');
+    nCPU=ComputerInformations(SringPosition+OffSet);
+
+    % We check if there are Processors/Cores more than 9.
+
+
+    t0=ComputerInformations(SringPosition+OffSet+1);
+    t1=str2num(t0);
+    t1=isempty(t1);
+
+    % if t1 is 0 the machine have more than 9 CPU.
+
+    if t1==0
+        nCPU=strcat(nCPU,t0);
+    end
+
+    nCPU=str2num(nCPU);
+
+    return
+  case 1            %LIKE UNIX OPERATING SYSTEM
+
+    % Da generalizzare a un numero di CPu maggiore di 9!!!
+
+    nCPU=str2num(ComputerInformations(length(ComputerInformations)-1))+1;
+
+  case 2            %MAC-OS OPERATING SYSTEM
+
+    nCPU=str2num(ComputerInformations);
+
+end
diff --git a/matlab/parallel/InitializeComputationalEnvironment.m b/matlab/parallel/InitializeComputationalEnvironment.m
index 02df7aad4..18ce19f11 100644
--- a/matlab/parallel/InitializeComputationalEnvironment.m
+++ b/matlab/parallel/InitializeComputationalEnvironment.m
@@ -10,7 +10,7 @@ function InitializeComputationalEnvironment()
 % OUTPUTS
 % None
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -37,7 +37,7 @@ function InitializeComputationalEnvironment()
 % Comment the line 'warning('off');' in order to view the warning message
 % in Octave!
 
-if isoctave 
+if isoctave
     warning('off');
 end
 
@@ -46,15 +46,15 @@ end
 global options_
 
 isHybridMatlabOctave = false;
-for j=1:length(options_.parallel),
-    if isempty(options_.parallel(j).MatlabOctavePath),
+for j=1:length(options_.parallel)
+    if isempty(options_.parallel(j).MatlabOctavePath)
         if isoctave
             options_.parallel(j).MatlabOctavePath = 'octave';
         else
             options_.parallel(j).MatlabOctavePath = 'matlab';
         end
     end
-    if options_.parallel(j).Local && isempty(options_.parallel(j).DynarePath),
+    if options_.parallel(j).Local && isempty(options_.parallel(j).DynarePath)
         dynareroot = strrep(which('dynare'),'dynare.m','');
         options_.parallel(j).DynarePath=dynareroot;
     end
@@ -62,7 +62,7 @@ for j=1:length(options_.parallel),
 end
 isHybridMatlabOctave = isHybridMatlabOctave && ~isoctave;
 options_.parallel_info.isHybridMatlabOctave = isHybridMatlabOctave;
-if isHybridMatlabOctave,
+if isHybridMatlabOctave
     % Reset dynare random generator and seed.
     set_dynare_seed('default');
 end
@@ -94,7 +94,7 @@ CPUWeightTemp=ones(1,lP)*(-1);
 CPUWeightTemp=CPUWeight;
 
 for i=1:lP
-    [NoNServes mP]=max(CPUWeightTemp);
+    [NoNServes, mP]=max(CPUWeightTemp);
     NewPosition(i)=mP;
     CPUWeightTemp(mP)=-1;
 end
diff --git a/matlab/parallel/closeSlave.m b/matlab/parallel/closeSlave.m
index 339d776bb..49c14deb3 100644
--- a/matlab/parallel/closeSlave.m
+++ b/matlab/parallel/closeSlave.m
@@ -1,4 +1,4 @@
-function closeSlave(Parallel,TmpFolder,partial),
+function closeSlave(Parallel,TmpFolder,partial)
 % PARALLEL CONTEXT
 % In parallel context, this utility closes all remote matlab instances
 % called by masterParallel when strategy (1) is active i.e. always open (which leaves
@@ -10,12 +10,12 @@ function closeSlave(Parallel,TmpFolder,partial),
 %                               This directory is named using current date
 %                               and is used only one time and then deleted.
 %                               If islocal==1, TmpFolder=''.
-% 
+%
 %
 % OUTPUTS
 %   None
 %
-% Copyright (C) 2010-2013 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,7 +32,7 @@ function closeSlave(Parallel,TmpFolder,partial),
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin<3,
+if nargin<3
     partial=0;
 end
 
@@ -40,50 +40,49 @@ s=warning('off');
 
 if partial==1
     save('slaveParallel_break.mat','partial')
-    for indPC=1:length(Parallel),
-        if (Parallel(indPC).Local==0),
+    for indPC=1:length(Parallel)
+        if (Parallel(indPC).Local==0)
             dynareParallelSendFiles('slaveParallel_break.mat',TmpFolder,Parallel(indPC));
         end
     end
-%     delete('slaveParallel_break')
+    %     delete('slaveParallel_break')
     return
 end
 if partial==-1
     delete('slaveParallel_break.mat')
-    for indPC=1:length(Parallel),
-        if (Parallel(indPC).Local==0),
+    for indPC=1:length(Parallel)
+        if (Parallel(indPC).Local==0)
             dynareParallelDelete( 'slaveParallel_break.mat',TmpFolder,Parallel(indPC));
         end
     end
-%     delete('slaveParallel_break')
+    %     delete('slaveParallel_break')
     return
 end
 
-for indPC=1:length(Parallel),
-    if (Parallel(indPC).Local==0),
+for indPC=1:length(Parallel)
+    if (Parallel(indPC).Local==0)
         dynareParallelDelete( 'slaveParallel_input*.mat',TmpFolder,Parallel(indPC));
     end
-    
-   
+
+
     delete( 'slaveParallel_input*.mat');
     delete( 'slaveJob*.mat');
     pause(1)
     delete(['slaveParallel_*.log']);
     delete ConcurrentCommand1.bat;
-    
+
 end
 
 while(1)
-    if isempty(dynareParallelDir(['P_slave_',int2str(j),'End.txt'],TmpFolder,Parallel));
-        for indPC=1:length(Parallel),
-            if (Parallel(indPC).Local==0),
-                dynareParallelRmDir(TmpFolder,Parallel(indPC)),
+    if isempty(dynareParallelDir(['P_slave_',int2str(j),'End.txt'],TmpFolder,Parallel))
+        for indPC=1:length(Parallel)
+            if (Parallel(indPC).Local==0)
+                dynareParallelRmDir(TmpFolder,Parallel(indPC))
             end
         end
         break
-        
+
     end
 end
 
-s=warning('on');
- 
+s=warning('on');
\ No newline at end of file
diff --git a/matlab/parallel/distributeJobs.m b/matlab/parallel/distributeJobs.m
index 0667d902f..c0c41925f 100644
--- a/matlab/parallel/distributeJobs.m
+++ b/matlab/parallel/distributeJobs.m
@@ -21,7 +21,7 @@ function [nCPU, totCPU, nBlockPerCPU, totSLAVES] = distributeJobs(Parallel, fBlo
 %                               It is a number between 1 and length(Parallel).
 
 
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,7 +40,7 @@ function [nCPU, totCPU, nBlockPerCPU, totSLAVES] = distributeJobs(Parallel, fBlo
 
 
 % The Parallel vector has already been sorted
-% (in accord with the CPUWeight values) in DESCENDING order in 
+% (in accord with the CPUWeight values) in DESCENDING order in
 % InitializeComputationalEnvironment!
 
 totCPU=0;
@@ -48,7 +48,7 @@ totCPU=0;
 lP=length(Parallel);
 CPUWeight=ones(1,length(Parallel))*(-1);
 
-for j=1:lP,    
+for j=1:lP
     if mod(length(Parallel(j).CPUnbr),Parallel(j).NumberOfThreadsPerJob)
         skipline()
         disp(['PARALLEL_ERROR:: NumberOfThreadsPerJob = ',int2str(Parallel(j).NumberOfThreadsPerJob),' is not an exact divisor of number of CPUs = ',int2str(length(Parallel(j).CPUnbr)),'!'])
@@ -57,7 +57,7 @@ for j=1:lP,
         error(['PARALLEL_ERROR:: NumberOfThreadsPerJob is not an exact divisor of CPUnbr'])
     end
     nCPU(j)=length(Parallel(j).CPUnbr)/Parallel(j).NumberOfThreadsPerJob;
-    totCPU=totCPU+nCPU(j);    
+    totCPU=totCPU+nCPU(j);
     CPUWeight(j)=str2num(Parallel(j).NodeWeight);
 end
 
@@ -77,7 +77,7 @@ NumbersOfJobs=nBlock-fBlock+1;
 SumOfJobs=0;
 JobsForNode=zeros(1,nC);
 
-for j=1:lP,
+for j=1:lP
     CPUWeight(j)=str2num(Parallel(j).NodeWeight)*nCPUoriginal(j);
 end
 CPUWeight=CPUWeight./sum(CPUWeight);
@@ -85,15 +85,15 @@ CPUWeight=CPUWeight./sum(CPUWeight);
 % Redistributing the jobs among the cluster nodes according to the
 % CPUWeight.
 for i=1:nC
-    
+
     JobsForNode(i)=CPUWeight(i)*NumbersOfJobs;
-    
+
     % Many choices are possible:
-    
+
     % JobsForNode(i)=round(JobsForNode(i));
     % JobsForNode(i)=floor(JobsForNode(i));
-      JobsForNode(i)=ceil(JobsForNode(i));
-    
+    JobsForNode(i)=ceil(JobsForNode(i));
+
 end
 
 % Check if there are more (fewer) jobs.
@@ -101,19 +101,19 @@ end
 SumOfJobs=sum(JobsForNode);
 
 if SumOfJobs~=NumbersOfJobs
-    
+
     if SumOfJobs>NumbersOfJobs
-        
+
         % Many choices are possible:
-        
+
         % - Remove the excess works at the node that has the greatest
         %   number of jobs.
         % - Remove the excess works at the node slower.
-        
+
         VerySlow=nC;
-        
+
         while SumOfJobs>NumbersOfJobs
-            
+
             if JobsForNode(VerySlow)==0
                 VerySlow=VerySlow-1;
                 continue
@@ -121,21 +121,21 @@ if SumOfJobs~=NumbersOfJobs
             JobsForNode(VerySlow)=JobsForNode(VerySlow)-1;
             SumOfJobs=SumOfJobs-1;
         end
-        
+
     end
-    
+
     if SumOfJobs<NumbersOfJobs
-        
+
         % Many choices are possible:
         % - ... (see above).
-        
+
         [NonServe VeryFast]= min(CPUWeight);
-        
+
         while SumOfJobs<NumbersOfJobs
             JobsForNode(VeryFast)=JobsForNode(VeryFast)+1;
             SumOfJobs=SumOfJobs+1;
         end
-        
+
     end
 end
 
@@ -148,36 +148,36 @@ JobAssignedCpu=0;
 RelativePosition=1;
 
 for i=1:nC
-    
+
     % Many choices are possible:
     % - ... (see above).
-     
+
     JobAssignedCpu=max(1,floor(JobsForNode(i)/nCPUoriginal(i)));
-    
+
     ChekOverFlow=0;
-    
+
     for j=RelativePosition:nCPU(i)
         JobsForCpu(j)=JobAssignedCpu;
         ChekOverFlow=ChekOverFlow+JobAssignedCpu;
-        
+
         if ChekOverFlow>=JobsForNode(i)
-            break;
+            break
         end
-        
+
     end
-    
+
     % Check if there are more (fewer) jobs.
     % This can happen when we use ceil, round, ... functions.
-    
+
     if ChekOverFlow ~=(JobsForNode(i))
-        
+
         if ChekOverFlow >(JobsForNode(i))
             while ChekOverFlow>JobsForNode(i)
                 JobsForCpu(nCPU(i))=JobsForCpu(nCPU(i))-1;
                 ChekOverFlow=ChekOverFlow-1;
             end
         end
-        
+
         if ChekOverFlow <(JobsForNode(i))
             while ChekOverFlow<JobsForNode(i)
                 JobsForCpu(nCPU(i))=JobsForCpu(nCPU(i))+1;
@@ -185,9 +185,9 @@ for i=1:nC
             end
         end
     end
-    
+
     RelativePosition=nCPU(i)+1;
-    
+
 end
 
 % Reshape the variables totCPU,totSLAVES and nBlockPerCPU in accord with
@@ -204,7 +204,7 @@ for i=1:nCPU(nC)
 end
 
 for i=1:nC
-    if JobsForNode(i)~=0;
+    if JobsForNode(i)~=0
         totSLAVES=totSLAVES+1;
     end
 end
@@ -216,5 +216,3 @@ for i=1:nCPU(nC)
         RelativeCounter=RelativeCounter+1;
     end
 end
-
-
diff --git a/matlab/parallel/dynareParallelDelete.m b/matlab/parallel/dynareParallelDelete.m
index 060a35f13..478b8c8e4 100644
--- a/matlab/parallel/dynareParallelDelete.m
+++ b/matlab/parallel/dynareParallelDelete.m
@@ -4,14 +4,14 @@ function dynareParallelDelete(fname,pname,Parallel)
 %
 % INPUTS
 %  o fname      []   ...
-%  o pname      []   ... 
-%  o Parallel   []   ...  
+%  o pname      []   ...
+%  o Parallel   []   ...
 %
 %  OUTPUTS
 %  None
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,20 +28,20 @@ function dynareParallelDelete(fname,pname,Parallel)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin ==0,
+if nargin ==0
     disp('dynareParallelDelete(fname)')
     return
 end
 
-if nargin ==1,
+if nargin ==1
     pname='';
 else
     pname=[pname,filesep];
 end
 
-for indPC=1:length(Parallel),
-    if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
-        if ~isempty(Parallel(indPC).Port),
+for indPC=1:length(Parallel)
+    if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
+        if ~isempty(Parallel(indPC).Port)
             ssh_token = ['-p ',Parallel(indPC).Port];
         else
             ssh_token = '';
@@ -53,5 +53,5 @@ for indPC=1:length(Parallel),
             delete(fname_temp);
         end
     end
-    
+
 end
diff --git a/matlab/parallel/dynareParallelDeleteNewFiles.m b/matlab/parallel/dynareParallelDeleteNewFiles.m
index e28cd77da..34fdab44b 100644
--- a/matlab/parallel/dynareParallelDeleteNewFiles.m
+++ b/matlab/parallel/dynareParallelDeleteNewFiles.m
@@ -15,7 +15,7 @@ function dynareParallelDeleteNewFiles(PRCDir,Parallel,PRCDirSnapshot,varargin)
 %
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -35,11 +35,11 @@ function dynareParallelDeleteNewFiles(PRCDir,Parallel,PRCDirSnapshot,varargin)
 NewFilesFromSlaves={};
 
 % try
-for indPC=1:length(Parallel),
-    
-    if Parallel(indPC).Local==0;
+for indPC=1:length(Parallel)
+
+    if Parallel(indPC).Local==0
         [NewFilesFromSlaves, PRCDirSnapshot{indPC}]=dynareParallelFindNewFiles(PRCDirSnapshot{indPC},Parallel(indPC), PRCDir);
-        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
+        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
             fS='/';
         else
             fS='\';
@@ -59,12 +59,12 @@ for indPC=1:length(Parallel),
                 for indexc=1:length(varargin)
                     exception_flag=exception_flag+(~isempty(strfind(fileaddress{2},varargin{indexc})));
                 end
-                if exception_flag==0,
-                dynareParallelDelete(fileaddress{2},[PRCDir,fS,fileaddress{1}],Parallel(indPC));
+                if exception_flag==0
+                    dynareParallelDelete(fileaddress{2},[PRCDir,fS,fileaddress{1}],Parallel(indPC));
 
-                disp('New file deleted in remote -->');
-                disp(fileaddress{2});
-                disp('<--');
+                    disp('New file deleted in remote -->');
+                    disp(fileaddress{2});
+                    disp('<--');
                 end
 
             end
@@ -75,6 +75,3 @@ for indPC=1:length(Parallel),
 
     end
 end
-
-
-
diff --git a/matlab/parallel/dynareParallelDir.m b/matlab/parallel/dynareParallelDir.m
index daecfe6cd..0625dd8e7 100644
--- a/matlab/parallel/dynareParallelDir.m
+++ b/matlab/parallel/dynareParallelDir.m
@@ -10,7 +10,7 @@ function dirlist = dynareParallelDir(filename,PRCDir,Parallel)
 %  OUTPUTS
 %  o dirlist    []   ...
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,24 +28,24 @@ function dirlist = dynareParallelDir(filename,PRCDir,Parallel)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 dirlist=[];
-for indPC=1:length(Parallel),
-    if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
-        if Parallel(indPC).Local==0,
-            if ~isempty(Parallel(indPC).Port),
+for indPC=1:length(Parallel)
+    if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
+        if Parallel(indPC).Local==0
+            if ~isempty(Parallel(indPC).Port)
                 ssh_token = ['-p ',Parallel(indPC).Port];
             else
                 ssh_token = '';
             end
             if isoctave % Patch for peculiar behaviour of ssh-ls under Linux.
-                % It is necessary to capture the ls warning message.
-                % To do it under the ssh protocol it is necessary to redirect the ls message in a text file.
-                % The file is 'OctaveStandardOutputMessage.txt' and it is
-                % saved in the Model directory.
+                        % It is necessary to capture the ls warning message.
+                        % To do it under the ssh protocol it is necessary to redirect the ls message in a text file.
+                        % The file is 'OctaveStandardOutputMessage.txt' and it is
+                        % saved in the Model directory.
                 [check, ax]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' ls ',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',filename, ' 2> OctaveStandardOutputMessage.txt']);
             else
                 [check, ax]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' ls ',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',filename]);
             end
-            if check ~= 0 || ~isempty(strfind(ax,'No such file or directory'));
+            if check ~= 0 || ~isempty(strfind(ax,'No such file or directory'))
                 ax=[];
             else
                 indax=regexp(ax,'\n');
@@ -57,11 +57,11 @@ for indPC=1:length(Parallel),
         else
 
             if isoctave % Patch for peculiar behaviour of ls under Linux.
-                
+
                 % It is necessary to capture the ls warning message and properly manage the jolly char '*'!
                 [check ax]=system(['ls ' ,filename, ' 2> OctaveStandardOutputMessage.txt']);
-                
-                if check ~= 0 || ~isempty(strfind(ax,'No such file or directory'));
+
+                if check ~= 0 || ~isempty(strfind(ax,'No such file or directory'))
                     ax=[];
                 end
             else
@@ -75,32 +75,32 @@ for indPC=1:length(Parallel),
         end
     else
         if isoctave     % Patch for peculiar behaviour of ls under Windows.
-            if Parallel(indPC).Local==0,
+            if Parallel(indPC).Local==0
                 ax0=dir(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',filename]);
             else
                 ax0=dir(filename);
             end
-            if isempty(ax0),
+            if isempty(ax0)
                 ax='';
             else
                 clear ax1;
-                for jax=1:length(ax0);
+                for jax=1:length(ax0)
                     ax1{jax}=ax0(jax).name;
                 end
                 ax=char(ax1{:});
             end
 
         else
-            if Parallel(indPC).Local==0,
+            if Parallel(indPC).Local==0
                 ax=ls(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',filename]);
             else
                 ax=ls(filename);
             end
         end
     end
-    if isempty(dirlist),
+    if isempty(dirlist)
         dirlist=ax;
-    elseif ~isempty(ax),
+    elseif ~isempty(ax)
         dirlist = char(dirlist, ax);
     end
 end
diff --git a/matlab/parallel/dynareParallelFindNewFiles.m b/matlab/parallel/dynareParallelFindNewFiles.m
index 4c6dabf36..d8cb6a9d7 100644
--- a/matlab/parallel/dynareParallelFindNewFiles.m
+++ b/matlab/parallel/dynareParallelFindNewFiles.m
@@ -15,7 +15,7 @@ function [NewFilesFrom, NewFileList]=dynareParallelFindNewFiles(FileList,Paralle
 %  o NewFilesFrom          []   ...
 %  o NewFileList           []   ...
 %
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,7 +36,7 @@ function [NewFilesFrom, NewFileList]=dynareParallelFindNewFiles(FileList,Paralle
 NewFilesFrom={};
 
 LfL=length(FileList);
-                                        % The first call ...
+% The first call ...
 NewFileList = dynareParallelListAllFiles('Root',PRCDir,Parallel);
 
 
@@ -45,35 +45,34 @@ LnFl=length(NewFileList);
 RelativePosition=1;
 
 for i=1:LnFl
-    
+
     % Exception Handling
-    
+
     % If you comment the code below all new file will be copied!
-    
+
     % 1. The comp_status* files are managed separately.
-    
+
     FiCoS=strfind(NewFileList{i},'comp_status_');
     if ~isempty(FiCoS)
         continue
     end
-    
+
     % 2. For the time being is not necessary to always copy *.log
     %    and *.txt files.
-    
+
     nC1 = strfind(NewFileList{i}, '.log');
     nC2 = strfind(NewFileList{i}, '.txt');
-    
+
     if (~isempty(nC1) || ~isempty(nC2))
         continue
     end
-    
+
     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-    
-    
+
+
     N=strmatch(NewFileList{i},FileList,'exact');
     if isempty(N)
         NewFilesFrom{RelativePosition}=NewFileList{i};
         RelativePosition=RelativePosition+1;
     end
 end
-
diff --git a/matlab/parallel/dynareParallelGetFiles.m b/matlab/parallel/dynareParallelGetFiles.m
index 6dbf0539e..6669f21a8 100644
--- a/matlab/parallel/dynareParallelGetFiles.m
+++ b/matlab/parallel/dynareParallelGetFiles.m
@@ -14,7 +14,7 @@ function dynareParallelGetFiles(NamFileInput,PRCDir,Parallel)
 %
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,32 +33,32 @@ function dynareParallelGetFiles(NamFileInput,PRCDir,Parallel)
 
 NamFileInput0=NamFileInput;
 
-for indPC=1:length(Parallel),
-    if Parallel(indPC).Local==0,
-        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
-            if ~isempty(Parallel(indPC).Port),
+for indPC=1:length(Parallel)
+    if Parallel(indPC).Local==0
+        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
+            if ~isempty(Parallel(indPC).Port)
                 ssh_token = ['-p ',Parallel(indPC).Port];
             else
                 ssh_token = '';
             end
-            if ~isempty(Parallel(indPC).Port),
+            if ~isempty(Parallel(indPC).Port)
                 scp_token = ['-P ',Parallel(indPC).Port];
             else
                 scp_token = '';
             end
-            if ischar(NamFileInput0),
-                for j=1:size(NamFileInput0,1),
+            if ischar(NamFileInput0)
+                for j=1:size(NamFileInput0,1)
                     NamFile(j,:)={['./'],deblank(NamFileInput0(j,:))};
                 end
                 NamFileInput = NamFile;
             end
-            for jfil=1:size(NamFileInput,1),
+            for jfil=1:size(NamFileInput,1)
 
                 if isoctave % Patch for peculiar behaviour of ls under Linux.
-                    % It is necessary to manage the jolly char '*'!
+                            % It is necessary to manage the jolly char '*'!
 
                     FindAst=strfind(NamFileInput{jfil,2},'comp_status_posterior_sampler_core*');
-                    
+
                     if isempty (FindAst)
 
                         [NonServeL NonServeR]= system(['scp ',scp_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,':',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',NamFileInput{jfil,1},NamFileInput{jfil,2},' ',NamFileInput{jfil,1}]);
@@ -66,9 +66,9 @@ for indPC=1:length(Parallel),
                     else
 
                         filenameTemp=NamFileInput{jfil,2};
-                        
+
                         [NotUsed FlI]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' ls ',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',filenameTemp, ' 2> OctaveStandardOutputMessage.txt']);
-                        
+
                         if isempty (FlI)
                             return
                         end
@@ -92,14 +92,14 @@ for indPC=1:length(Parallel),
 
             end
         else
-            if ischar(NamFileInput0),
-                for j=1:size(NamFileInput0,1),
+            if ischar(NamFileInput0)
+                for j=1:size(NamFileInput0,1)
                     NamFile(j,:)={['.\'],deblank(NamFileInput0(j,:))};
                 end
                 NamFileInput = NamFile;
             end
-            for jfil=1:size(NamFileInput,1),
-                if ~isempty(dynareParallelDir(NamFileInput{jfil,2},[PRCDir,filesep,NamFileInput{jfil,1}],Parallel(indPC))),
+            for jfil=1:size(NamFileInput,1)
+                if ~isempty(dynareParallelDir(NamFileInput{jfil,2},[PRCDir,filesep,NamFileInput{jfil,1}],Parallel(indPC)))
                     copyfile(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInput{jfil,1},NamFileInput{jfil,2}],NamFileInput{jfil,1});
                 end
             end
diff --git a/matlab/parallel/dynareParallelGetNewFiles.m b/matlab/parallel/dynareParallelGetNewFiles.m
index 5f7eb43a3..8d42bd375 100644
--- a/matlab/parallel/dynareParallelGetNewFiles.m
+++ b/matlab/parallel/dynareParallelGetNewFiles.m
@@ -15,7 +15,7 @@ function [PRCDirSnapshot]=dynareParallelGetNewFiles(PRCDir,Parallel,PRCDirSnapsh
 %
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,11 +36,11 @@ function [PRCDirSnapshot]=dynareParallelGetNewFiles(PRCDir,Parallel,PRCDirSnapsh
 NewFilesFromSlaves={};
 
 % try
-for indPC=1:length(Parallel),
-    
-    if Parallel(indPC).Local==0;
+for indPC=1:length(Parallel)
+
+    if Parallel(indPC).Local==0
         [NewFilesFromSlaves, PRCDirSnapshot{indPC}]=dynareParallelFindNewFiles(PRCDirSnapshot{indPC},Parallel(indPC), PRCDir);
-        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
+        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
             fS='/';
         else
             fS='\';
@@ -71,6 +71,3 @@ for indPC=1:length(Parallel),
 
     end
 end
-
-
-
diff --git a/matlab/parallel/dynareParallelListAllFiles.m b/matlab/parallel/dynareParallelListAllFiles.m
index 53e893e15..eab713422 100644
--- a/matlab/parallel/dynareParallelListAllFiles.m
+++ b/matlab/parallel/dynareParallelListAllFiles.m
@@ -14,7 +14,7 @@ function fileList = dynareParallelListAllFiles(dirName,PRCDir,Parallel)
 %  OUTPUTS
 %  o fileList          []   ...
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,33 +34,33 @@ function fileList = dynareParallelListAllFiles(dirName,PRCDir,Parallel)
 
 
 if (~ispc || strcmpi('unix',Parallel.OperatingSystem))
-   
+
     fileList={};
     currentPath=[];
-    if ~isempty(Parallel.Port),
+    if ~isempty(Parallel.Port)
         ssh_token = ['-p ',Parallel.Port];
     else
         ssh_token = '';
     end
 
-     % Get the data for the current remote directory.
-    [Flag fL]=system(['ssh ',ssh_token,' ',' ',Parallel.UserName,'@',Parallel.ComputerName,' ls ',Parallel.RemoteDirectory,'/',PRCDir, ' -R -p -1']);
+    % Get the data for the current remote directory.
+    [Flag, fL]=system(['ssh ',ssh_token,' ',' ',Parallel.UserName,'@',Parallel.ComputerName,' ls ',Parallel.RemoteDirectory,'/',PRCDir, ' -R -p -1']);
 
     % Format the return value fL.
-    
+
     nL=regexp(fL,'\n');
     start=1;
     j=1;
 
     for (i=1:length(nL))
-        
+
         stringProcessed=fL(start:nL(i)-1);
-        
+
         if isempty(stringProcessed)
             start=nL(i)+1;
             continue
         end
-            
+
         if strfind(stringProcessed,'/')
             if strfind(stringProcessed,PRCDir)
                 DD=strfind(stringProcessed,':');
@@ -70,11 +70,11 @@ if (~ispc || strcmpi('unix',Parallel.OperatingSystem))
             start=nL(i)+1;
             continue
         end
-        
+
         fileList{j,1}=[currentPath stringProcessed];
         start=nL(i)+1;
         j=j+1;
-    end 
+    end
 
 
 else
@@ -92,7 +92,7 @@ else
     % Build the path files:
     if ~isempty(fileList)
         fileList = cellfun(@(x) fullfile(dirName,x),...
-            fileList,'UniformOutput',false);
+                           fileList,'UniformOutput',false);
     end
 
     % Get a list of the subdirectories:
@@ -112,5 +112,3 @@ else
         fileList = [fileList; dynareParallelListAllFiles(nextDir,PRCDir,Parallel)];
     end
 end
-
-
diff --git a/matlab/parallel/dynareParallelMkDir.m b/matlab/parallel/dynareParallelMkDir.m
index 9e8d7b7de..e85d1af3a 100644
--- a/matlab/parallel/dynareParallelMkDir.m
+++ b/matlab/parallel/dynareParallelMkDir.m
@@ -3,14 +3,14 @@ function dynareParallelMkDir(PRCDir,Parallel)
 % In a parallel context, this is a specialized version of rmdir() function.
 %
 % INPUTS
-%  o PRCDir         []   ... 
-%  o Parallel       []   ...  
+%  o PRCDir         []   ...
+%  o Parallel       []   ...
 %
 %  OUTPUTS
 %  None
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,24 +29,22 @@ function dynareParallelMkDir(PRCDir,Parallel)
 
 
 
-if nargin ==0,
+if nargin ==0
     disp('dynareParallelMkDir(dirname,Parallel)')
     return
 end
 
 for indPC=1:length(Parallel)
-    if Parallel(indPC).Local==0,
-        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
-            if ~isempty(Parallel(indPC).Port),
+    if Parallel(indPC).Local==0
+        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
+            if ~isempty(Parallel(indPC).Port)
                 ssh_token = ['-p ',Parallel(indPC).Port];
             else
                 ssh_token = '';
             end
-            [NonServeS NonServeD]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' mkdir -p ',Parallel(indPC).RemoteDirectory,'/',PRCDir]);
+            [NonServeS, NonServeD]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' mkdir -p ',Parallel(indPC).RemoteDirectory,'/',PRCDir]);
         else
-            [NonServeS NonServeD]=mkdir(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir]);
+            [NonServeS, NonServeD]=mkdir(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir]);
         end
     end
-end
-
-return
\ No newline at end of file
+end
\ No newline at end of file
diff --git a/matlab/parallel/dynareParallelRmDir.m b/matlab/parallel/dynareParallelRmDir.m
index fbf7b7790..64f3c4fde 100644
--- a/matlab/parallel/dynareParallelRmDir.m
+++ b/matlab/parallel/dynareParallelRmDir.m
@@ -3,15 +3,15 @@ function dynareParallelRmDir(PRCDir,Parallel)
 % In a parallel context, this is a specialized version of rmdir() function.
 %
 % INPUTS
-%  o PRCDir         []   ... 
-%  o Parallel       []   ...  
+%  o PRCDir         []   ...
+%  o Parallel       []   ...
 %
 %  OUTPUTS
 %  None
 %
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ function dynareParallelRmDir(PRCDir,Parallel)
 
 
 
-if nargin ==0,
+if nargin ==0
     disp('dynareParallelRmDir(fname)')
     return
 end
@@ -45,7 +45,7 @@ ok(5)=~isempty(strfind(PRCDir,'m'));
 ok(6)=~isempty(strfind(PRCDir,'s'));
 ok(7)=~isempty(PRCDir);
 
-if sum(ok)<7,
+if sum(ok)<7
     error('The name of the remote tmp folder does not comply the security standards!'),
 end
 
@@ -53,34 +53,32 @@ if isoctave
     confirm_recursive_rmdir(false, 'local');
 end
 
-for indPC=1:length(Parallel),
+for indPC=1:length(Parallel)
     ok(1)=isempty(strfind(Parallel(indPC).RemoteDirectory,'..'));
-    if sum(ok)<7,
+    if sum(ok)<7
         error('The remote folder path structure does not comply the security standards!'),
     end
     while (1)
-        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
-            if ~isempty(Parallel(indPC).Port),
+        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
+            if ~isempty(Parallel(indPC).Port)
                 ssh_token = ['-p ',Parallel(indPC).Port];
             else
                 ssh_token = '';
             end
-            [stat NonServe] = system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' rm -fr ',Parallel(indPC).RemoteDirectory,'/',PRCDir,]);
-            break;
+            [stat, NonServe] = system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' rm -fr ',Parallel(indPC).RemoteDirectory,'/',PRCDir,]);
+            break
         else
             [stat, mess, id] = rmdir(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir],'s');
 
-            if stat==1,
-                break,
+            if stat==1
+                break
             else
-                if isempty(dynareParallelDir(PRCDir,'',Parallel));
-                    break,
+                if isempty(dynareParallelDir(PRCDir,'',Parallel))
+                    break
                 else
                     pause(1);
                 end
             end
         end
     end
-end
-
-return
\ No newline at end of file
+end
\ No newline at end of file
diff --git a/matlab/parallel/dynareParallelSendFiles.m b/matlab/parallel/dynareParallelSendFiles.m
index 6f7e645f5..6a3c8904c 100644
--- a/matlab/parallel/dynareParallelSendFiles.m
+++ b/matlab/parallel/dynareParallelSendFiles.m
@@ -14,7 +14,7 @@ function dynareParallelSendFiles(NamFileInput,PRCDir,Parallel)
 %
 %
 %
-% Copyright (C) 2009-2013 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,83 +32,83 @@ function dynareParallelSendFiles(NamFileInput,PRCDir,Parallel)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-if ischar(NamFileInput),
-    for j=1:size(NamFileInput,1),
+if ischar(NamFileInput)
+    for j=1:size(NamFileInput,1)
         NamFile(j,:)={'',deblank(NamFileInput(j,:))};
     end
     NamFileInput = NamFile;
 end
 
-for indPC=1:length(Parallel),
-    if Parallel(indPC).Local==0,
-        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem),
-            if ~isempty(Parallel(indPC).Port),
+for indPC=1:length(Parallel)
+    if Parallel(indPC).Local==0
+        if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)
+            if ~isempty(Parallel(indPC).Port)
                 ssh_token = ['-p ',Parallel(indPC).Port];
             else
                 ssh_token = '';
             end
-            if ~isempty(Parallel(indPC).Port),
+            if ~isempty(Parallel(indPC).Port)
                 scp_token = ['-P ',Parallel(indPC).Port];
             else
                 scp_token = '';
             end
-            for jfil=1:size(NamFileInput,1),
+            for jfil=1:size(NamFileInput,1)
                 if ~isempty(NamFileInput{jfil,1})
-                    [NonServeL NonServeR]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' mkdir -p ',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',NamFileInput{jfil,1}]);
+                    [NonServeL, NonServeR]=system(['ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' mkdir -p ',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',NamFileInput{jfil,1}]);
                 end
-                [NonServeL NonServeR]=system(['scp ',scp_token,' ',NamFileInput{jfil,1},NamFileInput{jfil,2},' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,':',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',NamFileInput{jfil,1}]);
+                [NonServeL, NonServeR]=system(['scp ',scp_token,' ',NamFileInput{jfil,1},NamFileInput{jfil,2},' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,':',Parallel(indPC).RemoteDirectory,'/',PRCDir,'/',NamFileInput{jfil,1}]);
             end
         else
             for jfil=1:size(NamFileInput,1)
                 if ~isempty(NamFileInput{jfil,1})
                     if isempty(dynareParallelDir(NamFileInput{jfil,1},PRCDir,Parallel(indPC)))
-                        
+
                         if isoctave % Patch for peculiar behaviour of mkdir under Windows.
-                            
+
                             % It is Necessary because Octave is not able to
                             % create two nested directory at the same time.
-                            
-                           % Remove (if present) the '/' chars. Can be easily transformed
-                           % in a function.
-                           
+
+                            % Remove (if present) the '/' chars. Can be easily transformed
+                            % in a function.
+
                             NamFileInputTemp=NamFileInput{jfil,1};
                             while(1)
                                 Bs=strfind(NamFileInputTemp,'/');
-                                if isempty(Bs),
-                                    break;
+                                if isempty(Bs)
+                                    break
                                 else
                                     NamFileInputTemp(1,Bs)='\';
                                 end
                             end
-                            
-                            [NonServeL NonServeR]=system(['mkdir \\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInputTemp]);
+
+                            [NonServeL, NonServeR]=system(['mkdir \\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInputTemp]);
 
                         else
                             mkdir(['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInput{jfil,1}]);
                         end
                     end
                 end
-                
+
                 if isoctave % Patch for peculiar behaviour copyfile ls under Windows.
-                    
+
                     % It is Necessary because Octave is not able to
                     % use the jolly char '*' with copyfile.
-                    
-                      % Remove (if present) the '/' chars. Can be easily transformed
-                      % in a function.
-                    
+
+                    % Remove (if present) the '/' chars. Can be easily transformed
+                    % in a function.
+
                     NamFileInputTemp=NamFileInput{jfil,1};
                     while(1)
                         Bs=strfind(NamFileInputTemp,'/');
-                        if isempty(Bs),
-                            break;
+                        if isempty(Bs)
+                            break
                         else
                             NamFileInputTemp(1,Bs)='\';
                         end
                     end
-                    
-                    [NonServeS NonServeD]=system(['copy ',NamFileInputTemp, NamFileInput{jfil,2},' \\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInputTemp]);
-                    
+
+                    [NonServeS, NonServeD]=system(['copy ',NamFileInputTemp, NamFileInput{jfil,2},' \\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInputTemp]);
+
                 else
                     copyfile([NamFileInput{jfil,1},NamFileInput{jfil,2}],['\\',Parallel(indPC).ComputerName,'\',Parallel(indPC).RemoteDrive,'$\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\',NamFileInput{jfil,1}]);
                 end
diff --git a/matlab/parallel/dynareParallelSnapshot.m b/matlab/parallel/dynareParallelSnapshot.m
index 4f07b04df..8566ebfe0 100644
--- a/matlab/parallel/dynareParallelSnapshot.m
+++ b/matlab/parallel/dynareParallelSnapshot.m
@@ -14,7 +14,7 @@ function [PRCDirSnapshot]=dynareParallelSnapshot(PRCDir,Parallel)
 %
 %
 %
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,10 +33,10 @@ function [PRCDirSnapshot]=dynareParallelSnapshot(PRCDir,Parallel)
 
 PRCDirSnapshot={};
 
-for indPC=1:length(Parallel),
-    if Parallel(indPC).Local==0;
-                                                       % The first call ...
+for indPC=1:length(Parallel)
+    if Parallel(indPC).Local==0
+        % The first call ...
         PRCDirSnapshot{indPC}=dynareParallelListAllFiles('Root',PRCDir,Parallel(indPC));
-        
+
     end
 end
diff --git a/matlab/parallel/fMessageStatus.m b/matlab/parallel/fMessageStatus.m
index 6d84705ab..2c9f8ab5f 100644
--- a/matlab/parallel/fMessageStatus.m
+++ b/matlab/parallel/fMessageStatus.m
@@ -3,18 +3,18 @@ function fMessageStatus(prtfrc, njob, waitbarString, waitbarTitle, Parallel)
 % In parallel context, this function is launched on slave
 % machines, and acts as a message passing device for the master machine.
 
-% INPUTS 
+% INPUTS
 % o prtfrc          [double]     fraction of iteration performed
 % o njob            [int]        index number of this CPU among all CPUs in the
 %                                cluster
-% o waitbarString   [char]       running message string to be displayed in the monitor window on master machine 
+% o waitbarString   [char]       running message string to be displayed in the monitor window on master machine
 % o waitbarTitle    [char]       title to be displayed in the monitor window on master machine
 % o Parallel        [struct]     options_.parallel(ThisMatlab), i.e. the parallel settings for this slave machine in the cluster.
 %
-% OUTPUTS 
-% o None 
+% OUTPUTS
+% o None
 
-% Copyright (C) 2006-2012 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,18 +33,17 @@ function fMessageStatus(prtfrc, njob, waitbarString, waitbarTitle, Parallel)
 
 global funcName
 
-if nargin<5,
+if nargin<5
     Parallel.Local=1;
 end
 
 try
     save(['comp_status_',funcName,int2str(njob),'.mat'],'prtfrc','njob','waitbarString','waitbarTitle');
-catch  
+catch
 end
 
 fslave = dir( ['slaveParallel_input',int2str(njob),'.mat']);
 fbreak = dir( ['slaveParallel_break.mat']);
-if isempty(fslave) || ~isempty(fbreak),
+if isempty(fslave) || ~isempty(fbreak)
     error('Master asked to break the job');
 end
-
diff --git a/matlab/parallel/fParallel.m b/matlab/parallel/fParallel.m
index 51e6ebe16..4bce41008 100644
--- a/matlab/parallel/fParallel.m
+++ b/matlab/parallel/fParallel.m
@@ -18,7 +18,7 @@ function fParallel(fblck,nblck,whoiam,ThisMatlab,fname)
 % OUTPUTS
 %   None
 %
-% Copyright (C) 2006-2012 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -53,7 +53,7 @@ load( [fname,'_input'])
 
 if exist('fGlobalVar') && ~isempty (fGlobalVar)
     globalVars = fieldnames(fGlobalVar);
-    for j=1:length(globalVars),
+    for j=1:length(globalVars)
         eval(['global ',globalVars{j},';'])
         evalin('base',['global ',globalVars{j},';'])
     end
@@ -67,12 +67,12 @@ fInputVar.Parallel = Parallel;
 
 
 % Launch the routine to be run in parallel.
-try,
-    tic,
-    
+try
+    tic
+
     fOutputVar = feval(fname, fInputVar ,fblck, nblck, whoiam, ThisMatlab);
-    toc,
-    if isfield(fOutputVar,'OutputFileName'),
+    toc
+    if isfield(fOutputVar,'OutputFileName')
         OutputFileName = fOutputVar.OutputFileName;
     else
         OutputFileName = '';
@@ -81,15 +81,15 @@ try,
         % Save the output result.
         save([ fname,'_output_',int2str(whoiam),'.mat'],'fOutputVar' )
     end
-    if isfield(fOutputVar,'CloseAllSlaves'),
+    if isfield(fOutputVar,'CloseAllSlaves')
         CloseAllSlaves = 1;
         fOutputVar = rmfield(fOutputVar,'CloseAllSlaves');
         save([ fname,'_output_',int2str(whoiam),'.mat'],'fOutputVar' )
         save(['comp_status_',funcName,int2str(whoiam),'.mat'],'CloseAllSlaves');
     end
-    
+
     disp(['fParallel ',int2str(whoiam),' completed.'])
-catch,
+catch
     theerror = lasterror;
     if strfind(theerror.message,'Master asked to break the job')
         fOutputVar.message = theerror;
@@ -101,14 +101,14 @@ catch,
         save([ fname,'_output_',int2str(whoiam),'.mat'],'fOutputVar' )
         waitbarString = theerror.message;
         %       waitbarTitle=['Metropolis-Hastings ',options_.parallel(ThisMatlab).ComputerName];
-        if Parallel(ThisMatlab).Local,
+        if Parallel(ThisMatlab).Local
             waitbarTitle='Local ';
         else
             waitbarTitle=[Parallel(ThisMatlab).ComputerName];
         end
         fMessageStatus(NaN,whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab));
     end
-    
+
 end
 diary off;
 delete(['P_',fname,'_',int2str(whoiam),'End.txt']);
diff --git a/matlab/parallel/masterParallel.m b/matlab/parallel/masterParallel.m
index 902b237dc..e51c6d023 100644
--- a/matlab/parallel/masterParallel.m
+++ b/matlab/parallel/masterParallel.m
@@ -3,37 +3,37 @@ function [fOutVar,nBlockPerCPU, totCPU] = masterParallel(Parallel,fBlock,nBlock,
 % This is the most important function for the management of DYNARE parallel
 % computing.
 % It is the top-level function called on the master computer when parallelizing a task.
-% 
+%
 % This function has two main computational strategies for managing the
 % matlab worker (slave process):
-% 
+%
 % 0 Simple Close/Open Stategy:
 %   In this case the new Matlab instances (slave process) are open when
 %   necessary and then closed. This can happen many times during the
 %   simulation of a model.
-% 
+%
 % 1 Always Open Strategy:
 %   In this case we have a more sophisticated management of slave processes,
 %   which are no longer closed at the end of each job. The slave processes
 %   wait for a new job (if it exists). If a slave does not receive a new job after a
 %   fixed time it is destroyed. This solution removes the computational
 %   time necessary to Open/Close new Matlab instances.
-% 
+%
 % The first (point 0) is the default Strategy
 % i.e.(Parallel_info.leaveSlaveOpen=0). This value can be changed by the
 % user in xxx.mod file or it is changed by the programmer if it is necessary to
 % reduce the overall computational time. See for example the
 % prior_posterior_statistics.m.
-% 
+%
 % The number of parallelized threads will be equal to (nBlock-fBlock+1).
 %
 % Treatment of global variables:
-%   Global variables used within the called function are wrapped and passed by storing their 
+%   Global variables used within the called function are wrapped and passed by storing their
 %   values at the start of the parallel computation in a file via
 %   storeGlobalVars.m. This file is then loaded in the separate,
 %   independent slave Matlab sessions. By keeping them separate, no
-%   interaction via global variables can take place. 
-% 
+%   interaction via global variables can take place.
+%
 % INPUTS
 %  o Parallel [struct vector]   copy of options_.parallel
 %  o fBlock [int]               index number of the first thread
@@ -62,7 +62,7 @@ function [fOutVar,nBlockPerCPU, totCPU] = masterParallel(Parallel,fBlock,nBlock,
 %                              the number of CPUs declared in "Parallel", if
 %                              the number of required threads is lower)
 
-% Copyright (C) 2009-2015 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -91,11 +91,11 @@ Strategy=Parallel_info.leaveSlaveOpen;
 
 islocal = 1;
 isHybridMatlabOctave = Parallel_info.isHybridMatlabOctave;
-for j=1:length(Parallel),
+for j=1:length(Parallel)
     islocal=islocal*Parallel(j).Local;
 end
 if nargin>8 && initialize==1
-    if islocal == 0,
+    if islocal == 0
         PRCDir=CreateTimeString();
         assignin('base','PRCDirTmp',PRCDir),
         evalin('base','options_.parallel_info.RemoteTmpFolder=PRCDirTmp;')
@@ -108,7 +108,7 @@ if nargin>8 && initialize==1
 end
 
 if isfield(Parallel_info,'local_files')
-    if isempty(NamFileInput),
+    if isempty(NamFileInput)
         NamFileInput=Parallel_info.local_files;
     else
         NamFileInput=[NamFileInput;Parallel_info.local_files];
@@ -120,31 +120,31 @@ end
 % in Octave!
 
 if isoctave
-    warning('off');
+    warning('off')
 end
 
 % check if there are function_handles in the input or global vars when
 % octave is used
 if isHybridMatlabOctave || isoctave
     fInputNames = fieldnames(fInputVar);
-    for j=1:length(fInputNames),
+    for j=1:length(fInputNames)
         TargetVar = fInputVar.(fInputNames{j});
-        if isa(TargetVar,'function_handle'),
+        if isa(TargetVar,'function_handle')
             TargetVar=func2str(TargetVar);
             fInputVar.(fInputNames{j})=TargetVar;
         end
     end
-    
-    if exist('fGlobalVar','var') && ~isempty(fGlobalVar),
-    fInputNames = fieldnames(fGlobalVar);
-    for j=1:length(fInputNames),
-        TargetVar = fGlobalVar.(fInputNames{j});
-        if isa(TargetVar,'function_handle'),
-            TargetVar=func2str(TargetVar);
-            fGlobalVar.(fInputNames{j})=TargetVar;
+
+    if exist('fGlobalVar','var') && ~isempty(fGlobalVar)
+        fInputNames = fieldnames(fGlobalVar);
+        for j=1:length(fInputNames)
+            TargetVar = fGlobalVar.(fInputNames{j});
+            if isa(TargetVar,'function_handle')
+                TargetVar=func2str(TargetVar);
+                fGlobalVar.(fInputNames{j})=TargetVar;
+            end
         end
     end
-    end
 end
 
 if Strategy==1
@@ -156,7 +156,7 @@ end
 
 DyMo=pwd;
 % fInputVar.DyMo=DyMo;
-if ispc,
+if ispc
     [tempo, MasterName]=system('hostname');
     MasterName=deblank(MasterName);
 end
@@ -165,18 +165,18 @@ end
 
 % Save input data for use by the slaves.
 switch Strategy
-    case 0
-        storeGlobalVars([fname,'_input.mat']);
-        save([fname,'_input.mat'],'fInputVar','Parallel','-append')
-        
-    case 1
-        if exist('fGlobalVar','var'),
-            save(['temp_input.mat'],'fInputVar','fGlobalVar')
-        else
-            save(['temp_input.mat'],'fInputVar')
-        end
-        save(['temp_input.mat'],'Parallel','-append')
-        closeSlave(Parallel,PRCDir,-1);
+  case 0
+    storeGlobalVars([fname,'_input.mat']);
+    save([fname,'_input.mat'],'fInputVar','Parallel','-append')
+
+  case 1
+    if exist('fGlobalVar','var')
+        save(['temp_input.mat'],'fInputVar','fGlobalVar')
+    else
+        save(['temp_input.mat'],'fInputVar')
+    end
+    save(['temp_input.mat'],'Parallel','-append')
+    closeSlave(Parallel,PRCDir,-1);
 end
 
 
@@ -184,7 +184,7 @@ end
 % to run on each CPU.
 
 [nCPU, totCPU, nBlockPerCPU, totSlaves] = distributeJobs(Parallel, fBlock, nBlock);
-for j=1:totSlaves,
+for j=1:totSlaves
     PRCDirSnapshot{j}={};
 end
 offset0 = fBlock-1;
@@ -206,7 +206,7 @@ fid = fopen('ConcurrentCommand1.bat','w+');
 
 
 % Create the directory devoted to remote computation.
-if isempty(PRCDir) && ~islocal,
+if isempty(PRCDir) && ~islocal
     error('PRCDir not initialized!')
 else
     dynareParallelMkDir(PRCDir,Parallel(1:totSlaves));
@@ -238,27 +238,27 @@ end
 
 % End
 
-for j=1:totCPU,
-    
+for j=1:totCPU
+
     if Strategy==1
         command1 = ' ';
     end
-    
+
     indPC=min(find(nCPU>=j));
-    
+
     % According to the information contained in configuration file, compThread can limit MATLAB
     % to a single computational thread. By default, MATLAB makes use of the multithreading
     % capabilities of the computer on which it is running. Nevertheless
     % exsperimental results show as matlab native
     % multithreading limit the performaces when the parallel computing is active.
-    
-    
-    if strcmp('true',Parallel(indPC).SingleCompThread),
+
+
+    if strcmp('true',Parallel(indPC).SingleCompThread)
         compThread = '-singleCompThread';
     else
         compThread = '';
     end
-    
+
     nthreads=Parallel(indPC).NumberOfThreadsPerJob;
     if indPC>1
         nCPU0 = nCPU(indPC-1);
@@ -266,20 +266,20 @@ for j=1:totCPU,
         nCPU0=0;
     end
     offset = sum(nBlockPerCPU(1:j-1))+offset0;
-    
+
     % Create a file used to monitoring if a parallel block (core)
     % computation is finished or not.
-    
+
     fid1=fopen(['P_',fname,'_',int2str(j),'End.txt'],'w+');
     fclose(fid1);
-    
-    if Strategy==1,
-        
+
+    if Strategy==1
+
         fblck = offset+1;
         nblck = sum(nBlockPerCPU(1:j));
         save temp_input.mat fblck nblck fname -append;
         copyfile('temp_input.mat',['slaveJob',int2str(j),'.mat']);
-        if Parallel(indPC).Local ==0,
+        if Parallel(indPC).Local ==0
             fid1=fopen(['stayalive',int2str(j),'.txt'],'w+');
             fclose(fid1);
             dynareParallelSendFiles(['stayalive',int2str(j),'.txt'],PRCDir,Parallel(indPC));
@@ -289,80 +289,157 @@ for j=1:totCPU,
         % internal criteria.
         pause(1);
         newInstance = 0;
-        
+
         % Check if j CPU is already alive.
-        if isempty(dynareParallelDir(['P_slave_',int2str(j),'End.txt'],PRCDir,Parallel(indPC)));
+        if isempty(dynareParallelDir(['P_slave_',int2str(j),'End.txt'],PRCDir,Parallel(indPC)))
             fid1=fopen(['P_slave_',int2str(j),'End.txt'],'w+');
             fclose(fid1);
-            if Parallel(indPC).Local==0,
+            if Parallel(indPC).Local==0
                 dynareParallelSendFiles(['P_slave_',int2str(j),'End.txt'],PRCDir,Parallel(indPC));
                 delete(['P_slave_',int2str(j),'End.txt']);
             end
-            
+
             newInstance = 1;
             storeGlobalVars( ['slaveParallel_input',int2str(j),'.mat']);
             save( ['slaveParallel_input',int2str(j),'.mat'],'Parallel','-append');
             % Prepare global vars for Slave.
         end
     else
-        
+
         % If the computation is executed remotely all the necessary files
         % are created localy, then copied in remote directory and then
         % deleted (loacal)!
-        
+
         save( ['slaveParallel_input',int2str(j),'.mat'],'j');
-        
-        if Parallel(indPC).Local==0,
+
+        if Parallel(indPC).Local==0
             dynareParallelSendFiles(['P_',fname,'_',int2str(j),'End.txt'],PRCDir,Parallel(indPC));
             delete(['P_',fname,'_',int2str(j),'End.txt']);
-            
+
             dynareParallelSendFiles(['slaveParallel_input',int2str(j),'.mat'],PRCDir,Parallel(indPC));
             delete(['slaveParallel_input',int2str(j),'.mat']);
-            
+
         end
-        
+
     end
-    
+
     % set affinity range on win CPU's
     affinity_range = [1:nthreads]+(j-1-nCPU0)*nthreads;
     my_affinity = int2str(Parallel(indPC).CPUnbr(affinity_range(1)));
-    for jaff=2:length(affinity_range),
+    for jaff=2:length(affinity_range)
         my_affinity = [my_affinity ',' int2str(Parallel(indPC).CPUnbr(affinity_range(jaff)))];
     end
-% % %                   int2str(Parallel(indPC).CPUnbr(j-nCPU0))
+    % % %                   int2str(Parallel(indPC).CPUnbr(j-nCPU0))
     % DA SINTETIZZARE:
-    
+
     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     % The following 'switch - case' code is the core of this function!
     switch Strategy
-        case 0
-            
-            if Parallel(indPC).Local == 1,                                  % 0.1 Run on the local machine (localhost).
-                
-                if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem), % Hybrid computing Windows <-> Unix!
-                    if regexpi([Parallel(indPC).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                        command1=[Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')" &'];
-                    else
-                        command1=[Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')" &'];
-                    end
-                else    % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+      case 0
+
+        if Parallel(indPC).Local == 1                                  % 0.1 Run on the local machine (localhost).
+
+            if ~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem) % Hybrid computing Windows <-> Unix!
+                if regexpi([Parallel(indPC).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                    command1=[Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')" &'];
+                else
+                    command1=[Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')" &'];
+                end
+            else    % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
+                    command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                else
+                    command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                end
+            end
+        else                                                            % 0.2 Parallel(indPC).Local==0: Run using network on remote machine or also on local machine.
+            if j==nCPU0+1
+                dynareParallelSendFiles([fname,'_input.mat'],PRCDir,Parallel(indPC));
+                dynareParallelSendFiles(NamFileInput,PRCDir,Parallel(indPC));
+            end
+
+            if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)) % Hybrid computing Windows <-> Unix!
+                if ispc
+                    token='start /B ';
+                else
+                    token = '';
+                end
+                if ~isempty(Parallel(indPC).Port)
+                    ssh_token = ['-p ',Parallel(indPC).Port];
+                else
+                    ssh_token = '';
+                end
+                % To manage the diferences in Unix/Windows OS syntax.
+                remoteFile=['remoteDynare',int2str(j)];
+                fidRemote=fopen([remoteFile,'.m'],'w+');
+                if regexpi([Parallel(indPC).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                    remoteString=['default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')'];
+                    command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir, '; ',Parallel(indPC).MatlabOctavePath,' -f --eval ',remoteFile,' " &'];
+                else
+                    remoteString=['addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')'];
+                    command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir, '; ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r ',remoteFile,';" &'];
+                end
+                fprintf(fidRemote,'%s\n',remoteString);
+                fclose(fidRemote);
+                dynareParallelSendFiles([remoteFile,'.m'],PRCDir,Parallel(indPC));
+                delete([remoteFile,'.m']);
+            else
+                if ~strcmpi(Parallel(indPC).ComputerName,MasterName)  % 0.3 Run on a remote machine!
+                                                                      % Hybrid computing Matlab(Master)-> Octave(Slaves) and Vice Versa!
                     if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
-                        command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                        command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -u ',Parallel(indPC).UserName,' -p ',Parallel(indPC).Password,' -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
+                                  ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
                     else
-                        command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+
+                        command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -u ',Parallel(indPC).UserName,' -p ',Parallel(indPC).Password,' -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
+                                  ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                    end
+                else                                                  % 0.4 Run on the local machine via the network
+                                                                      % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                    if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
+                        command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
+                                  ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                    else
+                        command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
+                                  ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
                     end
                 end
-            else                                                            % 0.2 Parallel(indPC).Local==0: Run using network on remote machine or also on local machine.
-                if j==nCPU0+1,
-                    dynareParallelSendFiles([fname,'_input.mat'],PRCDir,Parallel(indPC));
-                    dynareParallelSendFiles(NamFileInput,PRCDir,Parallel(indPC));
+            end
+        end
+
+
+      case 1
+        if Parallel(indPC).Local == 1 && newInstance                       % 1.1 Run on the local machine.
+            if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem))  % Hybrid computing Windows <-> Unix!
+                if regexpi([Parallel(indPC).MatlabOctavePath], 'octave')    % Hybrid computing Matlab(Master)-> Octave(Slaves) and Vice Versa!
+                    command1=[Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')" &'];
+                else
+                    command1=[Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')" &'];
                 end
-                
-                if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)), % Hybrid computing Windows <-> Unix!
-                    if ispc, token='start /B ';
-                    else token = '';
+            else    % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
+                    command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7'');addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
+                else
+                    command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
+                end
+            end
+        elseif Parallel(indPC).Local==0                                % 1.2 Run using network on remote machine or also on local machine.
+            if j==nCPU0+1
+                dynareParallelSendFiles(NamFileInput,PRCDir,Parallel(indPC));
+            end
+            dynareParallelSendFiles(['P_',fname,'_',int2str(j),'End.txt'],PRCDir,Parallel(indPC));
+            delete(['P_',fname,'_',int2str(j),'End.txt']);
+            if newInstance
+                dynareParallelSendFiles(['slaveJob',int2str(j),'.mat'],PRCDir,Parallel(indPC));
+                delete(['slaveJob',int2str(j),'.mat']);
+                dynareParallelSendFiles(['slaveParallel_input',int2str(j),'.mat'],PRCDir,Parallel(indPC))
+                if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)) % Hybrid computing Windows <-> Unix!
+                    if ispc
+                        token='start /B ';
+                    else
+                        token = '';
                     end
-                    if ~isempty(Parallel(indPC).Port),
+                    if ~isempty(Parallel(indPC).Port)
                         ssh_token = ['-p ',Parallel(indPC).Port];
                     else
                         ssh_token = '';
@@ -370,132 +447,59 @@ for j=1:totCPU,
                     % To manage the diferences in Unix/Windows OS syntax.
                     remoteFile=['remoteDynare',int2str(j)];
                     fidRemote=fopen([remoteFile,'.m'],'w+');
-                    if regexpi([Parallel(indPC).MatlabOctavePath], 'octave'),% Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                        remoteString=['default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')'];
-                        command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir, '; ',Parallel(indPC).MatlabOctavePath,' -f --eval ',remoteFile,' " &'];
+                    if regexpi([Parallel(indPC).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)-> Octave(Slaves) and Vice Versa!
+                        remoteString=['default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),');'];
+                        command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir '; ',Parallel(indPC).MatlabOctavePath,' -f --eval ',remoteFile,' " &'];
                     else
-                        remoteString=['addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')'];
-                        command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir, '; ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r ',remoteFile,';" &'];
+                        remoteString=['addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),');'];
+                        command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir '; ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r ',remoteFile,';" &'];
                     end
                     fprintf(fidRemote,'%s\n',remoteString);
                     fclose(fidRemote);
                     dynareParallelSendFiles([remoteFile,'.m'],PRCDir,Parallel(indPC));
                     delete([remoteFile,'.m']);
                 else
-                    if ~strcmpi(Parallel(indPC).ComputerName,MasterName),  % 0.3 Run on a remote machine!
-                        % Hybrid computing Matlab(Master)-> Octave(Slaves) and Vice Versa!
+                    if ~strcmpi(Parallel(indPC).ComputerName,MasterName) % 1.3 Run on a remote machine.
+                                                                         % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
                         if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
                             command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -u ',Parallel(indPC).UserName,' -p ',Parallel(indPC).Password,' -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                                      ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7'');addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
                         else
-             
                             command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -u ',Parallel(indPC).UserName,' -p ',Parallel(indPC).Password,' -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                                      ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
                         end
-                    else                                                  % 0.4 Run on the local machine via the network
-                        % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
+                    else                                                % 1.4 Run on the local machine via the network.
+                                                                        % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
                         if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
                             command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                                      ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
                         else
                             command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); fParallel(',int2str(offset+1),',',int2str(sum(nBlockPerCPU(1:j))),',',int2str(j),',',int2str(indPC),',''',fname,''')"'];
+                                      ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
                         end
                     end
                 end
-            end
-            
-            
-        case 1
-            if Parallel(indPC).Local == 1 && newInstance,                       % 1.1 Run on the local machine.
-                if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)),  % Hybrid computing Windows <-> Unix!                   
-                    if regexpi([Parallel(indPC).MatlabOctavePath], 'octave')    % Hybrid computing Matlab(Master)-> Octave(Slaves) and Vice Versa!
-                        command1=[Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')" &'];
-                    else
-                        command1=[Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')" &'];
-                    end
-                else    % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                    if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
-                        command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7'');addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
-                    else
-                        command1=['psexec -d -W "',DyMo, '" -a ',my_affinity,' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
-                    end
-                end
-            elseif Parallel(indPC).Local==0,                                % 1.2 Run using network on remote machine or also on local machine.
-                if j==nCPU0+1,
-                    dynareParallelSendFiles(NamFileInput,PRCDir,Parallel(indPC));
-                end
-                dynareParallelSendFiles(['P_',fname,'_',int2str(j),'End.txt'],PRCDir,Parallel(indPC));
-                delete(['P_',fname,'_',int2str(j),'End.txt']);
-                if newInstance,
-                    dynareParallelSendFiles(['slaveJob',int2str(j),'.mat'],PRCDir,Parallel(indPC));
-                    delete(['slaveJob',int2str(j),'.mat']);
-                    dynareParallelSendFiles(['slaveParallel_input',int2str(j),'.mat'],PRCDir,Parallel(indPC))
-                    if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)), % Hybrid computing Windows <-> Unix!
-                        if ispc, token='start /B ';
-                        else token = '';
-                        end
-                        if ~isempty(Parallel(indPC).Port),
-                            ssh_token = ['-p ',Parallel(indPC).Port];
-                        else
-                            ssh_token = '';
-                        end
-                        % To manage the diferences in Unix/Windows OS syntax.
-                        remoteFile=['remoteDynare',int2str(j)];
-                        fidRemote=fopen([remoteFile,'.m'],'w+');
-                        if regexpi([Parallel(indPC).MatlabOctavePath], 'octave') % Hybrid computing Matlab(Master)-> Octave(Slaves) and Vice Versa!
-                            remoteString=['default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),');'];
-                            command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir '; ',Parallel(indPC).MatlabOctavePath,' -f --eval ',remoteFile,' " &'];
-                        else
-                            remoteString=['addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),');'];
-                            command1=[token, 'ssh ',ssh_token,' ',Parallel(indPC).UserName,'@',Parallel(indPC).ComputerName,' "cd ',Parallel(indPC).RemoteDirectory,'/',PRCDir '; ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r ',remoteFile,';" &'];
-                        end
-                        fprintf(fidRemote,'%s\n',remoteString);
-                        fclose(fidRemote);
-                        dynareParallelSendFiles([remoteFile,'.m'],PRCDir,Parallel(indPC));
-                        delete([remoteFile,'.m']);
-                    else
-                        if ~strcmpi(Parallel(indPC).ComputerName,MasterName), % 1.3 Run on a remote machine.
-                            % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                            if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
-                                command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -u ',Parallel(indPC).UserName,' -p ',Parallel(indPC).Password,' -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                    ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7'');addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
-                            else
-                                command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -u ',Parallel(indPC).UserName,' -p ',Parallel(indPC).Password,' -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                    ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
-                            end
-                        else                                                % 1.4 Run on the local machine via the network.
-                            % Hybrid computing Matlab(Master)->Octave(Slaves) and Vice Versa!
-                            if  regexpi([Parallel(indPC).MatlabOctavePath], 'octave')
-                                command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                    ' -low  ',Parallel(indPC).MatlabOctavePath,' -f --eval "default_save_options(''-v7''); addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
-                            else
-                                command1=['psexec \\',Parallel(indPC).ComputerName,' -d -e -W "',Parallel(indPC).RemoteDrive,':\',Parallel(indPC).RemoteDirectory,'\',PRCDir,'\" -a ',my_affinity, ...
-                                    ' -low  ',Parallel(indPC).MatlabOctavePath,' -nosplash -nodesktop -minimize ',compThread,' -r "addpath(''',Parallel(indPC).DynarePath,'''), dynareroot = dynare_config(); slaveParallel(',int2str(j),',',int2str(indPC),')"'];
-                            end
-                        end
-                    end
+            else
+                % When the user user strategy is equal to 1, you must
+                % do PRCDirSnapshot here to to avoid problems of
+                % synchronization.
+
+                if isempty(PRCDirSnapshot{indPC})
+                    PRCDirSnapshot(indPC)=dynareParallelSnapshot(PRCDir,Parallel(indPC));
+                    PRCDirSnapshotInit(indPC) = PRCDirSnapshot(indPC);
                 else
-                    % When the user user strategy is equal to 1, you must
-                    % do PRCDirSnapshot here to to avoid problems of
-                    % synchronization.
-                    
-                    if isempty(PRCDirSnapshot{indPC}),
-                        PRCDirSnapshot(indPC)=dynareParallelSnapshot(PRCDir,Parallel(indPC));
-                        PRCDirSnapshotInit(indPC) = PRCDirSnapshot(indPC);
-                    else
-                        PRCDirSnapshot(indPC)=dynareParallelGetNewFiles(PRCDir,Parallel(indPC),PRCDirSnapshot(indPC));
-                    end
-                    dynareParallelSendFiles(['slaveJob',int2str(j),'.mat'],PRCDir,Parallel(indPC));
-                    delete(['slaveJob',int2str(j),'.mat']);
-                    
+                    PRCDirSnapshot(indPC)=dynareParallelGetNewFiles(PRCDir,Parallel(indPC),PRCDirSnapshot(indPC));
                 end
+                dynareParallelSendFiles(['slaveJob',int2str(j),'.mat'],PRCDir,Parallel(indPC));
+                delete(['slaveJob',int2str(j),'.mat']);
+
             end
-            
+        end
+
     end
-    
+
     fprintf(fid,'%s\n',command1);
-    
+
 end
 
 % In This way we are sure that the file 'ConcurrentCommand1.bat' is
@@ -511,16 +515,16 @@ end
 % the slaves ...
 % If the compuation is 'Local' it is not necessary to do it ...
 
-if Strategy==0 || newInstance, % See above.
+if Strategy==0 || newInstance % See above.
     PRCDirSnapshot=dynareParallelSnapshot(PRCDir,Parallel(1:totSlaves));
     PRCDirSnapshotInit = PRCDirSnapshot;
-    
+
     % Run the slaves.
-    if  ~ispc,
+    if  ~ispc
         system('sh ConcurrentCommand1.bat &');
         pause(1)
     else
-        
+
         if isoctave
             % Redirect the standard output to the file 'OctaveStandardOutputMessage.txt'!
             % This file is saved in the Model directory.
@@ -549,18 +553,18 @@ if isoctave || options_.console_mode
     end
 else
     hfigstatus = figure('name',['Parallel ',fname],...
-        'DockControls','off', ...
-        'IntegerHandle','off', ...
-        'Interruptible','off', ...
-        'MenuBar', 'none', ...
-        'NumberTitle','off', ...
-        'Renderer','Painters', ...
-        'Resize','off');
-    
+                        'DockControls','off', ...
+                        'IntegerHandle','off', ...
+                        'Interruptible','off', ...
+                        'MenuBar', 'none', ...
+                        'NumberTitle','off', ...
+                        'Renderer','Painters', ...
+                        'Resize','off');
+
     ncol = ceil(totCPU/10);
     hspace = 0.9/ncol;
     hstatus(1) = axes('position',[0.05/ncol 0.92 0.9/ncol 0.03], ...
-        'box','on','xtick',[],'ytick',[],'xlim',[0 1],'ylim',[0 1]);
+                      'box','on','xtick',[],'ytick',[],'xlim',[0 1],'ylim',[0 1]);
     set(hstatus(1),'Units','pixels')
     hpixel = get(hstatus(1),'Position');
     hfigure = get(hfigstatus,'Position');
@@ -569,16 +573,16 @@ else
     set(hstatus(1),'Units','normalized'),
     vspace = max(0.1,1/totCPU);
     vstart = 1-vspace+0.2*vspace;
-    for j=1:totCPU,
+    for j=1:totCPU
         jrow = mod(j-1,10)+1;
         jcol = ceil(j/10);
         hstatus(j) = axes('position',[0.05/ncol+(jcol-1)/ncol vstart-vspace*(jrow-1) 0.9/ncol 0.3*vspace], ...
-            'box','on','xtick',[],'ytick',[],'xlim',[0 1],'ylim',[0 1]);
+                          'box','on','xtick',[],'ytick',[],'xlim',[0 1],'ylim',[0 1]);
         hpat(j) = patch([0 0 0 0],[0 1 1 0],'r','EdgeColor','r');
         htit(j) = title(['Initialize ...']);
-        
+
     end
-    
+
     cumBlockPerCPU = cumsum(nBlockPerCPU);
 end
 pcerdone = NaN(1,totCPU);
@@ -592,20 +596,20 @@ idCPU = NaN(1,totCPU);
 % Caption for console mode computing ...
 
 if options_.console_mode ||  isoctave
-    
+
     if ~isoctave
         if strcmpi([Parallel(indPC).MatlabOctavePath], 'octave')
             RjInformation='Hybrid Computing Is Active: Remote jobs are computed by Octave!';
             fprintf([RjInformation,'\n\n']);
         end
     end
-    
+
     fnameTemp=fname;
-    
+
     L=length(fnameTemp);
-    
+
     PoCo=strfind(fnameTemp,'_core');
-    
+
     for i=PoCo:L
         if i==PoCo
             fnameTemp(i)=' ';
@@ -613,27 +617,27 @@ if options_.console_mode ||  isoctave
             fnameTemp(i)='.';
         end
     end
-    
+
     for i=1:L
-        if  fnameTemp(i)=='_';
+        if  fnameTemp(i)=='_'
             fnameTemp(i)=' ';
         end
     end
-    
+
     fnameTemp(L)='';
-    
+
     Information=['Parallel ' fnameTemp ' Computing ...'];
     if isoctave
         if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem)) && (Strategy==0)
             printf('\n');
             pause(2);
         end
-        
+
         printf([Information,'\n\n']);
     else
         fprintf([Information,'\n\n']);
     end
-    
+
 end
 
 
@@ -649,26 +653,26 @@ statusString = '';
 flag_CloseAllSlaves=0;
 
 while (ForEver)
-    
+
     waitbarString = '';
     statusString0 = repmat('\b',1,length(sprintf(statusString, 100 .* pcerdone)));
     statusString = '';
-    
+
     pause(1)
-    
+
     try
-        if islocal ==0,
+        if islocal ==0
             dynareParallelGetFiles(['comp_status_',fname,'*.mat'],PRCDir,Parallel(1:totSlaves));
         end
     catch
     end
-    
-    for j=1:totCPU,
+
+    for j=1:totCPU
         try
             if ~isempty(['comp_status_',fname,int2str(j),'.mat'])
                 load(['comp_status_',fname,int2str(j),'.mat']);
-%                 whoCloseAllSlaves = who(['comp_status_',fname,int2str(j),'.mat','CloseAllSlaves']);
-                if exist('CloseAllSlaves') && flag_CloseAllSlaves==0,
+                %                 whoCloseAllSlaves = who(['comp_status_',fname,int2str(j),'.mat','CloseAllSlaves']);
+                if exist('CloseAllSlaves') && flag_CloseAllSlaves==0
                     flag_CloseAllSlaves=1;
                     whoiamCloseAllSlaves=j;
                     closeSlave(Parallel(1:totSlaves),PRCDir,1);
@@ -687,7 +691,7 @@ while (ForEver)
                 status_Title{j} = waitbarTitle;
             end
         catch % ME
-            % To define!
+              % To define!
             if isoctave || options_.console_mode
                 if (~ispc || strcmpi('unix',Parallel(indPC).OperatingSystem))
                     statusString = [statusString, int2str(j), ' %3.f%% done! '];
@@ -706,20 +710,20 @@ while (ForEver)
             end
         end
     else
-        for j=1:totCPU,
+        for j=1:totCPU
             try
                 set(hpat(j),'XData',[0 0 pcerdone(j) pcerdone(j)]);
                 set(htit(j),'String',[status_Title{j},' - ',status_String{j}]);
             catch
-                
+
             end
         end
     end
-    
+
     % Check if the slave(s) has generated some new files remotely.
     % 1. The files .log and .txt are not copied.
     % 2. The comp_status_*.mat files are managed separately.
-    
+
     if isoctave % to avoid synchronism problems
         try
             PRCDirSnapshot=dynareParallelGetNewFiles(PRCDir,Parallel(1:totSlaves),PRCDirSnapshot);
@@ -728,11 +732,11 @@ while (ForEver)
     else
         PRCDirSnapshot=dynareParallelGetNewFiles(PRCDir,Parallel(1:totSlaves),PRCDirSnapshot);
     end
-    
-    if isempty(dynareParallelDir(['P_',fname,'_*End.txt'],PRCDir,Parallel(1:totSlaves)));
+
+    if isempty(dynareParallelDir(['P_',fname,'_*End.txt'],PRCDir,Parallel(1:totSlaves)))
         HoTuttiGliOutput=0;
-        for j=1:totCPU,
-            
+        for j=1:totCPU
+
             % Checking if the remote computation is finished and if we copied all the output here.
             if ~isempty(dir([fname,'_output_',int2str(j),'.mat']))
                 HoTuttiGliOutput=HoTuttiGliOutput+1;
@@ -741,8 +745,8 @@ while (ForEver)
                 dynareParallelGetFiles([fname,'_output_',int2str(j),'.mat'],PRCDir,Parallel(indPC));
             end
         end
-        
-        if HoTuttiGliOutput==totCPU,
+
+        if HoTuttiGliOutput==totCPU
             mydelete(['comp_status_',fname,'*.mat']);
             if isoctave || options_.console_mode
                 if isoctave
@@ -754,15 +758,15 @@ while (ForEver)
                 end
                 diary on;
             else
-                close(hfigstatus),
+                close(hfigstatus)
             end
-            
+
             break
         else
             disp('Waiting for output files from slaves ...')
         end
     end
-    
+
 end
 
 
@@ -770,19 +774,19 @@ end
 iscrash = 0;
 PRCDirSnapshot=dynareParallelGetNewFiles(PRCDir,Parallel(1:totSlaves),PRCDirSnapshot);
 
-for j=1:totCPU,
+for j=1:totCPU
     indPC=min(find(nCPU>=j));
     load([fname,'_output_',int2str(j),'.mat'],'fOutputVar');
     delete([fname,'_output_',int2str(j),'.mat']);
-    if isfield(fOutputVar,'OutputFileName') && Parallel(indPC).Local==0,
+    if isfield(fOutputVar,'OutputFileName') && Parallel(indPC).Local==0
         %   Check if input files have been updated!
-        OutputFileName=fOutputVar.OutputFileName;        
+        OutputFileName=fOutputVar.OutputFileName;
         tmp0='';
-        for i=1:size(NamFileInput,1),
+        for i=1:size(NamFileInput,1)
             FileList = regexp(strrep(PRCDirSnapshot{indPC},'\','/'),strrep(strrep([NamFileInput{i,:}],'\','/'),'*','(\w*)'),'match');
-            for k=1:length(FileList),
-                if ~isempty(FileList{k}),
-                    if isempty(tmp0),
+            for k=1:length(FileList)
+                if ~isempty(FileList{k})
+                    if isempty(tmp0)
                         tmp0=FileList{k}{1};
                     else
                         tmp0=char(tmp0,FileList{k}{1});
@@ -790,112 +794,112 @@ for j=1:totCPU,
                 end
             end
         end
-        for i=1:size(OutputFileName,1),
+        for i=1:size(OutputFileName,1)
             tmp1='';
             FileList = regexp(cellstr(tmp0),strrep(strrep([OutputFileName{i,:}],'\','/'),'*','(\w*)'),'match');
             FileList0 = regexp(cellstr(tmp0),strrep([OutputFileName{i,2}],'*','(\w*)'),'match');
-            for k=1:length(FileList),
-                if ~isempty(FileList{k}),
-                    if isempty(tmp1),
+            for k=1:length(FileList)
+                if ~isempty(FileList{k})
+                    if isempty(tmp1)
                         tmp1=FileList0{k}{1};
                     else
                         tmp1=char(tmp1,FileList0{k}{1});
                     end
                 end
             end
-            for k=1:size(tmp1,1),
-                    dynareParallelGetFiles([OutputFileName(i,1) {tmp1(k,:)}],PRCDir,Parallel(indPC));
+            for k=1:size(tmp1,1)
+                dynareParallelGetFiles([OutputFileName(i,1) {tmp1(k,:)}],PRCDir,Parallel(indPC));
             end
         end
         % check if some output file is missing!
-        for i=1:size(OutputFileName,1),
+        for i=1:size(OutputFileName,1)
             tmp1=dynareParallelDir([OutputFileName{i,:}],PRCDir,Parallel(indPC));
             tmp1 = regexp(cellstr(tmp1),strrep([OutputFileName{i,2}],'*','(\w*)'),'match');
             tmp1 = char(tmp1{:});
             tmp2=ls([OutputFileName{i,:}]);
-            for ij=1:size(tmp1,1),
+            for ij=1:size(tmp1,1)
                 icheck = regexp(cellstr(tmp2),tmp1(ij,:),'once');
                 isOutputFileMissing=1;
-                for ik=1:size(tmp2,1),
-                    if ~isempty(icheck{ik}),
+                for ik=1:size(tmp2,1)
+                    if ~isempty(icheck{ik})
                         isOutputFileMissing=0;
                     end
                 end
-                if isOutputFileMissing,
+                if isOutputFileMissing
                     dynareParallelGetFiles([OutputFileName(i,1) {tmp1(ij,:)}],PRCDir,Parallel(indPC));
                 end
             end
         end
 
     end
-    if isfield(fOutputVar,'error'),
+    if isfield(fOutputVar,'error')
         disp(['Job number ',int2str(j),' crashed with error:']);
         iscrash=1;
         disp([fOutputVar.error.message]);
         for jstack=1:length(fOutputVar.error.stack)
-            fOutputVar.error.stack(jstack),
+            fOutputVar.error.stack(jstack)
         end
-    elseif flag_CloseAllSlaves==0,
+    elseif flag_CloseAllSlaves==0
         fOutVar(j)=fOutputVar;
-    elseif j==whoiamCloseAllSlaves,
-        fOutVar=fOutputVar;        
+    elseif j==whoiamCloseAllSlaves
+        fOutVar=fOutputVar;
     end
 end
 
-if flag_CloseAllSlaves==1,
+if flag_CloseAllSlaves==1
     closeSlave(Parallel(1:totSlaves),PRCDir,-1);
 end
 
-if iscrash,
+if iscrash
     error('Remote jobs crashed');
 end
 
-pause(1), % Wait for all remote diary off completed
+pause(1) % Wait for all remote diary off completed
 
 % Cleanup.
 dynareParallelGetFiles('*.log',PRCDir,Parallel(1:totSlaves));
 
 switch Strategy
-    case 0
-        for indPC=1:min(find(nCPU>=totCPU)),
-            if Parallel(indPC).Local == 0
-                dynareParallelRmDir(PRCDir,Parallel(indPC));
-            end
-            
-            if isempty(dir('dynareParallelLogFiles'))
-                [A B C]=rmdir('dynareParallelLogFiles');
-                mkdir('dynareParallelLogFiles');
-            end
-            try
-                copyfile('*.log','dynareParallelLogFiles');
-                mydelete([fname,'*.log']);
-            catch
-            end
-            
-            mydelete(['*_core*_input*.mat']);
-            
+  case 0
+    for indPC=1:min(find(nCPU>=totCPU))
+        if Parallel(indPC).Local == 0
+            dynareParallelRmDir(PRCDir,Parallel(indPC));
         end
-        
+
+        if isempty(dir('dynareParallelLogFiles'))
+            [A B C]=rmdir('dynareParallelLogFiles');
+            mkdir('dynareParallelLogFiles');
+        end
+        try
+            copyfile('*.log','dynareParallelLogFiles');
+            mydelete([fname,'*.log']);
+        catch
+        end
+
+        mydelete(['*_core*_input*.mat']);
+
+    end
+
+    delete ConcurrentCommand1.bat
+  case 1
+    delete(['temp_input.mat'])
+    if newInstance
+        if isempty(dir('dynareParallelLogFiles'))
+            [A B C]=rmdir('dynareParallelLogFiles');
+            mkdir('dynareParallelLogFiles');
+        end
+    end
+    copyfile('*.log','dynareParallelLogFiles');
+    if newInstance
         delete ConcurrentCommand1.bat
-    case 1
-        delete(['temp_input.mat'])
-        if newInstance,
-            if isempty(dir('dynareParallelLogFiles'))
-                [A B C]=rmdir('dynareParallelLogFiles');
-                mkdir('dynareParallelLogFiles');
-            end
-        end
-        copyfile('*.log','dynareParallelLogFiles');
-        if newInstance,
-            delete ConcurrentCommand1.bat
-        end
-        dynareParallelDelete(['comp_status_',fname,'*.mat'],PRCDir,Parallel);
-        for indPC=1:min(find(nCPU>=totCPU)),
-            if Parallel(indPC).Local == 0,
-                dynareParallelDeleteNewFiles(PRCDir,Parallel(indPC),PRCDirSnapshotInit(indPC),'.log');
-                for ifil=1:size(NamFileInput,1),
-                    dynareParallelDelete([NamFileInput{ifil,:}],PRCDir,Parallel(indPC));
-                end
+    end
+    dynareParallelDelete(['comp_status_',fname,'*.mat'],PRCDir,Parallel);
+    for indPC=1:min(find(nCPU>=totCPU))
+        if Parallel(indPC).Local == 0
+            dynareParallelDeleteNewFiles(PRCDir,Parallel(indPC),PRCDirSnapshotInit(indPC),'.log');
+            for ifil=1:size(NamFileInput,1)
+                dynareParallelDelete([NamFileInput{ifil,:}],PRCDir,Parallel(indPC));
             end
         end
+    end
 end
\ No newline at end of file
diff --git a/matlab/parallel/slaveParallel.m b/matlab/parallel/slaveParallel.m
index d7275a4fd..5e3fe460c 100644
--- a/matlab/parallel/slaveParallel.m
+++ b/matlab/parallel/slaveParallel.m
@@ -2,7 +2,7 @@ function slaveParallel(whoiam,ThisMatlab)
 % PARALLEL CONTEXT
 % In a parallelization context, this function is launched on slave
 % machines, to initialize MATLAB and DYNARE environment and waits for
-% instructions sent by the Master. 
+% instructions sent by the Master.
 % This function is invoked by masterParallel only when the strategy (1),
 % i.e. always open, is actived.
 %
@@ -12,10 +12,10 @@ function slaveParallel(whoiam,ThisMatlab)
 %                       cluster.
 %  o ThisMatlab [int]   index number of this slave machine in the cluster.
 %
-% OUTPUTS 
-%   None  
+% OUTPUTS
+%   None
 
-% Copyright (C) 2006-2012 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -48,9 +48,9 @@ dynareroot = dynare_config();
 load( ['slaveParallel_input',int2str(whoiam)]);
 
 %Loads fGlobalVar Parallel.
-if exist('fGlobalVar'),
+if exist('fGlobalVar')
     globalVars = fieldnames(fGlobalVar);
-    for j=1:length(globalVars),
+    for j=1:length(globalVars)
         eval(['global ',globalVars{j},';']);
         evalin('base',['global ',globalVars{j},';']);
     end
@@ -65,50 +65,50 @@ end
 t0=clock;
 fslave = dir( ['slaveParallel_input',int2str(whoiam),'.mat']);
 
-while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',int2str(whoiam),'.txt'])),
-    if ~isempty(dir(['stayalive',int2str(whoiam),'.txt'])),
+while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',int2str(whoiam),'.txt']))
+    if ~isempty(dir(['stayalive',int2str(whoiam),'.txt']))
         t0=clock;
         delete(['stayalive',int2str(whoiam),'.txt']);
     end
     % I wait for 20 min or while mater asks to exit (i.e. it cancels fslave file)
-    pause(1);
-    
+    pause(1)
+
     fjob = dir(['slaveJob',int2str(whoiam),'.mat']);
-    
-    if ~isempty(fjob),
+
+    if ~isempty(fjob)
         clear fGlobalVar fInputVar fblck nblck fname
-        
+
         while(1)
             Go=0;
-            
+
             Go=fopen(['slaveJob',int2str(whoiam),'.mat']);
-            
-            if Go>0    
+
+            if Go>0
                 fclose(Go);
-                pause(1);
+                pause(1)
                 load(['slaveJob',int2str(whoiam),'.mat']);
                 break
             else
                 % Only for testing, will be remouved!
-                
+
                 %                if isunix
                 %                  E1=fopen('/home/ivano/Works/Errore-slaveParallel.txt','w+');
                 %                  fclose(E1);
-                %                else            
+                %                else
                 %                  E1=fopen('c:\dynare_calcs\Errore-slaveParallel.txt','w+');
                 %                  fclose(E1);
                 %                end
-                
+
             end
         end
-        
+
         funcName=fname;  % Update global job name.
 
         if exist('fGlobalVar') && ~isempty (fGlobalVar)
             globalVars = fieldnames(fGlobalVar);
-            for j=1:length(globalVars),
+            for j=1:length(globalVars)
                 info_whos = whos(globalVars{j});
-                if isempty(info_whos) || ~info_whos.global,
+                if isempty(info_whos) || ~info_whos.global
                     eval(['global ',globalVars{j},';']);
                     evalin('base',['global ',globalVars{j},';']);
                 end
@@ -120,13 +120,13 @@ while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',in
         end
         delete(['slaveJob',int2str(whoiam),'.mat']);
         fInputVar.Parallel = Parallel;
-        
+
         % Launch the routine to be run in parallel.
-        try,
-            tic,
+        try
+            tic
             fOutputVar = feval(fname, fInputVar ,fblck, nblck, whoiam, ThisMatlab);
-            toc,
-            if isfield(fOutputVar,'OutputFileName'),
+            toc
+            if isfield(fOutputVar,'OutputFileName')
                 OutputFileName = fOutputVar.OutputFileName;
             else
                 OutputFileName = '';
@@ -136,8 +136,8 @@ while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',in
 
                 % Save the output result.
                 save([ fname,'_output_',int2str(whoiam),'.mat'],'fOutputVar' );
-%                 keyboard,
-                if isfield(fOutputVar,'CloseAllSlaves'),
+                %                 keyboard,
+                if isfield(fOutputVar,'CloseAllSlaves')
                     CloseAllSlaves = 1;
                     fOutputVar = rmfield(fOutputVar,'CloseAllSlaves');
                     save([ fname,'_output_',int2str(whoiam),'.mat'],'fOutputVar' )
@@ -150,7 +150,7 @@ while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',in
 
             disp(['Job ',fname,' on CPU ',int2str(whoiam),' completed.']);
             t0 =clock; % Re-set waiting time of 20 mins
-        catch,
+        catch
             theerror = lasterror;
             if strfind(theerror.message,'Master asked to break the job')
                 disp(['Job ',fname,' on CPU ',int2str(whoiam),' broken from master.']);
@@ -162,7 +162,7 @@ while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',in
                 fOutputVar.error = lasterror;
                 save([ fname,'_output_',int2str(whoiam),'.mat'],'fOutputVar' );
                 waitbarString = fOutputVar.error.message;
-                if Parallel(ThisMatlab).Local,
+                if Parallel(ThisMatlab).Local
                     waitbarTitle='Local ';
                 else
                     waitbarTitle=[Parallel(ThisMatlab).ComputerName];
@@ -171,7 +171,7 @@ while (etime(clock,t0)<1200 && ~isempty(fslave)) || ~isempty(dir(['stayalive',in
                 delete(['P_',fname,'_',int2str(whoiam),'End.txt']);
                 break
             end
-            
+
         end
     end
     fslave = dir( ['slaveParallel_input',int2str(whoiam),'.mat']); % Check if Master asks to exit
diff --git a/matlab/parallel/storeGlobalVars.m b/matlab/parallel/storeGlobalVars.m
index cd0470c37..79b86aa35 100644
--- a/matlab/parallel/storeGlobalVars.m
+++ b/matlab/parallel/storeGlobalVars.m
@@ -1,6 +1,6 @@
 function storeGlobalVars(fname,append)
 % PARALLEL CONTEXT
-% In a parallel context, this function stores all global vars in structure 
+% In a parallel context, this function stores all global vars in structure
 % fGlobalVar and saves it in the file fname.mat
 %
 % INPUTS
@@ -12,7 +12,7 @@ function storeGlobalVars(fname,append)
 % None
 %
 %
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,12 +32,12 @@ function storeGlobalVars(fname,append)
 
 GlobalNames = who('global');
 % varlist = '';
-for j=1:length(GlobalNames);
+for j=1:length(GlobalNames)
     eval(['global ',GlobalNames{j},';']);
     eval(['fGlobalVar.',GlobalNames{j},'=',GlobalNames{j},';']);
 end
 
-if nargin<2,
+if nargin<2
     save(fname,'fGlobalVar');
 else
     save(fname,'fGlobalVar','-append');
diff --git a/matlab/parallel/struct2local.m b/matlab/parallel/struct2local.m
index fbe9666f0..d45bc12b8 100644
--- a/matlab/parallel/struct2local.m
+++ b/matlab/parallel/struct2local.m
@@ -6,11 +6,11 @@ function struct2local(S)
 %
 % INPUTS
 %  o S [struc]   This structure possibly containing several fields ...
-%  
+%
 %  OUTPUTS
 %  None
 %
-% Copyright (C) 2009-2010 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,6 +30,6 @@ function struct2local(S)
 
 vnam = fieldnames(S);
 
-for j=1:length(vnam),
+for j=1:length(vnam)
     assignin('caller',vnam{j},getfield(S,vnam{j}));
 end
diff --git a/matlab/partial_information/PCL_Part_info_irf.m b/matlab/partial_information/PCL_Part_info_irf.m
index 2fc0ff1d8..0c3c17c2b 100644
--- a/matlab/partial_information/PCL_Part_info_irf.m
+++ b/matlab/partial_information/PCL_Part_info_irf.m
@@ -1,11 +1,11 @@
 function  y=PCL_Part_info_irf( H, varobs, ivar, M_, dr, irfpers,ii)
 % sets up parameters and calls part-info kalman filter
-% developed by G Perendia, July 2006 for implementation from notes by Prof. Joe Pearlman to 
-% suit partial information RE solution in accordance with, and based on, the 
+% developed by G Perendia, July 2006 for implementation from notes by Prof. Joe Pearlman to
+% suit partial information RE solution in accordance with, and based on, the
 % Pearlman, Currie and Levine 1986 solution.
-% 22/10/06 - Version 2 for new Riccati with 4 params instead 5 
+% 22/10/06 - Version 2 for new Riccati with 4 params instead 5
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,8 +23,8 @@ function  y=PCL_Part_info_irf( H, varobs, ivar, M_, dr, irfpers,ii)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-% Recall that the state space is given by the 
-% predetermined variables s(t-1), x(t-1) 
+% Recall that the state space is given by the
+% predetermined variables s(t-1), x(t-1)
 % and the jump variables x(t).
 % The jump variables have dimension NETA
 
@@ -66,7 +66,7 @@ U22=0;
 % determine K1 and K2 observation mapping matrices
 % This uses the fact that measurements are given by L1*s(t)+L2*x(t)
 % and s(t) is expressed in the dynamics as
-% H1*eps(t)+G11*s(t-1)+G12*x(t-1)+G13*x(t).  
+% H1*eps(t)+G11*s(t-1)+G12*x(t-1)+G13*x(t).
 % Thus the observations o(t) can be written in the form
 % o(t)=K1*[eps(t)' s(t-1)' x(t-1)']' + K2*x(t) where
 % K1=[L1*H1 L1*G11 L1*G12] K2=L1*G13+L2
@@ -84,18 +84,18 @@ A21=G1(pd+1:end,1:pd);
 Lambda= nmat*A12+A22;
 I_L=inv(Lambda);
 BB=A12*inv(A22);
-FF=K2*inv(A22);       
-QQ=BB*U22*BB' + U11;        
+FF=K2*inv(A22);
+QQ=BB*U22*BB' + U11;
 UFT=U22*FF';
 AA=A11-BB*A21;
 CCCC=A11-A12*nmat; % F in new notation
 DD=K1-FF*A21; % H in new notation
 EE=K1-K2*nmat;
 RR=FF*UFT+VV;
-if ~any(RR) 
-    % if zero add some dummy measurement err. variance-covariances 
+if ~any(RR)
+    % if zero add some dummy measurement err. variance-covariances
     % with diagonals 0.000001. This would not be needed if we used
-    % the slow solver, or the generalised eigenvalue approach, 
+    % the slow solver, or the generalised eigenvalue approach,
     % but these are both slower.
     RR=eye(size(RR,1))*1.0e-6;
 end
@@ -128,14 +128,14 @@ imp=[impact(1:ss-FL_RANK,:); impact(1:ss-FL_RANK,:)];
 I_PD=(eye(ss-FL_RANK)-PDIDPDRD);
 LL0=[ EE (DD-EE)*I_PD];
 VV = [  dr.PI_TT1 dr.PI_TT2];
-stderr=diag(M_.Sigma_e^0.5);        
+stderr=diag(M_.Sigma_e^0.5);
 irfmat=zeros(size(dr.PI_TT1 ,1),irfpers+1);
-irfst=zeros(size(GG,1),irfpers+1); 
+irfst=zeros(size(GG,1),irfpers+1);
 irfst(:,1)=stderr(ii)*imp(:,ii);
-for jj=2:irfpers+1;
+for jj=2:irfpers+1
     irfst(:,jj)=GG*irfst(:,jj-1);
     irfmat(:,jj-1)=VV*irfst(NX+1:ss-FL_RANK,jj);
-end   
+end
 y = irfmat(:,1:irfpers);
 
 save ([M_.fname '_PCL_PtInfoIRFs_' num2str(ii) '_' deblank(exo_names(ii,:))], 'irfmat','irfst');
diff --git a/matlab/partial_information/PCL_Part_info_moments.m b/matlab/partial_information/PCL_Part_info_moments.m
index fdebe317f..bb16b6604 100644
--- a/matlab/partial_information/PCL_Part_info_moments.m
+++ b/matlab/partial_information/PCL_Part_info_moments.m
@@ -1,11 +1,11 @@
 function  AutoCOR_YRk=PCL_Part_info_moments( H, varobs, dr,ivar)
 % sets up parameters and calls part-info kalman filter
-% developed by G Perendia, July 2006 for implementation from notes by Prof. Joe Pearlman to 
-% suit partial information RE solution in accordance with, and based on, the 
+% developed by G Perendia, July 2006 for implementation from notes by Prof. Joe Pearlman to
+% suit partial information RE solution in accordance with, and based on, the
 % Pearlman, Currie and Levine 1986 solution.
-% 22/10/06 - Version 2 for new Riccati with 4 params instead 5 
+% 22/10/06 - Version 2 for new Riccati with 4 params instead 5
 
-% Copyright (C) 2006-2012 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -22,8 +22,8 @@ function  AutoCOR_YRk=PCL_Part_info_moments( H, varobs, dr,ivar)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-% Recall that the state space is given by the 
-% predetermined variables s(t-1), x(t-1) 
+% Recall that the state space is given by the
+% predetermined variables s(t-1), x(t-1)
 % and the jump variables x(t).
 % The jump variables have dimension NETA
 
@@ -48,13 +48,13 @@ LL = sparse(1:NOBS,OBS,ones(NOBS,1),NY,NY);
 
 if exist( 'irfpers')==1
     if ~isempty(irfpers)
-        if irfpers<=0, irfpers=20, end;
+        if irfpers<=0, irfpers=20, end
     else
         irfpers=20;
     end
 else
     irfpers=20;
-end      
+end
 
 ss=size(G1,1);
 
@@ -78,7 +78,7 @@ U22=0;
 % determine K1 and K2 observation mapping matrices
 % This uses the fact that measurements are given by L1*s(t)+L2*x(t)
 % and s(t) is expressed in the dynamics as
-% H1*eps(t)+G11*s(t-1)+G12*x(t-1)+G13*x(t).  
+% H1*eps(t)+G11*s(t-1)+G12*x(t-1)+G13*x(t).
 % Thus the observations o(t) can be written in the form
 % o(t)=K1*[eps(t)' s(t-1)' x(t-1)']' + K2*x(t) where
 % K1=[L1*H1 L1*G11 L1*G12] K2=L1*G13+L2
@@ -96,8 +96,8 @@ A21=G1(pd+1:end,1:pd);
 Lambda= nmat*A12+A22;
 I_L=inv(Lambda);
 BB=A12*inv(A22);
-FF=K2*inv(A22);       
-QQ=BB*U22*BB' + U11;        
+FF=K2*inv(A22);
+QQ=BB*U22*BB' + U11;
 UFT=U22*FF';
 % kf_param structure:
 AA=A11-BB*A21;
@@ -105,10 +105,10 @@ CCCC=A11-A12*nmat; % F in new notation
 DD=K1-FF*A21; % H in new notation
 EE=K1-K2*nmat;
 RR=FF*UFT+VV;
-if ~any(RR) 
-    % if zero add some dummy measurement err. variance-covariances 
+if ~any(RR)
+    % if zero add some dummy measurement err. variance-covariances
     % with diagonals 0.000001. This would not be needed if we used
-    % the slow solver, or the generalised eigenvalue approach, 
+    % the slow solver, or the generalised eigenvalue approach,
     % but these are both slower.
     RR=eye(size(RR,1))*1.0e-6;
 end
@@ -150,7 +150,7 @@ diagCovYR0=diag(COV_YR0);
 labels = deblank(M_.endo_names(ivar,:));
 
 if options_.nomoments == 0
-    z = [ sqrt(diagCovYR0(ivar)) diagCovYR0(ivar) ]; 
+    z = [ sqrt(diagCovYR0(ivar)) diagCovYR0(ivar) ];
     title='THEORETICAL MOMENTS';
     headers=char('VARIABLE','STD. DEV.','VARIANCE');
     dyntable(options_,title,headers,labels,z,size(labels,2)+2,16,10);
@@ -168,9 +168,9 @@ end
 
 ar = options_.ar;
 if ar > 0
-    COV_YRk= zeros(nn,ar); 
-    AutoCOR_YRk= zeros(nn,ar); 
-    for k=1:ar;
+    COV_YRk= zeros(nn,ar);
+    AutoCOR_YRk= zeros(nn,ar);
+    for k=1:ar
         COV_P=GAM*COV_P;
         COV_OMEGA= COV_P( end-nn+1:end, end-nn+1:end);
         COV_YRk = VV*COV_OMEGA*VV';
diff --git a/matlab/partial_information/PCL_resol.m b/matlab/partial_information/PCL_resol.m
index ba0b1666f..8f6bf4239 100644
--- a/matlab/partial_information/PCL_resol.m
+++ b/matlab/partial_information/PCL_resol.m
@@ -17,7 +17,7 @@ function [dr,info]=PCL_resol(ys,check_flag)
 %    info=6:         The jacobian evaluated at the steady state is complex.
 %    info=19:        The steadystate file did not compute the steady state (inconsistent deep parameters).
 %    info=20:        can't find steady state info(2) contains sum of sqare residuals
-%    info=21:        steady state is complex 
+%    info=21:        steady state is complex
 %                               info(2) contains sum of sqare of
 %                               imaginary part of steady state
 %    info=30:        Variance can't be computed
@@ -25,7 +25,7 @@ function [dr,info]=PCL_resol(ys,check_flag)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2012 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -45,7 +45,7 @@ function [dr,info]=PCL_resol(ys,check_flag)
 global M_ options_ oo_
 global it_
 
-jacobian_flag = 0; 
+jacobian_flag = 0;
 
 info = 0;
 
@@ -58,7 +58,7 @@ end
 % check if ys is steady state
 tempex = oo_.exo_simul;
 oo_.exo_simul = repmat(oo_.exo_steady_state',M_.maximum_lag+M_.maximum_lead+1,1);
-if M_.exo_det_nbr > 0 
+if M_.exo_det_nbr > 0
     tempexdet = oo_.exo_det_simul;
     oo_.exo_det_simul = repmat(oo_.exo_det_steady_state',M_.maximum_lag+M_.maximum_lead+1,1);
 end
@@ -70,7 +70,7 @@ if options_.steadystate_flag
     [dr.ys,check1] = feval([M_.fname '_steadystate'],dr.ys,...
                            [oo_.exo_steady_state; ...
                         oo_.exo_det_steady_state]);
-    if size(dr.ys,1) < M_.endo_nbr 
+    if size(dr.ys,1) < M_.endo_nbr
         if length(M_.aux_vars) > 0
             dr.ys = add_auxiliary_variables_to_steadystate(dr.ys,M_.aux_vars,...
                                                            M_.fname,...
@@ -143,5 +143,5 @@ tempex = [];
 
 % 01/01/2003 MJ added dr_algo == 1
 % 08/24/2001 MJ uses Schmitt-Grohe and Uribe (2001) constant correction
-%               in dr.ghs2 
+%               in dr.ghs2
 % 05/26/2003 MJ added temporary values for oo_.exo_simul
diff --git a/matlab/partial_information/PI_gensys.m b/matlab/partial_information/PI_gensys.m
index c46d45d07..589e39dc1 100644
--- a/matlab/partial_information/PI_gensys.m
+++ b/matlab/partial_information/PI_gensys.m
@@ -16,7 +16,7 @@ function [G1pi,C,impact,nmat,TT1,TT2,gev,eu, DD, E2, E5, GAMMA, FL_RANK ]=PI_gen
 % Corrected 10/28/96 by CAS
 
 % Copyright (C) 1996-2009 Christopher Sims
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -83,12 +83,12 @@ try
     end
     if singular == 1 || strcmp('MATLAB:nearlySingularMatrix',LastWarningID) == 1 || ...
                  strcmp('MATLAB:illConditionedMatrix',LastWarningID)==1 || ...
-                 strcmp('MATLAB:singularMatrix',LastWarningID)==1 
+                 strcmp('MATLAB:singularMatrix',LastWarningID)==1
         [C1,C2,C3,C4, C5, F1, F2, F3, F4, F5, M1, M2, UAVinv, FL_RANK, V01, V02] = PI_gensys_singularC(C1,C2,C3,C4, C5, F1, F2, F3, F4, F5, V01, V02, 0);
     end
     warning('on','MATLAB:singularMatrix');
     warning('on','MATLAB:nearlySingularMatrix');
-    if (any(any(isinf(UAVinv))) || any(any(isnan(UAVinv)))) 
+    if (any(any(isinf(UAVinv))) || any(any(isnan(UAVinv))))
         if(options_.ACES_solver==1)
             disp('ERROR! saving PI_gensys_data_dump');
             save PI_gensys_data_dump
@@ -96,7 +96,7 @@ try
         else
             warning('PI_gensys: Evading inversion of zero matrix UAVinv=inv(U02''*a1*V02)!');
             eu=[0,0];
-            return;
+            return
         end
     end
 catch
@@ -131,8 +131,8 @@ G23=eye(FL_RANK);
 num_inst=0;
 
 % New Definitions
-Ze11=zeros(NX,NX); 
-Ze12=zeros(NX,(n-FL_RANK)); 
+Ze11=zeros(NX,NX);
+Ze12=zeros(NX,(n-FL_RANK));
 Ze134=zeros(NX,FL_RANK);
 Ze31=zeros(FL_RANK,NX);
 
@@ -149,7 +149,7 @@ impact=[eye(NX,NX); zeros(n+FL_RANK,NX)];
 if(options_.ACES_solver==1)
     if isfield(lq_instruments,'names')
         num_inst=size(lq_instruments.names,1);
-        if num_inst>0 
+        if num_inst>0
             i_var=lq_instruments.inst_var_indices;
             N1=UAVinv*U02'*lq_instruments.B1;
             N3=-FF*N1+Sinv*U01'*lq_instruments.B1;
@@ -171,14 +171,14 @@ if(options_.ACES_solver==1)
             zeros(num_inst,size(E3,2)), II;
           ];
     eu =[1; 1], nmat=[], gev=[];
-    return; % do not check B&K compliancy
+    return % do not check B&K compliancy
 end
 
 G0pi=eye(n+FL_RANK+NX);
 try
-    % In Matlab: [aa bb q z v w] = qz(a,b) s.t. qaz = aa, qbz = bb % 
+    % In Matlab: [aa bb q z v w] = qz(a,b) s.t. qaz = aa, qbz = bb %
     % In Octave: [aa bb q z v w] = qz(a,b) s.t. q'az = aa, q'bz=bb %
-    % and qzcomplex() extension based on lapack zgges produces same 
+    % and qzcomplex() extension based on lapack zgges produces same
     % qz output for Octave as Matlab qz() does for Matlab thus:
     if isoctave
         [a b q z]=qzcomplex(G0pi,G1pi);
@@ -192,12 +192,12 @@ catch
         disp(['PI_Gensys: ' lerror.message]);
         if 0==strcmp('MATLAB:qz:matrixWithNaNInf',lerror.identifier)
             disp '** Unexpected Error PI_Gensys:qz: ** :';
-            button=questdlg('Continue Y/N?','Unexpected Error in qz','No','Yes','Yes'); 
-            switch button 
-              case 'No' 
+            button=questdlg('Continue Y/N?','Unexpected Error in qz','No','Yes','Yes');
+            switch button
+              case 'No'
                 error ('Terminated')
                 %case 'Yes'
-                
+
             end
         end
         G1pi=[];impact=[];nmat=[]; gev=[];
@@ -206,11 +206,11 @@ catch
     catch
         disp '** Unexpected Error in qz ** :';
         disp lerror.message;
-        button=questdlg('Continue Y/N?','Unexpected Error in qz','No','Yes','Yes'); 
-        switch button 
-          case 'No' 
-            error ('Terminated') 
-          case 'Yes' 
+        button=questdlg('Continue Y/N?','Unexpected Error in qz','No','Yes','Yes');
+        switch button
+          case 'No'
+            error ('Terminated')
+          case 'Yes'
             G1pi=[];impact=[];nmat=[]; gev=[];
             eu=[-2;-2];
             return
@@ -257,7 +257,7 @@ if zxz
 end
 if (FL_RANK ~= nunstab && options_.ACES_solver~=1)
     disp(['Number of unstable variables ' num2str(nunstab)]);
-    disp( ['does not match number of expectational equations ' num2str(FL_RANK)]); 
+    disp( ['does not match number of expectational equations ' num2str(FL_RANK)]);
     nmat=[];% gev=[];
     eu=[-2;-2];
     return
diff --git a/matlab/partial_information/PI_gensys_singularC.m b/matlab/partial_information/PI_gensys_singularC.m
index 5dc26ec63..b0c085faf 100644
--- a/matlab/partial_information/PI_gensys_singularC.m
+++ b/matlab/partial_information/PI_gensys_singularC.m
@@ -1,13 +1,13 @@
 function [C1,C2,C3,C4, C5, F1, F2, F3, F4, F5, M1, M2, UAVinv, FL_RANK, V01, V02]=PI_gensys_singularC(C1in, C2in, C3in, C4in, C5in, F1, F2, F3, F4, F5, V01, V02, level)
 % [C1,C2,C3,C4, C5, F1, F2, F3, F4, F5, M1, M2, UAVinv,FL_RANK, V01, V02]...
 %         =PI_gensys_singularC(C1in, C2in, C3in, C4in, C5in, F1, F2, F3, F4, F5, V01, V02, level)
-% 
+%
 % Recursive extension for PI_gensys function PCL general DSGE solver
-% devised by Prof. Joseph Pearlman 
+% devised by Prof. Joseph Pearlman
 % developed by George Perendia
 % December 2010
 
-% Copyright (C) 1996-2011 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -86,7 +86,4 @@ catch
     [errmsg, errcode]=lasterr;
     warning(['error callig PI_gensys_singularC: ' errmsg ],'errcode');
     error('errcode',['error callig PI_gensys_singularC: ' errmsg ]);
-end
-
-return;
-
+end
\ No newline at end of file
diff --git a/matlab/partial_information/add_auxiliary_variables_to_steadystate.m b/matlab/partial_information/add_auxiliary_variables_to_steadystate.m
index d99e36ebb..f90e7f6b0 100644
--- a/matlab/partial_information/add_auxiliary_variables_to_steadystate.m
+++ b/matlab/partial_information/add_auxiliary_variables_to_steadystate.m
@@ -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-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -21,7 +21,7 @@ function ys1 = add_auxiliary_variables_to_steadystate(ys,aux_vars,fname, ...
 n = length(aux_vars);
 ys1 = [ys;zeros(n,1)];
 
-for i=1:n+1;
+for i=1:n+1
     if byte_code
         [info, res] = bytecode('static','evaluate',ys1,...
                                [exo_steady_state; ...
@@ -30,7 +30,7 @@ for i=1:n+1;
         res = feval([fname '_static'],ys1,...
                     [exo_steady_state; ...
                      exo_det_steady_state],params);
-    end;
+    end
     for j=1:n
         el = aux_vars(j).endo_index;
         ys1(el) = ys1(el)-res(el);
diff --git a/matlab/partial_information/disc_riccati_fast.m b/matlab/partial_information/disc_riccati_fast.m
index 4a0bd0401..c97da7a12 100644
--- a/matlab/partial_information/disc_riccati_fast.m
+++ b/matlab/partial_information/disc_riccati_fast.m
@@ -1,17 +1,17 @@
 function Z=disc_riccati_fast(F,D,R,H,ch)
 % function Z=disc_riccati_fast(F,D,R,H,ch)
-% 
-% Solves discrete Riccati Equation: 
-% Z=FZF' - FZD'inv(DZD'+R)DZF' + H
-% Using the Doubling Algorithm 
 %
-% George Perendia: based on the doubling algorithm for Riccati   
-% and the disclyap_fast function provided by Prof. Joe Pearlman 
+% Solves discrete Riccati Equation:
+% Z=FZF' - FZD'inv(DZD'+R)DZF' + H
+% Using the Doubling Algorithm
+%
+% George Perendia: based on the doubling algorithm for Riccati
+% and the disclyap_fast function provided by Prof. Joe Pearlman
 % V.1 19/5/2006
 % V.2 22/10/06
 % =================================================================
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,16 +28,16 @@ function Z=disc_riccati_fast(F,D,R,H,ch)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin == 4 || isempty( ch ) == 1 
-    flag_ch = 0; 
-else 
-    flag_ch = 1; 
-end 
+if nargin == 4 || isempty( ch ) == 1
+    flag_ch = 0;
+else
+    flag_ch = 1;
+end
 
 
 % intialisation
 tol = 1e-10; % iteration convergence threshold
-P0=H; 
+P0=H;
 X0=F;
 if ~any(R) % i.e. ==0
     warning('Dangerously evading inversion of zero matrix!');
@@ -50,21 +50,21 @@ I=eye(size(POYO));
 clear POYO;
 
 % iterate Riccati equation solution
-matd=1; 
+matd=1;
 count=0;
 while matd > tol && count < 100
     INVPY=inv(I+P0*Y0);
-    P1=X0*INVPY*P0*X0'+ P0; 
-    Y1=X0'*Y0*INVPY*X0+ Y0; 
-    X1=X0*INVPY*X0; 
-    matd=sum( sum(abs( P1 - P0 ))); 
+    P1=X0*INVPY*P0*X0'+ P0;
+    Y1=X0'*Y0*INVPY*X0+ Y0;
+    X1=X0*INVPY*X0;
+    matd=sum( sum(abs( P1 - P0 )));
     %    P0=(P1+P1')/2
-    P0=P1; 
+    P0=P1;
     X0=X1;
     Y0=Y1;
     count=count+1;
     %    matd;
-end 
+end
 
 Z=(P0+P0')/2;
 %Z=P0
@@ -75,17 +75,17 @@ if count==100
     %    error.identifier='Riccati not converged!'
     %    error
 end
-%if count >5 
+%if count >5
 %    disp('Riccati count= ');
 %    count
 %end
 
-clear X0 X1 Y0 Y1 P1 I INVPY; 
+clear X0 X1 Y0 Y1 P1 I INVPY;
 
-% Check that X is positive definite 
-if flag_ch==1 
-    [C,p]=chol(Z); 
-    if p ~= 0 
+% Check that X is positive definite
+if flag_ch==1
+    [C,p]=chol(Z);
+    if p ~= 0
         error('Z is not positive definite')
-    end 
-end 
+    end
+end
diff --git a/matlab/partial_information/disclyap_fast.m b/matlab/partial_information/disclyap_fast.m
index 3e101a7a6..5dfcfe4b5 100644
--- a/matlab/partial_information/disclyap_fast.m
+++ b/matlab/partial_information/disclyap_fast.m
@@ -3,23 +3,23 @@ function [X,exitflag]=disclyap_fast(G,V,tol,check_flag)
 % Inputs:
 %   - G             [double]    first input matrix
 %   - V             [double]    second input matrix
-%   - tol           [scalar]    tolerance criterion 
+%   - tol           [scalar]    tolerance criterion
 %   - check_flag    empty of non-empty             if non-empty: check positive-definiteness
 % Outputs:
 %   - X             [double]    solution matrix
 %   - exitflag      [scalar]    0 if solution is found, 1 otherwise
 %
-% Solve the discrete Lyapunov Equation 
-% X=G*X*G'+V 
-% Using the Doubling Algorithm 
+% Solve the discrete Lyapunov Equation
+% X=G*X*G'+V
+% Using the Doubling Algorithm
 %
-% If check_flag is defined then the code will check if the resulting X 
-% is positive definite and generate an error message if it is not 
-% 
-% Joe Pearlman and Alejandro Justiniano 
-% 3/5/2005 
+% If check_flag is defined then the code will check if the resulting X
+% is positive definite and generate an error message if it is not
+%
+% Joe Pearlman and Alejandro Justiniano
+% 3/5/2005
 
-% Copyright (C) 2010-2016 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,40 +36,40 @@ function [X,exitflag]=disclyap_fast(G,V,tol,check_flag)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin <= 3 || isempty( check_flag ) == 1 
-    flag_ch = 0; 
-else 
-    flag_ch = 1; 
-end 
+if nargin <= 3 || isempty( check_flag ) == 1
+    flag_ch = 0;
+else
+    flag_ch = 1;
+end
 exitflag=0;
 
-P0=V; 
-A0=G; 
+P0=V;
+A0=G;
 
-matd=1; 
+matd=1;
 iter=1;
-while matd > tol && iter< 2000 
-    P1=P0+A0*P0*A0'; 
-    A1=A0*A0;  
-    matd=max( max( abs( P1 - P0 ) ) ); 
-    P0=P1; 
-    A0=A1; 
+while matd > tol && iter< 2000
+    P1=P0+A0*P0*A0';
+    A1=A0*A0;
+    matd=max( max( abs( P1 - P0 ) ) );
+    P0=P1;
+    A0=A1;
     iter=iter+1;
-end 
+end
 if iter==5000
     X=NaN(P0);
     exitflag=1;
     return
 end
-clear A0 A1 P1; 
+clear A0 A1 P1;
 
-X=(P0+P0')/2; 
+X=(P0+P0')/2;
 
-% Check that X is positive definite 
-if flag_ch==1 
-    [C,p]=chol(X); 
-    if p ~= 0 
+% Check that X is positive definite
+if flag_ch==1
+    [C,p]=chol(X);
+    if p ~= 0
         exitflag=1;
         error('X is not positive definite')
-    end 
-end 
\ No newline at end of file
+    end
+end
\ No newline at end of file
diff --git a/matlab/partial_information/dr1_PI.m b/matlab/partial_information/dr1_PI.m
index 0475d4bef..04fe8d926 100644
--- a/matlab/partial_information/dr1_PI.m
+++ b/matlab/partial_information/dr1_PI.m
@@ -6,7 +6,7 @@ function [dr,info,M_,options_,oo_] = dr1_PI(dr,task,M_,options_,oo_)
 % Prepares System as
 %        A0*E_t[y(t+1])+A1*y(t)=A2*y(t-1)+c+psi*eps(t)
 % with z an exogenous variable process.
-% and calls PI_Gensys.m solver 
+% and calls PI_Gensys.m solver
 % based on Pearlman et al 1986 paper and derived from
 % C.Sims' gensys linear solver.
 % to return solution in format
@@ -16,31 +16,31 @@ function [dr,info,M_,options_,oo_] = dr1_PI(dr,task,M_,options_,oo_)
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   task       [integer]          if task = 0 then dr1 computes decision rules.
 %                                 if task = 1 then dr1 computes eigenvalues.
-%   M_         [matlab structure] Definition of the model.           
+%   M_         [matlab structure] Definition of the model.
 %   options_   [matlab structure] Global options.
-%   oo_        [matlab structure] Results 
-%    
+%   oo_        [matlab structure] Results
+%
 % OUTPUTS
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   info       [integer]          info=1: the model doesn't define current variables uniquely
-%                                 info=2: problem in mjdgges.dll info(2) contains error code. 
+%                                 info=2: problem in mjdgges.dll info(2) contains error code.
 %                                 info=3: BK order condition not satisfied info(2) contains "distance"
 %                                         absence of stable trajectory.
 %                                 info=4: BK order condition not satisfied info(2) contains "distance"
 %                                         indeterminacy.
 %                                 info=5: BK rank condition not satisfied.
-%   M_         [matlab structure]            
+%   M_         [matlab structure]
 %   options_   [matlab structure]
 %   oo_        [matlab structure]
-%  
+%
 % ALGORITHM
 %   ...
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 1996-2012 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -66,9 +66,9 @@ xlen = M_.maximum_endo_lead + M_.maximum_endo_lag + 1;
 
 if (options_.aim_solver == 1)
     options_.aim_solver == 0;
-    warning('You can not use AIM with Part Info solver. AIM ignored'); 
+    warning('You can not use AIM with Part Info solver. AIM ignored');
 end
-if (options_.order > 1) 
+if (options_.order > 1)
     warning('You can not use order higher than 1 with Part Info solver. Order 1 assumed');
     options_.order =1;
 end
@@ -101,11 +101,11 @@ else
     iyv = iyv(:);
     iyr0 = find(iyv) ;
     it_ = M_.maximum_lag + 1 ;
-    
+
     if M_.exo_nbr == 0
         oo_.exo_steady_state = [] ;
     end
-    
+
 
     if options_.ACES_solver == 1
         sim_ruleids=[];
@@ -172,15 +172,15 @@ sdyn = M_.endo_nbr - nstatic;
 k0 = M_.lead_lag_incidence(M_.maximum_endo_lag+1,order_var);
 k1 = M_.lead_lag_incidence(find([1:klen] ~= M_.maximum_endo_lag+1),:);
 
-if (options_.aim_solver == 1) 
+if (options_.aim_solver == 1)
     error('Anderson and Moore AIM solver is not compatible with Partial Information models');
 end % end if useAIM and...
 
     % If required, try PCL86 solver, that is, if not the check being
-    % performed only and if it is 1st order 
+    % performed only and if it is 1st order
     % create sparse, extended jacobia AA:
     nendo=M_.endo_nbr; % = size(aa,1)
-    
+
 
     if(options_.ACES_solver==1)
         %if ~isfield(lq_instruments,'names')
@@ -239,8 +239,8 @@ end % end if useAIM and...
     %     E_t z(t)
     %     E_t z(t+1)
     %     E_t z(t+2)
-    %     E_t z(t+3) 
-    
+    %     E_t z(t+3)
+
     % partition jacobian:
     jlen=M_.nspred+M_.nsfwrd+M_.endo_nbr+M_.exo_nbr; % length of jacobian
     PSI=-jacobia_(:, jlen-M_.exo_nbr+1:end); % exog
@@ -253,12 +253,12 @@ end % end if useAIM and...
         AA2=AA0; % empty A2 and A3
         AA3=AA0;
         if xlen==nendo % && M_.maximum_lag <=1 && M_.maximum_lead <=1 % apply a shortcut
-            AA1=jacobia_(:,nspred+1:nspred+nendo); 
+            AA1=jacobia_(:,nspred+1:nspred+nendo);
             if M_.maximum_lead ==1
                 fnd = find(lead_lag(:,M_.maximum_lag+2));
                 AA0(:, fnd)= jacobia_(:,nonzeros(lead_lag(:,M_.maximum_lag+2))); %forwd jacobian
             end
-            if nspred>0 && M_.maximum_lag ==1  
+            if nspred>0 && M_.maximum_lag ==1
                 fnd = find(lead_lag(:,1));
                 AA2(:, fnd)= jacobia_(:,nonzeros(lead_lag(:,1))); %backward
             end
@@ -266,7 +266,7 @@ end % end if useAIM and...
         if nendo-xlen==num_inst
             PSI=[PSI;zeros(num_inst, M_.exo_nbr)];
             % AA1 contemporary
-            AA_all=jacobia_(:,nspred+1:nspred+nendo); 
+            AA_all=jacobia_(:,nspred+1:nspred+nendo);
             AA1=AA_all(:,lq_instruments.m_var); % endo without instruments
             lq_instruments.ij1=AA_all(:,lq_instruments.inst_var_indices); %  instruments only
             lq_instruments.B1=-[lq_instruments.ij1; eye(num_inst)];
@@ -281,7 +281,7 @@ end % end if useAIM and...
                 lq_instruments.B0=[lq_instruments.ij0; eye(num_inst)];
                 AA0=[AA0, zeros(xlen,num_inst); zeros(num_inst,xlen+num_inst)];
             end
-            if nspred>0 && M_.maximum_lag ==1  
+            if nspred>0 && M_.maximum_lag ==1
                 AA_all(:,:)=0.0;
                 fnd = find(lead_lag(:,1));
                 AA_all(:, fnd)= jacobia_(:,nonzeros(lead_lag(:,1))); %backward
@@ -312,7 +312,7 @@ end % end if useAIM and...
     NX=M_.exo_nbr; % no of exogenous varexo shock variables.
     NETA=nfwrd+nboth; % total no of exp. errors  set to no of forward looking equations
     FL_RANK=rank(AA0); % nfwrd+nboth; % min total no of forward looking equations and vars
-    
+
     try
         % call [G1pi,C,impact,nmat,TT1,TT2,gev,eu]=PI_gensys(a0,a1,a2,c,PSI,NX,NETA,NO_FL_EQS)
         % System given as
@@ -348,13 +348,13 @@ end % end if useAIM and...
             [G1pi,CC,impact,nmat,TT1,TT2,gev,eu, DD, E2,E5, GAMMA, FL_RANK]=PI_gensys(AA0,AA1,-AA2,AA3,cc,PSI,NX,NETA,FL_RANK, M_, options_);
         end
 
-        % reuse some of the bypassed code and tests that may be needed 
+        % reuse some of the bypassed code and tests that may be needed
         if (eu(1) ~= 1 || eu(2) ~= 1) && options_.ACES_solver==0
             info(1) = abs(eu(1)+eu(2));
             info(2) = 1.0e+8;
             %     return
         end
-        
+
         dr.PI_ghx=G1pi;
         dr.PI_ghu=impact;
         dr.PI_TT1=TT1;
@@ -369,7 +369,7 @@ end % end if useAIM and...
         dr.ghu=impact;
         dr.eigval = eig(G1pi);
         dr.rank=FL_RANK;
-        
+
         if options_.ACES_solver==1
             betap=options_.planner_discount;
             sigma_cov=M_.Sigma_e;
@@ -390,8 +390,8 @@ end % end if useAIM and...
             ACES.Q=DYN_Q;
             ACES.W=W;
             NY=nendo-num_inst;
-            
-            % save the followings in a subdirectory - BY    
+
+            % save the followings in a subdirectory - BY
             save ([ACES_DirectoryName,'/',M_.fname '_ACESLQ_Matrices'], 'ACES');
             save ([ACES_DirectoryName,'/',M_.fname '_ACESLQ_GAMMA'], 'GAMMA');
             save ([ACES_DirectoryName,'/',M_.fname '_ACESLQ_A.txt'], 'G1pi', '-ascii', '-double', '-tabs');
@@ -449,8 +449,6 @@ end % end if useAIM and...
         end
     end
 
-    % TODO: 
+    % TODO:
     % if options_.loglinear == 1
-    % if exogenous deterministic variables
-    
-    return;
+    % if exogenous deterministic variables
\ No newline at end of file
diff --git a/matlab/particles b/matlab/particles
index 285d5c171..84d213ea3 160000
--- a/matlab/particles
+++ b/matlab/particles
@@ -1 +1 @@
-Subproject commit 285d5c171104e44e1a5d2fe30f062be08dbab8cb
+Subproject commit 84d213ea3e705f36871bc8f960d175a330fd71de
diff --git a/matlab/perfect-foresight-models/det_cond_forecast.m b/matlab/perfect-foresight-models/det_cond_forecast.m
index e261de89c..ee177d830 100644
--- a/matlab/perfect-foresight-models/det_cond_forecast.m
+++ b/matlab/perfect-foresight-models/det_cond_forecast.m
@@ -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-2016 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -34,9 +34,9 @@ pp = 2;
 initial_conditions = oo_.steady_state;
 verbosity = options_.verbosity;
 if options_.periods == 0
-	options_.periods = 25;
-end;
-%We have to get an initial guess for the conditional forecast 
+    options_.periods = 25;
+end
+%We have to get an initial guess for the conditional forecast
 % and terminal conditions for the non-stationary variables, we
 % use the first order approximation of the rational expectation solution.
 if ~isfield(oo_,'dr') || (isempty(oo_.dr))
@@ -64,7 +64,7 @@ if length(varargin) > 3
     nvars = length(constrained_vars);
     for i = 1:max_periods_simulation
         constraint_index{i} = 1:nvars;
-    end;
+    end
     direct_mode = 0;
     shocks_present = 0;
     controlled_varexo = options_cond_fcst.controlled_varexo;
@@ -82,7 +82,7 @@ if length(varargin) > 3
             error(['Unknown exogenous variable ' controlled_varexo(i,:)]);
         end
     end
-        
+
 else
     % alternative way to call: plan, dset, dates_of_frcst
     plan = varargin{1};
@@ -102,32 +102,33 @@ else
                 s2 = strings(range(range.ndat));
                 error(['the dseries ' inputname(2) ' finish at time ' s1{1} ' before the last period of forecast ' s2{1}]);
             end
-            
+
             sym_dset = dset(dates(-range(1)):dates(range(range.ndat)));
             periods = options_.periods + M_.maximum_lag + M_.maximum_lead;
+            total_periods = periods + range.ndat;
             if isfield(oo_, 'exo_simul')
-                if size(oo_.exo_simul, 1) ~= max(range.ndat + 1, periods)
-                    oo_.exo_simul = repmat(oo_.exo_steady_state',max(range.ndat + 1, periods),1);
+                if size(oo_.exo_simul, 1) ~= total_periods
+                    oo_.exo_simul = repmat(oo_.exo_steady_state',total_periods,1);
                 end
             else
-                oo_.exo_simul = repmat(oo_.exo_steady_state',max(range.ndat + 1, periods),1);
+                oo_.exo_simul = repmat(oo_.exo_steady_state',total_periods,1);
             end
-            
-            oo_.endo_simul = repmat(oo_.steady_state, 1, max(range.ndat + 1, periods));
-            
+
+            oo_.endo_simul = repmat(oo_.steady_state, 1, total_periods);
+
             for i = 1:sym_dset.vobs
                 iy = find(strcmp(strtrim(sym_dset.name{i}), strtrim(plan.endo_names)));
                 if ~isempty(iy)
                     oo_.endo_simul(iy,1:sym_dset.nobs) = sym_dset.data(:, i);
                     initial_conditions(iy) = sym_dset.data(1, i);
-                 else
-                     ix = find(strcmp(strtrim(sym_dset.name{i}), strtrim(plan.exo_names)));
-                     if ~isempty(ix) 
-                         oo_.exo_simul(1, ix) = sym_dset.data(1, i)';
+                else
+                    ix = find(strcmp(strtrim(sym_dset.name{i}), strtrim(plan.exo_names)));
+                    if ~isempty(ix)
+                        oo_.exo_simul(1, ix) = sym_dset.data(1, i)';
                     else
                         %warning(['The variable ' sym_dset.name{i} ' in the dataset ' inputname(2) ' is not a endogenous neither an exogenous variable!!']);
                     end
-                 end
+                end
             end
             for i = 1:length(M_.aux_vars)
                 if M_.aux_vars(i).type == 1 %lag variable
@@ -144,8 +145,9 @@ else
             end
             %Compute the initial path using the the steady-state
             % steady-state
-            for jj = 2 : (options_.periods + 2)
-              oo_.endo_simul(:, jj) = oo_.steady_state;  
+            %for jj = 2 : (options_.periods + 2)
+            for jj = 2 : (range.ndat + 2)
+                oo_.endo_simul(:, jj) = oo_.steady_state;
             end
             missings = isnan(oo_.endo_simul(:,1));
             if any(missings)
@@ -161,9 +163,10 @@ else
                 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);
                 options_.dynatol.f = save_options_dynatol_f;
+
                 if Info == 0
-                  oo_.endo_simul = endo;
-                  oo_.exo_simul = exo;
+                    oo_.endo_simul = endo;
+                    oo_.exo_simul = exo;
                 end
                 endo = endo';
                 endo_l = size(endo(1+M_.maximum_lag:end,:),1);
@@ -176,7 +179,7 @@ else
                     else
                         pos = find(strcmp(dset.name{i},plan.exo_names));
                         if ~isempty(pos)
-                           data_set{dset.name{i}} = dseries(exo(1+M_.maximum_lag:end,pos), plan.date(1),dset.name{i});
+                            data_set{dset.name{i}} = dseries(exo(1+M_.maximum_lag:end,pos), plan.date(1),dset.name{i});
                         end
                     end
                 end
@@ -190,30 +193,30 @@ else
                     end
                 end
                 data_set = merge(dset(dset.dates(1):(plan.date(1)-1)), data_set);
-                return;
+                return
                 union_names = union(data_set.name, dset.name);
                 dif = setdiff(union_names, data_set.name);
                 data_set_nobs = data_set.nobs;
                 for i = 1:length(dif)
                     data_set{dif{i}} = dseries(nan(data_set_nobs,1),plan.date(1), dif(i), dif(i));
-                end;
+                end
                 dif = setdiff(union_names, dset.name);
                 dset_nobs = dset.nobs;
                 for i = 1:length(dif)
                     dset{dif{i}} = dseries(nan(dset_nobs,1),dset.dates(1), dif(i), dif(i));
-                end;
+                end
                 data_set = [dset(dset.dates(1):(plan.date(1)-1)) ; data_set];
-                return;
-            end;
+                return
+            end
         else
-           error('impossible case'); 
-        end;
-            
+            error('impossible case');
+        end
+
     else
         oo_.exo_simul = repmat(oo_.exo_steady_state',options_.periods+2,1);
         oo_.endo_simul = repmat(oo_.steady_state, 1, options_.periods+2);
     end
-    
+
     direct_mode = 1;
     constrained_paths = plan.constrained_paths_;
     constrained_vars = plan.constrained_vars_;
@@ -229,16 +232,16 @@ else
     else
         shocks_present = 0;
     end
-    
+
     total_periods = plan.date;
-    
-end;
+
+end
 
 if ~isfield(options_cond_fcst,'periods') || isempty(options_cond_fcst.periods)
     options_cond_fcst.periods = 100;
 end
 
-options_.periods = 10;   
+options_.periods = 10;
 
 if direct_mode == 1
     n_periods = length(constrained_periods);
@@ -257,7 +260,7 @@ if direct_mode == 1
         else
             init_periods = period_i;
             tp_end = period_i;
-        end;
+        end
         tp0 = tp;
         while tp < init_periods
             tp = tp + 1;
@@ -268,18 +271,18 @@ if direct_mode == 1
             constrained_paths(i, tp - tp0 + 1) = constrained_paths_cell{i}(j + 1);
             tp = tp + 1;
             j = j + 1;
-        end;
-        if tp - tp0 > max_periods_simulation 
+        end
+        if tp - tp0 > max_periods_simulation
             max_periods_simulation = tp - tp0;
-        end;
+        end
     end
     n_nnz = length(sum(is_constraint,2));
     if n_nnz > 0
         constraint_index = cell(n_nnz,1);
         for i= 1:n_nnz
             constraint_index{i} = find(is_constraint(i,:));
-        end;
-    end;
+        end
+    end
     if shocks_present
         n_periods = length(shock_periods);
         shock_paths_cell = shock_paths;
@@ -296,7 +299,7 @@ if direct_mode == 1
             else
                 init_periods = period_i;
                 tp_end = period_i;
-            end;
+            end
             tp0 = tp;
             while tp < init_periods
                 tp = tp + 1;
@@ -307,17 +310,17 @@ if direct_mode == 1
                 shock_paths(i, tp - tp0 + 1) = shock_paths_cell{i}(j + 1);
                 tp = tp + 1;
                 j = j + 1;
-            end;
-            if tp - tp0 > max_periods_simulation 
+            end
+            if tp - tp0 > max_periods_simulation
                 max_periods_simulation = tp - tp0;
-            end;
-        end;
+            end
+        end
         n_nnz = length(sum(is_shock,2));
         if n_nnz > 0
             shock_index = cell(n_nnz, 1);
             for i= 1:n_nnz
                 shock_index{i} = find(is_shock(i,:));
-            end;
+            end
         end
     end
 else
@@ -333,16 +336,16 @@ ny = size(ys,1);
 xs = [oo_.exo_steady_state ; oo_.exo_det_steady_state];
 nx = size(xs,1);
 
-constrained_periods = max_periods_simulation;   
+constrained_periods = max_periods_simulation;
 n_endo_constrained = size(constrained_vars,1);
 if isfield(options_cond_fcst,'controlled_varexo')
     n_control_exo = size(options_cond_fcst.controlled_varexo, 1);
     if n_control_exo ~= n_endo_constrained
         error(['det_cond_forecast: the number of exogenous controlled variables (' int2str(n_control_exo) ') has to be equal to the number of constrained endogenous variabes (' int2str(n_endo_constrained) ')'])
-    end;
+    end
 else
     error('det_cond_forecast: to run a deterministic conditional forecast you have to specified the exogenous variables controlled using the option controlled_varexo in forecast command');
-end;
+end
 
 % if n_endo_constrained == 0
 %     options_.ep.use_bytecode = options_.bytecode;
@@ -374,14 +377,14 @@ if isempty(indx_endo_solve_pf)
     pf = 0;
 else
     pf = length(indx_endo_solve_pf);
-end;
+end
 indx_endo_solve_surprise = setdiff(constrained_vars, indx_endo_solve_pf);
 
 if isempty(indx_endo_solve_surprise)
     surprise = 0;
 else
     surprise = length(indx_endo_solve_surprise);
-end;
+end
 
 
 eps = options_.solve_tolf;
@@ -411,7 +414,7 @@ if pf && ~surprise
     for j = 1:length(constrained_vars)
         indx_endo(col_count : col_count + constrained_periods - 1) = constrained_vars(j) + (time_index_constraint - 1) * ny;
         col_count = col_count + constrained_periods;
-    end;
+    end
     oo_=make_ex_(M_,options_,oo_);
     oo_=make_y_(M_,options_,oo_);
     it = 1;
@@ -433,9 +436,9 @@ if pf && ~surprise
                     y = oo_.endo_simul(constrained_vars(j), time_index_constraint);
                     r(col_count:col_count+constrained_periods - 1) = (y - constrained_paths(j,1:constrained_periods))';
                     col_count = col_count + constrained_periods;
-                end;
+                end
                 normr = norm(r, 1);
-            end;
+            end
             if (~oo_.deterministic_simulation.status || ~result || normr > normra) && it > 1
                 not_achieved = 1;
                 alpha = alpha / 2;
@@ -443,14 +446,14 @@ if pf && ~surprise
                 for j = controlled_varexo'
                     oo_.exo_simul(time_index_constraint,j) = (old_exo(:,j) + alpha * D_exo(col_count: (col_count + constrained_periods - 1)));
                     col_count = col_count + constrained_periods;
-                end;
+                end
                 disp(['Divergence in  Newton: reducing the path length alpha=' num2str(alpha)]);
                 oo_.endo_simul = repmat(oo_.steady_state, 1, options_cond_fcst.periods + 2);
             else
                 not_achieved = 0;
-            end;
-        end;
-        
+            end
+        end
+
         per = 30;
         z = oo_.endo_simul(:, 1 : per + 2 );
         zx = oo_.exo_simul(1: per + 2,:);
@@ -470,7 +473,7 @@ if pf && ~surprise
                 else
                     data1 = M_;
                     Size = 1;
-                end;
+                end
                 data1 = M_;
                 if (options_.bytecode)
                     [chck, zz, data1]= bytecode('dynamic','evaluate', z, zx, M_.params, oo_.steady_state, k, data1);
@@ -479,16 +482,16 @@ if pf && ~surprise
                     data1.g1_x = g1b(:,end - M_.exo_nbr + 1:end);
                     data1.g1 = g1b(:,1 : end - M_.exo_nbr);
                     chck = 0;
-                end;
+                end
                 mexErrCheck('bytecode', chck);
-            end;
-            if k == 1 
+            end
+            if k == 1
                 g1(1:M_.endo_nbr,-M_.endo_nbr + [cur_indx lead_indx]) = data1.g1(:,M_.nspred + 1:end);
             elseif k == per
                 g1(M_.endo_nbr * (k - 1) + 1 :M_.endo_nbr * k,M_.endo_nbr * (k -2) + [lag_indx cur_indx]) = data1.g1(:,1:M_.nspred + M_.endo_nbr);
             else
                 g1(M_.endo_nbr * (k - 1) + 1 :M_.endo_nbr * k, M_.endo_nbr * (k -2) + [lag_indx cur_indx lead_indx]) = data1.g1;
-            end;
+            end
             l2 = 1;
             pf_c = 1;
             if k <= constrained_periods
@@ -501,17 +504,17 @@ if pf && ~surprise
                         for ii = 2:constrained_periods
                             indx_x(l2) = length(controlled_varexo) + pf * (ii - 2) + constraint_index{k + ii - 1}(pf_c);
                             l2 = l2 + 1;
-                        end;
+                        end
                         pf_c = pf_c + 1;
                         cum_index_d_y_x = [cum_index_d_y_x; constrained_vars(l)];
                     else
                         cum_index_d_y_x = [cum_index_d_y_x; constrained_vars(l) + (k - 1) * M_.endo_nbr];
                     end
                     cum_l1 = cum_l1 + length(l1);
-                end;
-            end;
-        end;
-        
+                end
+            end
+        end
+
         d_y_x = - g1 \ g1_x;
 
         cum_l1 = 0;
@@ -530,25 +533,25 @@ if pf && ~surprise
                 cum_l1 = cum_l1 + length(l1);
             end
             cum_l1 = cum_l1 + length(constrained_vars(j1));
-        end;
-        
-        
-%         col_count = 1;
-%         for j = controlled_varexo'
-%             for time = time_index_constraint
-%                 saved = oo_.exo_simul(time,j);
-%                 oo_.exo_simul(time,j) = oo_.exo_simul(time,j) + eps1;
-%                 simul();
-%                 J1(:,col_count) = (oo_.endo_simul(indx_endo) - ys) / eps1;
-%                 oo_.exo_simul(time,j) = saved;
-%                 col_count = col_count + 1;
-%             end;
-%         end;
-%         J1
-%         sdfmlksdf;
-        
+        end
+
+
+        %         col_count = 1;
+        %         for j = controlled_varexo'
+        %             for time = time_index_constraint
+        %                 saved = oo_.exo_simul(time,j);
+        %                 oo_.exo_simul(time,j) = oo_.exo_simul(time,j) + eps1;
+        %                 simul();
+        %                 J1(:,col_count) = (oo_.endo_simul(indx_endo) - ys) / eps1;
+        %                 oo_.exo_simul(time,j) = saved;
+        %                 col_count = col_count + 1;
+        %             end
+        %         end
+        %         J1
+        %         sdfmlksdf;
+
         disp(['iteration ' int2str(it) ' error = ' num2str(normr)]);
-        
+
         if normr <= eps
             convg = 1;
             disp('convergence achieved');
@@ -561,25 +564,25 @@ if pf && ~surprise
             for j = controlled_varexo'
                 oo_.exo_simul(time_index_constraint,j) = oo_.exo_simul(time_index_constraint,j) + D_exo(col_count: (col_count + constrained_periods - 1));
                 col_count = col_count + constrained_periods - 1;
-            end;
-        end;
+            end
+        end
         it = it + 1;
         normra = normr;
-    end;
+    end
     endo = oo_.endo_simul';
     exo = oo_.exo_simul;
 else
     for t = 1:constrained_periods
-        
-        if direct_mode && ~isempty(is_constraint) 
+
+        if direct_mode && ~isempty(is_constraint)
             [pos_constrained_pf, junk] = find(constrained_perfect_foresight .* is_constraint(t, :)');
             indx_endo_solve_pf = constrained_vars(pos_constrained_pf);
             if isempty(indx_endo_solve_pf)
                 pf = 0;
             else
                 pf = length(indx_endo_solve_pf);
-            end;
-        
+            end
+
             [pos_constrained_surprise, junk] = find((1-constrained_perfect_foresight) .* is_constraint(t, :)');
             indx_endo_solve_surprise = constrained_vars(pos_constrained_surprise);
 
@@ -587,18 +590,18 @@ else
                 surprise = 0;
             else
                 surprise = length(indx_endo_solve_surprise);
-            end;
-        end;
-        
-        if direct_mode && ~isempty(is_shock) 
+            end
+        end
+
+        if direct_mode && ~isempty(is_shock)
             [pos_shock_pf, junk] = find(shock_perfect_foresight .* is_shock(t, :)');
             indx_endo_solve_pf = shock_vars(pos_shock_pf);
             if isempty(indx_endo_solve_pf)
                 b_pf = 0;
             else
                 b_pf = length(indx_endo_solve_pf);
-            end;
-        
+            end
+
             [pos_shock_surprise, junk] = find((1-shock_perfect_foresight) .* is_shock(t, :)');
             indx_endo_solve_surprise = shock_vars(pos_shock_surprise);
 
@@ -606,9 +609,9 @@ else
                 b_surprise = 0;
             else
                 b_surprise = length(indx_endo_solve_surprise);
-            end;
-        end;
-        
+            end
+        end
+
         disp('===============================================================================================');
         disp(['t=' int2str(t) ' conditional (surprise=' int2str(surprise) ' perfect foresight=' int2str(pf) ') unconditional (surprise=' int2str(b_surprise) ' perfect foresight=' int2str(b_pf) ')']);
         disp('===============================================================================================');
@@ -620,20 +623,20 @@ else
                 exo_init = zeros(size(oo_.exo_simul));
             end
             oo_=make_y_(M_,options_,oo_);
-        end;
+        end
         %exo_init
         oo_.exo_simul = exo_init;
         oo_.endo_simul(:,1) = initial_conditions;
-        
+
         time_index_constraint = maximum_lag + 1:maximum_lag + constrained_periods - t + 1;
-        
+
         if direct_mode
             nb_shocks = length(plan.shock_vars_);
             if nb_shocks > 0
                 shock_index_t = shock_index{t};
                 shock_vars_t = shock_vars(shock_index_t);
                 for shock_indx = shock_index_t
-                    if shock_perfect_foresight(shock_indx) 
+                    if shock_perfect_foresight(shock_indx)
                         oo_.exo_simul(time_index_constraint,shock_vars_t(shock_indx)) = shock_paths(shock_indx,t:constrained_periods);
                     else
                         oo_.exo_simul(maximum_lag + 1,shock_vars_t(shock_indx)) = shock_paths(shock_indx,t);
@@ -650,11 +653,11 @@ else
         for jj = 1 : (options_.periods + 2)
             oo_.endo_simul(:,jj) = oo_.steady_state + oo_.endo_simul(:,jj);
         end
-        
+
         constraint_index_t = constraint_index{t};
         controlled_varexo_t = controlled_varexo(constraint_index_t);
         constrained_vars_t = constrained_vars(constraint_index_t);
-        
+
         second_system_size = surprise + pf * (constrained_periods - t + 1);
         indx_endo = zeros(second_system_size,1);
         col_count = 1;
@@ -665,11 +668,11 @@ else
             else
                 indx_endo(col_count) = constrained_vars(j) + maximum_lag * ny;
                 col_count = col_count + 1;
-            end;
-        end;
-        
+            end
+        end
+
         r = zeros(second_system_size,1);
-        
+
         convg = 0;
         it = 1;
         while ~convg && it <= maxit
@@ -693,20 +696,20 @@ else
                         else
                             oo_.exo_simul(maximum_lag + 1,j) = old_exo(maximum_lag + 1,j) + alpha * D_exo(col_count);
                             col_count = col_count + 1;
-                        end;
-                    end;
+                        end
+                    end
                     disp(['Divergence in  Newton: reducing the path length alpha=' num2str(alpha) ' result=' num2str(result) ' sum(sum)=' num2str(sum(sum(isfinite(oo_.endo_simul(:,time_index_constraint))))) ' ny * length(time_index_constraint)=' num2str(ny * length(time_index_constraint)) ' oo_.deterministic_simulation.status=' num2str(oo_.deterministic_simulation.status)]);
                     oo_.endo_simul = [initial_conditions repmat(oo_.steady_state, 1, options_cond_fcst.periods + 1)];
                 else
                     not_achieved = 0;
-                end;
-            end;
+                end
+            end
             if t==constrained_periods
                 ycc = oo_.endo_simul;
-            end;
+            end
             yc = oo_.endo_simul(:,maximum_lag + 1);
             ys = oo_.endo_simul(indx_endo);
-            
+
             col_count = 1;
             for j = constraint_index_t
                 if constrained_perfect_foresight(j)
@@ -717,9 +720,9 @@ else
                     y = yc(constrained_vars(j));
                     r(col_count) = y - constrained_paths(j,t);
                     col_count = col_count + 1;
-                end;
+                end
             end
-            
+
             disp('computation of derivatives w.r. to exogenous shocks');
 
             per = 30;
@@ -742,7 +745,7 @@ else
                     else
                         data1 = M_;
                         Size = 1;
-                    end;
+                    end
                     data1 = M_;
                     if (options_.bytecode)
                         [chck, zz, data1]= bytecode('dynamic','evaluate', z, zx, M_.params, oo_.steady_state, k, data1);
@@ -751,17 +754,17 @@ else
                         data1.g1_x = g1b(:,end - M_.exo_nbr + 1:end);
                         data1.g1 = g1b(:,1 : end - M_.exo_nbr);
                         chck = 0;
-                    end;
+                    end
                     mexErrCheck('bytecode', chck);
-                end;
-                if k == 1 
+                end
+                if k == 1
                     g1(1:M_.endo_nbr,-M_.endo_nbr + [cur_indx lead_indx]) = data1.g1(:,M_.nspred + 1:end);
                 elseif k == per
                     g1(M_.endo_nbr * (k - 1) + 1 :M_.endo_nbr * k,M_.endo_nbr * (k -2) + [lag_indx cur_indx]) = data1.g1(:,1:M_.nspred + M_.endo_nbr);
                 else
                     g1(M_.endo_nbr * (k - 1) + 1 :M_.endo_nbr * k, M_.endo_nbr * (k -2) + [lag_indx cur_indx lead_indx]) = data1.g1;
-                end;
-                
+                end
+
                 l2 = 1;
                 pf_c = 1;
                 if t + k - 1 <= constrained_periods
@@ -776,25 +779,25 @@ else
                                     for ii = 2:constrained_periods - t + 1
                                         indx_x(l2) = length(controlled_varexo) + pf * (ii - 2) + constraint_index{k + ii - 1}(pf_c);
                                         l2 = l2 + 1;
-                                    end;
+                                    end
                                     pf_c = pf_c + 1;
                                 else
                                     indx_x(l2) = l;
                                     l2 = l2 + 1;
-                                end;
+                                end
                                 cum_index_d_y_x = [cum_index_d_y_x; constrained_vars_t(l)];
                             else
                                 cum_index_d_y_x = [cum_index_d_y_x; constrained_vars_t(l) + (k - 1) * M_.endo_nbr];
                             end
                             cum_l1 = cum_l1 + length(l1);
-                        end;
-                    end;
-                end;
-            end;
-            
+                        end
+                    end
+                end
+            end
+
             d_y_x = - g1 \ g1_x;
 
-            
+
             cum_l1 = 0;
             count_col = 1;
             cum_index_J  = 1:length(cum_index_d_y_x(indx_x));
@@ -816,41 +819,41 @@ else
                     count_col = count_col + 1;
                 end
                 cum_l1 = cum_l1 + length(constrained_vars_t(j1));
-            end;
+            end
+
+
+            %             % Numerical computation of the derivatives in the second systme
+            %             J1 = [];
+            %             col_count = 1;
+            %             for j = constraint_index_t
+            %                 j_pos = controlled_varexo(j);
+            %                 if constrained_perfect_foresight(j)
+            %                     for time = time_index_constraint
+            %                         saved = oo_.exo_simul(time,j_pos);
+            %                         oo_.exo_simul(time,j_pos) = oo_.exo_simul(time,j_pos) + eps1;
+            %                         simul();
+            %                         J1(:,col_count) = (oo_.endo_simul(indx_endo) - ys) / eps1;
+            %                         oo_.exo_simul(time,j_pos) = saved;
+            %                         col_count = col_count + 1;
+            %                     end
+            %                 else
+            %                     saved = oo_.exo_simul(maximum_lag+1,j_pos);
+            %                     oo_.exo_simul(maximum_lag+1,j_pos) = oo_.exo_simul(maximum_lag+1,j_pos) + eps1;
+            %                     simul();
+            % %                    indx_endo
+            %                     J1(:,col_count) = (oo_.endo_simul(indx_endo) - ys) / eps1;
+            % %                    J(:,col_count) = (oo_.endo_simul((pp - 1) * M_.endo_nbr + 1: pp * M_.endo_nbr) - ys) / eps1;
+            %                     oo_.exo_simul(maximum_lag+1,j_pos) = saved;
+            %                     col_count = col_count + 1;
+            %                 end
+            %             end
+            %             disp('J1');
+            %             disp(full(J1));
+            %             sdfmlk;
 
-            
-%             % Numerical computation of the derivatives in the second systme        
-%             J1 = [];
-%             col_count = 1;
-%             for j = constraint_index_t
-%                 j_pos = controlled_varexo(j);
-%                 if constrained_perfect_foresight(j)
-%                     for time = time_index_constraint
-%                         saved = oo_.exo_simul(time,j_pos);
-%                         oo_.exo_simul(time,j_pos) = oo_.exo_simul(time,j_pos) + eps1;
-%                         simul();
-%                         J1(:,col_count) = (oo_.endo_simul(indx_endo) - ys) / eps1;
-%                         oo_.exo_simul(time,j_pos) = saved;
-%                         col_count = col_count + 1;
-%                     end;
-%                 else
-%                     saved = oo_.exo_simul(maximum_lag+1,j_pos);
-%                     oo_.exo_simul(maximum_lag+1,j_pos) = oo_.exo_simul(maximum_lag+1,j_pos) + eps1;
-%                     simul();
-% %                    indx_endo
-%                     J1(:,col_count) = (oo_.endo_simul(indx_endo) - ys) / eps1;
-% %                    J(:,col_count) = (oo_.endo_simul((pp - 1) * M_.endo_nbr + 1: pp * M_.endo_nbr) - ys) / eps1;
-%                     oo_.exo_simul(maximum_lag+1,j_pos) = saved;
-%                     col_count = col_count + 1;
-%                 end;
-%             end;
-%             disp('J1');
-%             disp(full(J1));
-%             sdfmlk;
-            
 
             normr = norm(r, 1);
-            
+
             disp(['iteration ' int2str(it) ' error = ' num2str(normr) ' at time ' int2str(t)]);
 
             if normr <= eps
@@ -859,7 +862,7 @@ else
             else
                 % Newton update on exogenous shocks
                 try
-                   D_exo = - J \ r;
+                    D_exo = - J \ r;
                 catch
                     [V, D] = eig(full(J));
                     ev = diag(D);
@@ -867,7 +870,7 @@ else
                     z_root = find(abs(ev) < 1e-4);
                     z_root
                     disp(V(:,z_root));
-                end;
+                end
                 old_exo = oo_.exo_simul;
                 col_count = 1;
                 for j = constraint_index_t
@@ -878,14 +881,14 @@ else
                     else
                         oo_.exo_simul(maximum_lag + 1,j_pos) = oo_.exo_simul(maximum_lag + 1,j_pos) + D_exo(col_count);
                         col_count = col_count + 1;
-                    end;
-                end;
-            end;
+                    end
+                end
+            end
             it = it + 1;
-        end;
+        end
         if ~convg
             error(['convergence not achived at time ' int2str(t) ' after ' int2str(it) ' iterations']);
-        end;
+        end
         for j = constraint_index_t
             j_pos=controlled_varexo(j);
             if constrained_perfect_foresight(j)
@@ -897,20 +900,20 @@ else
                 end
             else
                 exo(maximum_lag + t,j_pos) = oo_.exo_simul(maximum_lag + 1,j_pos);
-            end;
-        end;
+            end
+        end
         past_val = past_val + length(time_index_constraint);
         if t < constrained_periods
             endo(maximum_lag + t,:) = yc;
         else
             endo(maximum_lag + t :maximum_lag + options_cond_fcst.periods ,:) = ycc(:,maximum_lag + 1:maximum_lag + options_cond_fcst.periods - constrained_periods + 1)';
-        end;
+        end
         initial_conditions = yc;
         if maximum_lag > 0
             exo_init(1,:) = exo(maximum_lag + t,:);
-        end;
-    end;
-end;
+        end
+    end
+end
 options_.periods = save_options_periods;
 options_.dynatol.f = save_options_dynatol_f;
 options_.initval_file = save_options_initval_file;
@@ -919,4 +922,4 @@ oo_.endo_simul = endo';
 oo_.exo_simul = exo;
 if direct_mode
     data_set = dseries([endo(2:end,1:M_.orig_endo_nbr) exo(2:end,:)], total_periods(1), {plan.endo_names{:} plan.exo_names{:}}, {plan.endo_names{:} plan.exo_names{:}});
-end;
+end
diff --git a/matlab/perfect-foresight-models/linear_approximation_accuracy.m b/matlab/perfect-foresight-models/linear_approximation_accuracy.m
index e3f9eb521..289997176 100644
--- a/matlab/perfect-foresight-models/linear_approximation_accuracy.m
+++ b/matlab/perfect-foresight-models/linear_approximation_accuracy.m
@@ -2,15 +2,15 @@ function err = linear_approximation_accuracy(options_, M_, oo_)
 % Evaluates the accuracy of the linear approximation when solving perfect foresight models, by
 % reporting the max absolute value of the dynamic residuals.
 %
-% INPUTS 
+% INPUTS
 % - options_ [struct] contains various options.
 % - M_       [struct] contains a description of the model.
 % - oo_      [struct] contains results.
 %
-% OUTPUTS 
+% OUTPUTS
 % - err      [double] n*1 vector, evaluation of the accuracy (n is the number of equations).
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/perfect-foresight-models/linear_perfect_foresight_problem.m b/matlab/perfect-foresight-models/linear_perfect_foresight_problem.m
index 306960b4c..78d9fed41 100644
--- a/matlab/perfect-foresight-models/linear_perfect_foresight_problem.m
+++ b/matlab/perfect-foresight-models/linear_perfect_foresight_problem.m
@@ -1,11 +1,11 @@
-function [residuals,JJacobian] = perfect_foresight_problem(y, dynamicjacobian, Y0, YT, ...
-                                           exo_simul, params, steady_state, ...
-                                           maximum_lag, T, ny, i_cols, ...
-                                           i_cols_J1, i_cols_1, i_cols_T, ...
-                                           i_cols_j,nnzJ,jendo,jexog)
+function [residuals,JJacobian] = linear_perfect_foresight_problem(y, dynamicjacobian, Y0, YT, ...
+                                                  exo_simul, params, steady_state, ...
+                                                  maximum_lag, T, ny, i_cols, ...
+                                                  i_cols_J1, i_cols_1, i_cols_T, ...
+                                                  i_cols_j,nnzJ,jendo,jexog)
 % function [residuals,JJacobian] = perfect_foresight_problem(x, model_dynamic, Y0, YT,exo_simul,
 % params, steady_state, maximum_lag, periods, ny, i_cols,i_cols_J1, i_cols_1,
-% i_cols_T, i_cols_j, nnzA) 
+% i_cols_T, i_cols_j, nnzA)
 % computes the residuals and th Jacobian matrix
 % for a perfect foresight problem over T periods.
 %
@@ -19,7 +19,7 @@ function [residuals,JJacobian] = perfect_foresight_problem(y, dynamicjacobian, Y
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/perfect-foresight-models/make_ex_.m b/matlab/perfect-foresight-models/make_ex_.m
index 73ab28f43..4f7259048 100644
--- a/matlab/perfect-foresight-models/make_ex_.m
+++ b/matlab/perfect-foresight-models/make_ex_.m
@@ -5,16 +5,16 @@ function oo_=make_ex_(M_,options_,oo_)
 %   M_:           Dynare model structure
 %   options_:     Dynare options structure
 %   oo_:          Dynare results structure
-%    
+%
 % OUTPUTS
 %   oo_:          Dynare results structure
 %
 % ALGORITHM
-%   
+%
 % SPECIAL REQUIREMENTS
-%  
+%
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -53,7 +53,7 @@ else
     else
         error('histval and endval cannot be used simultaneously')
     end
-end    
+end
 
 % Initialize oo_.exo_det_simul
 if M_.exo_det_nbr > 0
diff --git a/matlab/perfect-foresight-models/make_y_.m b/matlab/perfect-foresight-models/make_y_.m
index f3c8f686f..e96333825 100644
--- a/matlab/perfect-foresight-models/make_y_.m
+++ b/matlab/perfect-foresight-models/make_y_.m
@@ -1,22 +1,22 @@
 function oo_=make_y_(M_,options_,oo_)
 % function oo_=make_y_(M_,options_,oo_)
 % forms oo_.endo_simul as guess values for deterministic simulations
-%  
+%
 % INPUTS
 %   M_:           Dynare model structure
 %   options_:     Dynare options structure
 %   oo_:          Dynare results structure
-%    
+%
 % OUTPUTS
 %   oo_:          Dynare results structure
-% 
+%
 % ALGORITHM
 %   ...
 % SPECIAL REQUIREMENTS
 %   none
-%  
+%
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,7 +33,7 @@ function oo_=make_y_(M_,options_,oo_)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-global ys0_ 
+global ys0_
 
 if options_.steadystate_flag
     [oo_.steady_state,M_.params,check] = ...
diff --git a/matlab/perfect-foresight-models/perfect_foresight_mcp_problem.m b/matlab/perfect-foresight-models/perfect_foresight_mcp_problem.m
index d4b419308..eb898322d 100644
--- a/matlab/perfect-foresight-models/perfect_foresight_mcp_problem.m
+++ b/matlab/perfect-foresight-models/perfect_foresight_mcp_problem.m
@@ -1,8 +1,8 @@
 function [residuals,JJacobian] = perfect_foresight_mcp_problem(y, dynamic_function, Y0, YT, ...
-                                           exo_simul, params, steady_state, ...
-                                           maximum_lag, T, ny, i_cols, ...
-                                           i_cols_J1, i_cols_1, i_cols_T, ...
-                                           i_cols_j,nnzJ,eq_index)
+                                                  exo_simul, params, steady_state, ...
+                                                  maximum_lag, T, ny, i_cols, ...
+                                                  i_cols_J1, i_cols_1, i_cols_T, ...
+                                                  i_cols_j,nnzJ,eq_index)
 % function [residuals,JJacobian] = perfect_foresight_mcp_problem(y, dynamic_function, Y0, YT, ...
 %                                            exo_simul, params, steady_state, ...
 %                                            maximum_lag, T, ny, i_cols, ...
@@ -17,7 +17,7 @@ function [residuals,JJacobian] = perfect_foresight_mcp_problem(y, dynamic_functi
 %   Y0                  [double] N*1 array, initial conditions for the endogenous variables
 %   YT                  [double] N*1 array, terminal conditions for the endogenous variables
 %   exo_simul           [double] nperiods*M_.exo_nbr matrix of exogenous variables (in declaration order)
-%                                for all simulation periods           
+%                                for all simulation periods
 %   params              [double] nparams*1 array, parameter values
 %   steady_state        [double] endo_nbr*1 vector of steady state values
 %   maximum_lag         [scalar] maximum lag present in the model
@@ -25,7 +25,7 @@ function [residuals,JJacobian] = perfect_foresight_mcp_problem(y, dynamic_functi
 %   ny                  [scalar] number of endogenous variables
 %   i_cols              [double] indices of variables appearing in M.lead_lag_incidence
 %                                and that need to be passed to _dynamic-file
-%   i_cols_J1           [double] indices of contemporaneous and forward looking variables 
+%   i_cols_J1           [double] indices of contemporaneous and forward looking variables
 %                                appearing in M.lead_lag_incidence
 %   i_cols_1            [double] indices of contemporaneous and forward looking variables in
 %                                M.lead_lag_incidence in dynamic Jacobian (relevant in first period)
@@ -33,8 +33,8 @@ function [residuals,JJacobian] = perfect_foresight_mcp_problem(y, dynamic_functi
 %                                variables (relevant in last period)
 %   i_cols_j            [double] indices of variables in M.lead_lag_incidence
 %                                in dynamic Jacobian (relevant in intermediate periods)
-%   nnzJ                [scalar] number of non-zero elements in Jacobian                                
-%   eq_index            [double] N*1 array, index vector describing residual mapping resulting 
+%   nnzJ                [scalar] number of non-zero elements in Jacobian
+%   eq_index            [double] N*1 array, index vector describing residual mapping resulting
 %                                from complementarity setup
 % OUTPUTS
 %   residuals           [double] (N*T)*1 array, residuals of the stacked problem
@@ -45,7 +45,7 @@ function [residuals,JJacobian] = perfect_foresight_mcp_problem(y, dynamic_functi
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -77,11 +77,11 @@ i_cols_J = i_cols;
 for it = 2:(T+1)
     if nargout == 1
         res = dynamic_function(YY(i_cols),exo_simul, params, ...
-            steady_state,it);
+                               steady_state,it);
         residuals(i_rows) = res(eq_index);
     elseif nargout == 2
         [res,jacobian] = dynamic_function(YY(i_cols),exo_simul, params, ...
-            steady_state,it);
+                                          steady_state,it);
         residuals(i_rows) = res(eq_index);
         if it == 2
             [rows,cols,vals] = find(jacobian(eq_index,i_cols_1));
@@ -96,7 +96,7 @@ for it = 2:(T+1)
         end
         offset = offset + ny;
     end
-    
+
     i_rows = i_rows + ny;
     i_cols = i_cols + ny;
 end
@@ -104,5 +104,5 @@ end
 if nargout == 2
     iJacobian = cat(1,iJacobian{:});
     JJacobian = sparse(iJacobian(:,1),iJacobian(:,2),iJacobian(:,3),T* ...
-        ny,T*ny);
+                       ny,T*ny);
 end
\ No newline at end of file
diff --git a/matlab/perfect-foresight-models/perfect_foresight_problem.m b/matlab/perfect-foresight-models/perfect_foresight_problem.m
index 956119094..a4df03f80 100644
--- a/matlab/perfect-foresight-models/perfect_foresight_problem.m
+++ b/matlab/perfect-foresight-models/perfect_foresight_problem.m
@@ -1,8 +1,8 @@
 function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function, Y0, YT, ...
-                                           exo_simul, params, steady_state, ...
-                                           maximum_lag, T, ny, i_cols, ...
-                                           i_cols_J1, i_cols_1, i_cols_T, ...
-                                           i_cols_j,nnzJ)
+                                                  exo_simul, params, steady_state, ...
+                                                  maximum_lag, T, ny, i_cols, ...
+                                                  i_cols_J1, i_cols_1, i_cols_T, ...
+                                                  i_cols_j,nnzJ)
 % function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function, Y0, YT, ...
 %                                            exo_simul, params, steady_state, ...
 %                                            maximum_lag, T, ny, i_cols, ...
@@ -16,7 +16,7 @@ function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function,
 %   Y0                  [double] N*1 array, initial conditions for the endogenous variables
 %   YT                  [double] N*1 array, terminal conditions for the endogenous variables
 %   exo_simul           [double] nperiods*M_.exo_nbr matrix of exogenous variables (in declaration order)
-%                                for all simulation periods           
+%                                for all simulation periods
 %   params              [double] nparams*1 array, parameter values
 %   steady_state        [double] endo_nbr*1 vector of steady state values
 %   maximum_lag         [scalar] maximum lag present in the model
@@ -24,7 +24,7 @@ function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function,
 %   ny                  [scalar] number of endogenous variables
 %   i_cols              [double] indices of variables appearing in M.lead_lag_incidence
 %                                and that need to be passed to _dynamic-file
-%   i_cols_J1           [double] indices of contemporaneous and forward looking variables 
+%   i_cols_J1           [double] indices of contemporaneous and forward looking variables
 %                                appearing in M.lead_lag_incidence
 %   i_cols_1            [double] indices of contemporaneous and forward looking variables in
 %                                M.lead_lag_incidence in dynamic Jacobian (relevant in first period)
@@ -32,7 +32,7 @@ function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function,
 %                                variables (relevant in last period)
 %   i_cols_j            [double] indices of variables in M.lead_lag_incidence
 %                                in dynamic Jacobian (relevant in intermediate periods)
-%   nnzJ                [scalar] number of non-zero elements in Jacobian                                
+%   nnzJ                [scalar] number of non-zero elements in Jacobian
 % OUTPUTS
 %   residuals           [double] (N*T)*1 array, residuals of the stacked problem
 %   JJacobian           [double] (N*T)*(N*T) array, Jacobian of the stacked problem
@@ -42,7 +42,7 @@ function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function,
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -60,44 +60,44 @@ function [residuals,JJacobian] = perfect_foresight_problem(y, dynamic_function,
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 
-    YY = [Y0; y; YT];
-    
-    residuals = zeros(T*ny,1);
-    if nargout == 2
-        iJacobian = cell(T,1);
-    end
+YY = [Y0; y; YT];
 
-    i_rows = 1:ny;
-    i_cols_J = i_cols;
-    offset = 0;
-    
-    for it = 2:(T+1)
-        if nargout == 1
-             residuals(i_rows) = dynamic_function(YY(i_cols),exo_simul, params, ...
-                                                         steady_state,it);
-        elseif nargout == 2
-            [residuals(i_rows),jacobian] = dynamic_function(YY(i_cols),exo_simul, params, ...
-                                                         steady_state,it);
-            if it == 2
-                [rows,cols,vals] = find(jacobian(:,i_cols_1));
-                iJacobian{1} = [offset+rows, i_cols_J1(cols), vals];
-            elseif it == T + 1
-                [rows,cols,vals] = find(jacobian(:,i_cols_T));
-                iJacobian{T} = [offset+rows, i_cols_J(i_cols_T(cols)), vals];
-            else
-                [rows,cols,vals] = find(jacobian(:,i_cols_j));
-                iJacobian{it-1} = [offset+rows, i_cols_J(cols), vals];
-                i_cols_J = i_cols_J + ny;
-            end
-            offset = offset + ny;
+residuals = zeros(T*ny,1);
+if nargout == 2
+    iJacobian = cell(T,1);
+end
+
+i_rows = 1:ny;
+i_cols_J = i_cols;
+offset = 0;
+
+for it = 2:(T+1)
+    if nargout == 1
+        residuals(i_rows) = dynamic_function(YY(i_cols),exo_simul, params, ...
+                                             steady_state,it);
+    elseif nargout == 2
+        [residuals(i_rows),jacobian] = dynamic_function(YY(i_cols),exo_simul, params, ...
+                                                        steady_state,it);
+        if it == 2
+            [rows,cols,vals] = find(jacobian(:,i_cols_1));
+            iJacobian{1} = [offset+rows, i_cols_J1(cols), vals];
+        elseif it == T + 1
+            [rows,cols,vals] = find(jacobian(:,i_cols_T));
+            iJacobian{T} = [offset+rows, i_cols_J(i_cols_T(cols)), vals];
+        else
+            [rows,cols,vals] = find(jacobian(:,i_cols_j));
+            iJacobian{it-1} = [offset+rows, i_cols_J(cols), vals];
+            i_cols_J = i_cols_J + ny;
         end
-
-        i_rows = i_rows + ny;
-        i_cols = i_cols + ny;
+        offset = offset + ny;
     end
 
-    if nargout == 2
-        iJacobian = cat(1,iJacobian{:});
-        JJacobian = sparse(iJacobian(:,1),iJacobian(:,2),iJacobian(:,3),T* ...
-                           ny,T*ny);
-    end
\ No newline at end of file
+    i_rows = i_rows + ny;
+    i_cols = i_cols + ny;
+end
+
+if nargout == 2
+    iJacobian = cat(1,iJacobian{:});
+    JJacobian = sparse(iJacobian(:,1),iJacobian(:,2),iJacobian(:,3),T* ...
+                       ny,T*ny);
+end
\ No newline at end of file
diff --git a/matlab/perfect-foresight-models/perfect_foresight_setup.m b/matlab/perfect-foresight-models/perfect_foresight_setup.m
index 3b2825432..341d70aad 100644
--- a/matlab/perfect-foresight-models/perfect_foresight_setup.m
+++ b/matlab/perfect-foresight-models/perfect_foresight_setup.m
@@ -1,18 +1,18 @@
 function perfect_foresight_setup()
 % Prepares a deterministic simulation, by filling oo_.exo_simul and oo_.endo_simul
-%  
+%
 % INPUTS
 %   None
-%  
+%
 % OUTPUTS
 %   none
-%    
+%
 % ALGORITHM
-%   
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -35,14 +35,14 @@ test_for_deep_parameters_calibration(M_);
 
 if size(M_.lead_lag_incidence,2)-nnz(M_.lead_lag_incidence(M_.maximum_endo_lag+1,:)) > 0
     mess = ['PERFECT_FORESIGHT_SETUP: error in model specification : the variable(s) '];
-        var_list=M_.endo_names(find(M_.lead_lag_incidence(M_.maximum_lag+1,:)==0),:);
-        for i=1:size(var_list,1)
-            if i<size(var_list,1)
-                mess = [mess, deblank(var_list(i,:)) ', '];
-            else
-                mess = [mess, deblank(var_list(i,:)) ];
-            end
+    var_list=M_.endo_names(find(M_.lead_lag_incidence(M_.maximum_lag+1,:)==0),:);
+    for i=1:size(var_list,1)
+        if i<size(var_list,1)
+            mess = [mess, deblank(var_list(i,:)) ', '];
+        else
+            mess = [mess, deblank(var_list(i,:)) ];
         end
+    end
     mess = [mess ' don''t appear as current period variables.'];
     error(mess)
 end
diff --git a/matlab/perfect-foresight-models/perfect_foresight_simulation.m b/matlab/perfect-foresight-models/perfect_foresight_simulation.m
index ffef743ed..15f1b8b76 100644
--- a/matlab/perfect-foresight-models/perfect_foresight_simulation.m
+++ b/matlab/perfect-foresight-models/perfect_foresight_simulation.m
@@ -18,7 +18,7 @@ function info = perfect_foresight_simulation(compute_linear_solution,steady_stat
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2015 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/perfect-foresight-models/perfect_foresight_solver.m b/matlab/perfect-foresight-models/perfect_foresight_solver.m
index b5fc7e4f2..8e7c3bcbc 100644
--- a/matlab/perfect-foresight-models/perfect_foresight_solver.m
+++ b/matlab/perfect-foresight-models/perfect_foresight_solver.m
@@ -12,7 +12,7 @@ function perfect_foresight_solver()
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -184,20 +184,20 @@ if ~isreal(oo_.endo_simul(:)) %can only happen without bytecode
     [i_cols_J1,junk,i_cols_1] = find(illi(:));
     i_cols_T = nonzeros(M_.lead_lag_incidence(1:2,:)');
     residuals = perfect_foresight_problem(yy(:),str2func([M_.fname '_dynamic']), y0, yT, ...
-                                      oo_.exo_simul,M_.params,oo_.steady_state, ...
-                                      M_.maximum_lag,options_.periods,M_.endo_nbr,i_cols, ...
-                                      i_cols_J1, i_cols_1, i_cols_T, i_cols_j, ...
-                                      M_.NNZDerivatives(1));
+                                          oo_.exo_simul,M_.params,oo_.steady_state, ...
+                                          M_.maximum_lag,options_.periods,M_.endo_nbr,i_cols, ...
+                                          i_cols_J1, i_cols_1, i_cols_T, i_cols_j, ...
+                                          M_.NNZDerivatives(1));
     if max(abs(residuals))< options_.dynatol.f
         oo_.deterministic_simulation.status = 1;
         oo_.endo_simul=real(oo_.endo_simul);
     else
-        oo_.deterministic_simulation.status = 0; 
+        oo_.deterministic_simulation.status = 0;
         disp('Simulation terminated with imaginary parts in the residuals or endogenous variables.')
-    end            
+    end
 end
 
-if oo_.deterministic_simulation.status == 1 
+if oo_.deterministic_simulation.status == 1
     disp('Perfect foresight solution found.')
 else
     disp('Failed to solve perfect foresight model')
diff --git a/matlab/perfect-foresight-models/perfect_foresight_solver_core.m b/matlab/perfect-foresight-models/perfect_foresight_solver_core.m
index da267b7da..272cd3833 100644
--- a/matlab/perfect-foresight-models/perfect_foresight_solver_core.m
+++ b/matlab/perfect-foresight-models/perfect_foresight_solver_core.m
@@ -2,16 +2,16 @@ function [oo_, maxerror] = perfect_foresight_solver_core(M_, options_, oo_)
 %function [oo_, maxerror] = perfect_foresight_solver_core(M_, options_, oo_)
 % Core function calling solvers for perfect foresight model
 %
-% INPUTS 
+% INPUTS
 % - M_                  [struct] contains a description of the model.
 % - options_            [struct] contains various options.
 % - oo_                 [struct] contains results
 %
-% OUTPUTS 
+% OUTPUTS
 % - oo_                 [struct] contains results
 % - maxerror            [double] contains the maximum absolute error
 
-% Copyright (C) 2015-2016 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -81,8 +81,8 @@ else
             [oo_.endo_simul, oo_.deterministic_simulation] = ...
                 sim1_purely_backward(oo_.endo_simul, oo_.exo_simul, oo_.steady_state, M_, options_);
         elseif M_.maximum_endo_lag == 0 % Purely forward model
-            [oo_.endo_simul, oo_.deterministic_simulation] = ...
-                sim1_purely_forward(oo_.endo_simul, oo_.exo_simul, oo_.steady_state, M_, options_);
+        [oo_.endo_simul, oo_.deterministic_simulation] = ...
+            sim1_purely_forward(oo_.endo_simul, oo_.exo_simul, oo_.steady_state, M_, options_);
         else % General case
             switch options_.stack_solve_algo
               case 0
@@ -143,5 +143,3 @@ if nargout>1
         maxerror = max(max(abs(residuals)));
     end
 end
-
-
diff --git a/matlab/perfect-foresight-models/private/check_input_arguments.m b/matlab/perfect-foresight-models/private/check_input_arguments.m
index affb808e0..fc50114d0 100644
--- a/matlab/perfect-foresight-models/private/check_input_arguments.m
+++ b/matlab/perfect-foresight-models/private/check_input_arguments.m
@@ -3,7 +3,7 @@ function check_input_arguments(DynareOptions, DynareModel, DynareResults)
 %Conducts checks for inconsistent/missing inputs to deterministic
 %simulations
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,7 +43,7 @@ end
 
 
 if isempty(DynareResults.endo_simul) || any(size(DynareResults.endo_simul) ~= [ DynareModel.endo_nbr, DynareModel.maximum_lag+DynareOptions.periods+DynareModel.maximum_lead ])
-    
+
     if DynareOptions.initval_file
         fprintf('PERFECT_FORESIGHT_SOLVER: ''oo_.endo_simul'' has wrong size. Check whether your initval-file provides %d periods.',DynareModel.maximum_endo_lag+DynareOptions.periods+DynareModel.maximum_endo_lead)
         error('perfect_foresight_solver:ArgCheck','PERFECT_FORESIGHT_SOLVER: ''oo_.endo_simul'' has wrong size. Did you run ''perfect_foresight_setup'' ?')
diff --git a/matlab/perfect-foresight-models/private/initialize_stacked_problem.m b/matlab/perfect-foresight-models/private/initialize_stacked_problem.m
index 64beba34e..014bb9acb 100644
--- a/matlab/perfect-foresight-models/private/initialize_stacked_problem.m
+++ b/matlab/perfect-foresight-models/private/initialize_stacked_problem.m
@@ -4,19 +4,19 @@ function [options, y0, yT, z, i_cols, i_cols_J1, i_cols_T, i_cols_j, i_cols_1, .
 %           dynamicmodel] = initialize_stacked_problem(endogenousvariables, options, M, steadystate_y)
 % Sets up the stacked perfect foresight problem for use with dynare_solve.m
 %
-% INPUTS 
+% INPUTS
 % - endogenousvariables [double] N*T array, paths for the endogenous variables (initial guess).
 % - options             [struct] contains various options.
 % - M                   [struct] contains a description of the model.
 % - steadystate_y       [double] N*1 array, steady state for the endogenous variables.
-% OUTPUTS 
+% OUTPUTS
 % - options             [struct] contains various options.
 % - y0                  [double] N*1 array, initial conditions for the endogenous variables
 % - yT                  [double] N*1 array, terminal conditions for the endogenous variables
 % - z                   [double] T*M array, paths for the exogenous variables.
 % - i_cols              [double] indices of variables appearing in M.lead_lag_incidence
 %                                and that need to be passed to _dynamic-file
-% - i_cols_J1           [double] indices of contemporaneous and forward looking variables 
+% - i_cols_J1           [double] indices of contemporaneous and forward looking variables
 %                                appearing in M.lead_lag_incidence
 % - i_cols_T            [double] columns of dynamic Jacobian related to
 %                                contemporaneous and backward-looking
@@ -27,7 +27,7 @@ function [options, y0, yT, z, i_cols, i_cols_J1, i_cols_T, i_cols_j, i_cols_1, .
 %                                M.lead_lag_incidence in dynamic Jacobian (relevant in first period)
 % - dynamicmodel        [handle] function handle to _dynamic-file
 
-% Copyright (C) 2015-16 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,7 +43,7 @@ function [options, y0, yT, z, i_cols, i_cols_J1, i_cols_T, i_cols_j, i_cols_1, .
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 periods = options.periods;
 if (options.solve_algo == 10)
     if ~isfield(options.lmmcp,'lb')
diff --git a/matlab/perfect-foresight-models/private/simulation_core.m b/matlab/perfect-foresight-models/private/simulation_core.m
index b52ecad17..0c944c2a6 100644
--- a/matlab/perfect-foresight-models/private/simulation_core.m
+++ b/matlab/perfect-foresight-models/private/simulation_core.m
@@ -1,7 +1,7 @@
 function [oo_, maxerror] = simulation_core(options_, M_, oo_)
 %function [oo_, maxerror] = simulation_core(options_, M_, oo_)
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -66,8 +66,8 @@ else
             [oo_.endo_simul, oo_.deterministic_simulation] = ...
                 sim1_purely_backward(oo_.endo_simul, oo_.exo_simul, oo_.steady_state, M_, options_);
         elseif M_.maximum_endo_lag == 0 % Purely forward model
-            [oo_.endo_simul, oo_.deterministic_simulation] = ...
-                sim1_purely_forward(oo_.endo_simul, oo_.exo_simul, oo_.steady_state, M_, options_);
+        [oo_.endo_simul, oo_.deterministic_simulation] = ...
+            sim1_purely_forward(oo_.endo_simul, oo_.exo_simul, oo_.steady_state, M_, options_);
         else % General case
             if options_.stack_solve_algo == 0
                 if options_.linear_approximation
diff --git a/matlab/perfect-foresight-models/sim1.m b/matlab/perfect-foresight-models/sim1.m
index 05ef5b186..b8d09a808 100644
--- a/matlab/perfect-foresight-models/sim1.m
+++ b/matlab/perfect-foresight-models/sim1.m
@@ -17,7 +17,7 @@ function [endogenousvariables, info] = sim1(endogenousvariables, exogenousvariab
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -154,17 +154,22 @@ for iter = 1:options.simul.maxit
     if endogenous_terminal_period && iter>1
         dy = ZERO;
         if options.simul.robust_lin_solve
-            dy(1:i_rows(end)) = -lin_solve_robust( A(1:i_rows(end),1:i_rows(end)), res(1:i_rows(end)),verbose );            
+            dy(1:i_rows(end)) = -lin_solve_robust( A(1:i_rows(end),1:i_rows(end)), res(1:i_rows(end)),verbose );
         else
             dy(1:i_rows(end)) = -lin_solve( A(1:i_rows(end),1:i_rows(end)), res(1:i_rows(end)), verbose );
         end
     else
         if options.simul.robust_lin_solve
-            dy = -lin_solve_robust( A, res, verbose );            
+            dy = -lin_solve_robust( A, res, verbose );
         else
             dy = -lin_solve( A, res, verbose );
         end
     end
+    if any(~isreal(dy)) || any(isnan(dy)) || any(isinf(dy))
+        if verbose
+            display_critical_variables(reshape(dy,[ny periods])', M);
+        end
+    end
     Y(i_upd) = Y(i_upd) + dy;
 end
 
@@ -184,7 +189,12 @@ if stop
         if verbose
             skipline()
             disp(sprintf('Total time of simulation: %s.', num2str(etime(clock,h1))))
-            disp('Simulation terminated with NaN or Inf in the residuals or endogenous variables.')
+            if ~isreal(res) || ~isreal(Y)
+                disp('Simulation terminated with imaginary parts in the residuals or endogenous variables.')
+            else
+                disp('Simulation terminated with NaN or Inf in the residuals or endogenous variables.')
+            end
+            display_critical_variables(reshape(dy,[ny periods])', M);
             disp('There is most likely something wrong with your model. Try model_diagnostics or another simulation method.')
             printline(105)
         end
@@ -218,82 +228,106 @@ if verbose
 end
 
 function x = lin_solve( A, b,verbose)
-    if norm( b ) < sqrt( eps ) % then x = 0 is a solution
-        x = 0;
-        return
-    end
-    
-    x = A\b;
-    x( ~isfinite( x ) ) = 0;
-    relres = norm( b - A * x ) / norm( b );
-    if relres > 1e-6 && verbose
-        fprintf( 'WARNING : Failed to find a solution to the linear system.\n' );
-    end
-    
+if norm( b ) < sqrt( eps ) % then x = 0 is a solution
+    x = 0;
+    return
+end
+
+x = A\b;
+x( ~isfinite( x ) ) = 0;
+relres = norm( b - A * x ) / norm( b );
+if relres > 1e-6 && verbose
+    fprintf( 'WARNING : Failed to find a solution to the linear system.\n' );
+end
+
 function [ x, flag, relres ] = lin_solve_robust( A, b , verbose)
-    if norm( b ) < sqrt( eps ) % then x = 0 is a solution
-        x = 0;
-        flag = 0;
-        relres = 0;
-        return
-    end
-    
-    x = A\b;
-    x( ~isfinite( x ) ) = 0;
-    [ x, flag, relres ] = bicgstab( A, b, [], [], [], [], x ); % returns immediately if x is a solution
-    if flag == 0
-        return
-    end
+if norm( b ) < sqrt( eps ) % then x = 0 is a solution
+    x = 0;
+    flag = 0;
+    relres = 0;
+    return
+end
 
-    disp( relres );
+x = A\b;
+x( ~isfinite( x ) ) = 0;
+[ x, flag, relres ] = bicgstab( A, b, [], [], [], [], x ); % returns immediately if x is a solution
+if flag == 0
+    return
+end
 
-    if verbose
-        fprintf( 'Initial bicgstab failed, trying alternative start point.\n' );
-    end
-    old_x = x;
-    old_relres = relres;
-    [ x, flag, relres ] = bicgstab( A, b );
-    if flag == 0
-        return
-    end
+disp( relres );
 
-    if verbose
-        fprintf( 'Alternative start point also failed with bicgstab, trying gmres.\n' );
-    end
-    if old_relres < relres
-        x = old_x;
-    end
-    [ x, flag, relres ] = gmres( A, b, [], [], [], [], [], x );
-    if flag == 0
-        return
-    end
+if verbose
+    fprintf( 'Initial bicgstab failed, trying alternative start point.\n' );
+end
+old_x = x;
+old_relres = relres;
+[ x, flag, relres ] = bicgstab( A, b );
+if flag == 0
+    return
+end
 
-    if verbose
-        fprintf( 'Initial gmres failed, trying alternative start point.\n' );
-    end
-    old_x = x;
-    old_relres = relres;
-    [ x, flag, relres ] = gmres( A, b );
-    if flag == 0
-        return
-    end
+if verbose
+    fprintf( 'Alternative start point also failed with bicgstab, trying gmres.\n' );
+end
+if old_relres < relres
+    x = old_x;
+end
+[ x, flag, relres ] = gmres( A, b, [], [], [], [], [], x );
+if flag == 0
+    return
+end
 
-    if verbose
-        fprintf( 'Alternative start point also failed with gmres, using the (SLOW) Moore-Penrose Pseudo-Inverse.\n' );
-    end
-    if old_relres < relres
-        x = old_x;
-        relres = old_relres;
-    end
-    old_x = x;
-    old_relres = relres;
-    x = pinv( full( A ) ) * b;
-    relres = norm( b - A * x ) / norm( b );
-    if old_relres < relres
-        x = old_x;
-        relres = old_relres;
-    end
-    flag = relres > 1e-6;
-    if flag ~= 0 && verbose
-        fprintf( 'WARNING : Failed to find a solution to the linear system\n' );
-    end
\ No newline at end of file
+if verbose
+    fprintf( 'Initial gmres failed, trying alternative start point.\n' );
+end
+old_x = x;
+old_relres = relres;
+[ x, flag, relres ] = gmres( A, b );
+if flag == 0
+    return
+end
+
+if verbose
+    fprintf( 'Alternative start point also failed with gmres, using the (SLOW) Moore-Penrose Pseudo-Inverse.\n' );
+end
+if old_relres < relres
+    x = old_x;
+    relres = old_relres;
+end
+old_x = x;
+old_relres = relres;
+x = pinv( full( A ) ) * b;
+relres = norm( b - A * x ) / norm( b );
+if old_relres < relres
+    x = old_x;
+    relres = old_relres;
+end
+flag = relres > 1e-6;
+if flag ~= 0 && verbose
+    fprintf( 'WARNING : Failed to find a solution to the linear system\n' );
+end
+
+function display_critical_variables(dyy, M)
+
+if any(isnan(dyy))
+    indx = find(any(isnan(dyy)));
+    endo_names=cellstr(M.endo_names(indx,:));
+    disp('Last iteration provided NaN for the following variables:')
+    fprintf('%s, ',endo_names{:}),
+    fprintf('\n'),
+end
+if any(isinf(dyy))
+    indx = find(any(isinf(dyy)));
+    endo_names=cellstr(M.endo_names(indx,:));
+    disp('Last iteration diverged (Inf) for the following variables:')
+    fprintf('%s, ',endo_names{:}),
+    fprintf('\n'),
+end
+if any(~isreal(dyy))
+    indx = find(any(~isreal(dyy)));
+    endo_names=cellstr(M.endo_names(indx,:));
+    disp('Last iteration provided complex number for the following variables:')
+    fprintf('%s, ',endo_names{:}),
+    fprintf('\n'),
+end
diff --git a/matlab/perfect-foresight-models/sim1_lbj.m b/matlab/perfect-foresight-models/sim1_lbj.m
index d4d8c24f2..a9b585907 100644
--- a/matlab/perfect-foresight-models/sim1_lbj.m
+++ b/matlab/perfect-foresight-models/sim1_lbj.m
@@ -15,7 +15,7 @@ function [endogenousvariables, info] = sim1_lbj(endogenousvariables, exogenousva
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 1996-2015 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -122,7 +122,7 @@ if ~stop
     end
     info.status = 0;% more iterations are needed.
     info.error = err;
-    info.errors = c/abs(err);    
+    info.errors = c/abs(err);
     info.iterations = options.simul.maxit;
 end
 
diff --git a/matlab/perfect-foresight-models/sim1_linear.m b/matlab/perfect-foresight-models/sim1_linear.m
index 6820c92bc..85dc38405 100644
--- a/matlab/perfect-foresight-models/sim1_linear.m
+++ b/matlab/perfect-foresight-models/sim1_linear.m
@@ -2,7 +2,7 @@ function [endogenousvariables, info] = sim1_linear(endogenousvariables, exogenou
 
 % Solves a linear approximation of a perfect foresight model using sparse matrix.
 %
-% INPUTS 
+% INPUTS
 % - endogenousvariables [double] N*T array, paths for the endogenous variables (initial guess).
 % - exogenousvariables  [double] T*M array, paths for the exogenous variables.
 % - steadystate_y       [double] N*1 array, steady state for the endogenous variables.
@@ -10,16 +10,16 @@ function [endogenousvariables, info] = sim1_linear(endogenousvariables, exogenou
 % - M                   [struct] contains a description of the model.
 % - options             [struct] contains various options.
 %
-% OUTPUTS 
+% OUTPUTS
 % - endogenousvariables [double] N*T array, paths for the endogenous variables (solution of the perfect foresight model).
 % - info                [struct] contains informations about the results.
 %
-% NOTATIONS 
+% NOTATIONS
 % - N is the number of endogenous variables.
 % - M is the number of innovations.
 % - T is the number of periods (including initial and/or terminal conditions).
 %
-% REMARKS 
+% REMARKS
 % - The structure `M` describing the structure of the model, must contain the
 % following informations:
 %  + lead_lag_incidence, incidence matrix (given by the preprocessor).
@@ -38,7 +38,7 @@ function [endogenousvariables, info] = sim1_linear(endogenousvariables, exogenou
 % to center the variables around the deterministic steady state to solve the
 % perfect foresight model.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/perfect-foresight-models/sim1_purely_backward.m b/matlab/perfect-foresight-models/sim1_purely_backward.m
index abc871a68..a2ec8db13 100644
--- a/matlab/perfect-foresight-models/sim1_purely_backward.m
+++ b/matlab/perfect-foresight-models/sim1_purely_backward.m
@@ -2,7 +2,7 @@ function [endogenousvariables, info] = sim1_purely_backward(endogenousvariables,
 
 % Performs deterministic simulation of a purely backward model
 
-% Copyright (C) 2012-2015 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,12 +28,12 @@ else
     nyb = 0;
     iyb = [];
 end
-        
+
 
 if ny0 ~= M.endo_nbr
     error('All endogenous variables must appear at the current period!')
 end
-    
+
 dynamicmodel = str2func([M.fname,'_dynamic']);
 
 info.status = 1;
diff --git a/matlab/perfect-foresight-models/sim1_purely_forward.m b/matlab/perfect-foresight-models/sim1_purely_forward.m
index ca2b2b5b2..31cd12b77 100644
--- a/matlab/perfect-foresight-models/sim1_purely_forward.m
+++ b/matlab/perfect-foresight-models/sim1_purely_forward.m
@@ -1,7 +1,7 @@
 function [endogenousvariables, info] = sim1_purely_forward(endogenousvariables, exogenousvariables, steadystate, M, options)
 % Performs deterministic simulation of a purely forward model
 
-% Copyright (C) 2012-2015 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -24,7 +24,7 @@ iyf = find(M.lead_lag_incidence(2,:)>0); % Indices of variables at next period
 if ny0 ~= M.endo_nbr
     error('All endogenous variables must appear at the current period!')
 end
-    
+
 dynamicmodel = str2func([M.fname,'_dynamic']);
 
 info.status = 1;
diff --git a/matlab/perfect-foresight-models/solve_stacked_linear_problem.m b/matlab/perfect-foresight-models/solve_stacked_linear_problem.m
index 52a2efe48..5464c9e06 100644
--- a/matlab/perfect-foresight-models/solve_stacked_linear_problem.m
+++ b/matlab/perfect-foresight-models/solve_stacked_linear_problem.m
@@ -1,6 +1,6 @@
 function [endogenousvariables, info] = solve_stacked_linear_problem(endogenousvariables, exogenousvariables, steadystate_y, steadystate_x, M, options)
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,11 +42,11 @@ z = bsxfun(@minus, z, steadystate_y);
 x = bsxfun(@minus, exogenousvariables, steadystate_x');
 
 [y, check] = dynare_solve(@linear_perfect_foresight_problem,z(:), options, ...
-                        jacobian, y0-steadystate_y, yT-steadystate_y, ...
-                        x, M.params, steadystate_y, ...
-                        M.maximum_lag, options.periods, M.endo_nbr, i_cols, ...
-                        i_cols_J1, i_cols_1, i_cols_T, i_cols_j, ...
-                        M.NNZDerivatives(1), jendo, jexog);
+                          jacobian, y0-steadystate_y, yT-steadystate_y, ...
+                          x, M.params, steadystate_y, ...
+                          M.maximum_lag, options.periods, M.endo_nbr, i_cols, ...
+                          i_cols_J1, i_cols_1, i_cols_T, i_cols_j, ...
+                          M.NNZDerivatives(1), jendo, jexog);
 
 if all(imag(y)<.1*options.dynatol.x)
     if ~isreal(y)
diff --git a/matlab/perfect-foresight-models/solve_stacked_problem.m b/matlab/perfect-foresight-models/solve_stacked_problem.m
index 7a1835ba6..dd3bc6363 100644
--- a/matlab/perfect-foresight-models/solve_stacked_problem.m
+++ b/matlab/perfect-foresight-models/solve_stacked_problem.m
@@ -1,19 +1,19 @@
-function [endogenousvariables, info] = solve_stacked_problem(endogenousvariables, exogenousvariables, steadystate, M, options);
+function [endogenousvariables, info] = solve_stacked_problem(endogenousvariables, exogenousvariables, steadystate, M, options)
 % [endogenousvariables, info] = solve_stacked_problem(endogenousvariables, exogenousvariables, steadystate, M, options);
 % Solves the perfect foresight model using dynare_solve
 %
-% INPUTS 
+% INPUTS
 % - endogenousvariables [double] N*T array, paths for the endogenous variables (initial guess).
 % - exogenousvariables  [double] T*M array, paths for the exogenous variables.
 % - steadystate         [double] N*1 array, steady state for the endogenous variables.
 % - M                   [struct] contains a description of the model.
 % - options             [struct] contains various options.
 %
-% OUTPUTS 
+% OUTPUTS
 % - endogenousvariables [double] N*T array, paths for the endogenous variables (solution of the perfect foresight model).
 % - info                [struct] contains informations about the results.
 
-% Copyright (C) 2015-16 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,7 +29,7 @@ function [endogenousvariables, info] = solve_stacked_problem(endogenousvariables
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 [options, y0, yT, z, i_cols, i_cols_J1, i_cols_T, i_cols_j, i_cols_1, dynamicmodel] = ...
     initialize_stacked_problem(endogenousvariables, options, M, steadystate);
 
@@ -74,6 +74,6 @@ endogenousvariables = [y0 reshape(y, M.endo_nbr, options.periods) yT];
 if check
     info.status = false;
 else
-    
+
     info.status = true;
 end
\ No newline at end of file
diff --git a/matlab/plot_icforecast.m b/matlab/plot_icforecast.m
index 62d788414..c4e3c2b2b 100644
--- a/matlab/plot_icforecast.m
+++ b/matlab/plot_icforecast.m
@@ -1,16 +1,16 @@
 function plot_icforecast(Variables,periods,options_)
 % Build plots for the conditional forecasts.
 %
-% INPUTS 
-%  o Variables     [char]        m*x array holding the names of the endogenous variables to be plotted. 
+% INPUTS
+%  o Variables     [char]        m*x array holding the names of the endogenous variables to be plotted.
 %
 % OUTPUTS
 %  None.
-% 
+%
 % SPECIAL REQUIREMENTS
 %  This routine has to be called after imcforecast.m.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -57,7 +57,7 @@ for i=1:size(Variables,1)
 end
 
 function build_figure(name,cci1,cci2,mm1,mm2,options_,graphoptions)
-hh = dyn_figure(options_,'Name',['Conditional forecast (' graphoptions.title ,'): ' name '.']);
+hh = dyn_figure(options_.nodisplay,'Name',['Conditional forecast (' graphoptions.title ,'): ' name '.']);
 H = length(mm1);
 h1 = area(1:H,cci1(2,1:H),'BaseValue',min([min(cci1(1,:)),min(cci2(1,:))]),'FaceColor',[.9 .9 .9]);
 hold on
@@ -68,4 +68,4 @@ plot(1:H,cci2(1,:),'--k','linewidth',1)
 plot(1:H,cci2(2,:),'--k','linewidth',1)
 axis tight
 hold off
-dyn_saveas(hh,[graphoptions.OutputDirectoryName '/Conditional_forecast_',strrep(deblank(graphoptions.title),' ','_'),'_',deblank(name)],options_)
\ No newline at end of file
+dyn_saveas(hh,[graphoptions.OutputDirectoryName '/Conditional_forecast_',strrep(deblank(graphoptions.title),' ','_'),'_',deblank(name)],options_.nodisplay,options_.graph_format)
\ No newline at end of file
diff --git a/matlab/plot_identification.m b/matlab/plot_identification.m
index e24695025..12da56804 100644
--- a/matlab/plot_identification.m
+++ b/matlab/plot_identification.m
@@ -8,18 +8,18 @@ function plot_identification(params,idemoments,idehess,idemodel, idelre, advance
 %    o idemodel           [structure] identification results for the reduced form solution
 %    o idelre             [structure] identification results for the LRE model
 %    o advanced           [integer] flag for advanced identification checks
-%    o tittxt             [char] name of the results to plot 
+%    o tittxt             [char] name of the results to plot
 %    o name               [char] list of names
 %    o IdentifDirectoryName   [char] directory name
-%    o tittxt             [char] TeX-name of the results to plot 
+%    o tittxt             [char] TeX-name of the results to plot
 %    o name_tex           [char] TeX-names of the parameters
 % OUTPUTS
 %    None
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 
-% Copyright (C) 2008-2016 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,8 +41,8 @@ global M_ options_
 if nargin <10 || isempty(tit_TeX)
     tit_TeX=tittxt;
 end
-    
-if nargin <11 
+
+if nargin <11
     name_TeX=name;
 end
 
@@ -58,9 +58,9 @@ siLREnorm = idelre.siLREnorm;
 % end
 tittxt1=regexprep(tittxt, ' ', '_');
 tittxt1=strrep(tittxt1, '.', '');
-if SampleSize == 1,
+if SampleSize == 1
     siJ = idemoments.siJ;
-    hh = dyn_figure(options_,'Name',[tittxt, ' - Identification using info from observables']);
+    hh = dyn_figure(options_.nodisplay,'Name',[tittxt, ' - Identification using info from observables']);
     subplot(211)
     mmm = (idehess.ide_strength_J);
     [ss, is] = sort(mmm);
@@ -72,7 +72,7 @@ if SampleSize == 1,
     set(gca,'xlim',[0 nparam+1])
     set(gca,'xticklabel','')
     dy = get(gca,'ylim');
-    for ip=1:nparam,
+    for ip=1:nparam
         text(ip,dy(1),name{is(ip)},'rotation',90,'HorizontalAlignment','right','interpreter','none')
     end
     if ~all(isnan(idehess.ide_strength_J_prior))
@@ -80,12 +80,12 @@ if SampleSize == 1,
     else
         legend('relative to param value','Location','Best')
     end
-    if  idehess.flag_score,
+    if  idehess.flag_score
         title('Identification strength with asymptotic Information matrix (log-scale)')
     else
         title('Identification strength with moments Information matrix (log-scale)')
     end
-    
+
     subplot(212)
     if ~all(isnan(idehess.deltaM_prior))
         bar(log([idehess.deltaM(is) idehess.deltaM_prior(is)]))
@@ -96,7 +96,7 @@ if SampleSize == 1,
     set(gca,'xlim',[0 nparam+1])
     set(gca,'xticklabel','')
     dy = get(gca,'ylim');
-    for ip=1:nparam,
+    for ip=1:nparam
         text(ip,dy(1),name{is(ip)},'rotation',90,'HorizontalAlignment','right','interpreter','none')
     end
     if ~all(isnan(idehess.deltaM_prior))
@@ -104,7 +104,7 @@ if SampleSize == 1,
     else
         legend('relative to param value','Location','Best')
     end
-    if  idehess.flag_score,
+    if  idehess.flag_score
         title('Sensitivity component with asymptotic Information matrix (log-scale)')
     else
         title('Sensitivity component with moments Information matrix (log-scale)')
@@ -122,17 +122,17 @@ if SampleSize == 1,
         fprintf(fidTeX,'%% End Of TeX file. \n');
         fclose(fidTeX);
     end
-    dyn_saveas(hh,[IdentifDirectoryName '/' M_.fname '_ident_strength_' tittxt1],options_);
-    
-    if advanced,
-        if ~options_.nodisplay,
+    dyn_saveas(hh,[IdentifDirectoryName '/' M_.fname '_ident_strength_' tittxt1],options_.nodisplay,options_.graph_format);
+
+    if advanced
+        if ~options_.nodisplay
             skipline()
             disp('Press ENTER to plot advanced diagnostics'), pause(5),
         end
         if all(isnan([siJnorm';siHnorm';siLREnorm']))
             fprintf('\nIDENTIFICATION: Skipping sensitivity plot, because standard deviation of parameters is NaN, possibly due to the use of ML.\n')
         else
-            hh = dyn_figure(options_,'Name',[tittxt, ' - Sensitivity plot']);
+            hh = dyn_figure(options_.nodisplay,'Name',[tittxt, ' - Sensitivity plot']);
             subplot(211)
             mmm = (siJnorm)'./max(siJnorm);
             mmm1 = (siHnorm)'./max(siHnorm);
@@ -146,12 +146,12 @@ if SampleSize == 1,
             set(gca,'xlim',[0 nparam+1])
             set(gca,'xticklabel','')
             dy = get(gca,'ylim');
-            for ip=1:nparam,
+            for ip=1:nparam
                 text(ip,dy(1),name{is(ip)},'rotation',90,'HorizontalAlignment','right','interpreter','none')
             end
             legend('Moments','Model','LRE model','Location','Best')
             title('Sensitivity bars using derivatives (log-scale)')
-            dyn_saveas(hh,[IdentifDirectoryName '/' M_.fname '_sensitivity_' tittxt1 ],options_);
+            dyn_saveas(hh,[IdentifDirectoryName '/' M_.fname '_sensitivity_' tittxt1 ],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fidTeX = fopen([IdentifDirectoryName '/' M_.fname '_sensitivity_' tittxt1,'.tex'],'w');
                 fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
@@ -167,29 +167,29 @@ if SampleSize == 1,
             end
         end
         % identificaton patterns
-        for  j=1:size(idemoments.cosnJ,2),
+        for  j=1:size(idemoments.cosnJ,2)
             pax=NaN(nparam,nparam);
-%             fprintf('\n')
-%             disp(['Collinearity patterns with ', int2str(j) ,' parameter(s)'])
-%             fprintf('%-15s [%-*s] %10s\n','Parameter',(15+1)*j,' Expl. params ','cosn')
-            for i=1:nparam,
+            %             fprintf('\n')
+            %             disp(['Collinearity patterns with ', int2str(j) ,' parameter(s)'])
+            %             fprintf('%-15s [%-*s] %10s\n','Parameter',(15+1)*j,' Expl. params ','cosn')
+            for i=1:nparam
                 namx='';
-                for in=1:j,
+                for in=1:j
                     dumpindx = idemoments.pars{i,j}(in);
-                    if isnan(dumpindx),
+                    if isnan(dumpindx)
                         namx=[namx ' ' sprintf('%-15s','--')];
                     else
                         namx=[namx ' ' sprintf('%-15s',name{dumpindx})];
                         pax(i,dumpindx)=idemoments.cosnJ(i,j);
                     end
                 end
-%                 fprintf('%-15s [%s] %10.3f\n',name{i},namx,idemoments.cosnJ(i,j))
+                %                 fprintf('%-15s [%s] %10.3f\n',name{i},namx,idemoments.cosnJ(i,j))
             end
-            hh = dyn_figure(options_,'Name',[tittxt,' - Collinearity patterns with ', int2str(j) ,' parameter(s)']);
+            hh = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Collinearity patterns with ', int2str(j) ,' parameter(s)']);
             imagesc(pax,[0 1]);
             set(gca,'xticklabel','')
             set(gca,'yticklabel','')
-            for ip=1:nparam,
+            for ip=1:nparam
                 text(ip,(0.5),name{ip},'rotation',90,'HorizontalAlignment','left','interpreter','none')
                 text(0.5,ip,name{ip},'rotation',0,'HorizontalAlignment','right','interpreter','none')
             end
@@ -198,14 +198,14 @@ if SampleSize == 1,
             ax=colormap;
             ax(1,:)=[0.9 0.9 0.9];
             colormap(ax);
-            if nparam>10,
+            if nparam>10
                 set(gca,'xtick',(5:5:nparam))
                 set(gca,'ytick',(5:5:nparam))
             end
             set(gca,'xgrid','on')
             set(gca,'ygrid','on')
             xlabel([tittxt,' - Collinearity patterns with ', int2str(j) ,' parameter(s)'],'interpreter','none')
-            dyn_saveas(hh,[ IdentifDirectoryName '/' M_.fname '_ident_collinearity_' tittxt1 '_' int2str(j) ],options_);
+            dyn_saveas(hh,[ IdentifDirectoryName '/' M_.fname '_ident_collinearity_' tittxt1 '_' int2str(j) ],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fidTeX = fopen([ IdentifDirectoryName '/' M_.fname '_ident_collinearity_' tittxt1 '_' int2str(j),'.tex'],'w');
                 fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
@@ -223,54 +223,54 @@ if SampleSize == 1,
         skipline()
         [U,S,V]=svd(idehess.AHess,0);
         S=diag(S);
-        if idehess.flag_score,
-            if nparam<5,
-                f1 = dyn_figure(options_,'Name',[tittxt,' - Identification patterns (Information matrix)']);
+        if idehess.flag_score
+            if nparam<5
+                f1 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Identification patterns (Information matrix)']);
                 tex_tit_1=[tittxt,' - Identification patterns (Information matrix)'];
             else
-                f1 = dyn_figure(options_,'Name',[tittxt,' - Identification patterns (Information matrix): SMALLEST SV']);
+                f1 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Identification patterns (Information matrix): SMALLEST SV']);
                 tex_tit_1=[tittxt,' - Identification patterns (Information matrix): SMALLEST SV'];
-                f2 = dyn_figure(options_,'Name',[tittxt,' - Identification patterns (Information matrix): HIGHEST SV']);
+                f2 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Identification patterns (Information matrix): HIGHEST SV']);
                 tex_tit_2=[tittxt,' - Identification patterns (Information matrix): HIGHEST SV'];
             end
         else
-%             S = idemoments.S;
-%             V = idemoments.V;
-            if nparam<5,
-                f1 = dyn_figure(options_,'Name',[tittxt,' - Identification patterns (moments Information matrix)']);
+            %             S = idemoments.S;
+            %             V = idemoments.V;
+            if nparam<5
+                f1 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Identification patterns (moments Information matrix)']);
                 tex_tit_1=[tittxt,' - Identification patterns (moments Information matrix)'];
             else
-                f1 = dyn_figure(options_,'Name',[tittxt,' - Identification patterns (moments Information matrix): SMALLEST SV']);
+                f1 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Identification patterns (moments Information matrix): SMALLEST SV']);
                 tex_tit_1=[tittxt,' - Identification patterns (moments Information matrix): SMALLEST SV'];
-                f2 = dyn_figure(options_,'Name',[tittxt,' - Identification patterns (moments Information matrix): HIGHEST SV']);
+                f2 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - Identification patterns (moments Information matrix): HIGHEST SV']);
                 tex_tit_2=[tittxt,' - Identification patterns (moments Information matrix): HIGHEST SV'];
             end
         end
-        for j=1:min(nparam,8),
-            if j<5,
+        for j=1:min(nparam,8)
+            if j<5
                 set(0,'CurrentFigure',f1),
                 jj=j;
             else
                 set(0,'CurrentFigure',f2),
                 jj=j-4;
             end
-            subplot(4,1,jj),
+            subplot(4,1,jj)
             if j<5
-                bar(abs(V(:,end-j+1))),
+                bar(abs(V(:,end-j+1)))
                 Stit = S(end-j+1);
             else
                 bar(abs(V(:,jj))),
                 Stit = S(jj);
             end
             set(gca,'xticklabel','')
-            if j==4 || j==nparam || j==8,
-                for ip=1:nparam,
+            if j==4 || j==nparam || j==8
+                for ip=1:nparam
                     text(ip,-0.02,name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
                 end
             end
             title(['Singular value ',num2str(Stit)])
         end
-        dyn_saveas(f1,[  IdentifDirectoryName '/' M_.fname '_ident_pattern_' tittxt1 '_1' ],options_);
+        dyn_saveas(f1,[  IdentifDirectoryName '/' M_.fname '_ident_pattern_' tittxt1 '_1' ],options_.nodisplay,options_.graph_format);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fidTeX = fopen([  IdentifDirectoryName '/' M_.fname '_ident_pattern_' tittxt1 '_1','.tex'],'w');
             fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
@@ -284,8 +284,8 @@ if SampleSize == 1,
             fprintf(fidTeX,'%% End Of TeX file. \n');
             fclose(fidTeX);
         end
-        if nparam>4,
-            dyn_saveas(f2,[  IdentifDirectoryName '/' M_.fname '_ident_pattern_' tittxt1 '_2' ],options_);
+        if nparam>4
+            dyn_saveas(f2,[  IdentifDirectoryName '/' M_.fname '_ident_pattern_' tittxt1 '_2' ],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fidTeX = fopen([  IdentifDirectoryName '/' M_.fname '_ident_pattern_' tittxt1 '_2.tex'],'w');
                 fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
@@ -301,35 +301,35 @@ if SampleSize == 1,
             end
         end
     end
-    
+
 else
-    hh = dyn_figure(options_,'Name',['MC sensitivities']);
+    hh = dyn_figure(options_.nodisplay,'Name',['MC sensitivities']);
     subplot(211)
     mmm = (idehess.ide_strength_J);
     [ss, is] = sort(mmm);
     mmm = mean(siJnorm)';
     mmm = mmm./max(mmm);
-    if advanced,
+    if advanced
         mmm1 = mean(siHnorm)';
         mmm=[mmm mmm1./max(mmm1)];
         mmm1 = mean(siLREnorm)';
         offset=size(siHnorm,2)-size(siLREnorm,2);
         mmm1 = [NaN(offset,1); mmm1./max(mmm1)];
         mmm=[mmm mmm1];
-    end        
-        
+    end
+
     bar(mmm(is,:))
     set(gca,'xlim',[0 nparam+1])
     set(gca,'xticklabel','')
     dy = get(gca,'ylim');
-    for ip=1:nparam,
+    for ip=1:nparam
         text(ip,dy(1),name{is(ip)},'rotation',90,'HorizontalAlignment','right','interpreter','none')
     end
-    if advanced,
+    if advanced
         legend('Moments','Model','LRE model','Location','Best')
     end
     title('MC mean of sensitivity measures')
-    dyn_saveas(hh,[ IdentifDirectoryName '/' M_.fname '_MC_sensitivity' ],options_);
+    dyn_saveas(hh,[ IdentifDirectoryName '/' M_.fname '_MC_sensitivity' ],options_.nodisplay,options_.graph_format);
     if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         fidTeX = fopen([ IdentifDirectoryName '/' M_.fname '_MC_sensitivity.tex'],'w');
         fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
@@ -343,14 +343,14 @@ else
         fprintf(fidTeX,'%% End Of TeX file. \n');
         fclose(fidTeX);
     end
-    
-    if advanced,
+
+    if advanced
         if ~options_.nodisplay,
             skipline()
             disp('Press ENTER to display advanced diagnostics'), pause(5),
         end
-%         options_.nograph=1;
-        hh = dyn_figure(options_,'Name','MC Condition Number');
+        %         options_.nograph=1;
+        hh = dyn_figure(options_.nodisplay,'Name','MC Condition Number');
         subplot(221)
         hist(log10(idemodel.cond))
         title('log10 of Condition number in the model')
@@ -360,7 +360,7 @@ else
         subplot(223)
         hist(log10(idelre.cond))
         title('log10 of Condition number in the LRE model')
-        dyn_saveas(hh,[IdentifDirectoryName '/' M_.fname '_ident_COND' ],options_);
+        dyn_saveas(hh,[IdentifDirectoryName '/' M_.fname '_ident_COND' ],options_.nodisplay,options_.graph_format);
         options_mcf.pvalue_ks = 0.1;
         options_mcf.pvalue_corr = 0.001;
         options_mcf.alpha2 = 0;
@@ -386,34 +386,34 @@ else
         options_mcf.title = 'MC Highest Condition Number Model Moments';
         [dum,is]=sort(idemoments.cond);
         mcf_analysis(params, is(1:ncut), is(ncut+1:end), options_mcf, options_);
-%         [proba, dproba] = stab_map_1(idemoments.Mco', is(1:ncut), is(ncut+1:end), 'HighestCondNumberMoments_vs_Mco', 1, [], IdentifDirectoryName);
-%         for j=1:nparam,
-% %             ibeh=find(idemoments.Mco(j,:)<0.9);
-% %             inonbeh=find(idemoments.Mco(j,:)>=0.9);
-% %             if ~isempty(ibeh) && ~isempty(inonbeh)
-% %                 [proba, dproba] = stab_map_1(params, ibeh, inonbeh, ['HighestMultiCollinearity_',name{j}], 1, [], IdentifDirectoryName);
-% %             end
-%             [~,is]=sort(idemoments.Mco(:,j));
-%             [proba, dproba] = stab_map_1(params, is(1:ncut), is(ncut+1:end), ['MC_HighestMultiCollinearity_',name{j}], 1, [], IdentifDirectoryName, 0.15);
-%         end
+        %         [proba, dproba] = stab_map_1(idemoments.Mco', is(1:ncut), is(ncut+1:end), 'HighestCondNumberMoments_vs_Mco', 1, [], IdentifDirectoryName);
+        %         for j=1:nparam,
+        % %             ibeh=find(idemoments.Mco(j,:)<0.9);
+        % %             inonbeh=find(idemoments.Mco(j,:)>=0.9);
+        % %             if ~isempty(ibeh) && ~isempty(inonbeh)
+        % %                 [proba, dproba] = stab_map_1(params, ibeh, inonbeh, ['HighestMultiCollinearity_',name{j}], 1, [], IdentifDirectoryName);
+        % %             end
+        %             [~,is]=sort(idemoments.Mco(:,j));
+        %             [proba, dproba] = stab_map_1(params, is(1:ncut), is(ncut+1:end), ['MC_HighestMultiCollinearity_',name{j}], 1, [], IdentifDirectoryName, 0.15);
+        %         end
 
-        if nparam<5,
-            f1 = dyn_figure(options_,'Name',[tittxt,' - MC Identification patterns (moments): HIGHEST SV']);
+        if nparam<5
+            f1 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - MC Identification patterns (moments): HIGHEST SV']);
             tex_tit_1=[tittxt,' - MC Identification patterns (moments): HIGHEST SV'];
         else
-            f1 = dyn_figure(options_,'Name',[tittxt,' - MC Identification patterns (moments): SMALLEST SV']);
+            f1 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - MC Identification patterns (moments): SMALLEST SV']);
             tex_tit_1=[tittxt,' - MC Identification patterns (moments): SMALLEST SV'];
-            f2 = dyn_figure(options_,'Name',[tittxt,' - MC Identification patterns (moments): HIGHEST SV']);
+            f2 = dyn_figure(options_.nodisplay,'Name',[tittxt,' - MC Identification patterns (moments): HIGHEST SV']);
             tex_tit_2=[tittxt,' - MC Identification patterns (moments): HIGHEST SV'];
         end
         nplots=min(nparam,8);
-        if nplots>4,
+        if nplots>4
             nsubplo=ceil(nplots/2);
         else
             nsubplo=nplots;
         end
-        for j=1:nplots,
-            if (nparam>4 && j<=ceil(nplots/2)) || nparam<5,
+        for j=1:nplots
+            if (nparam>4 && j<=ceil(nplots/2)) || nparam<5
                 set(0,'CurrentFigure',f1),
                 jj=j;
                 VVV=squeeze(abs(idemoments.V(:,:,end-j+1)));
@@ -424,8 +424,8 @@ else
                 VVV=squeeze(abs(idemoments.V(:,:,jj)));
                 SSS = idemoments.S(:,jj);
             end
-            subplot(nsubplo,1,jj),
-            for i=1:nparam,
+            subplot(nsubplo,1,jj)
+            for i=1:nparam
                 [post_mean, post_median(:,i), post_var, hpd_interval(i,:), post_deciles] = posterior_moments(VVV(:,i),0,0.9);
             end
             bar(post_median)
@@ -433,14 +433,14 @@ else
             Stit=mean(SSS);
 
             set(gca,'xticklabel','')
-            if j==4 || j==nparam || j==8,
-                for ip=1:nparam,
+            if j==4 || j==nparam || j==8
+                for ip=1:nparam
                     text(ip,-0.02,name{ip},'rotation',90,'HorizontalAlignment','right','interpreter','none')
                 end
             end
             title(['MEAN Singular value ',num2str(Stit)])
         end
-        dyn_saveas(f1,[IdentifDirectoryName '/' M_.fname '_MC_ident_pattern_1' ],options_);
+        dyn_saveas(f1,[IdentifDirectoryName '/' M_.fname '_MC_ident_pattern_1' ],options_.nodisplay,options_.graph_format);
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             fidTeX = fopen([IdentifDirectoryName '/' M_.fname '_MC_ident_pattern_1.tex'],'w');
             fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
@@ -454,8 +454,8 @@ else
             fprintf(fidTeX,'%% End Of TeX file. \n');
             fclose(fidTeX);
         end
-        if nparam>4,
-            dyn_saveas(f2,[  IdentifDirectoryName '/' M_.fname '_MC_ident_pattern_2' ],options_);
+        if nparam>4
+            dyn_saveas(f2,[  IdentifDirectoryName '/' M_.fname '_MC_ident_pattern_2' ],options_.nodisplay,options_.graph_format);
             if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                 fidTeX = fopen([  IdentifDirectoryName '/' M_.fname '_MC_ident_pattern_2.tex'],'w');
                 fprintf(fidTeX,'%% TeX eps-loader file generated by plot_identification.m (Dynare).\n');
diff --git a/matlab/plot_priors.m b/matlab/plot_priors.m
index 15842b8e9..2b2fc83f6 100644
--- a/matlab/plot_priors.m
+++ b/matlab/plot_priors.m
@@ -13,7 +13,7 @@ function plot_priors(bayestopt_,M_,estim_params_,options_)
 % SPECIAL REQUIREMENTS
 %    None
 
-% Copyright (C) 2004-2016 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -42,8 +42,8 @@ if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
     fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
     fprintf(fidTeX,' \n');
 end
-for plt = 1:nbplt,
-    hplt = dyn_figure(options_,'Name',figurename);
+for plt = 1:nbplt
+    hplt = dyn_figure(options_.nodisplay,'Name',figurename);
     if TeX
         TeXNAMES = [];
         NAMES    = [];
@@ -70,10 +70,10 @@ for plt = 1:nbplt,
         title(nam,'Interpreter','none')
         drawnow
     end
-    dyn_saveas(hplt,[M_.fname '_Priors' int2str(plt)],options_);
+    dyn_saveas(hplt,[M_.fname '_Priors' int2str(plt)],options_.nodisplay,options_.graph_format);
     if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         fprintf(fidTeX,'\\begin{figure}[H]\n');
-        for jj = 1:nstar0,
+        for jj = 1:nstar0
             fprintf(fidTeX,'\\psfrag{%s}[1][][0.5][0]{%s}\n',deblank(NAMES(jj,:)),deblank(TeXNAMES(jj,:)));
         end
         fprintf(fidTeX,'\\centering\n');
diff --git a/matlab/plot_shock_decomposition.m b/matlab/plot_shock_decomposition.m
new file mode 100644
index 000000000..182a0f906
--- /dev/null
+++ b/matlab/plot_shock_decomposition.m
@@ -0,0 +1,351 @@
+function [z, steady_state] = plot_shock_decomposition(M_,oo_,options_,varlist)
+% function plot_shock_decomposition(M_,oo_,options_,varlist)
+% Plots the results of shock_decomposition
+%
+% INPUTS
+%    M_:          [structure]  Definition of the model
+%    oo_:         [structure]  Storage of results
+%    options_:    [structure]  Options
+%    varlist:     [char]       List of variables
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2016-2017 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/>.
+
+options_.nodisplay = options_.plot_shock_decomp.nodisplay;
+options_.graph_format = options_.plot_shock_decomp.graph_format;
+options_.use_shock_groups = options_.plot_shock_decomp.use_shock_groups;
+
+% indices of endogenous variables
+if size(varlist,1) == 0
+    varlist = M_.endo_names(1:M_.orig_endo_nbr,:);
+end
+
+[i_var,nvar,index_uniques] = varlist_indices(varlist,M_.endo_names);
+varlist=varlist(index_uniques,:);
+
+% number of variables
+endo_nbr = M_.endo_nbr;
+
+% number of shocks
+nshocks = M_.exo_nbr;
+% type = '';
+fig_name='';
+% detail_plot=0;
+% realtime_=0; % 0 is standard; 1 is realtime (pool/vintage); 2 is conditional (pool/vintage); 3 is forecast (pool/vintage)
+% vintage_=0; % 0 pool realtime/conditional; int: forecast/conditional shock decompositions
+% forecast_=0;
+% steadystate=0;
+% write_xls=0;
+
+if isfield(options_.plot_shock_decomp,'expand') % private trap for uimenu calls
+    expand=options_.plot_shock_decomp.expand;
+else
+    expand=0;
+end
+
+if ~isempty(options_.plot_shock_decomp.fig_name)
+    fig_name=[' ' options_.plot_shock_decomp.fig_name];
+end
+type=options_.plot_shock_decomp.type;
+detail_plot=options_.plot_shock_decomp.detail_plot;
+realtime_= options_.plot_shock_decomp.realtime;
+vintage_ = options_.plot_shock_decomp.vintage;
+forecast_ = options_.shock_decomp.forecast;
+steadystate = options_.plot_shock_decomp.steadystate;
+write_xls = options_.plot_shock_decomp.write_xls;
+
+if vintage_
+    forecast_ = min(forecast_,options_.nobs-vintage_);
+end
+
+initial_date = options_.initial_date;
+
+if isfield(options_.plot_shock_decomp,'q2a') % private trap for aoa calls
+    q2a=options_.plot_shock_decomp.q2a;
+    if isstruct(q2a) && isempty(fieldnames(q2a))
+        q2a=0;
+    end
+else
+    q2a=0;
+end
+
+switch realtime_
+
+  case 0
+    z = oo_.shock_decomposition;
+    fig_name1=fig_name;
+
+  case 1 % realtime
+    if vintage_
+        z = oo_.realtime_shock_decomposition.(['time_' int2str(vintage_)]);
+        fig_name1=[fig_name ' realtime (vintage ' char(initial_date+vintage_-1) ')'];
+    else
+        z = oo_.realtime_shock_decomposition.pool;
+        fig_name1=[fig_name ' realtime (rolling)'];
+    end
+
+  case 2 % conditional
+    if vintage_
+        z = oo_.realtime_conditional_shock_decomposition.(['time_' int2str(vintage_)]);
+        initial_date = options_.initial_date+vintage_-1;
+        fig_name1=[fig_name ' ' int2str(forecast_) '-step ahead conditional forecast (given ' char(initial_date) ')'];
+    else
+        z = oo_.conditional_shock_decomposition.pool;
+        fig_name1=[fig_name ' 1-step ahead conditional forecast (rolling)'];
+    end
+
+  case 3 % forecast
+    if vintage_
+        z = oo_.realtime_forecast_shock_decomposition.(['time_' int2str(vintage_)]);
+        initial_date = options_.initial_date+vintage_-1;
+        fig_name1=[fig_name ' ' int2str(forecast_) '-step ahead forecast (given ' char(initial_date) ')'];
+    else
+        z = oo_.realtime_forecast_shock_decomposition.pool;
+        fig_name1=[fig_name ' 1-step ahead forecast (rolling)'];
+    end
+end
+
+steady_state = oo_.steady_state;
+
+if isequal(type,'aoa') && isstruct(q2a) && realtime_
+    if isempty(initial_date)
+        t0=1;
+        initial_date = dates('1Y');
+    else
+        initial_date0 = dates([int2str(initial_date.time(1)) 'Y']);
+        if initial_date.time(2)==1
+            t0=1;
+            initial_date1=initial_date0;
+        else
+            t0=(4-initial_date.time(2)+2);
+            initial_date1=initial_date0+1;
+        end
+    end
+    t0=min(options_.plot_shock_decomp.save_realtime);
+    ini1 = initial_date+t0-1;
+    t0=t0+(4-ini1.time(2));
+    if ~isfield(q2a,'var_type') % private trap for aoa calls
+        q2a.var_type=1;
+    end
+    if ~isfield(q2a,'islog') % private trap for aoa calls
+        q2a.islog=0;
+    end
+    if ~isfield(q2a,'GYTREND0') % private trap for aoa calls
+        q2a.GYTREND0=0;
+    end
+    if ~isfield(q2a,'aux') % private trap for aoa calls
+        q2a.aux=0;
+    end
+    if ~isfield(q2a,'cumfix') % private trap for aoa calls
+        q2a.cumfix=1;
+    end
+    if ~isfield(q2a,'plot') % private trap for aoa calls
+        q2a.plot=1; % growth rate
+    end
+
+    %     if isstruct(q2a.aux) && ischar(q2a.aux.y)
+    %         opts=options_;
+    %         opts.plot_shock_decomp.type='qoq';
+    %         [y_aux, steady_state_aux] = plot_shock_decomposition(M_,oo_,opts,q2a.aux.y);
+    %         q2a.aux.y=y_aux;
+    %         q2a.aux.yss=steady_state_aux;
+    %     end
+    [za, endo_names, endo_names_tex, steady_state, i_var, oo_] = ...
+        annualized_shock_decomposition(oo_,M_, options_, i_var, t0, options_.nobs, realtime_, vintage_, steady_state,q2a);
+    %     if realtime_<2
+    %         initial_date = initial_date1;
+    %     else
+    %         initial_date = initial_date0;
+    %     end
+end
+
+
+
+if ~expand
+    fig_name = fig_name1;
+end
+gend = size(z,3);
+if options_.plot_shock_decomp.use_shock_groups
+    shock_groups = M_.shock_groups.(options_.plot_shock_decomp.use_shock_groups);
+    shock_ind = fieldnames(shock_groups);
+    ngroups = length(shock_ind);
+    fig_name=[fig_name ' group ' options_.plot_shock_decomp.use_shock_groups];
+    shock_names = shock_ind;
+    for i=1:ngroups
+        shock_names{i} = (shock_groups.(shock_ind{i}).label);
+    end
+    zz = zeros(endo_nbr,ngroups+2,gend);
+    kcum=[];
+    for i=1:ngroups
+        for j = shock_groups.(shock_ind{i}).shocks
+            k = find(strcmp(j,cellstr(M_.exo_names)));
+            zz(:,i,:) = zz(:,i,:) + z(:,k,:);
+            z(:,k,:) = 0;
+            kcum = [kcum k];
+        end
+    end
+    zothers = sum(z(:,1:nshocks,:),2);
+    shock_groups.(['group' int2str(ngroups+1)]).label =  'Others';
+    shock_groups.(['group' int2str(ngroups+1)]).shocks =  cellstr(M_.exo_names(find(~ismember([1:M_.exo_nbr],kcum)),:))';
+    M_.shock_groups.(options_.plot_shock_decomp.use_shock_groups)=shock_groups;
+    if any(any(zothers))
+        shock_names = [shock_names; {'Others + Initial Values'}];
+    end
+    zz(:,ngroups+1,:) = sum(z(:,1:nshocks+1,:),2);
+    zz(:,ngroups+2,:) = z(:,nshocks+2,:);
+    z = zz;
+else
+    shock_names = M_.exo_names;
+end
+
+func = @(x) colorspace('RGB->Lab',x);
+MAP = distinguishable_colors(size(z,2)-1,'w',func);
+%         MAP = [MAP; MAP(end,:)];
+MAP(end,:) = [0.7 0.7 0.7];
+%         MAP = [MAP; [0.7 0.7 0.7]; [0.3 0.3 0.3]];
+
+if isempty(options_.plot_shock_decomp.colormap)
+    options_.plot_shock_decomp.colormap = MAP;
+end
+
+switch type
+
+  case '' % default
+
+  case 'qoq'
+
+  case 'yoy'
+    z=z(:,:,1:end-3)+z(:,:,2:end-2)+z(:,:,3:end-1)+z(:,:,4:end);
+    if ~isempty(initial_date),
+        initial_date = initial_date+3;
+    else
+        initial_date = dates('1Q4');
+    end
+    steady_state = 4*steady_state;
+
+  case 'aoa'
+
+    if isempty(initial_date)
+        t0=4;
+        initial_date = dates('1Y');
+    else
+        initial_date0 = dates([int2str(initial_date.time(1)) 'Y']);
+        if initial_date.time(2)==1
+            t0=1;
+            initial_date1=initial_date0;
+        else
+            t0=(4-initial_date.time(2)+2);
+            initial_date1=initial_date0+1;
+        end
+    end
+    if isstruct(q2a)
+        if realtime_ == 0
+            if ~isfield(q2a,'var_type') % private trap for aoa calls
+                q2a.var_type=1;
+            end
+            if ~isfield(q2a,'islog') % private trap for aoa calls
+                q2a.islog=0;
+            end
+            if ~isfield(q2a,'GYTREND0') % private trap for aoa calls
+                q2a.GYTREND0=0;
+            end
+            if ~isfield(q2a,'aux') % private trap for aoa calls
+                q2a.aux=0;
+            end
+            if ~isfield(q2a,'cumfix') % private trap for aoa calls
+                q2a.cumfix=1;
+            end
+            if ~isfield(q2a,'plot') % private trap for aoa calls
+                q2a.plot=1; % growth rate
+            end
+
+            if isstruct(q2a.aux) && ischar(q2a.aux.y)
+                opts=options_;
+                opts.plot_shock_decomp.type='qoq';
+                [y_aux, steady_state_aux] = plot_shock_decomposition(M_,oo_,opts,q2a.aux.y);
+                q2a.aux.y=y_aux;
+                q2a.aux.yss=steady_state_aux;
+            end
+            [za, endo_names, endo_names_tex, steady_state, i_var, oo_] = ...
+                annualized_shock_decomposition(z,M_, options_, i_var, t0, options_.nobs, realtime_, vintage_, steady_state,q2a);
+        end
+        z = za;
+        M_.endo_names = endo_names;
+        M_.endo_names_tex = endo_names_tex;
+        %     endo_nbr = size(z,1);
+        if realtime_<2
+            initial_date = initial_date1;
+        else
+            initial_date = initial_date0;
+        end
+    else
+        t0=4-initial_date.time(2)+1;
+        initial_date = initial_date0;
+        z=z(:,:,t0:4:end);
+    end
+
+    if ~isempty(options_.plot_shock_decomp.plot_init_date)
+        options_.plot_shock_decomp.plot_init_date = dates([int2str(options_.plot_shock_decomp.plot_init_date.time(1)) 'Y']);
+    end
+    if ~isempty(options_.plot_shock_decomp.plot_end_date)
+        options_.plot_shock_decomp.plot_end_date = dates([int2str(options_.plot_shock_decomp.plot_end_date.time(1)) 'Y']);
+    end
+
+
+  otherwise
+
+    error('plot_shock_decomposition:: Wrong type')
+
+end
+if steadystate
+    options_.plot_shock_decomp.steady_state=steady_state;
+end
+
+if nargout
+    z=z(i_var,:,:);
+    steady_state = steady_state(i_var);
+    return
+end
+
+% here we crop data if needed
+my_initial_date = initial_date;
+a = 1;
+b = size(z,3);
+if ~isempty(options_.plot_shock_decomp.plot_init_date)
+    my_initial_date = max(initial_date,options_.plot_shock_decomp.plot_init_date);
+    a = find((initial_date:initial_date+b-1)==options_.plot_shock_decomp.plot_init_date);
+end
+if ~isempty(options_.plot_shock_decomp.plot_end_date)
+    b = find((initial_date:initial_date+b-1)==options_.plot_shock_decomp.plot_end_date);
+end
+z = z(:,:,a:b);
+% end crop data
+
+options_.plot_shock_decomp.fig_name=fig_name;
+options_.plot_shock_decomp.orig_varlist = varlist;
+if detail_plot
+    graph_decomp_detail(z,shock_names,M_.endo_names,i_var,my_initial_date,M_,options_)
+else
+    graph_decomp(z,shock_names,M_.endo_names,i_var,my_initial_date,M_,options_);
+end
+
+if write_xls
+    WriteShockDecomp2Excel(z,shock_names,M_.endo_names,i_var,initial_date,M_,options_,options_.plot_shock_decomp);
+end
diff --git a/matlab/pltorg.m b/matlab/pltorg.m
index 7f100e4b2..e7f680772 100644
--- a/matlab/pltorg.m
+++ b/matlab/pltorg.m
@@ -1,6 +1,6 @@
 function [nbplt,nr,nc,lr,lc,nstar] = pltorg(number)
 
-% Copyright (C) 2004-2008 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -48,11 +48,11 @@ elseif number == 5
 elseif number == 6
     nbplt = 1;
     nr    = 3;
-    nc    = 2;    
+    nc    = 2;
 elseif number == 7
     nbplt = 1;
     nr    = 3;
-    nc    = 3;    
+    nc    = 3;
 elseif number == 8
     nbplt = 1;
     nr    = 3;
@@ -67,7 +67,7 @@ else
         nr    = nrstar;
         nc    = ncstar;
         lr    = nr;
-        lc    = nc; 
+        lc    = nc;
     else
         nbplt = ceil(number/nstar);
         nr    = nrstar;
@@ -90,10 +90,10 @@ else
             lc    = 2;
         elseif reste == 6
             lr    = 3;
-            lc    = 2;    
+            lc    = 2;
         elseif reste == 7
             lr    = 3;
-            lc    = 3;    
+            lc    = 3;
         elseif reste == 8
             lr    = 3;
             lc    = 3;
diff --git a/matlab/pm3.m b/matlab/pm3.m
index ae0f474d1..695b641d8 100644
--- a/matlab/pm3.m
+++ b/matlab/pm3.m
@@ -7,7 +7,7 @@ function pm3(n1,n2,ifil,B,tit1,tit2,tit3,tit_tex,names1,names2,name3,DirectoryNa
 %  n2           [scalar] size of second dimension of moment matrix
 %  ifil         [scalar] number of moment files to load
 %  B            [scalar] number of subdraws
-%  tit1         [string] Figure title 
+%  tit1         [string] Figure title
 %  tit2         [string] not used
 %  tit3         [string] Save name for figure
 %  tit_tex      [cell array] TeX-Names for Variables
@@ -24,7 +24,7 @@ function pm3(n1,n2,ifil,B,tit1,tit2,tit3,tit_tex,names1,names2,name3,DirectoryNa
 % See also the comment in posterior_sampler.m funtion.
 
 
-% Copyright (C) 2007-2016 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -60,10 +60,10 @@ else
     end
 end
 if options_.TeX
-    if isempty(tit_tex),
+    if isempty(tit_tex)
         tit_tex=names1;
     end
-        
+
     varlist_TeX = [];
     for i=1:nvar
         if i==1
@@ -92,7 +92,7 @@ for file = 1:ifil
     stock=loaded_file.stock;
     if strcmp(var_type,'_filter_step_ahead')
         if file==1 %on first run, initialize variable for storing filter_step_ahead
-            stock1_filter_step_ahead=NaN(n1,n2,B,length(options_.filter_step_ahead)); 
+            stock1_filter_step_ahead=NaN(n1,n2,B,length(options_.filter_step_ahead));
             stock1 = zeros(n1,n2,B);
         end
         filter_step_ahead_indicator=1;
@@ -289,112 +289,111 @@ if strcmp(var_type,'_trend_coeff') || max(max(abs(Mean(:,:))))<=10^(-6) || all(a
     return %not do plots
 end
 %%
-%% 	Finally I build the plots.
+%%      Finally I build the plots.
 %%
 
 if ~options_.nograph && ~options_.no_graph.posterior
-% Block of code executed in parallel, with the exception of file
-% .tex generation always run sequentially. This portion of code is execute in parallel by
-% pm3_core1.m function.
+    % Block of code executed in parallel, with the exception of file
+    % .tex generation always run sequentially. This portion of code is execute in parallel by
+    % pm3_core1.m function.
 
-% %%%%%%%%%   PARALLEL BLOCK % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% %%% The file .TeX! are not saved in parallel.
+    % %%%%%%%%%   PARALLEL BLOCK % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    %
+    % %%% The file .TeX! are not saved in parallel.
 
 
 
-% Store the variable mandatory for local/remote parallel computing.
+    % Store the variable mandatory for local/remote parallel computing.
 
-localVars=[];
+    localVars=[];
 
-localVars.tit1=tit1;
-localVars.nn=nn;
-localVars.n2=n2;
-localVars.Distrib=Distrib;
-localVars.varlist=varlist;
-localVars.MaxNumberOfPlotsPerFigure=MaxNumberOfPlotsPerFigure;
-localVars.name3=name3;
-localVars.tit3=tit3;
-localVars.Mean=Mean;
-% Like sequential execution!
-nvar0=nvar;
+    localVars.tit1=tit1;
+    localVars.nn=nn;
+    localVars.n2=n2;
+    localVars.Distrib=Distrib;
+    localVars.varlist=varlist;
+    localVars.MaxNumberOfPlotsPerFigure=MaxNumberOfPlotsPerFigure;
+    localVars.name3=name3;
+    localVars.tit3=tit3;
+    localVars.Mean=Mean;
+    % Like sequential execution!
+    nvar0=nvar;
 
-if ~isoctave
-    % Commenting for testing!
-    if isnumeric(options_.parallel) || ceil(size(varlist,1)/MaxNumberOfPlotsPerFigure)<4,
-        fout = pm3_core(localVars,1,nvar,0);
-        
-        % Parallel execution!
-    else
-        isRemoteOctave = 0;
-        for indPC=1:length(options_.parallel),
-            isRemoteOctave = isRemoteOctave + (findstr(options_.parallel(indPC).MatlabOctavePath, 'octave'));
-        end
-        if isRemoteOctave
+    if ~isoctave
+        % Commenting for testing!
+        if isnumeric(options_.parallel) || ceil(size(varlist,1)/MaxNumberOfPlotsPerFigure)<4
             fout = pm3_core(localVars,1,nvar,0);
+
+            % Parallel execution!
         else
-            globalVars = struct('M_',M_, ...
-                'options_', options_, ...
-                'oo_', oo_);
-            [fout, nvar0, totCPU] = masterParallel(options_.parallel, 1, nvar, [],'pm3_core', localVars,globalVars, options_.parallel_info);
-        end
-    end
-else
-    % For the time being in Octave enviroment the pm3.m is executed only in
-    % serial modality, to avoid problem with the plots.
-    
-    fout = pm3_core(localVars,1,nvar,0);
-end
-
-subplotnum = 0;
-
-if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
-    fidTeX = fopen([M_.dname '/Output/' M_.fname '_' name3 '.tex'],'w');
-    fprintf(fidTeX,'%% TeX eps-loader file generated by Dynare.\n');
-    fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
-    fprintf(fidTeX,' \n');
-    nvar0=cumsum(nvar0);
-
-    i=0;    
-    for j=1:length(nvar0),
-    
-    NAMES = [];
-    TEXNAMES = [];
-    nvar=nvar0(j);
-    while i<nvar,
-        i=i+1;
-        if max(abs(Mean(:,i))) > 10^(-6)
-            subplotnum = subplotnum+1;
-            name = deblank(varlist(i,:));
-            texname = deblank(varlist_TeX(i,:));
-            if subplotnum==1
-                NAMES = name;
-                TEXNAMES = ['$' texname '$'];
+            isRemoteOctave = 0;
+            for indPC=1:length(options_.parallel)
+                isRemoteOctave = isRemoteOctave + (findstr(options_.parallel(indPC).MatlabOctavePath, 'octave'));
+            end
+            if isRemoteOctave
+                fout = pm3_core(localVars,1,nvar,0);
             else
-                NAMES = char(NAMES,name);
-                TEXNAMES = char(TEXNAMES,['$' texname '$']);
+                globalVars = struct('M_',M_, ...
+                                    'options_', options_, ...
+                                    'oo_', oo_);
+                [fout, nvar0, totCPU] = masterParallel(options_.parallel, 1, nvar, [],'pm3_core', localVars,globalVars, options_.parallel_info);
             end
         end
-        if subplotnum == MaxNumberOfPlotsPerFigure || i == nvar
-            fprintf(fidTeX,'\\begin{figure}[H]\n');
-            for jj = 1:size(TEXNAMES,1)
-                fprintf(fidTeX,['\\psfrag{%s}[1][][0.5][0]{%s}\n'],deblank(NAMES(jj,:)),deblank(TEXNAMES(jj,:)));
-            end
-            fprintf(fidTeX,'\\centering \n');
-            fprintf(fidTeX,['\\includegraphics[width=%2.2f\\textwidth]{%s/Output/%s_' name3 '_%s}\n'],options_.figures.textwidth*min(subplotnum/nn,1),M_.dname,M_.fname,deblank(tit3(i,:)));
-            fprintf(fidTeX,'\\label{Fig:%s:%s}\n',name3,deblank(tit3(i,:)));
-            fprintf(fidTeX,'\\caption{%s}\n',tit1);
-            fprintf(fidTeX,'\\end{figure}\n');
-            fprintf(fidTeX,' \n');
-            subplotnum = 0;
+    else
+        % For the time being in Octave enviroment the pm3.m is executed only in
+        % serial modality, to avoid problem with the plots.
+
+        fout = pm3_core(localVars,1,nvar,0);
+    end
+
+    subplotnum = 0;
+
+    if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
+        fidTeX = fopen([M_.dname '/Output/' M_.fname '_' name3 '.tex'],'w');
+        fprintf(fidTeX,'%% TeX eps-loader file generated by Dynare.\n');
+        fprintf(fidTeX,['%% ' datestr(now,0) '\n']);
+        fprintf(fidTeX,' \n');
+        nvar0=cumsum(nvar0);
+
+        i=0;
+        for j=1:length(nvar0)
             NAMES = [];
             TEXNAMES = [];
+            nvar=nvar0(j);
+            while i<nvar
+                i=i+1;
+                if max(abs(Mean(:,i))) > 10^(-6)
+                    subplotnum = subplotnum+1;
+                    name = deblank(varlist(i,:));
+                    texname = deblank(varlist_TeX(i,:));
+                    if subplotnum==1
+                        NAMES = name;
+                        TEXNAMES = ['$' texname '$'];
+                    else
+                        NAMES = char(NAMES,name);
+                        TEXNAMES = char(TEXNAMES,['$' texname '$']);
+                    end
+                end
+                if subplotnum == MaxNumberOfPlotsPerFigure || i == nvar
+                    fprintf(fidTeX,'\\begin{figure}[H]\n');
+                    for jj = 1:size(TEXNAMES,1)
+                        fprintf(fidTeX,['\\psfrag{%s}[1][][0.5][0]{%s}\n'],deblank(NAMES(jj,:)),deblank(TEXNAMES(jj,:)));
+                    end
+                    fprintf(fidTeX,'\\centering \n');
+                    fprintf(fidTeX,['\\includegraphics[width=%2.2f\\textwidth]{%s/Output/%s_' name3 '_%s}\n'],options_.figures.textwidth*min(subplotnum/nn,1),M_.dname,M_.fname,deblank(tit3(i,:)));
+                    fprintf(fidTeX,'\\label{Fig:%s:%s}\n',name3,deblank(tit3(i,:)));
+                    fprintf(fidTeX,'\\caption{%s}\n',tit1);
+                    fprintf(fidTeX,'\\end{figure}\n');
+                    fprintf(fidTeX,' \n');
+                    subplotnum = 0;
+                    NAMES = [];
+                    TEXNAMES = [];
+                end
+            end
         end
+        fprintf(fidTeX,'%% End of TeX file.\n');
+        fclose(fidTeX);
     end
-    end
-    fprintf(fidTeX,'%% End of TeX file.\n');
-    fclose(fidTeX);
-end
 end
 
 fprintf(['Estimation::mcmc: ' tit1 ', done!\n']);
diff --git a/matlab/pm3_core.m b/matlab/pm3_core.m
index c2d248f76..881c4b423 100644
--- a/matlab/pm3_core.m
+++ b/matlab/pm3_core.m
@@ -3,7 +3,7 @@ function myoutput=pm3_core(myinputs,fpar,nvar,whoiam, ThisMatlab)
 % PARALLEL CONTEXT
 % Core functionality for pm3.m function, which can be parallelized.
 
-% INPUTS 
+% INPUTS
 % See the comment in posterior_sampler_core.m funtion.
 
 % OUTPUTS
@@ -13,7 +13,7 @@ function myoutput=pm3_core(myinputs,fpar,nvar,whoiam, ThisMatlab)
 % SPECIAL REQUIREMENTS.
 %   None.
 
-% Copyright (C) 2007-2016 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ function myoutput=pm3_core(myinputs,fpar,nvar,whoiam, ThisMatlab)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin<4,
+if nargin<4
     whoiam=0;
 end
 
@@ -64,9 +64,9 @@ end
 
 figunumber = 0;
 subplotnum = 0;
-hh = dyn_figure(options_,'Name',[tit1 ' ' int2str(figunumber+1)]);
+hh = dyn_figure(options_.nodisplay,'Name',[tit1 ' ' int2str(figunumber+1)]);
 RemoteFlag = 0;
-if whoiam,
+if whoiam
     if Parallel(ThisMatlab).Local ==0
         RemoteFlag=1;
     end
@@ -100,35 +100,35 @@ for i=fpar:nvar
             set(gca,'yticklabel',yticklabels_new)
         end
     end
-    
-    if whoiam,
+
+    if whoiam
         if Parallel(ThisMatlab).Local==0
             DirectoryName = CheckPath('Output',M_.dname);
         end
     end
-    
+
     if subplotnum == MaxNumberOfPlotsPerFigure || i == nvar
-        dyn_saveas(hh,[M_.dname '/Output/'  M_.fname '_' name3 '_' deblank(tit3(i,:))],options_);
-        if RemoteFlag==1,
+        dyn_saveas(hh,[M_.dname '/Output/'  M_.fname '_' name3 '_' deblank(tit3(i,:))],options_.nodisplay,options_.graph_format);
+        if RemoteFlag==1
             OutputFileName = [OutputFileName; {[M_.dname, filesep, 'Output',filesep], [M_.fname '_' name3 '_' deblank(tit3(i,:)) '.*']}];
         end
         subplotnum = 0;
         figunumber = figunumber+1;
         if (i ~= nvar)
-            hh = dyn_figure(options_,'Name',[name3 ' ' int2str(figunumber+1)]);
+            hh = dyn_figure(options_.nodisplay,'Name',[name3 ' ' int2str(figunumber+1)]);
         end
     end
-    
-    if whoiam,
-%         waitbarString = [ 'Variable ' int2str(i) '/' int2str(nvar) ' done.'];
-%         fMessageStatus((i-fpar+1)/(nvar-fpar+1),whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab));
+
+    if whoiam
+        %         waitbarString = [ 'Variable ' int2str(i) '/' int2str(nvar) ' done.'];
+        %         fMessageStatus((i-fpar+1)/(nvar-fpar+1),whoiam,waitbarString, waitbarTitle, Parallel(ThisMatlab));
         dyn_waitbar((i-fpar+1)/(nvar-fpar+1),h);
     end
-    
-    
+
+
 end
 
-if whoiam,
+if whoiam
     dyn_waitbar_close(h);
 end
 myoutput.OutputFileName=OutputFileName;
diff --git a/matlab/posterior_analysis.m b/matlab/posterior_analysis.m
index faa117c03..fa365b607 100644
--- a/matlab/posterior_analysis.m
+++ b/matlab/posterior_analysis.m
@@ -1,5 +1,5 @@
-function oo_ = posterior_analysis(type,arg1,arg2,arg3,options_,M_,oo_)  
-% Copyright (C) 2008-2012 Dynare Team
+function oo_ = posterior_analysis(type,arg1,arg2,arg3,options_,M_,oo_)
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,14 +55,14 @@ switch type
             dsge_simulated_theoretical_covariance(SampleSize,M_,options_,oo_,'posterior');
     end
     oo_ = covariance_mc_analysis(SampleSize,'posterior',M_.dname,M_.fname,...
-                                 vartan,nvar,arg1,arg2,options_.mh_conf_sig,oo_,options_);          
+                                 vartan,nvar,arg1,arg2,options_.mh_conf_sig,oo_,options_);
   case 'decomposition'
     if nargin==narg1
         [nvar,vartan,NumberOfFiles] = ...
             dsge_simulated_theoretical_variance_decomposition(SampleSize,M_,options_,oo_,'posterior');
     end
     oo_ = variance_decomposition_mc_analysis(SampleSize,'posterior',M_.dname,M_.fname,...
-                                             M_.exo_names,arg2,vartan,arg1,options_.mh_conf_sig,oo_,options_);    
+                                             M_.exo_names,arg2,vartan,arg1,options_.mh_conf_sig,oo_,options_);
   case 'correlation'
     if nargin==narg1
         [nvar,vartan,NumberOfFiles] = ...
@@ -76,7 +76,7 @@ switch type
             dsge_simulated_theoretical_conditional_variance_decomposition(SampleSize,arg3,M_,options_,oo_,'posterior');
     end
     oo_ = conditional_variance_decomposition_mc_analysis(SampleSize,'posterior',M_.dname,M_.fname,...
-                                                      arg3,M_.exo_names,arg2,vartan,arg1,options_.mh_conf_sig,oo_,options_);    
+                                                      arg3,M_.exo_names,arg2,vartan,arg1,options_.mh_conf_sig,oo_,options_);
   otherwise
     disp('Not yet implemented')
 end
\ No newline at end of file
diff --git a/matlab/posterior_moments.m b/matlab/posterior_moments.m
index beb1b0a41..915827328 100644
--- a/matlab/posterior_moments.m
+++ b/matlab/posterior_moments.m
@@ -11,17 +11,17 @@ function [post_mean, post_median, post_var, hpd_interval, post_deciles, density]
 %    post_mean     [double]    Scalar, posterior mean.
 %    post_median   [double]    Scalar, posterior median.
 %    post_var      [double]    Scalar, posterior variance.
-%    hpd_interval  [double]    Vector (1*2), Highest Probability Density interval 
+%    hpd_interval  [double]    Vector (1*2), Highest Probability Density interval
 %    post_deciles  [double]    Vector (9*1), deciles of the posterior distribution.
-%    density       [double]    Matrix (n*2), non parametric estimate of the posterior density. First and second 
-%                              columns are respectively abscissa and ordinate coordinates.  
-%    
+%    density       [double]    Matrix (n*2), non parametric estimate of the posterior density. First and second
+%                              columns are respectively abscissa and ordinate coordinates.
+%
 % SPECIAL REQUIREMENTS
-%    Other matlab routines distributed with Dynare: mh_optimal_bandwidth.m 
+%    Other matlab routines distributed with Dynare: mh_optimal_bandwidth.m
 %                                                   kernel_density_estimate.m.
 %
 
-% Copyright (C) 2005-2011 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -41,7 +41,7 @@ function [post_mean, post_median, post_var, hpd_interval, post_deciles, density]
 if nargin<4
     number_of_grid_points = 2^9;      % 2^9 = 512 !... Must be a power of two.
     bandwidth = 0;                    % Rule of thumb optimal bandwidth parameter.
-    kernel_function = 'gaussian';     % Gaussian kernel for Fast Fourrier Transform approximaton.  
+    kernel_function = 'gaussian';     % Gaussian kernel for Fast Fourrier Transform approximaton.
 else
     number_of_grid_points = kernel_options.gridpoints;
     bandwidth = kernel_options.bandwidth;
@@ -69,7 +69,7 @@ if hpd_draws>2
     [kmin,idx] = min(kk);
     hpd_interval = [xx(idx) xx(idx)+kmin];
 else
-    hpd_interval=NaN(1,2);    
+    hpd_interval=NaN(1,2);
 end
 if length(xx)>9
     post_deciles = xx([round(0.1*number_of_draws) ...
diff --git a/matlab/posterior_sampler.m b/matlab/posterior_sampler.m
index d7b758185..70f7b5de9 100644
--- a/matlab/posterior_sampler.m
+++ b/matlab/posterior_sampler.m
@@ -1,8 +1,8 @@
 function posterior_sampler(TargetFun,ProposalFun,xparam1,sampler_options,mh_bounds,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,oo_)
 % function posterior_sampler(TargetFun,ProposalFun,xparam1,sampler_options,mh_bounds,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,oo_)
-% Random Walk Metropolis-Hastings algorithm. 
-% 
-% INPUTS 
+% Random Walk Metropolis-Hastings algorithm.
+%
+% INPUTS
 %   o TargetFun  [char]     string specifying the name of the objective
 %                           function (posterior kernel).
 %   o ProposalFun  [char]   string specifying the name of the proposal
@@ -10,7 +10,7 @@ function posterior_sampler(TargetFun,ProposalFun,xparam1,sampler_options,mh_boun
 %   o xparam1    [double]   (p*1) vector of parameters to be estimated (initial values).
 %   o sampler_options       structure
 %            .invhess       [double]   (p*p) matrix, posterior covariance matrix (at the mode).
-%   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters. 
+%   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters.
 %   o dataset_              data structure
 %   o dataset_info          dataset info structure
 %   o options_              options structure
@@ -27,7 +27,7 @@ function posterior_sampler(TargetFun,ProposalFun,xparam1,sampler_options,mh_boun
 % in parallel. The code suitable to be executed in
 % parallel on multi core or cluster machine (in general a 'for' cycle)
 % has been removed from this function and been placed in the posterior_sampler_core.m funtion.
-% 
+%
 % The DYNARE parallel packages comprise a i) set of pairs of Matlab functions that can be executed in
 % parallel and called name_function.m and name_function_core.m and ii) a second set of functions used
 % to manage the parallel computations.
@@ -37,7 +37,7 @@ function posterior_sampler(TargetFun,ProposalFun,xparam1,sampler_options,mh_boun
 % Then the comments write here can be used for all the other pairs of
 % parallel functions and also for management functions.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -107,7 +107,7 @@ localVars =   struct('TargetFun', TargetFun, ...
                      'oo_', oo_,...
                      'varargin',[]);
 
-if strcmp(sampler_options.posterior_sampling_method,'tailored_random_block_metropolis_hastings');
+if strcmp(sampler_options.posterior_sampling_method,'tailored_random_block_metropolis_hastings')
     localVars.options_.silent_optimizer=1; %locally set optimizer to silent mode
     if ~isempty(sampler_options.optim_opt)
         localVars.options_.optim_opt=sampler_options.optim_opt; %locally set options for optimizer
@@ -117,26 +117,31 @@ end
 % User doesn't want to use parallel computing, or wants to compute a
 % single chain compute sequentially.
 
-if isnumeric(options_.parallel) || (nblck-fblck)==0,
+if isnumeric(options_.parallel) || (nblck-fblck)==0
     fout = posterior_sampler_core(localVars, fblck, nblck, 0);
     record = fout.record;
-    % Parallel in Local or remote machine.   
-else 
+    % Parallel in Local or remote machine.
+else
     % Global variables for parallel routines.
     globalVars = struct();
     % which files have to be copied to run remotely
     NamFileInput(1,:) = {'',[ModelName '_static.m']};
     NamFileInput(2,:) = {'',[ModelName '_dynamic.m']};
-    if options_.steadystate_flag,
-        NamFileInput(length(NamFileInput)+1,:)={'',[ModelName '_steadystate.m']};
+    NamFileInput(3,:) = {'',[M_.fname '_set_auxiliary_variables.m']};
+    if options_.steadystate_flag
+        if options_.steadystate_flag == 1
+            NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate.m']};
+        else
+            NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate2.m']};
+        end
     end
-    if (options_.load_mh_file~=0)  && any(fline>1) ,
+    if (options_.load_mh_file~=0)  && any(fline>1)
         NamFileInput(length(NamFileInput)+1,:)={[M_.dname '/metropolis/'],[ModelName '_mh' int2str(NewFile(1)) '_blck*.mat']};
     end
     % from where to get back results
     %     NamFileOutput(1,:) = {[M_.dname,'/metropolis/'],'*.*'};
     [fout, nBlockPerCPU, totCPU] = masterParallel(options_.parallel, fblck, nblck,NamFileInput,'posterior_sampler_core', localVars, globalVars, options_.parallel_info);
-    for j=1:totCPU,
+    for j=1:totCPU
         offset = sum(nBlockPerCPU(1:j-1))+fblck-1;
         record.LastLogPost(offset+1:sum(nBlockPerCPU(1:j)))=fout(j).record.LastLogPost(offset+1:sum(nBlockPerCPU(1:j)));
         record.LastParameters(offset+1:sum(nBlockPerCPU(1:j)),:)=fout(j).record.LastParameters(offset+1:sum(nBlockPerCPU(1:j)),:);
diff --git a/matlab/posterior_sampler_core.m b/matlab/posterior_sampler_core.m
index d88ae742a..b753391b4 100644
--- a/matlab/posterior_sampler_core.m
+++ b/matlab/posterior_sampler_core.m
@@ -31,12 +31,12 @@ function myoutput = posterior_sampler_core(myinputs,fblck,nblck,whoiam, ThisMatl
 %
 % SPECIAL REQUIREMENTS.
 %   None.
-% 
+%
 % PARALLEL CONTEXT
 % See the comments in the posterior_sampler.m funtion.
 
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -53,7 +53,7 @@ function myoutput = posterior_sampler_core(myinputs,fblck,nblck,whoiam, ThisMatl
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if nargin<4,
+if nargin<4
     whoiam=0;
 end
 
@@ -108,7 +108,7 @@ end
 %
 
 sampler_options.xparam1 = xparam1;
-if ~isempty(d),
+if ~isempty(d)
     sampler_options.proposal_covariance_Cholesky_decomposition = d*diag(bayestopt_.jscale);
     %store information for load_mh_file
     record.ProposalCovariance=d;
@@ -117,7 +117,7 @@ end
 
 block_iter=0;
 
-for curr_block = fblck:nblck,
+for curr_block = fblck:nblck
     LastSeeds=[];
     block_iter=block_iter+1;
     try
@@ -132,9 +132,9 @@ for curr_block = fblck:nblck,
             set_dynare_seed(options_.DynareRandomStreams.seed+curr_block);
         end
         % Set the state of the RNG
-        set_dynare_random_generator_state(record.InitialSeeds(curr_block).Unifor, record.InitialSeeds(curr_block).Normal);            
+        set_dynare_random_generator_state(record.InitialSeeds(curr_block).Unifor, record.InitialSeeds(curr_block).Normal);
     catch
-        % If the state set by master is incompatible with the slave, we only reseed 
+        % If the state set by master is incompatible with the slave, we only reseed
         set_dynare_seed(options_.DynareRandomStreams.seed+curr_block);
     end
     if (options_.load_mh_file~=0) && (fline(curr_block)>1) && OpenOldFile(curr_block) %load previous draws and likelihood
@@ -164,9 +164,9 @@ for curr_block = fblck:nblck,
     feval_this_file = 0;
     draw_index_current_file = fline(curr_block); %get location of first draw in current block
     draw_iter = 1;
-    
+
     while draw_iter <= nruns(curr_block)
-        
+
         [par, logpost, accepted, neval] = posterior_sampler_iteration(TargetFun, last_draw(curr_block,:), last_posterior(curr_block), sampler_options,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_);
 
         x2(draw_index_current_file,:) = par;
@@ -192,7 +192,7 @@ for curr_block = fblck:nblck,
         end
         if (draw_index_current_file == InitSizeArray(curr_block)) || (draw_iter == nruns(curr_block)) % Now I save the simulations, either because the current file is full or the chain is done
             [LastSeeds.(['file' int2str(NewFile(curr_block))]).Unifor, LastSeeds.(['file' int2str(NewFile(curr_block))]).Normal] = get_dynare_random_generator_state();
-            if save_tmp_file,
+            if save_tmp_file
                 delete([BaseName '_mh_tmp_blck' int2str(curr_block) '.mat']);
             end
             save([BaseName '_mh' int2str(NewFile(curr_block)) '_blck' int2str(curr_block) '.mat'],'x2','logpo2','LastSeeds');
diff --git a/matlab/posterior_sampler_initialization.m b/matlab/posterior_sampler_initialization.m
index f7927a173..b8b65e8b8 100644
--- a/matlab/posterior_sampler_initialization.m
+++ b/matlab/posterior_sampler_initialization.m
@@ -3,13 +3,13 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 % function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npar, NumberOfBlocks, nruns, NewFile, MAX_nruns, d, bayestopt_] = ...
 %     metropolis_hastings_initialization(TargetFun, xparam1, vv, mh_bounds,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,oo_)
 % Metropolis-Hastings initialization.
-% 
-% INPUTS 
+%
+% INPUTS
 %   o TargetFun  [char]     string specifying the name of the objective
 %                           function (posterior kernel).
 %   o xparam1    [double]   (p*1) vector of parameters to be estimated (initial values).
 %   o vv         [double]   (p*p) matrix, posterior covariance matrix (at the mode).
-%   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters. 
+%   o mh_bounds  [double]   (p*2) matrix defining lower and upper bounds for the parameters.
 %   o dataset_              data structure
 %   o dataset_info          dataset info structure
 %   o options_              options structure
@@ -17,17 +17,17 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 %   o estim_params_         estimated parameters structure
 %   o bayestopt_            estimation options structure
 %   o oo_                   outputs structure
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   o ix2                   [double]   (NumberOfBlocks*npar) vector of starting points for different chains
 %   o ilogpo2               [double]   (NumberOfBlocks*1) vector of initial posterior values for different chains
 %   o ModelName             [string]    name of the mod-file
 %   o MetropolisFolder      [string]    path to the Metropolis subfolder
-%   o FirstBlock            [scalar]    number of the first MH chain to be run (not equal to 1 in case of recovery)   
-%   o FirstLine             [double]   (NumberOfBlocks*1) vector of first draw in each chain (not equal to 1 in case of recovery)   
+%   o FirstBlock            [scalar]    number of the first MH chain to be run (not equal to 1 in case of recovery)
+%   o FirstLine             [double]   (NumberOfBlocks*1) vector of first draw in each chain (not equal to 1 in case of recovery)
 %   o npar                  [scalar]    number of parameters estimated
-%   o NumberOfBlocks        [scalar]    Number of MCM chains requested   
-%   o nruns                 [double]   (NumberOfBlocks*1) number of draws in each chain 
+%   o NumberOfBlocks        [scalar]    Number of MCM chains requested
+%   o nruns                 [double]   (NumberOfBlocks*1) number of draws in each chain
 %   o NewFile               [scalar]    (NumberOfBlocks*1) vector storing the number
 %                                       of the first MH-file to created for each chain when saving additional
 %                                       draws
@@ -38,7 +38,7 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2015 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,7 +58,7 @@ function [ ix2, ilogpo2, ModelName, MetropolisFolder, FirstBlock, FirstLine, npa
 %Initialize outputs
 ix2 = [];
 ilogpo2 = [];
-ModelName = []; 
+ModelName = [];
 MetropolisFolder = [];
 FirstBlock = [];
 FirstLine = [];
@@ -112,7 +112,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
     fprintf(fidlog,['  Number of blocks...............: ' int2str(NumberOfBlocks) '\n']);
     fprintf(fidlog,['  Number of simulations per block: ' int2str(nruns(1)) '\n']);
     fprintf(fidlog,' \n');
-    if isempty(d),
+    if isempty(d)
         prior_draw(bayestopt_,options_.prior_trunc);
     end
     % Find initial values for the NumberOfBlocks chains...
@@ -127,12 +127,12 @@ if ~options_.load_mh_file && ~options_.mh_recover
             init_iter   = 0;
             trial = 1;
             while validate == 0 && trial <= 10
-                if isempty(d),
+                if isempty(d)
                     candidate = prior_draw();
                 else
                     candidate = rand_multivariate_normal( transpose(xparam1), d * options_.mh_init_scale, npar);
                 end
-                if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub) 
+                if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub)
                     ix2(j,:) = candidate;
                     ilogpo2(j) = - feval(TargetFun,ix2(j,:)',dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_);
                     if ~isfinite(ilogpo2(j)) % if returned log-density is
@@ -175,7 +175,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
     else% Case 2: one chain (we start from the posterior mode)
         fprintf(fidlog,['  Initial values of the parameters:\n']);
         candidate = transpose(xparam1(:));%
-        if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub) 
+        if all(candidate(:) >= mh_bounds.lb) && all(candidate(:) <= mh_bounds.ub)
             ix2 = candidate;
             ilogpo2 = - feval(TargetFun,ix2',dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_);
             disp('Estimation::mcmc: Initialization at the posterior mode.')
@@ -234,7 +234,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
     fprintf(fidlog,['    Expected number of files per block.......: ' int2str(AnticipatedNumberOfFiles) '.\n']);
     fprintf(fidlog,['    Expected number of lines in the last file: ' int2str(AnticipatedNumberOfLinesInTheLastFile) '.\n']);
     fprintf(fidlog,['\n']);
-    for j = 1:NumberOfBlocks,
+    for j = 1:NumberOfBlocks
         fprintf(fidlog,['    Initial state of the Gaussian random number generator for chain number ',int2str(j),':\n']);
         for i=1:length(record.InitialSeeds(j).Normal)
             fprintf(fidlog,['      ' num2str(record.InitialSeeds(j).Normal(i)') '\n']);
@@ -243,7 +243,7 @@ if ~options_.load_mh_file && ~options_.mh_recover
         for i=1:length(record.InitialSeeds(j).Unifor)
             fprintf(fidlog,['      ' num2str(record.InitialSeeds(j).Unifor(i)') '\n']);
         end
-    end,
+    end
     fprintf(fidlog,' \n');
     fclose(fidlog);
 elseif options_.load_mh_file && ~options_.mh_recover
@@ -293,7 +293,7 @@ elseif options_.load_mh_file && ~options_.mh_recover
     NumberOfDrawsWrittenInThePastLastFile = MAX_nruns - LastLineNumber;
     NumberOfDrawsToBeSaved = nruns(1) - NumberOfDrawsWrittenInThePastLastFile;
     AnticipatedNumberOfFiles = ceil(NumberOfDrawsToBeSaved/MAX_nruns);
-    AnticipatedNumberOfLinesInTheLastFile = NumberOfDrawsToBeSaved - (AnticipatedNumberOfFiles-1)*MAX_nruns;  
+    AnticipatedNumberOfLinesInTheLastFile = NumberOfDrawsToBeSaved - (AnticipatedNumberOfFiles-1)*MAX_nruns;
     record.LastFileNumber = LastFileNumber + AnticipatedNumberOfFiles;
     record.LastLineNumber = AnticipatedNumberOfLinesInTheLastFile;
     record.MhDraws(end,1) = nruns(1);
@@ -312,15 +312,15 @@ elseif options_.mh_recover
     load_last_mh_history_file(MetropolisFolder, ModelName);
     NumberOfBlocks = record.Nblck;% Number of "parallel" mcmc chains.
     options_.mh_nblck = NumberOfBlocks;
-    
+
     %% check consistency of options
     if record.MhDraws(end,1)~=options_.mh_replic
         fprintf('\nEstimation::mcmc: You cannot specify a different mh_replic than in the chain you are trying to recover\n')
         fprintf('Estimation::mcmc: I am resetting mh_replic to %u\n',record.MhDraws(end,1))
         options_.mh_replic=record.MhDraws(end,1);
         nruns = ones(NumberOfBlocks,1)*options_.mh_replic;
-    end    
-    
+    end
+
     if ~isnan(record.MAX_nruns(end,1)) %field exists
         if record.MAX_nruns(end,1)~=MAX_nruns
             fprintf('\nEstimation::mcmc: You cannot specify a different MaxNumberOfBytes than in the chain you are trying to recover\n')
@@ -347,9 +347,9 @@ elseif options_.mh_recover
     if OldMhExists
         LastLineNumberInThePreviousMh = record.MhDraws(end-1,3);% Number of lines in the last mh files of the previous session.
         LastFileNumberInThePreviousMh = sum(record.MhDraws(1:end-1,2),1);% Number of mh files in the the previous sessions.
-        %Test if the last mh files of the previous session were not full yet 
-        if LastLineNumberInThePreviousMh < MAX_nruns%not full 
-            %store starting point if whole chain needs to be redone
+                                                                         %Test if the last mh files of the previous session were not full yet
+        if LastLineNumberInThePreviousMh < MAX_nruns%not full
+                                                    %store starting point if whole chain needs to be redone
             NewFile = ones(NumberOfBlocks,1)*LastFileNumberInThePreviousMh;
             FirstLine = ones(NumberOfBlocks,1)*(LastLineNumberInThePreviousMh+1);
             LastFileFullIndicator=0;
@@ -368,7 +368,7 @@ elseif options_.mh_recover
     end
     [d,bayestopt_]=set_proposal_density_to_previous_value(record,options_,bayestopt_);
     %% Now find out what exactly needs to be redone
-    % 1. Check if really something needs to be done 
+    % 1. Check if really something needs to be done
     % How many mh files should we have ?
     ExpectedNumberOfMhFilesPerBlock = sum(record.MhDraws(:,2),1);
     ExpectedNumberOfMhFiles = ExpectedNumberOfMhFilesPerBlock*NumberOfBlocks;
@@ -378,7 +378,7 @@ elseif options_.mh_recover
     % Quit if no crashed mcmc chain can be found as there are as many files as expected
     if (TotalNumberOfMhFiles==ExpectedNumberOfMhFiles)
         disp('Estimation::mcmc: It appears that you don''t need to use the mh_recover option!')
-        disp('                  You have to edit the mod file and remove the mh_recover option') 
+        disp('                  You have to edit the mod file and remove the mh_recover option')
         disp('                  in the estimation command')
         error('Estimation::mcmc: mh_recover option not required!')
     end
@@ -401,15 +401,15 @@ elseif options_.mh_recover
         end
         FirstBlock = FirstBlock+1;
     end
-    
-    %% 3. Overwrite default settings for 
+
+    %% 3. Overwrite default settings for
     % How many mh-files are saved in this block?
     NumberOfSavedMhFilesInTheCrashedBlck = NumberOfMhFilesPerBlock(FirstBlock);
     ExistingDrawsInLastMCFile=0; %initialize: no MCMC draws of current MCMC are in file from last run
-    % Check whether last present file is a file included in the last MCMC run
-    if ~LastFileFullIndicator 
+                                 % Check whether last present file is a file included in the last MCMC run
+    if ~LastFileFullIndicator
         if NumberOfSavedMhFilesInTheCrashedBlck==NewFile(FirstBlock) %only that last file exists, but no files from current MCMC
-            loaded_results=load([BaseName '_mh' int2str(NewFile(FirstBlock)) '_blck' int2str(FirstBlock) '.mat']);    
+            loaded_results=load([BaseName '_mh' int2str(NewFile(FirstBlock)) '_blck' int2str(FirstBlock) '.mat']);
             %check whether that last file was filled
             if size(loaded_results.x2,1)==MAX_nruns %file is full
                 NewFile(FirstBlock)=NewFile(FirstBlock)+1; %set first file to be created to next one
@@ -419,20 +419,20 @@ elseif options_.mh_recover
                 ExistingDrawsInLastMCFile=0;
             end
         end
-    elseif LastFileFullIndicator 
+    elseif LastFileFullIndicator
         ExistingDrawsInLastMCFile=0;
         if NumberOfSavedMhFilesInTheCrashedBlck==NewFile(FirstBlock) %only the last file exists, but no files from current MCMC
             NewFile(FirstBlock)=NewFile(FirstBlock)+1; %set first file to be created to next one
         end
     end
-%     % Correct the number of saved mh files if the crashed Metropolis was not the first session (so
-%     % that NumberOfSavedMhFilesInTheCrashedBlck is the number of saved mh files in the crashed chain 
-%     % of the current session).  
-%     if OldMhExists
-%         NumberOfSavedMhFilesInTheCrashedBlck = NumberOfSavedMhFilesInTheCrashedBlck - LastFileNumberInThePreviousMh;
-%     end
-%     NumberOfSavedMhFiles = NumberOfSavedMhFilesInTheCrashedBlck+LastFileNumberInThePreviousMh;
-    
+    %     % Correct the number of saved mh files if the crashed Metropolis was not the first session (so
+    %     % that NumberOfSavedMhFilesInTheCrashedBlck is the number of saved mh files in the crashed chain
+    %     % of the current session).
+    %     if OldMhExists
+    %         NumberOfSavedMhFilesInTheCrashedBlck = NumberOfSavedMhFilesInTheCrashedBlck - LastFileNumberInThePreviousMh;
+    %     end
+    %     NumberOfSavedMhFiles = NumberOfSavedMhFilesInTheCrashedBlck+LastFileNumberInThePreviousMh;
+
     % Correct initial conditions.
     if NumberOfSavedMhFilesInTheCrashedBlck<ExpectedNumberOfMhFilesPerBlock
         loaded_results=load([BaseName '_mh' int2str(NumberOfSavedMhFilesInTheCrashedBlck) '_blck' int2str(FirstBlock) '.mat']);
@@ -452,19 +452,19 @@ elseif options_.mh_recover
 end
 
 function [d,bayestopt_]=set_proposal_density_to_previous_value(record,options_,bayestopt_,d)
-    if isfield(record,'ProposalCovariance') && isfield(record,'ProposalCovariance')
-        if isfield(record,'MCMC_sampler')
-            if ~strcmp(record.MCMC_sampler,options_.posterior_sampler_options.posterior_sampling_method)
-                error(fprintf('Estimation::mcmc: The posterior_sampling_method differs from the one of the original chain. Please reset it to %s',record.MCMC_sampler))
-            end 
-        end
-        fprintf('Estimation::mcmc: Recovering the previous proposal density.\n')
-        d=record.ProposalCovariance;
-        bayestopt_.jscale=record.ProposalScaleVec;
-    else
-        if options_.mode_compute~=0
-            fprintf('Estimation::mcmc: No stored previous proposal density found, continuing with the one implied by mode_compute\n.');
-        elseif ~isempty(options_.mode_file)
-            fprintf('Estimation::mcmc: No stored previous proposal density found, continuing with the one implied by the mode_file\n.');
+if isfield(record,'ProposalCovariance') && isfield(record,'ProposalCovariance')
+    if isfield(record,'MCMC_sampler')
+        if ~strcmp(record.MCMC_sampler,options_.posterior_sampler_options.posterior_sampling_method)
+            error(fprintf('Estimation::mcmc: The posterior_sampling_method differs from the one of the original chain. Please reset it to %s',record.MCMC_sampler))
         end
     end
+    fprintf('Estimation::mcmc: Recovering the previous proposal density.\n')
+    d=record.ProposalCovariance;
+    bayestopt_.jscale=record.ProposalScaleVec;
+else
+    if options_.mode_compute~=0
+        fprintf('Estimation::mcmc: No stored previous proposal density found, continuing with the one implied by mode_compute\n.');
+    elseif ~isempty(options_.mode_file)
+        fprintf('Estimation::mcmc: No stored previous proposal density found, continuing with the one implied by the mode_file\n.');
+    end
+end
diff --git a/matlab/posterior_sampler_iteration.m b/matlab/posterior_sampler_iteration.m
index 09e5d8851..5b54e785e 100644
--- a/matlab/posterior_sampler_iteration.m
+++ b/matlab/posterior_sampler_iteration.m
@@ -1,173 +1,173 @@
-function  [par, logpost, accepted, neval] = posterior_sampler_iteration(TargetFun,last_draw, last_posterior, sampler_options,varargin)
-
-% function [par, logpost, accepted, neval] = posterior_sampler_iteration(TargetFun,last_draw, last_posterior, sampler_options,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_)
-% posterior samplers
-%
-% INPUTS
-%   posterior_sampler_options:       posterior sampler options
-%   options_:       structure storing the options
-
-% OUTPUTS
-%   posterior_sampler_options:       checked posterior sampler options
-%
-% SPECIAL REQUIREMENTS
-%   none
-
-% Copyright (C) 2015-16 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/>.
-
-
-posterior_sampling_method = sampler_options.posterior_sampling_method;
-mh_bounds = sampler_options.bounds;
-
-switch posterior_sampling_method
-    case 'slice'
-        
-        [par, logpost, neval] = slice_sampler(TargetFun,last_draw, [mh_bounds.lb mh_bounds.ub], sampler_options,varargin{:});
-        accepted = 1;
-    case 'random_walk_metropolis_hastings'
-        neval = 1;
-        ProposalFun = sampler_options.proposal_distribution;
-        proposal_covariance_Cholesky_decomposition = sampler_options.proposal_covariance_Cholesky_decomposition;
-        n = sampler_options.n;
-
-        par = feval(ProposalFun, last_draw, proposal_covariance_Cholesky_decomposition, n);
-        if all( par(:) > mh_bounds.lb ) && all( par(:) < mh_bounds.ub )
-            try
-                logpost = - feval(TargetFun, par(:),varargin{:});
-            catch
-                logpost = -inf;
-            end
-        else
-            logpost = -inf;
-        end
-        r = logpost-last_posterior;
-        if (logpost > -inf) && (log(rand) < r)
-            accepted = 1;
-        else
-            accepted = 0;
-            par = last_draw;
-            logpost = last_posterior;
-        end
-    case 'tailored_random_block_metropolis_hastings'
-        options_=varargin{3};
-        bayestopt_=varargin{6};
-        npar=length(last_draw);
-        %% randomize indices for blocking in this iteration
-        indices=randperm(npar)';
-        blocks=[1; (1+cumsum((rand(length(indices)-1,1)>(1-sampler_options.new_block_probability))))];
-        nblocks=blocks(end,1); %get number of blocks this iteration
-        current_draw=last_draw'; %get starting point for current draw for updating
-        blocked_draws_counter=0;
-        accepted_draws_counter=0;
-        for block_iter=1:nblocks
-            blocked_draws_counter=blocked_draws_counter+1;
-            nxopt=length(indices(blocks==block_iter,1)); %get size of current block
-            par_start_current_block=current_draw(indices(blocks==block_iter,1));
-            [xopt_current_block, fval, exitflag, hess_mat_optimizer, options_, Scale] = dynare_minimize_objective(@TaRB_optimizer_wrapper,par_start_current_block,sampler_options.mode_compute,options_,[mh_bounds.lb(indices(blocks==block_iter,1),1) mh_bounds.ub(indices(blocks==block_iter,1),1)],bayestopt_.name,bayestopt_,[],...
-                current_draw,indices(blocks==block_iter,1),TargetFun,...% inputs for wrapper
-                varargin{:}); %inputs for objective           
-            %% covariance for proposal density
-            hessian_mat = reshape(hessian('TaRB_optimizer_wrapper',xopt_current_block, ...
-                    options_.gstep,...
-                    current_draw,indices(blocks==block_iter,1),TargetFun,...% inputs for wrapper
-                    varargin{:}),nxopt,nxopt);
-            
-            if any(any(isnan(hessian_mat))) || any(any(isinf(hessian_mat)))
-                inverse_hessian_mat=eye(nxopt)*1e-4; %use diagonal
-            else
-                inverse_hessian_mat=inv(hessian_mat); %get inverse Hessian
-                if any(any((isnan(inverse_hessian_mat)))) || any(any((isinf(inverse_hessian_mat))))
-                    inverse_hessian_mat=eye(nxopt)*1e-4; %use diagonal
-                end               
-            end
-            [proposal_covariance_Cholesky_decomposition_upper,negeigenvalues]=chol(inverse_hessian_mat);            
-            %if not positive definite, use generalized Cholesky of Eskow/Schnabel
-            if negeigenvalues~=0 
-                proposal_covariance_Cholesky_decomposition_upper=chol_SE(inverse_hessian_mat,0);
-            end
-            proposal_covariance_Cholesky_decomposition_upper=proposal_covariance_Cholesky_decomposition_upper*diag(bayestopt_.jscale(indices(blocks==block_iter,1),:));
-            %get proposal draw
-            if strcmpi(sampler_options.proposal_distribution,'rand_multivariate_normal')
-                n = nxopt;
-            elseif strcmpi(sampler_options.proposal_distribution,'rand_multivariate_student')
-                n = options_.student_degrees_of_freedom;
-            end
-    
-            proposed_par = feval(sampler_options.proposal_distribution, xopt_current_block', proposal_covariance_Cholesky_decomposition_upper, n);
-            % check whether draw is valid and compute posterior
-            if all( proposed_par(:) > mh_bounds.lb(indices(blocks==block_iter,1),:) ) && all( proposed_par(:) < mh_bounds.ub(indices(blocks==block_iter,1),:) )
-                try
-                    logpost = - feval('TaRB_optimizer_wrapper', proposed_par(:),...
-                        current_draw,indices(blocks==block_iter,1),TargetFun,...% inputs for wrapper
-                        varargin{:});
-                catch
-                    logpost = -inf;
-                end
-            else
-                logpost = -inf;
-            end
-            %get ratio of proposal densities, required because proposal depends
-            %on current mode via Hessian and is thus not symmetric anymore
-            if strcmpi(sampler_options.proposal_distribution,'rand_multivariate_normal')
-                proposal_density_proposed_move_forward=multivariate_normal_pdf(proposed_par,xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
-                proposal_density_proposed_move_backward=multivariate_normal_pdf(par_start_current_block',xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
-            elseif strcmpi(sampler_options.proposal_distribution,'rand_multivariate_student')
-                proposal_density_proposed_move_forward=multivariate_student_pdf(proposed_par,xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
-                proposal_density_proposed_move_backward=multivariate_student_pdf(par_start_current_block',xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
-            end
-            accprob=logpost-last_posterior+ log(proposal_density_proposed_move_backward)-log(proposal_density_proposed_move_forward); %Formula (6), Chib/Ramamurthy
-
-            if (logpost > -inf) && (log(rand) < accprob)
-                current_draw(indices(blocks==block_iter,1))=proposed_par;
-                last_posterior=logpost;
-                accepted_draws_counter =accepted_draws_counter +1;
-            else %no updating 
-                %do nothing, keep old value
-            end
-        end
-        accepted=accepted_draws_counter/blocked_draws_counter;
-        par = current_draw;
-        neval=1;
-    case 'independent_metropolis_hastings'
-        neval = 1;
-        ProposalFun = sampler_options.proposal_distribution;
-        ProposalDensity = sampler_options.ProposalDensity;
-        proposal_covariance_Cholesky_decomposition = sampler_options.proposal_covariance_Cholesky_decomposition;
-        n = sampler_options.n;
-        xparam1 = sampler_options.xparam1';
-        par = feval(ProposalFun, xparam1, proposal_covariance_Cholesky_decomposition, n);
-        if all( par(:) > mh_bounds.lb ) && all( par(:) < mh_bounds.ub )
-            try
-                logpost = - feval(TargetFun, par(:),varargin{:});
-            catch
-                logpost = -inf;
-            end
-        else
-            logpost = -inf;
-        end
-            r = logpost - last_posterior + ...
-                log(feval(ProposalDensity, last_draw, xparam1, proposal_covariance_Cholesky_decomposition, n)) - ...
-                log(feval(ProposalDensity, par, xparam1, proposal_covariance_Cholesky_decomposition, n));
-        if (logpost > -inf) && (log(rand) < r)
-            accepted = 1;
-        else
-            accepted = 0;
-            par = last_draw;
-            logpost = last_posterior;
-        end
+function  [par, logpost, accepted, neval] = posterior_sampler_iteration(TargetFun,last_draw, last_posterior, sampler_options,varargin)
+
+% function [par, logpost, accepted, neval] = posterior_sampler_iteration(TargetFun,last_draw, last_posterior, sampler_options,dataset_,dataset_info,options_,M_,estim_params_,bayestopt_,mh_bounds,oo_)
+% posterior samplers
+%
+% INPUTS
+%   posterior_sampler_options:       posterior sampler options
+%   options_:       structure storing the options
+
+% OUTPUTS
+%   posterior_sampler_options:       checked posterior sampler options
+%
+% SPECIAL REQUIREMENTS
+%   none
+
+% Copyright (C) 2015-16 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/>.
+
+
+posterior_sampling_method = sampler_options.posterior_sampling_method;
+mh_bounds = sampler_options.bounds;
+
+switch posterior_sampling_method
+  case 'slice'
+
+    [par, logpost, neval] = slice_sampler(TargetFun,last_draw, [mh_bounds.lb mh_bounds.ub], sampler_options,varargin{:});
+    accepted = 1;
+  case 'random_walk_metropolis_hastings'
+    neval = 1;
+    ProposalFun = sampler_options.proposal_distribution;
+    proposal_covariance_Cholesky_decomposition = sampler_options.proposal_covariance_Cholesky_decomposition;
+    n = sampler_options.n;
+
+    par = feval(ProposalFun, last_draw, proposal_covariance_Cholesky_decomposition, n);
+    if all( par(:) > mh_bounds.lb ) && all( par(:) < mh_bounds.ub )
+        try
+            logpost = - feval(TargetFun, par(:),varargin{:});
+        catch
+            logpost = -inf;
+        end
+    else
+        logpost = -inf;
+    end
+    r = logpost-last_posterior;
+    if (logpost > -inf) && (log(rand) < r)
+        accepted = 1;
+    else
+        accepted = 0;
+        par = last_draw;
+        logpost = last_posterior;
+    end
+  case 'tailored_random_block_metropolis_hastings'
+    options_=varargin{3};
+    bayestopt_=varargin{6};
+    npar=length(last_draw);
+    %% randomize indices for blocking in this iteration
+    indices=randperm(npar)';
+    blocks=[1; (1+cumsum((rand(length(indices)-1,1)>(1-sampler_options.new_block_probability))))];
+    nblocks=blocks(end,1); %get number of blocks this iteration
+    current_draw=last_draw'; %get starting point for current draw for updating
+    blocked_draws_counter=0;
+    accepted_draws_counter=0;
+    for block_iter=1:nblocks
+        blocked_draws_counter=blocked_draws_counter+1;
+        nxopt=length(indices(blocks==block_iter,1)); %get size of current block
+        par_start_current_block=current_draw(indices(blocks==block_iter,1));
+        [xopt_current_block, fval, exitflag, hess_mat_optimizer, options_, Scale] = dynare_minimize_objective(@TaRB_optimizer_wrapper,par_start_current_block,sampler_options.mode_compute,options_,[mh_bounds.lb(indices(blocks==block_iter,1),1) mh_bounds.ub(indices(blocks==block_iter,1),1)],bayestopt_.name,bayestopt_,[],...
+                                                          current_draw,indices(blocks==block_iter,1),TargetFun,...% inputs for wrapper
+                                                          varargin{:}); %inputs for objective
+        %% covariance for proposal density
+        hessian_mat = reshape(hessian('TaRB_optimizer_wrapper',xopt_current_block, ...
+                                      options_.gstep,...
+                                      current_draw,indices(blocks==block_iter,1),TargetFun,...% inputs for wrapper
+                                      varargin{:}),nxopt,nxopt);
+
+        if any(any(isnan(hessian_mat))) || any(any(isinf(hessian_mat)))
+            inverse_hessian_mat=eye(nxopt)*1e-4; %use diagonal
+        else
+            inverse_hessian_mat=inv(hessian_mat); %get inverse Hessian
+            if any(any((isnan(inverse_hessian_mat)))) || any(any((isinf(inverse_hessian_mat))))
+                inverse_hessian_mat=eye(nxopt)*1e-4; %use diagonal
+            end
+        end
+        [proposal_covariance_Cholesky_decomposition_upper,negeigenvalues]=chol(inverse_hessian_mat);
+        %if not positive definite, use generalized Cholesky of Eskow/Schnabel
+        if negeigenvalues~=0
+            proposal_covariance_Cholesky_decomposition_upper=chol_SE(inverse_hessian_mat,0);
+        end
+        proposal_covariance_Cholesky_decomposition_upper=proposal_covariance_Cholesky_decomposition_upper*diag(bayestopt_.jscale(indices(blocks==block_iter,1),:));
+        %get proposal draw
+        if strcmpi(sampler_options.proposal_distribution,'rand_multivariate_normal')
+            n = nxopt;
+        elseif strcmpi(sampler_options.proposal_distribution,'rand_multivariate_student')
+            n = options_.student_degrees_of_freedom;
+        end
+
+        proposed_par = feval(sampler_options.proposal_distribution, xopt_current_block', proposal_covariance_Cholesky_decomposition_upper, n);
+        % check whether draw is valid and compute posterior
+        if all( proposed_par(:) > mh_bounds.lb(indices(blocks==block_iter,1),:) ) && all( proposed_par(:) < mh_bounds.ub(indices(blocks==block_iter,1),:) )
+            try
+                logpost = - feval('TaRB_optimizer_wrapper', proposed_par(:),...
+                                  current_draw,indices(blocks==block_iter,1),TargetFun,...% inputs for wrapper
+                                  varargin{:});
+            catch
+                logpost = -inf;
+            end
+        else
+            logpost = -inf;
+        end
+        %get ratio of proposal densities, required because proposal depends
+        %on current mode via Hessian and is thus not symmetric anymore
+        if strcmpi(sampler_options.proposal_distribution,'rand_multivariate_normal')
+            proposal_density_proposed_move_forward=multivariate_normal_pdf(proposed_par,xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
+            proposal_density_proposed_move_backward=multivariate_normal_pdf(par_start_current_block',xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
+        elseif strcmpi(sampler_options.proposal_distribution,'rand_multivariate_student')
+            proposal_density_proposed_move_forward=multivariate_student_pdf(proposed_par,xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
+            proposal_density_proposed_move_backward=multivariate_student_pdf(par_start_current_block',xopt_current_block',proposal_covariance_Cholesky_decomposition_upper,n);
+        end
+        accprob=logpost-last_posterior+ log(proposal_density_proposed_move_backward)-log(proposal_density_proposed_move_forward); %Formula (6), Chib/Ramamurthy
+
+        if (logpost > -inf) && (log(rand) < accprob)
+            current_draw(indices(blocks==block_iter,1))=proposed_par;
+            last_posterior=logpost;
+            accepted_draws_counter =accepted_draws_counter +1;
+        else %no updating
+             %do nothing, keep old value
+        end
+    end
+    accepted=accepted_draws_counter/blocked_draws_counter;
+    par = current_draw;
+    neval=1;
+  case 'independent_metropolis_hastings'
+    neval = 1;
+    ProposalFun = sampler_options.proposal_distribution;
+    ProposalDensity = sampler_options.ProposalDensity;
+    proposal_covariance_Cholesky_decomposition = sampler_options.proposal_covariance_Cholesky_decomposition;
+    n = sampler_options.n;
+    xparam1 = sampler_options.xparam1';
+    par = feval(ProposalFun, xparam1, proposal_covariance_Cholesky_decomposition, n);
+    if all( par(:) > mh_bounds.lb ) && all( par(:) < mh_bounds.ub )
+        try
+            logpost = - feval(TargetFun, par(:),varargin{:});
+        catch
+            logpost = -inf;
+        end
+    else
+        logpost = -inf;
+    end
+    r = logpost - last_posterior + ...
+        log(feval(ProposalDensity, last_draw, xparam1, proposal_covariance_Cholesky_decomposition, n)) - ...
+        log(feval(ProposalDensity, par, xparam1, proposal_covariance_Cholesky_decomposition, n));
+    if (logpost > -inf) && (log(rand) < r)
+        accepted = 1;
+    else
+        accepted = 0;
+        par = last_draw;
+        logpost = last_posterior;
+    end
 end
\ No newline at end of file
diff --git a/matlab/print_bytecode_dynamic_model.m b/matlab/print_bytecode_dynamic_model.m
index f4e381ed1..af5eb0115 100644
--- a/matlab/print_bytecode_dynamic_model.m
+++ b/matlab/print_bytecode_dynamic_model.m
@@ -1,17 +1,17 @@
 function print_bytecode_dynamic_model()
 % function print_bytecode_dynamic_model()
 % print the model and jacobian from the bytecode format for the dynamic model
-%  
+%
 % INPUTS
 %   none
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2011 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/print_bytecode_static_model.m b/matlab/print_bytecode_static_model.m
index bc216c70d..ece12428b 100644
--- a/matlab/print_bytecode_static_model.m
+++ b/matlab/print_bytecode_static_model.m
@@ -1,17 +1,17 @@
 function print_bytecode_static_model()
 % function print_bytecode_static_model()
 % print the model and jacobian from the bytecode format for the static model
-%  
+%
 % INPUTS
 %   none
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2011 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/print_info.m b/matlab/print_info.m
index af5b40fc8..76ec1d115 100644
--- a/matlab/print_info.m
+++ b/matlab/print_info.m
@@ -2,7 +2,7 @@ function print_info(info, noprint, DynareOptions)
 % Prints error messages
 %
 % INPUTS
-%   info              [double]     vector returned by resol.m 
+%   info              [double]     vector returned by resol.m
 %   noprint           [integer]    equal to 0 if the error message has to be printed.
 %   DynareOptions     [structure]  --> options_
 % OUTPUTS
@@ -11,7 +11,7 @@ function print_info(info, noprint, DynareOptions)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2013 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,15 +54,15 @@ if ~noprint
         error('One of the eigenvalues is close to 0/0 (the absolute value of numerator and denominator is smaller than %s!\n If you believe that the model has a unique solution you can try to reduce the value of qz_zero_threshold.',num2str(DynareOptions.qz_zero_threshold))
       case 8
         if size(info,2)>=2
-          global M_;
+            global M_;
             disp_string=deblank(M_.param_names(info(2),:));
-          for ii=1:length(info)-2
-            disp_string=[disp_string,', ',deblank(M_.param_names(info(2+ii),:))];
-          end
-          error(['The Jacobian contains NaNs because the following parameters are NaN: '...
-              disp_string])
+            for ii=1:length(info)-2
+                disp_string=[disp_string,', ',deblank(M_.param_names(info(2+ii),:))];
+            end
+            error(['The Jacobian contains NaNs because the following parameters are NaN: '...
+                   disp_string])
         else
-          error(['The Jacobian contains NaNs. For more information, use options_.debug.'])
+            error(['The Jacobian contains NaNs. For more information, use options_.debug.'])
         end
       case 9
         error(['k_order_pert was unable to compute the solution'])
@@ -78,7 +78,7 @@ if ~noprint
         if DynareOptions.linear
             error(['Impossible to find the steady state. Either the model' ...
                    ' doesn''t have a steady state or there are an infinity of steady states.' ...
-                   ' Check whether your model is truly linear or whether there is a mistake in linearization.'])        
+                   ' Check whether your model is truly linear or whether there is a mistake in linearization.'])
         else
             error(['Impossible to find the steady state. Either the model' ...
                    ' doesn''t have a steady state, there are an infinity of steady states,' ...
@@ -117,12 +117,14 @@ if ~noprint
       case 49
         error('The model violates one (many) endogenous prior restriction(s)')
       case 50
-        error('Likelihood is Inf')        
+        error('Likelihood is Inf')
       case 51
         fprintf('\n The dsge_prior_weight is dsge_var=%5.4f, but must be at least %5.4f for the prior to be proper.\n',info(2),info(3));
         error('You are estimating a DSGE-VAR model, but the value of the dsge prior weight is too low!')
       case 52 %dsge_var_likelihood
-        error('You are estimating a DSGE-VAR model, but the implied covariance matrix of the VAR''s innovations is not positive definite!');
+        error('You are estimating a DSGE-VAR model, but the implied covariance matrix of the VAR''s innovations, based on artificial and actual sample is not positive definite!');
+      case 53 %dsge_var_likelihood
+        error('You are estimating a DSGE-VAR model, but the implied covariance matrix of the VAR''s innovations, based on the artificial sample, is not positive definite!');
       case 55
         error('Fast Kalman filter only works with stationary models [lik_init=1] or stationary observables for non-stationary models [lik_init=3]')
       case 61 %Discretionary policy
diff --git a/matlab/print_moments_implied_prior.m b/matlab/print_moments_implied_prior.m
index 496e3bf86..94d14cb02 100644
--- a/matlab/print_moments_implied_prior.m
+++ b/matlab/print_moments_implied_prior.m
@@ -1,9 +1,9 @@
 function print_moments_implied_prior(ModelInfo, mm, vm, mv, vv)
 
 % This routine prints in the command window some descriptive statistics
-% about the endogenous variables implied prior moments. 
+% about the endogenous variables implied prior moments.
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/print_table_prior.m b/matlab/print_table_prior.m
index 605adfabf..e4c7894a8 100644
--- a/matlab/print_table_prior.m
+++ b/matlab/print_table_prior.m
@@ -1,8 +1,8 @@
 function print_table_prior(lb, ub, DynareOptions, ModelInfo, BayesInfo, EstimationInfo)
 
-% This routine prints in the command window some descriptive statistics about the prior distribution. 
+% This routine prints in the command window some descriptive statistics about the prior distribution.
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -25,6 +25,8 @@ PriorNames = strvcat(PriorNames,'Gaussian');
 PriorNames = strvcat(PriorNames,'Inverted Gamma');
 PriorNames = strvcat(PriorNames,'Uniform');
 PriorNames = strvcat(PriorNames,'Inverted Gamma -- 2');
+PriorNames = strvcat(PriorNames,'Dirichlet');
+PriorNames = strvcat(PriorNames,'Weibull');
 
 n = size(BayesInfo.name,1); % Numbe rof estimated parameters.
 
@@ -71,7 +73,7 @@ for i=1:size(BayesInfo.name,1)
         if ~isinf(ub(i))
             UpperBound=min(UpperBound,ub(i));
         end
-      case { 2 , 4 , 6 }
+      case { 2 , 4 , 6 , 8}
         LowerBound = BayesInfo.p3(i);
         if ~isinf(lb(i))
             LowerBound=max(LowerBound,lb(i));
@@ -111,7 +113,7 @@ for i=1:size(BayesInfo.name,1)
                   UpperBound, ...
                   PriorIntervals.lb(i), ...
                   PriorIntervals.ub(i) );
-    T2 = strvcat(T2, str);    
+    T2 = strvcat(T2, str);
 end
 
 T1 = strvcat(T1, l1);
@@ -134,25 +136,25 @@ skipline(2)
 
 
 function format_string = build_format_string(PriorMode,PriorStandardDeviation,LowerBound,UpperBound)
-    format_string = ['%s \t %6.4f \t'];
-    if isnan(PriorMode)
-        format_string = [ format_string , ' %s \t'];
-    else
-        format_string = [ format_string , ' %6.4f \t'];
-    end
-    if ~isnumeric(PriorStandardDeviation)
-        format_string = [ format_string , ' %s \t'];
-    else
-        format_string = [ format_string , ' %6.4f \t'];
-    end
-    if ~isnumeric(LowerBound)
-        format_string = [ format_string , ' %s \t'];
-    else
-        format_string = [ format_string , ' %6.4f \t'];
-    end
-    if ~isnumeric(UpperBound)
-        format_string = [ format_string , ' %s \t'];
-    else
-        format_string = [ format_string , ' %6.4f \t'];
-    end
-    format_string = [ format_string , ' %6.4f \t %6.4f'];
\ No newline at end of file
+format_string = ['%s \t %6.4f \t'];
+if isnan(PriorMode)
+    format_string = [ format_string , ' %s \t'];
+else
+    format_string = [ format_string , ' %6.4f \t'];
+end
+if ~isnumeric(PriorStandardDeviation)
+    format_string = [ format_string , ' %s \t'];
+else
+    format_string = [ format_string , ' %6.4f \t'];
+end
+if ~isnumeric(LowerBound)
+    format_string = [ format_string , ' %s \t'];
+else
+    format_string = [ format_string , ' %6.4f \t'];
+end
+if ~isnumeric(UpperBound)
+    format_string = [ format_string , ' %s \t'];
+else
+    format_string = [ format_string , ' %6.4f \t'];
+end
+format_string = [ format_string , ' %6.4f \t %6.4f'];
\ No newline at end of file
diff --git a/matlab/printline.m b/matlab/printline.m
index c60d0906a..29d4ec1c3 100644
--- a/matlab/printline.m
+++ b/matlab/printline.m
@@ -1,16 +1,16 @@
 function varargout = printline(n, s, fid)
 % This function print a line formed by replicating a symbol s.
 %
-% INPUTS 
+% INPUTS
 %
 %   n  [integer]    Length of the printed line
 %   s  [char]       Symbol used to draw the line (+, -, =, ...)
 %   f  [integer]    file id returned by fopen
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   None
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -25,7 +25,7 @@ function varargout = printline(n, s, fid)
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 if nargin<3
     f = 1;
diff --git a/matlab/prior_analysis.m b/matlab/prior_analysis.m
index fd79414e5..5820f69c3 100644
--- a/matlab/prior_analysis.m
+++ b/matlab/prior_analysis.m
@@ -1,5 +1,5 @@
 function oo_ = prior_analysis(type,arg1,arg2,arg3,options_,M_,oo_,estim_params_)
-% Copyright (C) 2009-2012 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -56,7 +56,7 @@ switch type
             dsge_simulated_theoretical_covariance(SampleSize,M_,options_,oo_,'prior');
     end
     oo_ = covariance_mc_analysis(SampleSize,'prior',M_.dname,M_.fname,...
-                                 vartan,nvar,arg1,arg2,options_.mh_conf_sig,oo_,options_);          
+                                 vartan,nvar,arg1,arg2,options_.mh_conf_sig,oo_,options_);
   case 'decomposition'
     if nargin==narg1
         [nvar,vartan,NumberOfFiles] = ...
diff --git a/matlab/prior_bounds.m b/matlab/prior_bounds.m
index 2bf1173ed..56ef1eb32 100644
--- a/matlab/prior_bounds.m
+++ b/matlab/prior_bounds.m
@@ -40,14 +40,14 @@ function bounds = prior_bounds(bayestopt, prior_trunc)
 %
 % INPUTS
 %    bayestopt  [structure]  characterizing priors (shape, mean, p1..p4)
-%    
+%
 % OUTPUTS
 %    bounds     [double]      structure specifying prior bounds (lb and ub fields)
-%    
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2012 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/prior_draw.m b/matlab/prior_draw.m
index 4eb628df9..c97eaeefd 100644
--- a/matlab/prior_draw.m
+++ b/matlab/prior_draw.m
@@ -2,10 +2,10 @@ function pdraw = prior_draw(BayesInfo, prior_trunc, uniform) % --*-- Unitary tes
 
 % This function generate one draw from the joint prior distribution and
 % allows sampling uniformly from the prior support (uniform==1 when called with init==1)
-% 
-% INPUTS 
-%   o init             [integer]    scalar equal to: 
-%                                       1: first call to set up persistent variables 
+%
+% INPUTS
+%   o init             [integer]    scalar equal to:
+%                                       1: first call to set up persistent variables
 %                                             describing the prior
 %                                       0: subsequent call to get prior
 %                                               draw
@@ -13,8 +13,8 @@ function pdraw = prior_draw(BayesInfo, prior_trunc, uniform) % --*-- Unitary tes
 %                                       1: sample uniformly from prior
 %                                           support (overwrites prior shape used for sampling within this function)
 %                                       0: sample from joint prior distribution
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   o pdraw            [double]     1*npar vector, draws from the joint prior density.
 %
 %
@@ -25,8 +25,8 @@ function pdraw = prior_draw(BayesInfo, prior_trunc, uniform) % --*-- Unitary tes
 % NOTE 2. A given draw from the joint prior distribution does not satisfy BK conditions a priori.
 % NOTE 3. This code relies on bayestopt_ as created in the base workspace
 %           by the preprocessor (or as updated in subsequent pieces of code and handed to the base workspace)
-% 
-% Copyright (C) 2006-2016 Dynare Team
+%
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -108,9 +108,9 @@ if nargin>0
 end
 
 if uniform_draws
-    pdraw(uniform_index) = rand(length(uniform_index),1).*(p4(uniform_index)-p3(uniform_index)) + p3(uniform_index);  
+    pdraw(uniform_index) = rand(length(uniform_index),1).*(p4(uniform_index)-p3(uniform_index)) + p3(uniform_index);
     out_of_bound = find( (pdraw(uniform_index)'>ub(uniform_index)) | (pdraw(uniform_index)'<lb(uniform_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(uniform_index) = rand(length(uniform_index),1).*(p4(uniform_index)-p3(uniform_index)) + p3(uniform_index);
         out_of_bound = find( (pdraw(uniform_index)'>ub(uniform_index)) | (pdraw(uniform_index)'<lb(uniform_index)));
     end
@@ -119,7 +119,7 @@ end
 if gaussian_draws
     pdraw(gaussian_index) = randn(length(gaussian_index),1).*p7(gaussian_index) + p6(gaussian_index);
     out_of_bound = find( (pdraw(gaussian_index)'>ub(gaussian_index)) | (pdraw(gaussian_index)'<lb(gaussian_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(gaussian_index(out_of_bound)) = randn(length(gaussian_index(out_of_bound)),1).*p7(gaussian_index(out_of_bound)) + p6(gaussian_index(out_of_bound));
         out_of_bound = find( (pdraw(gaussian_index)'>ub(gaussian_index)) | (pdraw(gaussian_index)'<lb(gaussian_index)));
     end
@@ -128,7 +128,7 @@ end
 if gamma_draws
     pdraw(gamma_index) = gamrnd(p6(gamma_index),p7(gamma_index))+p3(gamma_index);
     out_of_bound = find( (pdraw(gamma_index)'>ub(gamma_index)) | (pdraw(gamma_index)'<lb(gamma_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(gamma_index(out_of_bound)) = gamrnd(p6(gamma_index(out_of_bound)),p7(gamma_index(out_of_bound)))+p3(gamma_index(out_of_bound));
         out_of_bound = find( (pdraw(gamma_index)'>ub(gamma_index)) | (pdraw(gamma_index)'<lb(gamma_index)));
     end
@@ -137,7 +137,7 @@ end
 if beta_draws
     pdraw(beta_index) = (p4(beta_index)-p3(beta_index)).*betarnd(p6(beta_index),p7(beta_index))+p3(beta_index);
     out_of_bound = find( (pdraw(beta_index)'>ub(beta_index)) | (pdraw(beta_index)'<lb(beta_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(beta_index(out_of_bound)) = (p4(beta_index(out_of_bound))-p3(beta_index(out_of_bound))).*betarnd(p6(beta_index(out_of_bound)),p7(beta_index(out_of_bound)))+p3(beta_index(out_of_bound));
         out_of_bound = find( (pdraw(beta_index)'>ub(beta_index)) | (pdraw(beta_index)'<lb(beta_index)));
     end
@@ -147,7 +147,7 @@ if inverse_gamma_1_draws
     pdraw(inverse_gamma_1_index) = ...
         sqrt(1./gamrnd(p7(inverse_gamma_1_index)/2,2./p6(inverse_gamma_1_index)))+p3(inverse_gamma_1_index);
     out_of_bound = find( (pdraw(inverse_gamma_1_index)'>ub(inverse_gamma_1_index)) | (pdraw(inverse_gamma_1_index)'<lb(inverse_gamma_1_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(inverse_gamma_1_index(out_of_bound)) = ...
             sqrt(1./gamrnd(p7(inverse_gamma_1_index(out_of_bound))/2,2./p6(inverse_gamma_1_index(out_of_bound))))+p3(inverse_gamma_1_index(out_of_bound));
         out_of_bound = find( (pdraw(inverse_gamma_1_index)'>ub(inverse_gamma_1_index)) | (pdraw(inverse_gamma_1_index)'<lb(inverse_gamma_1_index)));
@@ -158,7 +158,7 @@ if inverse_gamma_2_draws
     pdraw(inverse_gamma_2_index) = ...
         1./gamrnd(p7(inverse_gamma_2_index)/2,2./p6(inverse_gamma_2_index))+p3(inverse_gamma_2_index);
     out_of_bound = find( (pdraw(inverse_gamma_2_index)'>ub(inverse_gamma_2_index)) | (pdraw(inverse_gamma_2_index)'<lb(inverse_gamma_2_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(inverse_gamma_2_index(out_of_bound)) = ...
             1./gamrnd(p7(inverse_gamma_2_index(out_of_bound))/2,2./p6(inverse_gamma_2_index(out_of_bound)))+p3(inverse_gamma_2_index(out_of_bound));
         out_of_bound = find( (pdraw(inverse_gamma_2_index)'>ub(inverse_gamma_2_index)) | (pdraw(inverse_gamma_2_index)'<lb(inverse_gamma_2_index)));
@@ -168,7 +168,7 @@ end
 if weibull_draws
     pdraw(weibull_index) = wblrnd(p7(weibull_index), p6(weibull_index)) + p3(weibull_index);
     out_of_bound = find( (pdraw(weibull_index)'>ub(weibull_index)) | (pdraw(weibull_index)'<lb(weibull_index)));
-    while ~isempty(out_of_bound),
+    while ~isempty(out_of_bound)
         pdraw(weibull_index(out_of_bound)) = wblrnd(p7(weibull_index(out_of_bound)),p6(weibull_index(out_of_bound)))+p3(weibull_index(out_of_bound));
         out_of_bound = find( (pdraw(weibull_index)'>ub(weibull_index)) | (pdraw(weibull_index)'<lb(weibull_index)));
     end
diff --git a/matlab/prior_posterior_statistics.m b/matlab/prior_posterior_statistics.m
index 039bd79b3..064e7874a 100644
--- a/matlab/prior_posterior_statistics.m
+++ b/matlab/prior_posterior_statistics.m
@@ -14,12 +14,12 @@ function prior_posterior_statistics(type,dataset,dataset_info)
 %
 % SPECIAL REQUIREMENTS
 %    none
-% 
+%
 % PARALLEL CONTEXT
 % See the comments in the posterior_sampler.m funtion.
-% 
-% 
-% Copyright (C) 2005-2016 Dynare Team
+%
+%
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -79,7 +79,7 @@ elseif strcmpi(type,'gsa')
         DirectoryName = CheckPath(['gsa',filesep,'mc'],M_.dname);
         load([ RootDirectoryName filesep  M_.fname '_mc.mat'],'lpmat0','lpmat','istable')
     end
-    if ~isempty(lpmat0),
+    if ~isempty(lpmat0)
         x=[lpmat0(istable,:) lpmat(istable,:)];
     else
         x=lpmat(istable,:);
@@ -117,13 +117,13 @@ if options_.filter_covariance
     MAX_filter_covariance = min(B,ceil(MaxNumberOfBytes/(endo_nbr^2*(gend+1))/8));
 end
 
-if options_.smoothed_state_uncertainty 
+if options_.smoothed_state_uncertainty
     MAX_n_smoothed_state_uncertainty = min(B,ceil(MaxNumberOfBytes/((endo_nbr*endo_nbr)*gend)/8));
 end
 
 varlist = options_.varlist;
 if isempty(varlist)
-    varlist = M_.endo_names(1:M_.orig_endo_nbr, :);
+    varlist = char(sort(cellstr(M_.endo_names(1:M_.orig_endo_nbr,:))));
 end
 nvar = size(varlist,1);
 SelecVariables = [];
@@ -141,6 +141,11 @@ ifil = zeros(n_variables_to_fill,1);
 run_smoother = 0;
 if options_.smoother || options_.forecast || options_.filter_step_ahead || options_.smoothed_state_uncertainty
     run_smoother = 1;
+    if options_.loglinear
+        oo_.Smoother.loglinear = true;
+    else
+        oo_.Smoother.loglinear = false;
+    end
 end
 
 filter_covariance=0;
@@ -191,7 +196,7 @@ end
 if options_.filter_covariance
     localVars.MAX_filter_covariance = MAX_filter_covariance;
 end
-if options_.smoothed_state_uncertainty 
+if options_.smoothed_state_uncertainty
     localVars.MAX_n_smoothed_state_uncertainty = MAX_n_smoothed_state_uncertainty ;
 end
 localVars.MAX_n_smoothed_constant=MAX_n_smoothed_constant;
@@ -202,28 +207,43 @@ localVars.MAX_momentsno = MAX_momentsno;
 localVars.ifil=ifil;
 localVars.DirectoryName = DirectoryName;
 
-if strcmpi(type,'posterior'),
-    b=0;
-    logpost=NaN(B,1);
-    while b<=B
-        b = b + 1;
-        [x(b,:), logpost(b,1)] = GetOneDraw(type);
+if strcmpi(type,'posterior')
+    BaseName = [DirectoryName filesep M_.fname];
+    load_last_mh_history_file(DirectoryName, M_.fname);
+    FirstMhFile = record.KeepedDraws.FirstMhFile;
+    FirstLine = record.KeepedDraws.FirstLine;
+    TotalNumberOfMhFiles = sum(record.MhDraws(:,2));
+    LastMhFile = TotalNumberOfMhFiles;
+    TotalNumberOfMhDraws = sum(record.MhDraws(:,1));
+    NumberOfDraws = TotalNumberOfMhDraws-floor(options_.mh_drop*TotalNumberOfMhDraws);
+    mh_nblck = options_.mh_nblck;
+    if B==NumberOfDraws*mh_nblck
+        % we load all retained MH runs !
+        logpost=GetAllPosteriorDraws(0, FirstMhFile, FirstLine, TotalNumberOfMhFiles, NumberOfDraws);
+        for column=1:npar
+            x(:,column) = GetAllPosteriorDraws(column, FirstMhFile, FirstLine, TotalNumberOfMhFiles, NumberOfDraws);
+        end
+    else
+        logpost=NaN(B,1);
+        for b=1:B
+            [x(b,:), logpost(b)] = GetOneDraw(type);
+        end
     end
     localVars.logpost=logpost;
 end
 
-if ~strcmpi(type,'prior'),
+if ~strcmpi(type,'prior')
     localVars.x=x;
 end
 
 % Like sequential execution!
-if isnumeric(options_.parallel),
+if isnumeric(options_.parallel)
     [fout] = prior_posterior_statistics_core(localVars,1,B,0);
     % Parallel execution!
 else
     [nCPU, totCPU, nBlockPerCPU] = distributeJobs(options_.parallel, 1, B);
     ifil=zeros(n_variables_to_fill,totCPU);
-    for j=1:totCPU-1,
+    for j=1:totCPU-1
         if run_smoother
             nfiles = ceil(nBlockPerCPU(j)/MAX_nsmoo);
             ifil(1,j+1) =ifil(1,j)+nfiles;
@@ -254,14 +274,14 @@ else
         end
         if run_smoother
             nfiles = ceil(nBlockPerCPU(j)/MAX_n_trend_coeff);
-            ifil(9,j+1) =ifil(9,j)+nfiles;  
+            ifil(9,j+1) =ifil(9,j)+nfiles;
             nfiles = ceil(nBlockPerCPU(j)/MAX_n_smoothed_constant);
-            ifil(10,j+1) =ifil(10,j)+nfiles;  
+            ifil(10,j+1) =ifil(10,j)+nfiles;
             nfiles = ceil(nBlockPerCPU(j)/MAX_n_smoothed_trend);
-            ifil(11,j+1) =ifil(11,j)+nfiles;  
+            ifil(11,j+1) =ifil(11,j)+nfiles;
             if smoothed_state_uncertainty
                 nfiles = ceil(nBlockPerCPU(j)/MAX_n_smoothed_state_uncertainty);
-                ifil(13,j+1) =ifil(13,j)+nfiles;           
+                ifil(13,j+1) =ifil(13,j)+nfiles;
             end
         end
     end
@@ -274,8 +294,13 @@ else
     % which files have to be copied to run remotely
     NamFileInput(1,:) = {'',[M_.fname '_static.m']};
     NamFileInput(2,:) = {'',[M_.fname '_dynamic.m']};
-    if options_.steadystate_flag,
-        NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate.m']};
+    NamFileInput(3,:) = {'',[M_.fname '_set_auxiliary_variables.m']};
+    if options_.steadystate_flag
+        if options_.steadystate_flag == 1
+            NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate.m']};
+        else
+            NamFileInput(length(NamFileInput)+1,:)={'',[M_.fname '_steadystate2.m']};
+        end
     end
     [fout] = masterParallel(options_.parallel, 1, B,NamFileInput,'prior_posterior_statistics_core', localVars,globalVars, options_.parallel_info);
 
@@ -300,19 +325,19 @@ end
 
 if options_.smoother
     pm3(endo_nbr,gend,ifil(1),B,'Smoothed variables',...
-        '',M_.endo_names(1:M_.orig_endo_nbr, :),M_.endo_names_tex,M_.endo_names,...
+        '',varlist,M_.endo_names_tex,M_.endo_names,...
         varlist,'SmoothedVariables',DirectoryName,'_smooth');
     pm3(exo_nbr,gend,ifil(2),B,'Smoothed shocks',...
         '',M_.exo_names,M_.exo_names_tex,M_.exo_names,...
         M_.exo_names,'SmoothedShocks',DirectoryName,'_inno');
     pm3(endo_nbr,1,ifil(9),B,'Trend_coefficients',...
-    '',M_.endo_names(1:M_.orig_endo_nbr,:),M_.endo_names_tex,M_.endo_names,...
+        '',varlist,M_.endo_names_tex,M_.endo_names,...
         varlist,'TrendCoeff',DirectoryName,'_trend_coeff');
     pm3(endo_nbr,gend,ifil(10),B,'Smoothed constant',...
-        '',M_.endo_names(1:M_.orig_endo_nbr, :),M_.endo_names_tex,M_.endo_names,...
+        '',varlist,M_.endo_names_tex,M_.endo_names,...
         varlist,'Constant',DirectoryName,'_smoothed_constant');
     pm3(endo_nbr,gend,ifil(11),B,'Smoothed trend',...
-        '',M_.endo_names(1:M_.orig_endo_nbr, :),M_.endo_names_tex,M_.endo_names,...
+        '',varlist,M_.endo_names_tex,M_.endo_names,...
         varlist,'Trend',DirectoryName,'_smoothed_trend');
     pm3(endo_nbr,gend,ifil(1),B,'Updated Variables',...
         '',varlist,M_.endo_names_tex,M_.endo_names,...
@@ -323,17 +348,17 @@ if options_.smoother
             '',varlist,M_.endo_names_tex,M_.endo_names,...
             varlist,'StateUncertainty',DirectoryName,'_state_uncert');
     end
-    
+
     if nvn
-        for obs_iter=1:length(options_.varobs)        
+        for obs_iter=1:length(options_.varobs)
             meas_error_names{obs_iter,1}=['SE_EOBS_' M_.endo_names(strmatch(options_.varobs{obs_iter},M_.endo_names,'exact'),:)];
             texnames{obs_iter,1}=['SE_EOBS_' M_.endo_names_tex(strmatch(options_.varobs{obs_iter},M_.endo_names,'exact'),:)];
         end
         meas_error_names=char(meas_error_names);
         texnames=char(texnames);
         pm3(meas_err_nbr,gend,ifil(3),B,'Smoothed measurement errors',...
-           '',meas_error_names,texnames,meas_error_names,...
-           meas_error_names,'SmoothedMeasurementErrors',DirectoryName,'_error')
+            '',meas_error_names,texnames,meas_error_names,...
+            meas_error_names,'SmoothedMeasurementErrors',DirectoryName,'_error')
     end
 end
 
@@ -352,7 +377,7 @@ if options_.forecast
         varlist,'PointForecast',DirectoryName,'_forc_point');
     if ~isequal(M_.H,0) && ~isempty(intersect(options_.varobs,varlist))
         texnames=[];
-        for obs_iter=1:length(options_.varobs)        
+        for obs_iter=1:length(options_.varobs)
             obs_names{obs_iter,1}=M_.endo_names(strmatch(options_.varobs{obs_iter},M_.endo_names,'exact'),:);
             texnames{obs_iter,1}=M_.endo_names_tex(strmatch(options_.varobs{obs_iter},M_.endo_names,'exact'),:);
         end
@@ -360,8 +385,8 @@ if options_.forecast
         texnames=char(texnames);
         varlist_forecast_ME=intersect(options_.varobs,varlist);
         pm3(meas_err_nbr,horizon,ifil(12),B,'Forecasted variables (point) with ME',...
-           '',char(varlist_forecast_ME),texnames,obs_names,...
-           char(varlist_forecast_ME),'PointForecastME',DirectoryName,'_forc_point_ME')    
+            '',char(varlist_forecast_ME),texnames,obs_names,...
+            char(varlist_forecast_ME),'PointForecastME',DirectoryName,'_forc_point_ME')
     end
 end
 
@@ -372,9 +397,9 @@ if options_.filter_covariance
 end
 
 
-if ~isnumeric(options_.parallel),
+if ~isnumeric(options_.parallel)
     options_.parallel_info.leaveSlaveOpen = leaveSlaveOpen;
-    if leaveSlaveOpen == 0,
+    if leaveSlaveOpen == 0
         closeSlave(options_.parallel,options_.parallel_info.RemoteTmpFolder),
     end
 end
\ No newline at end of file
diff --git a/matlab/prior_posterior_statistics_core.m b/matlab/prior_posterior_statistics_core.m
index 3e8e31436..03cc43a3e 100644
--- a/matlab/prior_posterior_statistics_core.m
+++ b/matlab/prior_posterior_statistics_core.m
@@ -30,7 +30,7 @@ function myoutput=prior_posterior_statistics_core(myinputs,fpar,B,whoiam, ThisMa
 % SPECIAL REQUIREMENTS.
 %   None.
 
-% Copyright (C) 2005-2016 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,7 +49,7 @@ function myoutput=prior_posterior_statistics_core(myinputs,fpar,B,whoiam, ThisMa
 
 global options_ oo_ M_ bayestopt_ estim_params_
 
-if nargin<4,
+if nargin<4
     whoiam=0;
 end
 
@@ -103,9 +103,9 @@ MAX_nruns=myinputs.MAX_nruns;
 MAX_momentsno = myinputs.MAX_momentsno;
 ifil=myinputs.ifil;
 
-if ~strcmpi(type,'prior'),
+if ~strcmpi(type,'prior')
     x=myinputs.x;
-    if strcmpi(type,'posterior'),
+    if strcmpi(type,'posterior')
         logpost=myinputs.logpost;
     end
 end
@@ -128,7 +128,7 @@ end
 
 RemoteFlag = 0;
 if whoiam
-    if Parallel(ThisMatlab).Local==0,
+    if Parallel(ThisMatlab).Local==0
         RemoteFlag =1;
     end
     ifil=ifil(:,whoiam);
@@ -138,7 +138,7 @@ else
 end
 h = dyn_waitbar(prct0,['Taking ',type,' subdraws...']);
 
-if RemoteFlag==1,
+if RemoteFlag==1
     OutputFileName_smooth = {};
     OutputFileName_update = {};
     OutputFileName_inno = {};
@@ -157,22 +157,22 @@ end
 
 %initialize arrays
 if run_smoother
-  stock_smooth=NaN(endo_nbr,gend,MAX_nsmoo);
-  stock_update=NaN(endo_nbr,gend,MAX_nsmoo);
-  stock_innov=NaN(M_.exo_nbr,gend,MAX_ninno);
-  stock_smoothed_constant=NaN(endo_nbr,gend,MAX_n_smoothed_constant);
-  stock_smoothed_trend=NaN(endo_nbr,gend,MAX_n_smoothed_trend);
-  stock_trend_coeff = zeros(endo_nbr,MAX_n_trend_coeff);
-  if horizon
-      stock_forcst_mean= NaN(endo_nbr,horizon,MAX_nforc1);
-      stock_forcst_point = NaN(endo_nbr,horizon,MAX_nforc2);
-      if ~isequal(M_.H,0)
-          stock_forcst_point_ME = NaN(length(varobs),horizon,MAX_nforc_ME);
-      end
-  end
+    stock_smooth=NaN(endo_nbr,gend,MAX_nsmoo);
+    stock_update=NaN(endo_nbr,gend,MAX_nsmoo);
+    stock_innov=NaN(M_.exo_nbr,gend,MAX_ninno);
+    stock_smoothed_constant=NaN(endo_nbr,gend,MAX_n_smoothed_constant);
+    stock_smoothed_trend=NaN(endo_nbr,gend,MAX_n_smoothed_trend);
+    stock_trend_coeff = zeros(endo_nbr,MAX_n_trend_coeff);
+    if horizon
+        stock_forcst_mean= NaN(endo_nbr,horizon,MAX_nforc1);
+        stock_forcst_point = NaN(endo_nbr,horizon,MAX_nforc2);
+        if ~isequal(M_.H,0)
+            stock_forcst_point_ME = NaN(length(varobs),horizon,MAX_nforc_ME);
+        end
+    end
 end
 if nvn
-  stock_error = NaN(length(varobs),gend,MAX_nerro);
+    stock_error = NaN(length(varobs),gend,MAX_nerro);
 end
 if naK
     stock_filter_step_ahead =NaN(length(options_.filter_step_ahead),endo_nbr,gend+max(options_.filter_step_ahead),MAX_naK);
@@ -206,7 +206,7 @@ for b=fpar:B
         [dr,info,M_,options_,oo_] = resol(0,M_,options_,oo_);
         [alphahat,etahat,epsilonhat,alphatilde,SteadyState,trend_coeff,aK,junk1,junk2,P,junk4,junk5,trend_addition,state_uncertainty,M_,oo_,options_,bayestopt_] = ...
             DsgeSmoother(deep,gend,Y,data_index,missing_value,M_,oo_,options_,bayestopt_,estim_params_);
-        
+
         stock_trend_coeff(options_.varobs_id,irun(9))=trend_coeff;
         stock_smoothed_trend(IdObs,:,irun(11))=trend_addition;
         if options_.loglinear %reads values from smoother results, which are in dr-order and put them into declaration order
@@ -221,7 +221,7 @@ for b=fpar:B
                 constant_part;
             stock_update(dr.order_var,:,irun(1)) = alphatilde(1:endo_nbr,:)+ ...
                 constant_part;
-        end       
+        end
         stock_smoothed_constant(dr.order_var,:,irun(10))=constant_part;
         %% Compute constant for observables
         if options_.prefilter == 1 %as mean is taken after log transformation, no distinction is needed here
@@ -243,10 +243,10 @@ for b=fpar:B
             %smoothed variables are E_T(y_t) so no trend shift is required
             stock_smooth(IdObs,:,irun(1))=stock_smooth(IdObs,:,irun(1))+trend_addition+mean_correction;
             %updated variables are E_t(y_t) so no trend shift is required
-            stock_update(IdObs,:,irun(1))=stock_update(IdObs,:,irun(1))+trend_addition+mean_correction;         
+            stock_update(IdObs,:,irun(1))=stock_update(IdObs,:,irun(1))+trend_addition+mean_correction;
         else
             stock_smooth(IdObs,:,irun(1))=stock_smooth(IdObs,:,irun(1))+trend_addition;
-            stock_update(IdObs,:,irun(1))=stock_update(IdObs,:,irun(1))+trend_addition; 
+            stock_update(IdObs,:,irun(1))=stock_update(IdObs,:,irun(1))+trend_addition;
         end
         stock_innov(:,:,irun(2))  = etahat;
         if nvn
@@ -259,11 +259,11 @@ for b=fpar:B
                 constant_part=repmat(log(SteadyState(dr.order_var))',[length(options_.filter_step_ahead),1,gend+max(options_.filter_step_ahead)]);
             else
                 constant_part=repmat(SteadyState(dr.order_var)',[length(options_.filter_step_ahead),1,gend+max(options_.filter_step_ahead)]);
-            end       
+            end
 
             stock_filter_step_ahead(:,dr.order_var,:,irun(4)) = aK(options_.filter_step_ahead,1:endo_nbr,:) + ...
                 constant_part;
-            
+
             %now add trend to observables
             for ii=1:length(options_.filter_step_ahead)
                 if options_.prefilter
@@ -280,16 +280,16 @@ for b=fpar:B
         if horizon
             yyyy = alphahat(iendo,i_last_obs);
             yf = forcst2a(yyyy,dr,zeros(horizon,exo_nbr));
-            if options_.prefilter 
+            if options_.prefilter
                 % add mean
                 yf(:,IdObs) = yf(:,IdObs)+repmat(mean_varobs, ...
                                                  horizon+maxlag,1);
                 % add trend, taking into account that last point of sample is still included in forecasts and only cut off later
                 yf(:,IdObs) = yf(:,IdObs)+((options_.first_obs-1)+gend+[1-maxlag:horizon]')*trend_coeff'-...
-                             repmat(mean(trend_coeff*[options_.first_obs:options_.first_obs+gend-1],2)',length(1-maxlag:horizon),1); %center trend
+                    repmat(mean(trend_coeff*[options_.first_obs:options_.first_obs+gend-1],2)',length(1-maxlag:horizon),1); %center trend
             else
                 % add trend, taking into account that last point of sample is still included in forecasts and only cut off later
-                    yf(:,IdObs) = yf(:,IdObs)+((options_.first_obs-1)+gend+[1-maxlag:horizon]')*trend_coeff';                
+                yf(:,IdObs) = yf(:,IdObs)+((options_.first_obs-1)+gend+[1-maxlag:horizon]')*trend_coeff';
             end
             if options_.loglinear
                 yf = yf+repmat(log(SteadyState'),horizon+maxlag,1);
@@ -303,10 +303,10 @@ for b=fpar:B
                     repmat(mean_varobs,[horizon+maxlag,1,1]);
                 % add trend, taking into account that last point of sample is still included in forecasts and only cut off later
                 yf1(:,IdObs) = yf1(:,IdObs)+((options_.first_obs-1)+gend+[1-maxlag:horizon]')*trend_coeff'-...
-                             repmat(mean(trend_coeff*[options_.first_obs:options_.first_obs+gend-1],2)',length(1-maxlag:horizon),1); %center trend
+                    repmat(mean(trend_coeff*[options_.first_obs:options_.first_obs+gend-1],2)',length(1-maxlag:horizon),1); %center trend
             else
-               % add trend, taking into account that last point of sample is still included in forecasts and only cut off later
-               yf1(:,IdObs,:) = yf1(:,IdObs,:)+repmat(((options_.first_obs-1)+gend+[1-maxlag:horizon]')* ...
+                % add trend, taking into account that last point of sample is still included in forecasts and only cut off later
+                yf1(:,IdObs,:) = yf1(:,IdObs,:)+repmat(((options_.first_obs-1)+gend+[1-maxlag:horizon]')* ...
                                                        trend_coeff',[1,1,1]);
             end
             if options_.loglinear
@@ -345,14 +345,14 @@ for b=fpar:B
     irun = irun +  ones(13,1);
 
 
-    if run_smoother && (irun(1) > MAX_nsmoo || b == B),
+    if run_smoother && (irun(1) > MAX_nsmoo || b == B)
         stock = stock_smooth(:,:,1:irun(1)-1);
         ifil(1) = ifil(1) + 1;
         save([DirectoryName '/' M_.fname '_smooth' int2str(ifil(1)) '.mat'],'stock');
 
         stock = stock_update(:,:,1:irun(1)-1);
         save([DirectoryName '/' M_.fname '_update' int2str(ifil(1)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_smooth = [OutputFileName_smooth; {[DirectoryName filesep], [M_.fname '_smooth' int2str(ifil(1)) '.mat']}];
             OutputFileName_update = [OutputFileName_update; {[DirectoryName filesep], [M_.fname '_update' int2str(ifil(1)) '.mat']}];
         end
@@ -363,7 +363,7 @@ for b=fpar:B
         stock = stock_innov(:,:,1:irun(2)-1);
         ifil(2) = ifil(2) + 1;
         save([DirectoryName '/' M_.fname '_inno' int2str(ifil(2)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_inno = [OutputFileName_inno; {[DirectoryName filesep], [M_.fname '_inno' int2str(ifil(2)) '.mat']}];
         end
         irun(2) = 1;
@@ -373,7 +373,7 @@ for b=fpar:B
         stock = stock_error(:,:,1:irun(3)-1);
         ifil(3) = ifil(3) + 1;
         save([DirectoryName '/' M_.fname '_error' int2str(ifil(3)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_error = [OutputFileName_error; {[DirectoryName filesep], [M_.fname '_error' int2str(ifil(3)) '.mat']}];
         end
         irun(3) = 1;
@@ -383,7 +383,7 @@ for b=fpar:B
         stock = stock_filter_step_ahead(:,:,:,1:irun(4)-1);
         ifil(4) = ifil(4) + 1;
         save([DirectoryName '/' M_.fname '_filter_step_ahead' int2str(ifil(4)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_filter_step_ahead = [OutputFileName_filter_step_ahead; {[DirectoryName filesep], [M_.fname '_filter_step_ahead' int2str(ifil(4)) '.mat']}];
         end
         irun(4) = 1;
@@ -395,7 +395,7 @@ for b=fpar:B
         stock_ys = stock_ys(1:irun(5)-1,:);
         ifil(5) = ifil(5) + 1;
         save([DirectoryName '/' M_.fname '_param' int2str(ifil(5)) '.mat'],'stock','stock_logpo','stock_ys');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_param = [OutputFileName_param; {[DirectoryName filesep], [M_.fname '_param' int2str(ifil(5)) '.mat']}];
         end
         irun(5) = 1;
@@ -405,7 +405,7 @@ for b=fpar:B
         stock = stock_forcst_mean(:,:,1:irun(6)-1);
         ifil(6) = ifil(6) + 1;
         save([DirectoryName '/' M_.fname '_forc_mean' int2str(ifil(6)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_forc_mean = [OutputFileName_forc_mean; {[DirectoryName filesep], [M_.fname '_forc_mean' int2str(ifil(6)) '.mat']}];
         end
         irun(6) = 1;
@@ -415,39 +415,39 @@ for b=fpar:B
         stock = stock_forcst_point(:,:,1:irun(7)-1);
         ifil(7) = ifil(7) + 1;
         save([DirectoryName '/' M_.fname '_forc_point' int2str(ifil(7)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_forc_point = [OutputFileName_forc_point; {[DirectoryName filesep], [M_.fname '_forc_point' int2str(ifil(7)) '.mat']}];
         end
         irun(7) = 1;
     end
-    
+
     if run_smoother && filter_covariance && (irun(8) > MAX_filter_covariance || b == B)
         stock = stock_filter_covariance(:,:,:,1:irun(8)-1);
         ifil(8) = ifil(8) + 1;
         save([DirectoryName '/' M_.fname '_filter_covar' int2str(ifil(8)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_filter_covar = [OutputFileName_filter_covar; {[DirectoryName filesep], [M_.fname '_filter_covar' int2str(ifil(8)) '.mat']}];
         end
         irun(8) = 1;
     end
-    
+
     irun_index=9;
     if run_smoother && (irun(irun_index) > MAX_n_trend_coeff || b == B)
         stock = stock_trend_coeff(:,1:irun(irun_index)-1);
         ifil(irun_index) = ifil(irun_index) + 1;
         save([DirectoryName '/' M_.fname '_trend_coeff' int2str(ifil(irun_index)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_trend_coeff = [OutputFileName_trend_coeff; {[DirectoryName filesep], [M_.fname '_trend_coeff' int2str(ifil(irun_index)) '.mat']}];
         end
         irun(irun_index) = 1;
     end
-    
+
     irun_index=10;
     if run_smoother && (irun(irun_index) > MAX_n_smoothed_constant || b == B)
         stock = stock_smoothed_constant(:,:,1:irun(irun_index)-1);
         ifil(irun_index) = ifil(irun_index) + 1;
         save([DirectoryName '/' M_.fname '_smoothed_constant' int2str(ifil(irun_index)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_smoothed_constant = [OutputFileName_smoothed_constant; {[DirectoryName filesep], [M_.fname '_smoothed_constant' int2str(ifil(irun_index)) '.mat']}];
         end
         irun(irun_index) = 1;
@@ -458,29 +458,29 @@ for b=fpar:B
         stock = stock_smoothed_trend(:,:,1:irun(irun_index)-1);
         ifil(irun_index) = ifil(irun_index) + 1;
         save([DirectoryName '/' M_.fname '_smoothed_trend' int2str(ifil(irun_index)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_smoothed_trend = [OutputFileName_smoothed_trend; {[DirectoryName filesep], [M_.fname '_smoothed_trend' int2str(ifil(irun_index)) '.mat']}];
         end
         irun(irun_index) = 1;
     end
-    
+
     irun_index=12;
     if run_smoother && horizon && ~isequal(M_.H,0) && (irun(irun_index) > MAX_nforc_ME ||  b == B)
         stock = stock_forcst_point_ME(:,:,1:irun(irun_index)-1);
         ifil(irun_index) = ifil(irun_index) + 1;
         save([DirectoryName '/' M_.fname '_forc_point_ME' int2str(ifil(irun_index)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_forc_point_ME = [OutputFileName_forc_point_ME; {[DirectoryName filesep], [M_.fname '_forc_point_ME' int2str(ifil(irun_index)) '.mat']}];
         end
         irun(irun_index) = 1;
     end
-    
+
     irun_index=13;
     if run_smoother && smoothed_state_uncertainty && (irun(irun_index) > MAX_n_smoothed_state_uncertainty || b == B)
         stock = stock_smoothed_uncert(:,:,:,1:irun(irun_index)-1);
         ifil(irun_index) = ifil(irun_index) + 1;
         save([DirectoryName '/' M_.fname '_state_uncert' int2str(ifil(irun_index)) '.mat'],'stock');
-        if RemoteFlag==1,
+        if RemoteFlag==1
             OutputFileName_state_uncert = [OutputFileName_state_uncert; {[DirectoryName filesep], [M_.fname '_state_uncert' int2str(ifil(irun_index)) '.mat']}];
         end
         irun(irun_index) = 1;
@@ -490,7 +490,7 @@ for b=fpar:B
 end
 
 myoutput.ifil=ifil;
-if RemoteFlag==1,
+if RemoteFlag==1
     myoutput.OutputFileName = [OutputFileName_smooth;
                         OutputFileName_update;
                         OutputFileName_inno;
@@ -508,4 +508,3 @@ if RemoteFlag==1,
 end
 
 dyn_waitbar_close(h);
-
diff --git a/matlab/prior_sampler.m b/matlab/prior_sampler.m
index 267563d8e..e846cd021 100644
--- a/matlab/prior_sampler.m
+++ b/matlab/prior_sampler.m
@@ -13,7 +13,7 @@ function results = prior_sampler(drsave,M_,bayestopt_,options_,oo_,estim_params_
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2009-2012 Dynare Team
+% Copyright (C) 2009-2016 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,6 +49,7 @@ count_complex_steadystate = 0;
 count_nan_steadystate = 0;
 count_nan_params = 0;
 count_complex_params = 0;
+count_nonpositive_steadystate = 0;
 count_unknown_problem = 0;
 NumberOfSimulations = options_.prior_mc;
 NumberOfParameters = length(bayestopt_.p1);
@@ -135,6 +136,8 @@ while iteration < NumberOfSimulations
         count_complex_params = count_complex_params + 1 ;
       case 24
         count_nan_params = count_nan_params + 1 ;
+      case 26
+        count_nonpositive_steadystate = count_nonpositive_steadystate + 1;
       otherwise
         count_unknown_problem = count_unknown_problem + 1 ;
     end
@@ -162,6 +165,7 @@ results.dll.problem_share = count_dll_problem/loop_indx;
 results.ss.problem_share = count_no_steadystate/loop_indx;
 results.ss.complex_share = count_complex_steadystate/loop_indx;
 results.ass.problem_share = count_steadystate_file_exit/loop_indx;
+results.ss.nonpositive_share = count_nonpositive_steadystate/loop_indx;
 results.jacobian.problem_share = count_complex_jacobian/loop_indx;
 results.garbage_share = ...
     results.bk.indeterminacy_share + ...
@@ -170,6 +174,8 @@ results.garbage_share = ...
     results.dll.problem_share + ...
     results.ss.problem_share + ...
     results.ass.problem_share + ...
+    results.ss.complex_share + ...
+    results.ss.nonpositive_share + ...
     results.jacobian.problem_share + ...
     count_unknown_problem/loop_indx ;
 results.prior.mean = sampled_prior_expectation;
diff --git a/matlab/priordens.m b/matlab/priordens.m
index f760680cf..b988e7ea1 100644
--- a/matlab/priordens.m
+++ b/matlab/priordens.m
@@ -1,7 +1,7 @@
 function [logged_prior_density, dlprior, d2lprior, info] = priordens(x, pshape, p6, p7, p3, p4, initialization) % --*-- Unitary tests --*--
 % Computes a prior density for the structural parameters of DSGE models
 %
-% INPUTS 
+% INPUTS
 %    x              [double]      vector with n elements.
 %    pshape         [integer]     vector with n elements (bayestopt_.pshape).
 %    p6:            [double]      vector with n elements, first  parameter of the prior distribution (bayestopt_.p6).
@@ -9,13 +9,13 @@ function [logged_prior_density, dlprior, d2lprior, info] = priordens(x, pshape,
 %    p3:            [double]      vector with n elements, lower bounds of the untruncated standard or generalized distribution
 %    p4:            [double]      vector with n elements, upper bound of the untruncated standard or generalized distribution
 %    initialization [integer]     if 1: initialize persistent variables
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %    logged_prior_density  [double]  scalar, log of the prior density evaluated at x.
 %    info                  [double]  error code for index of Inf-prior parameter
 %
 
-% Copyright (C) 2003-2015 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -89,12 +89,12 @@ d2lprior = 0.0;
 if tt1
     logged_prior_density = logged_prior_density + sum(lpdfgbeta(x(id1),p6(id1),p7(id1),p3(id1),p4(id1))) ;
     if isinf(logged_prior_density)
-        if nargout ==4 
+        if nargout ==4
             info=id1(isinf(lpdfgbeta(x(id1),p6(id1),p7(id1),p3(id1),p4(id1))));
         end
         return
     end
-    if nargout == 2,
+    if nargout == 2
         [tmp, dlprior(id1)]=lpdfgbeta(x(id1),p6(id1),p7(id1),p3(id1),p4(id1));
     elseif nargout == 3
         [tmp, dlprior(id1), d2lprior(id1)]=lpdfgbeta(x(id1),p6(id1),p7(id1),p3(id1),p4(id1));
@@ -104,12 +104,12 @@ end
 if tt2
     logged_prior_density = logged_prior_density + sum(lpdfgam(x(id2)-p3(id2),p6(id2),p7(id2))) ;
     if isinf(logged_prior_density)
-        if nargout ==4 
+        if nargout ==4
             info=id2(isinf(lpdfgam(x(id2)-p3(id2),p6(id2),p7(id2))));
         end
         return
     end
-    if nargout == 2,
+    if nargout == 2
         [tmp, dlprior(id2)]=lpdfgam(x(id2)-p3(id2),p6(id2),p7(id2));
     elseif nargout == 3
         [tmp, dlprior(id2), d2lprior(id2)]=lpdfgam(x(id2)-p3(id2),p6(id2),p7(id2));
@@ -118,7 +118,7 @@ end
 
 if tt3
     logged_prior_density = logged_prior_density + sum(lpdfnorm(x(id3),p6(id3),p7(id3))) ;
-    if nargout == 2,
+    if nargout == 2
         [tmp, dlprior(id3)]=lpdfnorm(x(id3),p6(id3),p7(id3));
     elseif nargout == 3
         [tmp, dlprior(id3), d2lprior(id3)]=lpdfnorm(x(id3),p6(id3),p7(id3));
@@ -128,12 +128,12 @@ end
 if tt4
     logged_prior_density = logged_prior_density + sum(lpdfig1(x(id4)-p3(id4),p6(id4),p7(id4))) ;
     if isinf(logged_prior_density)
-        if nargout ==4 
+        if nargout ==4
             info=id4(isinf(lpdfig1(x(id4)-p3(id4),p6(id4),p7(id4))));
         end
         return
     end
-    if nargout == 2,
+    if nargout == 2
         [tmp, dlprior(id4)]=lpdfig1(x(id4)-p3(id4),p6(id4),p7(id4));
     elseif nargout == 3
         [tmp, dlprior(id4), d2lprior(id4)]=lpdfig1(x(id4)-p3(id4),p6(id4),p7(id4));
@@ -143,13 +143,13 @@ end
 if tt5
     if any(x(id5)-p3(id5)<0) || any(x(id5)-p4(id5)>0)
         logged_prior_density = -Inf ;
-        if nargout ==4 
+        if nargout ==4
             info=id5((x(id5)-p3(id5)<0) || (x(id5)-p4(id5)>0));
         end
         return
     end
     logged_prior_density = logged_prior_density + sum(log(1./(p4(id5)-p3(id5)))) ;
-    if nargout >1,
+    if nargout >1
         dlprior(id5)=zeros(length(id5),1);
     end
     if nargout == 3
@@ -160,12 +160,12 @@ end
 if tt6
     logged_prior_density = logged_prior_density + sum(lpdfig2(x(id6)-p3(id6),p6(id6),p7(id6))) ;
     if isinf(logged_prior_density)
-        if nargout ==4 
+        if nargout ==4
             info=id6(isinf(lpdfig2(x(id6)-p3(id6),p6(id6),p7(id6))));
         end
         return
     end
-    if nargout == 2,
+    if nargout == 2
         [tmp, dlprior(id6)]=lpdfig2(x(id6)-p3(id6),p6(id6),p7(id6));
     elseif nargout == 3
         [tmp, dlprior(id6), d2lprior(id6)]=lpdfig2(x(id6)-p3(id6),p6(id6),p7(id6));
@@ -175,7 +175,7 @@ end
 if tt8
     logged_prior_density = logged_prior_density + sum(lpdfgweibull(x(id8),p6(id8),p7(id8)));
     if isinf(logged_prior_density)
-        if nargout ==4 
+        if nargout ==4
             info=id8(isinf(log(lpdfgweibull(x(id8),p6(id8),p7(id8)))));
         end
         return
@@ -187,7 +187,7 @@ if tt8
     end
 end
 
-if nargout==3,
+if nargout==3
     d2lprior = diag(d2lprior);
 end
 
diff --git a/matlab/qr2.m b/matlab/qr2.m
index 3c84db996..bdd1c0dea 100644
--- a/matlab/qr2.m
+++ b/matlab/qr2.m
@@ -1,23 +1,23 @@
 function [Q,R] = qr2(varargin)
 % This routine performs a qr decomposition of matrix X such that the
-% diagonal scalars of the upper-triangular matrix R are positive. If X 
+% diagonal scalars of the upper-triangular matrix R are positive. If X
 % is a full (column) rank matrix, then R is also the cholesky
-% factorization of X'X. This property is needed for the Del Negro 
+% factorization of X'X. This property is needed for the Del Negro
 % & Schorfheides's identification scheme.
-% 
-% INPUTS 
+%
+% INPUTS
 %   See matlab's documentation for QR decomposition.
-%     
-% OUTPUTS 
+%
+% OUTPUTS
 %   See matlab's documentation for QR decomposition.
 %
 % ALGORITHM
-%   None.       
+%   None.
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2012 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/quadratic_matrix_equation_solver.m b/matlab/quadratic_matrix_equation_solver.m
index f222df843..40342085e 100644
--- a/matlab/quadratic_matrix_equation_solver.m
+++ b/matlab/quadratic_matrix_equation_solver.m
@@ -47,7 +47,7 @@ function [X,info] = quadratic_matrix_equation_solver(A,B,C,tol,maxit,line_search
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -106,34 +106,34 @@ end
 
 
 function f = eval_quadratic_matrix_equation(A,B,C,X)
-    f = C + (B + A*X)*X;
+f = C + (B + A*X)*X;
 
 function [p0,p1] = merit_polynomial(A,H,F)
-    AHH = A*H*H;
-    gamma = norm(AHH,'fro')^2;
-    alpha = norm(F,'fro')^2;
-    beta  = trace(F*AHH*AHH*F);
-    p0 = [gamma, -beta, alpha+beta, -2*alpha, alpha];
-    p1 = [4*gamma, -3*beta, 2*(alpha+beta), -2*alpha];
+AHH = A*H*H;
+gamma = norm(AHH,'fro')^2;
+alpha = norm(F,'fro')^2;
+beta  = trace(F*AHH*AHH*F);
+p0 = [gamma, -beta, alpha+beta, -2*alpha, alpha];
+p1 = [4*gamma, -3*beta, 2*(alpha+beta), -2*alpha];
 
 function t = line_search(A,H,F)
-    [p0,p1] = merit_polynomial(A,H,F);
-    if any(isnan(p0)) || any(isinf(p0))
-        t = 1.0;
-        return
-    end
-    r = roots(p1);
-    s = [Inf(3,1),r];
-    for i = 1:3
-        if isreal(r(i))
-            s(i,1) = p0(1)*r(i)^4 + p0(2)*r(i)^3 + p0(3)*r(i)^2 + p0(4)*r(i) + p0(5);
-        end
-    end
-    s = sortrows(s,1);
-    t = s(1,2);
-    if t<=1e-12 || t>=2
-        t = 1;
+[p0,p1] = merit_polynomial(A,H,F);
+if any(isnan(p0)) || any(isinf(p0))
+    t = 1.0;
+    return
+end
+r = roots(p1);
+s = [Inf(3,1),r];
+for i = 1:3
+    if isreal(r(i))
+        s(i,1) = p0(1)*r(i)^4 + p0(2)*r(i)^3 + p0(3)*r(i)^2 + p0(4)*r(i) + p0(5);
     end
+end
+s = sortrows(s,1);
+t = s(1,2);
+if t<=1e-12 || t>=2
+    t = 1;
+end
 
 %@test:1
 %$ addpath ../matlab
diff --git a/matlab/qz/mjdgges.m b/matlab/qz/mjdgges.m
index 2225e257b..12c91d801 100644
--- a/matlab/qz/mjdgges.m
+++ b/matlab/qz/mjdgges.m
@@ -6,23 +6,23 @@ function [err,ss,tt,w,sdim,eigval,info] = mjdgges(e,d,qz_criterium, fake)
 %   e            [double] real square (n*n) matrix.
 %   d            [double] real square (n*n) matrix.
 %   qz_criterium [double] scalar (1+epsilon).
-%    
+%
 % OUTPUTS
 %   err          [double]  scalar: 1 indicates failure, 0 indicates success
 %   ss           [complex] (n*n) matrix.
 %   tt           [complex] (n*n) matrix.
 %   w            [complex] (n*n) matrix.
-%   sdim         [integer] scalar.    
-%   eigval       [complex] (n*1) vector. 
+%   sdim         [integer] scalar.
+%   eigval       [complex] (n*1) vector.
 %   info         [integer] scalar.
-%    
+%
 % ALGORITHM
 %   Sims's qzdiv routine is used.
 %
 % SPECIAL REQUIREMENTS
 %   none.
 
-% Copyright (C) 1996-2010 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,6 +43,7 @@ function [err,ss,tt,w,sdim,eigval,info] = mjdgges(e,d,qz_criterium, fake)
 if nargin>4 || nargin<2 || nargout>7 || nargout==0
     error('MJDGGES: takes 2 or 3 input arguments and between 1 and 7 output arguments.')
 end
+
 % Check the first two inputs.
 [me,ne] = size(e);
 [md,nd] = size(d);
@@ -53,40 +54,34 @@ end
 
 % Set default value of qz_criterium.
 if nargin <3
-    qz_criterium = 1 + 1e-6; 
+    qz_criterium = 1 + 1e-6;
 end
 
 info = 0;
 
-% qz() function doesn't behave the same way under Octave and MATLAB:
-% - under MATLAB, complex decomposition by default, real is also available
-%   as an option
-% - under Octave, only real decomposition available, but grouping of
-%   eigenvalues <= 1 is implemented as an option (criterium can't be changed)
-if isoctave
-    [ss,tt,w,eigval] = qz(e,d,'S');
-    sdim = sum(abs(eigval) <= 1.0);
-    if any(abs(eigval) > 1.0 & abs(eigval) <= qz_criterium)
-        warning('Some eigenvalues are > 1.0 but <= qz_criterium in modulus. They have nevertheless been considered as explosive, because of a limitation of Octave. To solve this, you should compile the MEX files for Octave.')
-    end
-else
-    % Initialization of the output arguments.
-    ss = zeros(ne,ne);
-    tt = zeros(ne,ne);
-    w  = zeros(ne,ne);
-    sdim   = 0;
-    eigval = zeros(ne,1);
-    % Computational part.
-    try
-        [ss,tt,qq,w] = qz(e,d);
-        [tt,ss,qq,w] = qzdiv(qz_criterium,tt,ss,qq,w);
-        warning_old_state = warning;
-        warning off;
-        eigval = diag(ss)./diag(tt);
-        warning(warning_old_state);
-        sdim = sum(abs(eigval) < qz_criterium);
-    catch
-        info = 1;% Not as precise as lapack's info!
+% Initialization of the output arguments.
+ss = zeros(ne,ne);
+tt = zeros(ne,ne);
+w  = zeros(ne,ne);
+sdim   = 0;
+eigval = zeros(ne,1);
+
+% Computational part.
+try
+    if isoctave()
+        % Force complex QZ factorization.
+        e = complex(e);
+        d = complex(d);
     end
+    [ss,tt,qq,w,a,b,c] = qz(e, d);
+    warning_old_state = warning;
+    warning off;
+    [tt,ss,qq,w] = qzdiv(qz_criterium, tt, ss, qq, w);
+    eigval = diag(ss)./diag(tt);
+    warning(warning_old_state);
+    sdim = sum(abs(eigval) < qz_criterium);
+catch
+    info = 1;% Not as precise as lapack's info!
 end
+
 err = 0;
\ No newline at end of file
diff --git a/matlab/qzdiv.m b/matlab/qzdiv.m
index 2c88184f1..ba5206efa 100644
--- a/matlab/qzdiv.m
+++ b/matlab/qzdiv.m
@@ -2,7 +2,7 @@ function [A,B,Q,Z] = qzdiv(stake,A,B,Q,Z)
 %function [A,B,Q,Z] = qzdiv(stake,A,B,Q,Z)
 %
 % Takes U.T. matrices A, B, orthonormal matrices Q,Z, rearranges them
-% so that all cases of abs(B(i,i)/A(i,i))>stake are in lower right 
+% so that all cases of abs(B(i,i)/A(i,i))>stake are in lower right
 % corner, while preserving U.T. and orthonormal properties and Q'AZ' and
 % Q'BZ'.
 
@@ -10,7 +10,7 @@ function [A,B,Q,Z] = qzdiv(stake,A,B,Q,Z)
 % http://sims.princeton.edu/yftp/gensys/mfiles/qzdiv.m
 
 % Copyright (C) 1993-2007 Christopher Sims
-% Copyright (C) 2008-2011 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -27,25 +27,25 @@ function [A,B,Q,Z] = qzdiv(stake,A,B,Q,Z)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-[n jnk] = size(A);
+[n, jnk] = size(A);
 root = abs([diag(A) diag(B)]);
 root(:,1) = root(:,1)-(root(:,1)<1.e-13).*(root(:,1)+root(:,2));
 root(:,2) = root(:,2)./root(:,1);
 for i = n:-1:1
     m=0;
     for j=i:-1:1
-        if (root(j,2) > stake || root(j,2) < -.1) 
+        if (root(j,2) > stake || root(j,2) < -.1)
             m=j;
             break
         end
     end
-    if (m==0) 
-        return 
+    if (m==0)
+        return
     end
     for k=m:1:i-1
-        [A B Q Z] = qzswitch(k,A,B,Q,Z);
+        [A, B, Q, Z] = qzswitch(k,A,B,Q,Z);
         tmp = root(k,2);
         root(k,2) = root(k+1,2);
         root(k+1,2) = tmp;
     end
-end         
+end
diff --git a/matlab/ramsey_policy.m b/matlab/ramsey_policy.m
index 7f932ab2e..2ca9079fe 100644
--- a/matlab/ramsey_policy.m
+++ b/matlab/ramsey_policy.m
@@ -1,6 +1,6 @@
 function info = ramsey_policy(var_list)
 
-% Copyright (C) 2007-2012 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -33,8 +33,12 @@ if inst_nbr~=0
     elseif inst_nbr<implied_inst_nbr
         error('You have specified fewer instruments than there are omitted equations')
     end
+else
+    if options_.steadystate_flag
+        error('You have specified a steady state file, but not provided an instrument. Either delete the steady state file or provide an instrument')
+    end
 end
-        
+
 info = stoch_simul(var_list);
 
 oo_.steady_state = oo_.dr.ys;
diff --git a/matlab/read_data_.m b/matlab/read_data_.m
index 7ad6b4228..d7de0843d 100644
--- a/matlab/read_data_.m
+++ b/matlab/read_data_.m
@@ -1,6 +1,6 @@
 function read_data_()
 % function read_data_
-% reads endogenous and exogenous variables from a text file 
+% reads endogenous and exogenous variables from a text file
 % Used by datafile option in simulate
 %
 % INPUT
@@ -12,7 +12,7 @@ function read_data_()
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2007-2012 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/read_key_value_string.m b/matlab/read_key_value_string.m
index d6b7124ed..446afd2f5 100644
--- a/matlab/read_key_value_string.m
+++ b/matlab/read_key_value_string.m
@@ -4,7 +4,7 @@ function c = read_key_value_string(s)
 % estimation command) into a cell (first column for the option name ans second column for the
 % option value).
 
-% Copyright (C) 2011-2016 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -40,7 +40,7 @@ iComma = strfind(s,',');
 
 %delete commata in sublists from further checks
 for sublist_iter=length(i_begin_sublist):-1:1
-   iComma(iComma>=i_begin_sublist(sublist_iter) & iComma<=i_end_sublist(sublist_iter))=[];
+    iComma(iComma>=i_begin_sublist(sublist_iter) & iComma<=i_end_sublist(sublist_iter))=[];
 end
 
 nComma = length(iComma);
@@ -85,10 +85,10 @@ end
 
 
 function j = comma2opt(i)
-    if isodd(i)
-        % The comma is a separator between a Key and a Value (returned j is minus the option number).
-        j = - (i+1)/2;
-    else
-        % The comma is a separator between two options (returned j is the option number).
-        j = i/2;
-    end
\ No newline at end of file
+if isodd(i)
+    % The comma is a separator between a Key and a Value (returned j is minus the option number).
+    j = - (i+1)/2;
+else
+    % The comma is a separator between two options (returned j is the option number).
+    j = i/2;
+end
\ No newline at end of file
diff --git a/matlab/read_variables.m b/matlab/read_variables.m
index 6859a6795..a50501252 100644
--- a/matlab/read_variables.m
+++ b/matlab/read_variables.m
@@ -6,7 +6,7 @@ function dyn_data_01=read_variables(file_name_01,var_names_01,dyn_data_01,xls_sh
 % INPUTS
 %    file_name_01:    file name
 %    var_names_01:    variables name
-%    dyn_data_01:     
+%    dyn_data_01:
 %    xls_sheet:       Excel sheet name
 %    xls_range:       Excel range specification
 %
@@ -17,7 +17,7 @@ function dyn_data_01=read_variables(file_name_01,var_names_01,dyn_data_01,xls_sh
 % all local variables have complicated names in order to avoid name
 % conflicts with possible user variable names
 
-% Copyright (C) 2005-2013 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -65,64 +65,64 @@ fullname = [basename extension];
 
 if ~exist(fullname)
     error(['Can''t find datafile: ' fullname ]);
-end 
+end
 
 switch (extension)
-    case '.m'
-        eval(basename);
-        for dyn_i_01=1:var_size_01
-            dyn_tmp_01 = eval(var_names_01{dyn_i_01});
+  case '.m'
+    eval(basename);
+    for dyn_i_01=1:var_size_01
+        dyn_tmp_01 = eval(var_names_01{dyn_i_01});
+        if length(dyn_tmp_01) > dyn_size_01 && dyn_size_01 > 0
+            cd(old_pwd)
+            error('data size is too large')
+        end
+        dyn_data_01(:,dyn_i_01) = dyn_tmp_01;
+    end
+  case '.mat'
+    s = load(basename);
+    for dyn_i_01=1:var_size_01
+        dyn_tmp_01 = s.(var_names_01{dyn_i_01});
+        if length(dyn_tmp_01) > dyn_size_01 && dyn_size_01 > 0
+            cd(old_pwd)
+            error('data size is too large')
+        end
+        dyn_data_01(:,dyn_i_01) = dyn_tmp_01;
+    end
+  case { '.xls', '.xlsx' }
+    [freq,init,data,varlist] = load_xls_file_data(fullname,xls_sheet,xls_range);
+    for dyn_i_01=1:var_size_01
+        iv = strmatch(strtrim(var_names_01(dyn_i_01,:)),varlist,'exact');
+        if ~isempty(iv)
+            dyn_tmp_01 = [data(:,iv)]';
             if length(dyn_tmp_01) > dyn_size_01 && dyn_size_01 > 0
                 cd(old_pwd)
                 error('data size is too large')
             end
             dyn_data_01(:,dyn_i_01) = dyn_tmp_01;
+        else
+            cd(old_pwd)
+            error([strtrim(var_names_01(dyn_i_01,:)) ' not found in ' fullname])
         end
-    case '.mat'
-        s = load(basename);
-        for dyn_i_01=1:var_size_01
-            dyn_tmp_01 = s.(var_names_01{dyn_i_01});
+    end
+  case '.csv'
+    [freq,init,data,varlist] = load_csv_file_data(fullname);
+    for dyn_i_01=1:var_size_01
+        iv = strmatch(var_names_01{dyn_i_01},varlist,'exact');
+        if ~isempty(iv)
+            dyn_tmp_01 = [data(:,iv)]';
             if length(dyn_tmp_01) > dyn_size_01 && dyn_size_01 > 0
                 cd(old_pwd)
                 error('data size is too large')
             end
             dyn_data_01(:,dyn_i_01) = dyn_tmp_01;
+        else
+            cd(old_pwd)
+            error([var_names_01{dyn_i_01} ' not found in ' fullname])
         end
-    case { '.xls', '.xlsx' }
-        [freq,init,data,varlist] = load_xls_file_data(fullname,xls_sheet,xls_range);
-        for dyn_i_01=1:var_size_01
-            iv = strmatch(strtrim(var_names_01(dyn_i_01,:)),varlist,'exact');
-            if ~isempty(iv)
-                dyn_tmp_01 = [data(:,iv)]';
-                if length(dyn_tmp_01) > dyn_size_01 && dyn_size_01 > 0
-                    cd(old_pwd)
-                    error('data size is too large')
-                end
-                dyn_data_01(:,dyn_i_01) = dyn_tmp_01;
-            else
-                cd(old_pwd)
-                error([strtrim(var_names_01(dyn_i_01,:)) ' not found in ' fullname])
-            end
-        end
-    case '.csv'
-        [freq,init,data,varlist] = load_csv_file_data(fullname);
-        for dyn_i_01=1:var_size_01
-            iv = strmatch(var_names_01{dyn_i_01},varlist,'exact');
-            if ~isempty(iv)
-                dyn_tmp_01 = [data(:,iv)]';
-                if length(dyn_tmp_01) > dyn_size_01 && dyn_size_01 > 0
-                    cd(old_pwd)
-                    error('data size is too large')
-                end
-                dyn_data_01(:,dyn_i_01) = dyn_tmp_01;
-            else
-                cd(old_pwd)
-                error([var_names_01{dyn_i_01} ' not found in ' fullname])
-            end
-        end
-    otherwise
-        cd(old_pwd)
-        error(['Unsupported extension for datafile: ' extension])
+    end
+  otherwise
+    cd(old_pwd)
+    error(['Unsupported extension for datafile: ' extension])
 end
 
 cd(old_pwd)
diff --git a/matlab/realtime_shock_decomposition.m b/matlab/realtime_shock_decomposition.m
new file mode 100644
index 000000000..64bf96c6f
--- /dev/null
+++ b/matlab/realtime_shock_decomposition.m
@@ -0,0 +1,262 @@
+function oo_ = realtime_shock_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_params_)
+% function oo_ = realtime_shock_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_params_)
+% Computes shocks contribution to a simulated trajectory. The fields set are
+% oo_.realtime_shock_decomposition, oo_.conditional_shock_decomposition and oo_.realtime_forecast_shock_decomposition.
+% Subfields are arrays n_var by nshock+2 by nperiods. The
+% first nshock columns store the respective shock contributions, column n+1
+% stores the role of the initial conditions, while column n+2 stores the
+% value of the smoothed variables.  Both the variables and shocks are stored
+% in the order of declaration, i.e. M_.endo_names and M_.exo_names, respectively.
+%
+% INPUTS
+%    M_:          [structure]  Definition of the model
+%    oo_:         [structure]  Storage of results
+%    options_:    [structure]  Options
+%    varlist:     [char]       List of variables
+%    bayestopt_:  [structure]  describing the priors
+%    estim_params_: [structure] characterizing parameters to be estimated
+%
+% OUTPUTS
+%    oo_:         [structure]  Storage of results
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2009-2017 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/>.
+
+% indices of endogenous variables
+if size(varlist,1) == 0
+    varlist = M_.endo_names(1:M_.orig_endo_nbr,:);
+end
+
+[i_var,nvar,index_uniques] = varlist_indices(varlist,M_.endo_names);
+varlist=varlist(index_uniques,:);
+
+% number of variables
+endo_nbr = M_.endo_nbr;
+
+% number of shocks
+nshocks = M_.exo_nbr;
+
+% parameter set
+parameter_set = options_.parameter_set;
+if isempty(parameter_set)
+    if isfield(oo_,'posterior_mean')
+        parameter_set = 'posterior_mean';
+    elseif isfield(oo_,'mle_mode')
+        parameter_set = 'mle_mode';
+    elseif isfield(oo_,'posterior')
+        parameter_set = 'posterior_mode';
+    else
+        error(['realtime_shock_decomposition: option parameter_set is not specified ' ...
+               'and posterior mode is not available'])
+    end
+end
+
+presample = max(1,options_.presample);
+if isfield(options_.shock_decomp,'presample')
+    presample = max(presample,options_.shock_decomp.presample);
+end
+% forecast_=0;
+forecast_ = options_.shock_decomp.forecast;
+forecast_params=0;
+if forecast_ && isfield(options_.shock_decomp,'forecast_params')
+    forecast_params = options_.shock_decomp.forecast_params;
+end
+
+% save_realtime=0;
+save_realtime = options_.shock_decomp.save_realtime;
+% array of time points in the range options_.presample+1:options_.nobs
+
+zreal = zeros(endo_nbr,nshocks+2,options_.nobs+forecast_);
+zcond = zeros(endo_nbr,nshocks+2,options_.nobs);
+skipline()
+skipline()
+running_text = 'Realtime shock decomposition ';
+newString=sprintf(running_text);
+fprintf(['\b%s'],newString);
+
+options_.selected_variables_only = 0; %make sure all variables are stored
+options_.plot_priors=0;
+init=1;
+nobs = options_.nobs;
+
+if forecast_ && any(forecast_params)
+    M1=M_;
+    M1.params = forecast_params;
+    [junk1,junk2,junk3,junk4,junk5,junk6,oo1] = dynare_resolve(M1,options_,oo_);
+    clear junk1 junk2 junk3 junk4 junk5 junk6
+end
+
+for j=presample+1:nobs
+    %    evalin('base',['options_.nobs=' int2str(j) ';'])
+    options_.nobs=j;
+    [oo, M_, junk2, junk3, Smoothed_Variables_deviation_from_mean] = evaluate_smoother(parameter_set,varlist,M_,oo_,options_,bayestopt_,estim_params_);
+
+    % reduced form
+    dr = oo.dr;
+
+    % data reordering
+    order_var = dr.order_var;
+    inv_order_var = dr.inv_order_var;
+
+
+    % coefficients
+    A = dr.ghx;
+    B = dr.ghu;
+
+    if forecast_
+        if any(forecast_params)
+            Af = oo1.dr.ghx;
+            Bf = oo1.dr.ghu;
+        else
+            Af = A;
+            Bf = B;
+        end
+    end
+
+    % initialization
+    gend = size(oo.SmoothedShocks.(deblank(M_.exo_names(1,:))),1);
+    epsilon=NaN(nshocks,gend);
+    for i=1:nshocks
+        epsilon(i,:) = oo.SmoothedShocks.(deblank(M_.exo_names(i,:)));
+    end
+    epsilon=[epsilon zeros(nshocks,forecast_)];
+
+    z = zeros(endo_nbr,nshocks+2,gend+forecast_);
+
+    z(:,end,1:gend) = Smoothed_Variables_deviation_from_mean;
+
+    maximum_lag = M_.maximum_lag;
+
+    k2 = dr.kstate(find(dr.kstate(:,2) <= maximum_lag+1),[1 2]);
+    i_state = order_var(k2(:,1))+(min(i,maximum_lag)+1-k2(:,2))*M_.endo_nbr;
+    for i=1:gend+forecast_
+        if i > 1 && i <= maximum_lag+1
+            lags = min(i-1,maximum_lag):-1:1;
+        end
+
+        if i > 1
+            tempx = permute(z(:,1:nshocks,lags),[1 3 2]);
+            m = min(i-1,maximum_lag);
+            tempx = [reshape(tempx,endo_nbr*m,nshocks); zeros(endo_nbr*(maximum_lag-i+1),nshocks)];
+            if i > gend
+                z(:,nshocks+2,i) = Af(inv_order_var,:)*z(i_state,nshocks+2,lags);
+                %             z(:,nshocks+2,i) = A(inv_order_var,:)*permute(z(i_state,nshocks+2,lags),[1 3 2]);
+                z(:,1:nshocks,i) = Af(inv_order_var,:)*tempx(i_state,:);
+            else
+                z(:,1:nshocks,i) = A(inv_order_var,:)*tempx(i_state,:);
+            end
+            lags = lags+1;
+            z(:,1:nshocks,i) = z(:,1:nshocks,i) + B(inv_order_var,:).*repmat(epsilon(:,i)',endo_nbr,1);
+        end
+
+        %         z(:,1:nshocks,i) = z(:,1:nshocks,i) + B(inv_order_var,:).*repmat(epsilon(:,i)',endo_nbr,1);
+        z(:,nshocks+1,i) = z(:,nshocks+2,i) - sum(z(:,1:nshocks,i),2);
+    end
+
+    %% conditional shock decomp 1 step ahead
+    z1 = zeros(endo_nbr,nshocks+2);
+    z1(:,end) = Smoothed_Variables_deviation_from_mean(:,gend);
+    for i=gend
+
+        z1(:,1:nshocks) = z1(:,1:nshocks) + B(inv_order_var,:).*repmat(epsilon(:,i)',endo_nbr,1);
+        z1(:,nshocks+1) = z1(:,nshocks+2) - sum(z1(:,1:nshocks),2);
+    end
+    %%
+
+    %% conditional shock decomp k step ahead
+    if forecast_ && forecast_<j
+        zn = zeros(endo_nbr,nshocks+2,forecast_+1);
+        zn(:,end,1:forecast_+1) = Smoothed_Variables_deviation_from_mean(:,gend-forecast_:gend);
+        for i=1:forecast_+1
+            if i > 1 && i <= maximum_lag+1
+                lags = min(i-1,maximum_lag):-1:1;
+            end
+
+            if i > 1
+                tempx = permute(zn(:,1:nshocks,lags),[1 3 2]);
+                m = min(i-1,maximum_lag);
+                tempx = [reshape(tempx,endo_nbr*m,nshocks); zeros(endo_nbr*(maximum_lag-i+1-1),nshocks)];
+                zn(:,1:nshocks,i) = A(inv_order_var,:)*tempx(i_state,:);
+                lags = lags+1;
+                zn(:,1:nshocks,i) = zn(:,1:nshocks,i) + B(inv_order_var,:).*repmat(epsilon(:,i+gend-forecast_-1)',endo_nbr,1);
+            end
+
+            %             zn(:,1:nshocks,i) = zn(:,1:nshocks,i) + B(inv_order_var,:).*repmat(epsilon(:,i+gend-forecast_-1)',endo_nbr,1);
+            zn(:,nshocks+1,i) = zn(:,nshocks+2,i) - sum(zn(:,1:nshocks,i),2);
+        end
+        oo_.conditional_shock_decomposition.(['time_' int2str(j-forecast_)])=zn;
+    end
+    %%
+
+    if init
+        zreal(:,:,1:j) = z(:,:,1:j);
+    else
+        zreal(:,:,j) = z(:,:,gend);
+    end
+    zcond(:,:,j) = z1;
+    if ismember(j,save_realtime)
+        oo_.realtime_shock_decomposition.(['time_' int2str(j)])=z;
+    end
+
+    if forecast_
+        zfrcst(:,:,j+1) = z(:,:,gend+1);
+        oo_.realtime_forecast_shock_decomposition.(['time_' int2str(j)])=z(:,:,gend:end);
+        if j>forecast_+presample
+            %% realtime conditional shock decomp k step ahead
+            oo_.realtime_conditional_shock_decomposition.(['time_' int2str(j-forecast_)]) = ...
+                zreal(:,:,j-forecast_:j) - ...
+                oo_.realtime_forecast_shock_decomposition.(['time_' int2str(j-forecast_)]);
+            oo_.realtime_conditional_shock_decomposition.(['time_' int2str(j-forecast_)])(:,end-1,:) = ...
+                oo_.realtime_forecast_shock_decomposition.(['time_' int2str(j-forecast_)])(:,end,:);
+            oo_.realtime_conditional_shock_decomposition.(['time_' int2str(j-forecast_)])(:,end,:) = ...
+                zreal(:,end,j-forecast_:j);
+
+            if j==nobs
+                for my_forecast_=(forecast_-1):-1:1
+                    oo_.realtime_conditional_shock_decomposition.(['time_' int2str(j-my_forecast_)]) = ...
+                        zreal(:,:,j-my_forecast_:j) - ...
+                        oo_.realtime_forecast_shock_decomposition.(['time_' int2str(j-my_forecast_)])(:,:,1:my_forecast_+1);
+                    oo_.realtime_conditional_shock_decomposition.(['time_' int2str(j-my_forecast_)])(:,end-1,:) = ...
+                        oo_.realtime_forecast_shock_decomposition.(['time_' int2str(j-my_forecast_)])(:,end,1:my_forecast_+1);
+                    oo_.realtime_conditional_shock_decomposition.(['time_' int2str(j-my_forecast_)])(:,end,:) = ...
+                        zreal(:,end,j-my_forecast_:j);
+                end
+            end
+
+        end
+    end
+
+    prctdone=(j-presample)/(nobs-presample);
+    if isoctave
+        printf([running_text,' %3.f%% done\r'], prctdone*100);
+    else
+        s0=repmat('\b',1,length(newString));
+        newString=sprintf([running_text,' %3.1f%% done'], prctdone*100);
+        fprintf([s0,'%s'],newString);
+    end
+    init=0;
+end
+oo_.realtime_shock_decomposition.pool = zreal;
+oo_.conditional_shock_decomposition.pool = zcond;
+if forecast_
+    oo_.realtime_forecast_shock_decomposition.pool = zfrcst;
+end
+
+skipline()
diff --git a/matlab/recursive_moments.m b/matlab/recursive_moments.m
index 712a4b597..4d38d9b1b 100644
--- a/matlab/recursive_moments.m
+++ b/matlab/recursive_moments.m
@@ -1,25 +1,25 @@
 function [mu,sigma,offset] = recursive_moments(m0,s0,data,offset)
 % Recursive estimation of order one and two moments (expectation and
-% covariance matrix). 
-% 
-% INPUTS 
+% covariance matrix).
+%
+% INPUTS
 %   o m0         [double]    (n*1) vector, the prior expectation.
 %   o s0         [double]    (n*n) matrix, the prior covariance matrix.
-%   o data       [double]    (T*n) matrix.  
+%   o data       [double]    (T*n) matrix.
 %   o offset     [integer]   scalar, number of observation previously
 %                            used to compute m0 and s0.
-% OUTPUTS 
-%   o mu         [double]    (n*1) vector, the posterior expectation. 
+% OUTPUTS
+%   o mu         [double]    (n*1) vector, the posterior expectation.
 %   o sigma      [double]    (n*n) matrix, the posterior covariance matrix.
 %   o offset     [integer]   = offset + T.
 %
-% ALGORITHM 
-%   None.       
+% ALGORITHM
+%   None.
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2009 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -47,6 +47,6 @@ for t = 1:T
     s0 = s1;
 end
 
-mu = m1; 
+mu = m1;
 sigma = s1;
 offset = offset+T;
\ No newline at end of file
diff --git a/matlab/reduced_form_models/local_state_space_iteration_2/local_state_space_iteration_2.m b/matlab/reduced_form_models/local_state_space_iteration_2/local_state_space_iteration_2.m
index 0c6a52d07..522456728 100644
--- a/matlab/reduced_form_models/local_state_space_iteration_2/local_state_space_iteration_2.m
+++ b/matlab/reduced_form_models/local_state_space_iteration_2/local_state_space_iteration_2.m
@@ -58,7 +58,7 @@ function [y,y_] = local_state_space_iteration_2(yhat,epsilon,ghx,ghu,constant,gh
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/reduced_rank_cholesky.m b/matlab/reduced_rank_cholesky.m
index 1af9ec609..fe9edbace 100644
--- a/matlab/reduced_rank_cholesky.m
+++ b/matlab/reduced_rank_cholesky.m
@@ -36,7 +36,7 @@ function T = reduced_rank_cholesky(X)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -51,8 +51,8 @@ function T = reduced_rank_cholesky(X)
 % 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/>.    
-    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+
 [T,X_is_not_positive_definite] = chol(X);
 
 if X_is_not_positive_definite
@@ -87,7 +87,7 @@ end
 %$ catch
 %$    t(1) = 0;
 %$    T = all(t);
-%$    return;
+%$    return
 %$ end
 %$
 %$
diff --git a/matlab/resid.m b/matlab/resid.m
index 7383c1944..f124409c1 100644
--- a/matlab/resid.m
+++ b/matlab/resid.m
@@ -2,17 +2,17 @@ function z = resid(junk)
 % function z = resid(junk)
 %
 % Computes static residuals associated with the guess values.
-% 
+%
 % INPUTS
 %    junk:   dummy value for backward compatibility
-%    
+%
 % OUTPUTS
 %    z:      residuals
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2012 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -58,9 +58,9 @@ if any(imag(oo_.steady_state))
         for iter=1:length(imagrow)
             fprintf('%s\n',M_.endo_names(imagrow(iter),:));
         end
-    end   
+    end
 end
-    
+
 if options_.steadystate_flag
     [oo_.steady_state,M_.params,info] = ...
         evaluate_steady_state(oo_.steady_state,M_,options_,oo_,0);
diff --git a/matlab/resol.m b/matlab/resol.m
index 31ce81ede..ba3d0e647 100644
--- a/matlab/resol.m
+++ b/matlab/resol.m
@@ -76,7 +76,7 @@ function [dr,info,M,options,oo] = resol(check_flag,M,options,oo)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -93,7 +93,7 @@ function [dr,info,M,options,oo] = resol(check_flag,M,options,oo)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-if isfield(oo,'dr');
+if isfield(oo,'dr')
     dr = oo.dr;
 end
 
@@ -101,7 +101,7 @@ if M.exo_nbr == 0
     oo.exo_steady_state = [] ;
 end
 
-[dr.ys,M.params,info] = evaluate_steady_state(oo.steady_state,M,options,oo,0);
+[dr.ys,M.params,info] = evaluate_steady_state(oo.steady_state,M,options,oo,~options.steadystate.nocheck);
 
 if info(1)
     oo.dr = dr;
@@ -122,7 +122,7 @@ if options.loglinear
             for var_iter=1:length(idx)
                 fprintf(' - %s (%s)\n',deblank(variables_with_non_positive_steady_state(var_iter,:)), num2str(dr.ys(idx(var_iter))))
             end
-            if isestimation()
+            if isinestimationobjective()
                 fprintf('You should check that the priors and/or bounds over the deep parameters are such\n')
                 fprintf('that the steady state levels of all the variables are strictly positive, or consider\n')
                 fprintf('a linearization of the model instead of a log linearization.\n')
diff --git a/matlab/rotated_slice_sampler.m b/matlab/rotated_slice_sampler.m
index 66908d77d..6dbfded0f 100644
--- a/matlab/rotated_slice_sampler.m
+++ b/matlab/rotated_slice_sampler.m
@@ -1,184 +1,183 @@
-function [theta, fxsim, neval] = rotated_slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin)
-% ----------------------------------------------------------
-% ROTATED SLICE SAMPLER - with stepping out (Neal, 2003)
-% extension of the orthogonal univarite sampler (slice_sampler.m)
-% copyright M. Ratto (European Commission)
-%
-% objective_function(theta,varargin): -log of any unnormalized pdf 
-% with varargin (optional) a vector of auxiliaty parameters
-% to be passed to f( ).
-% ----------------------------------------------------------
-%
-% INPUTS
-%   objective_function:       objective function (expressed as minus the log of a density)
-%   theta:                    last value of theta
-%   thetaprior:               bounds of the theta space
-%   sampler_options:          posterior sampler options
-%   varargin:                 optional input arguments to objective function
-%
-% OUTPUTS
-%   theta:       new theta sample
-%   fxsim:       value of the objective function for the new sample
-%   neval:       number of function evaluations
-%
-% SPECIAL REQUIREMENTS
-%   none
-
-% Copyright (C) 2015 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/>.
-
-theta=theta(:);
-npar = length(theta);
-neval = zeros(npar,1);
-W1=[];
-if isfield(sampler_options,'WR'),
-    W1 = sampler_options.WR;
-end
-if ~isempty(sampler_options.mode),
-    mm = sampler_options.mode;
-    n = length(mm);
-    for j=1:n,
-        distance(j)=sqrt(sum((theta-mm(j).m).^2));
-    end
-    [m, im] = min(distance);
-    
-    r=im;
-    V1 = mm(r).m;
-    jj=0;
-    for j=1:n,
-        if j~=r,
-            jj=jj+1;
-            tmp=mm(j).m-mm(r).m;
-            %tmp=mm(j).m-theta;
-            V1(:,jj)=tmp/norm(tmp);
-        end
-    end
-    resul=randperm(n-1,n-1);
-    V1 = V1(:,resul);
-
-    %V1 = V1(:, randperm(n-1));
-%     %d = chol(mm(r).invhess);
-%     %V1 = transpose(feval(sampler_options.proposal_distribution, transpose(mm(r).m), d, npar));
-% 
-%     V1=eye(npar);
-%     V1=V1(:,randperm(npar));
-%     for j=1:2,
-%         V1(:,j)=mm(r(j)).m-theta;
-%         V1(:,j)=V1(:,j)/norm(V1(:,j));
-%     end
-%     % Gram-Schmidt
-%     for j=2:npar,
-%         for k=1:j-1,
-%             V1(:,j)=V1(:,j)-V1(:,k)'*V1(:,j)*V1(:,k);
-%         end
-%         V1(:,j)=V1(:,j)/norm(V1(:,j));
-%     end    
-%     for j=1:n,
-%         distance(j)=sqrt(sum((theta-mm(j).m).^2));
-%     end
-%     [m, im] = min(distance);
-%     if im==r, 
-%         fxsim=[];
-%         return,
-%     else
-%         theta1=theta;
-%     end
-else
-    V1 = sampler_options.V1;    
-end
-npar=size(V1,2);
-    
-for it=1:npar,
-    theta0 = theta;
-    neval(it) = 0;
-    xold  = 0;
-   % XLB   = thetaprior(3);
-   % XUB   = thetaprior(4);
-    tb=sort([(thetaprior(:,1)-theta)./V1(:,it) (thetaprior(:,2)-theta)./V1(:,it)],2);
-    XLB=max(tb(:,1));
-    XUB=min(tb(:,2));  
-    if isempty(W1),
-        W = (XUB-XLB); %*0.8; 
-    else
-        W = W1(it);
-    end
-        
-    % -------------------------------------------------------
-    % 1. DRAW Z = ln[f(X0)] - EXP(1) where EXP(1)=-ln(U(0,1))
-    %    THIS DEFINES THE SLICE S={x: z < ln(f(x))}
-    % -------------------------------------------------------
-    
-    fxold = -feval(objective_function,theta,varargin{:});
-    %I have to be sure that the rotation is for L,R or for Fxold, theta(it)
-    neval(it) = neval(it) + 1;
-    Z = fxold + log(rand(1,1));
-    % -------------------------------------------------------------
-    % 2. FIND I=(L,R) AROUND X0 THAT CONTAINS S AS MUCH AS POSSIBLE
-    %    STEPPING-OUT PROCEDURE
-    % -------------------------------------------------------------
-    u = rand(1,1);
-    L = max(XLB,xold-W*u);
-    R = min(XUB,L+W);
-    
-    %[L R]=slice_rotation(L, R, alpha);
-    while(L > XLB)
-        xsim = L;
-        theta = theta0+xsim*V1(:,it);
-        fxl = -feval(objective_function,theta,varargin{:});
-        neval(it) = neval(it) + 1;
-        if (fxl <= Z)
-            break;
-        end
-        L = max(XLB,L-W);
-    end
-    while(R < XUB)
-        xsim = R;
-        theta = theta0+xsim*V1(:,it);
-        fxr = -feval(objective_function,theta,varargin{:});
-        neval(it) = neval(it) + 1;
-        if (fxr <= Z)
-            break;
-        end
-        R = min(XUB,R+W);
-    end
-    % ------------------------------------------------------
-    % 3. SAMPLING FROM THE SET A = (I INTERSECT S) = (LA,RA)
-    % ------------------------------------------------------
-    fxsim = Z-1;
-    while (fxsim < Z)
-        u = rand(1,1);
-        xsim = L + u*(R - L);
-        theta = theta0+xsim*V1(:,it);
-        fxsim = -feval(objective_function,theta,varargin{:});
-        neval(it) = neval(it) + 1;
-        if (xsim > xold)
-            R = xsim;
-        else
-            L = xsim;
-        end
-    end
-end
-
-% if ~isempty(sampler_options.mode),
-%     dist1=sqrt(sum((theta-mm(r).m).^2));
-%     if dist1>distance(r),
-%         theta=theta1;
-%         fxsim=[];
-%     end
-% end
-end
-
+function [theta, fxsim, neval] = rotated_slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin)
+% ----------------------------------------------------------
+% ROTATED SLICE SAMPLER - with stepping out (Neal, 2003)
+% extension of the orthogonal univarite sampler (slice_sampler.m)
+% copyright M. Ratto (European Commission)
+%
+% objective_function(theta,varargin): -log of any unnormalized pdf
+% with varargin (optional) a vector of auxiliaty parameters
+% to be passed to f( ).
+% ----------------------------------------------------------
+%
+% INPUTS
+%   objective_function:       objective function (expressed as minus the log of a density)
+%   theta:                    last value of theta
+%   thetaprior:               bounds of the theta space
+%   sampler_options:          posterior sampler options
+%   varargin:                 optional input arguments to objective function
+%
+% OUTPUTS
+%   theta:       new theta sample
+%   fxsim:       value of the objective function for the new sample
+%   neval:       number of function evaluations
+%
+% SPECIAL REQUIREMENTS
+%   none
+
+% Copyright (C) 2015-2017 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/>.
+
+theta=theta(:);
+npar = length(theta);
+neval = zeros(npar,1);
+W1=[];
+if isfield(sampler_options,'WR')
+    W1 = sampler_options.WR;
+end
+if ~isempty(sampler_options.mode)
+    mm = sampler_options.mode;
+    n = length(mm);
+    for j=1:n
+        distance(j)=sqrt(sum((theta-mm(j).m).^2));
+    end
+    [m, im] = min(distance);
+
+    r=im;
+    V1 = mm(r).m;
+    jj=0;
+    for j=1:n
+        if j~=r
+            jj=jj+1;
+            tmp=mm(j).m-mm(r).m;
+            %tmp=mm(j).m-theta;
+            V1(:,jj)=tmp/norm(tmp);
+        end
+    end
+    resul=randperm(n-1,n-1);
+    V1 = V1(:,resul);
+
+    %V1 = V1(:, randperm(n-1));
+    %     %d = chol(mm(r).invhess);
+    %     %V1 = transpose(feval(sampler_options.proposal_distribution, transpose(mm(r).m), d, npar));
+    %
+    %     V1=eye(npar);
+    %     V1=V1(:,randperm(npar));
+    %     for j=1:2,
+    %         V1(:,j)=mm(r(j)).m-theta;
+    %         V1(:,j)=V1(:,j)/norm(V1(:,j));
+    %     end
+    %     % Gram-Schmidt
+    %     for j=2:npar,
+    %         for k=1:j-1,
+    %             V1(:,j)=V1(:,j)-V1(:,k)'*V1(:,j)*V1(:,k);
+    %         end
+    %         V1(:,j)=V1(:,j)/norm(V1(:,j));
+    %     end
+    %     for j=1:n,
+    %         distance(j)=sqrt(sum((theta-mm(j).m).^2));
+    %     end
+    %     [m, im] = min(distance);
+    %     if im==r,
+    %         fxsim=[];
+    %         return,
+    %     else
+    %         theta1=theta;
+    %     end
+else
+    V1 = sampler_options.V1;
+end
+npar=size(V1,2);
+
+for it=1:npar
+    theta0 = theta;
+    neval(it) = 0;
+    xold  = 0;
+    % XLB   = thetaprior(3);
+    % XUB   = thetaprior(4);
+    tb=sort([(thetaprior(:,1)-theta)./V1(:,it) (thetaprior(:,2)-theta)./V1(:,it)],2);
+    XLB=max(tb(:,1));
+    XUB=min(tb(:,2));
+    if isempty(W1)
+        W = (XUB-XLB); %*0.8;
+    else
+        W = W1(it);
+    end
+
+    % -------------------------------------------------------
+    % 1. DRAW Z = ln[f(X0)] - EXP(1) where EXP(1)=-ln(U(0,1))
+    %    THIS DEFINES THE SLICE S={x: z < ln(f(x))}
+    % -------------------------------------------------------
+
+    fxold = -feval(objective_function,theta,varargin{:});
+    %I have to be sure that the rotation is for L,R or for Fxold, theta(it)
+    neval(it) = neval(it) + 1;
+    Z = fxold + log(rand(1,1));
+    % -------------------------------------------------------------
+    % 2. FIND I=(L,R) AROUND X0 THAT CONTAINS S AS MUCH AS POSSIBLE
+    %    STEPPING-OUT PROCEDURE
+    % -------------------------------------------------------------
+    u = rand(1,1);
+    L = max(XLB,xold-W*u);
+    R = min(XUB,L+W);
+
+    %[L R]=slice_rotation(L, R, alpha);
+    while(L > XLB)
+        xsim = L;
+        theta = theta0+xsim*V1(:,it);
+        fxl = -feval(objective_function,theta,varargin{:});
+        neval(it) = neval(it) + 1;
+        if (fxl <= Z)
+            break
+        end
+        L = max(XLB,L-W);
+    end
+    while(R < XUB)
+        xsim = R;
+        theta = theta0+xsim*V1(:,it);
+        fxr = -feval(objective_function,theta,varargin{:});
+        neval(it) = neval(it) + 1;
+        if (fxr <= Z)
+            break
+        end
+        R = min(XUB,R+W);
+    end
+    % ------------------------------------------------------
+    % 3. SAMPLING FROM THE SET A = (I INTERSECT S) = (LA,RA)
+    % ------------------------------------------------------
+    fxsim = Z-1;
+    while (fxsim < Z)
+        u = rand(1,1);
+        xsim = L + u*(R - L);
+        theta = theta0+xsim*V1(:,it);
+        fxsim = -feval(objective_function,theta,varargin{:});
+        neval(it) = neval(it) + 1;
+        if (xsim > xold)
+            R = xsim;
+        else
+            L = xsim;
+        end
+    end
+end
+
+% if ~isempty(sampler_options.mode),
+%     dist1=sqrt(sum((theta-mm(r).m).^2));
+%     if dist1>distance(r),
+%         theta=theta1;
+%         fxsim=[];
+%     end
+% end
+end
diff --git a/matlab/row_header_width.m b/matlab/row_header_width.m
index c3132e261..e3a995502 100644
--- a/matlab/row_header_width.m
+++ b/matlab/row_header_width.m
@@ -1,19 +1,19 @@
 function w=row_header_width(M_,estim_params_,bayestopt_)
 % This function computes the width of the row headers for
 % the estimation results
-% 
-% INPUTS 
-%   estim_params_    [structure] 
+%
+% INPUTS
+%   estim_params_    [structure]
 %   M_               [structure]
 %   bayestopt_       [structure]
-%  
-% OUTPUTS 
+%
+% OUTPUTS
 %   w                integer
 %
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2013 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,13 +44,13 @@ if np
 end
 if nvx
     for i=1:nvx
-        k = estim_params_.var_exo(i,1); 
+        k = estim_params_.var_exo(i,1);
         w = max(w,length(deblank(M_.exo_names(k,:))));
     end
 end
 if nvn
     for i=1:nvn
-        k = estim_params_.var_endo(i,1); 
+        k = estim_params_.var_endo(i,1);
         w = max(w,length(deblank(M_.endo_names(k,:))));
     end
 end
@@ -72,4 +72,3 @@ if ncn
 
     end
 end
-
diff --git a/matlab/rplot.m b/matlab/rplot.m
index 5705abdc1..cc7f30515 100644
--- a/matlab/rplot.m
+++ b/matlab/rplot.m
@@ -14,7 +14,7 @@ function rplot(s1)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -52,11 +52,11 @@ ix = [1 - M_.maximum_lag:size(oo_.endo_simul,2)-M_.maximum_lag]' ;
 
 y = [];
 for k=1:size(s1,1)
-    if isempty(strmatch(deblank(s1(k,:)),M_.endo_names,'exact')) 
-        if isempty(strmatch(deblank(s1(k,:)),M_.exo_names,'exact')) 
+    if isempty(strmatch(deblank(s1(k,:)),M_.endo_names,'exact'))
+        if isempty(strmatch(deblank(s1(k,:)),M_.exo_names,'exact'))
             error (['rplot: One of the variables specified does not exist']) ;
         else
-            y = [y; oo_.exo_simul(:,strmatch(deblank(s1(k,:)),M_.exo_names,'exact'))'] ;        
+            y = [y; oo_.exo_simul(:,strmatch(deblank(s1(k,:)),M_.exo_names,'exact'))'] ;
         end
     else
         y = [y; oo_.endo_simul(strmatch(deblank(s1(k,:)),M_.endo_names,'exact'),:)] ;
@@ -81,7 +81,7 @@ if rplottype == 0
     for j = 1:size(y,1)
         t = [t s1(j,:) ' '] ;
     end
-    hh=dyn_figure(options_,'Name',['Simulated Trajectory']);
+    hh=dyn_figure(options_.nodisplay,'Name',['Simulated Trajectory']);
     plot(ix(i),y(:,i)) ;
     title (t,'Interpreter','none') ;
     xlabel('Periods') ;
@@ -94,24 +94,24 @@ if rplottype == 0
             set(h, 'Interpreter', 'none');
         end
     end
-    dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'SimulatedTrajectory_' deblank(s1(1,:))],options_)
+    dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'SimulatedTrajectory_' deblank(s1(1,:))],options_.nodisplay,options_.graph_format)
     if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         create_TeX_loader(fidTeX,options_,[M_.fname, '/graphs/', 'SimulatedTrajectory_' deblank(s1(1,:))],'Simulated trajectories','SimulatedTrajectory_',deblank(s1(1,:)),1)
     end
 elseif rplottype == 1
     for j = 1:size(y,1)
-        hh=dyn_figure(options_,'Name',['Simulated Trajectory']);
+        hh=dyn_figure(options_.nodisplay,'Name',['Simulated Trajectory']);
         plot(ix(i),y(j,i)) ;
         xlim([min(ix(i)) max(ix(i))])
         title(['Plot of ' s1(j,:)],'Interpreter','none') ;
         xlabel('Periods') ;
-        dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'SimulatedTrajectory_' deblank(s1(j,:))],options_)
+        dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'SimulatedTrajectory_' deblank(s1(j,:))],options_.nodisplay,options_.graph_format)
         if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
             create_TeX_loader(fidTeX,options_,[M_.fname, '/graphs/', 'SimulatedTrajectory_' deblank(s1(j,:))],'Simulated trajectories','SimulatedTrajectory_',deblank(s1(j,:)),1);
         end
     end
 elseif rplottype == 2
-    hh=dyn_figure(options_,'Name',['Simulated Trajectory']);
+    hh=dyn_figure(options_.nodisplay,'Name',['Simulated Trajectory']);
     nl = max(1,fix(size(y,1)/4)) ;
     nc = ceil(size(y,1)/nl) ;
     for j = 1:size(y,1)
@@ -128,7 +128,7 @@ elseif rplottype == 2
         title(['Plot of ' s1(j,:)],'Interpreter','none') ;
         axis tight;
     end
-    dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'SimulatedTrajectory_' deblank(s1(1,:))],options_)
+    dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'SimulatedTrajectory_' deblank(s1(1,:))],options_.nodisplay,options_.graph_format)
     if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         create_TeX_loader(fidTeX,options_,[M_.fname, '/graphs/', 'SimulatedTrajectory_' deblank(s1(1,:))],'Simulated trajectories','SimulatedTrajectory_',deblank(s1(1,:)),min(j/nc,1));
     end
@@ -140,16 +140,16 @@ if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
 end
 
 function []=create_TeX_loader(fidTeX,options,figpath,caption,label_name,label_type,scale_factor)
-    if nargin<6
-        scale_factor=1;
-    end
-    fprintf(fidTeX,' \n'); 
-    fprintf(fidTeX,'\\begin{figure}[H]\n');
-    fprintf(fidTeX,'\\centering \n');
-    fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s}\n',0.8*scale_factor,strrep(figpath,'\','/'));
-    fprintf(fidTeX,'\\caption{%s.}',caption);
-    fprintf(fidTeX,'\\label{Fig:%s:%s}\n',label_name,label_type);
-    fprintf(fidTeX,'\\end{figure}\n\n');
+if nargin<6
+    scale_factor=1;
+end
+fprintf(fidTeX,' \n');
+fprintf(fidTeX,'\\begin{figure}[H]\n');
+fprintf(fidTeX,'\\centering \n');
+fprintf(fidTeX,'\\includegraphics[width=%2.2f\\textwidth]{%s}\n',0.8*scale_factor,strrep(figpath,'\','/'));
+fprintf(fidTeX,'\\caption{%s.}',caption);
+fprintf(fidTeX,'\\label{Fig:%s:%s}\n',label_name,label_type);
+fprintf(fidTeX,'\\end{figure}\n\n');
 
 % 02/28/01 MJ replaced bseastr by MATLAB's strmatch
 % 06/19/01 MJ added 'exact' to strmatch calls
diff --git a/matlab/sample_autocovariance.m b/matlab/sample_autocovariance.m
index 12bd34e86..3ae17e1a0 100644
--- a/matlab/sample_autocovariance.m
+++ b/matlab/sample_autocovariance.m
@@ -1,19 +1,19 @@
 function [autocov,autocor] = sample_autocovariance(data,q)
 % Computes the autocovariance function associated to a time series.
-% 
 %
-% INPUTS 
+%
+% INPUTS
 %
 %   data            [double]       T*1 vector of data.
-%   q               [integer]      Order of the autocovariance function. 
-%    
-% OUTPUTS 
-%   autocov         [double]       (q+1)*1 vector, autocovariance function (first scalar is the variance).  
+%   q               [integer]      Order of the autocovariance function.
+%
+% OUTPUTS
+%   autocov         [double]       (q+1)*1 vector, autocovariance function (first scalar is the variance).
 %   autocor         [double]       (q+1)*1 vector, autocorrelation function (first scalar is equal to one).
 %
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2008 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/sample_hp_filter.m b/matlab/sample_hp_filter.m
index a7b3592cf..381086b3d 100644
--- a/matlab/sample_hp_filter.m
+++ b/matlab/sample_hp_filter.m
@@ -1,18 +1,18 @@
 function [hptrend,hpcycle] = sample_hp_filter(y,s)
 % HP filters a collection of time series.
-% 
-% INPUTS 
+%
+% INPUTS
 %   y                        [double]   T*n matrix of data (n is the number of variables)
 %   s                        [double]   scalar, smoothing parameter.
-% 
-% OUTPUTS 
+%
+% OUTPUTS
 %   hptrend                  [double]   T*n matrix, trend component of y.
-%   hpcycle                  [double]   T*n matrix, cycle component of y.  
-%               
+%   hpcycle                  [double]   T*n matrix, cycle component of y.
+%
 % SPECIAL REQUIREMENTS
-%    
+%
 
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/save_params_and_steady_state.m b/matlab/save_params_and_steady_state.m
index 0f8dbfe1a..273800fce 100644
--- a/matlab/save_params_and_steady_state.m
+++ b/matlab/save_params_and_steady_state.m
@@ -12,17 +12,17 @@ function save_params_and_steady_state(filename)
 % Note that no variable type is stored in the file, so that the values
 % can be reloaded (with load_params_and_steady_state) in a setup where
 % the variable types are different.
-%  
+%
 % INPUTS
 %   filename:   where to store the saved values
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/score.m b/matlab/score.m
index 273ca6395..06c01cc0d 100644
--- a/matlab/score.m
+++ b/matlab/score.m
@@ -8,7 +8,7 @@ function [DLIK] = score(T,R,Q,H,P,Y,DT,DYss,DOm,DH,DP,start,mf,kalman_tol,riccat
 % NOTE: the derivative matrices (DT,DR ...) are 3-dim. arrays with last
 % dimension equal to the number of structural parameters
 
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -25,95 +25,95 @@ function [DLIK] = score(T,R,Q,H,P,Y,DT,DYss,DOm,DH,DP,start,mf,kalman_tol,riccat
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licen
 
-    k = size(DT,3);                                 % number of structural parameters
-    smpl = size(Y,2);                               % Sample size.
-    mm   = size(T,2);                               % Number of state variables.
-    a    = zeros(mm,1);                             % State vector.
-    Om   = R*Q*transpose(R);                        % Variance of R times the vector of structural innovations.
-    t    = 0;                                       % Initialization of the time index.
-    oldK = 0;
-    notsteady   = 1;                                % Steady state flag.
-    F_singular  = 1;
+k = size(DT,3);                                 % number of structural parameters
+smpl = size(Y,2);                               % Sample size.
+mm   = size(T,2);                               % Number of state variables.
+a    = zeros(mm,1);                             % State vector.
+Om   = R*Q*transpose(R);                        % Variance of R times the vector of structural innovations.
+t    = 0;                                       % Initialization of the time index.
+oldK = 0;
+notsteady   = 1;                                % Steady state flag.
+F_singular  = 1;
+
+DLIK  = zeros(k,1);                             % Initialization of the score.
+Da    = zeros(mm,k);                            % State vector.
+Dv    = zeros(length(mf),k);                    % observation vector.
 
-    DLIK  = zeros(k,1);                             % Initialization of the score.
-    Da    = zeros(mm,k);                            % State vector.
-    Dv    = zeros(length(mf),k);                    % observation vector.
-    
 %     for ii = 1:k
-%         DOm = DR(:,:,ii)*Q*transpose(R) + R*DQ(:,:,ii)*transpose(R) + R*Q*transpose(DR(:,:,ii)); 
+%         DOm = DR(:,:,ii)*Q*transpose(R) + R*DQ(:,:,ii)*transpose(R) + R*Q*transpose(DR(:,:,ii));
 %     end
-    
-    while notsteady & t<smpl
-        t  = t+1;
-        v  = Y(:,t)-a(mf);
-        F  = P(mf,mf) + H;
-        if rcond(F) < kalman_tol
-            if ~all(abs(F(:))<kalman_tol)
-                return
-            else
-                a = T*a;
-                P = T*P*transpose(T)+Om;
-            end
+
+while notsteady & t<smpl
+    t  = t+1;
+    v  = Y(:,t)-a(mf);
+    F  = P(mf,mf) + H;
+    if rcond(F) < kalman_tol
+        if ~all(abs(F(:))<kalman_tol)
+            return
         else
-            F_singular = 0;
-            iF     = inv(F);
-            K      = P(:,mf)*iF;
-
-            [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K);
-            for ii = 1:k
-                Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
-                Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
-                if t>=start
-                   DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
-                end
-            end
-            a      = T*(a+K*v);                   
-            P      = T*(P-K*P(mf,:))*transpose(T)+Om;
-            DP     = DP1;
+            a = T*a;
+            P = T*P*transpose(T)+Om;
         end
-        notsteady = max(max(abs(K-oldK))) > riccati_tol;
-        oldK = K;
-    end
+    else
+        F_singular = 0;
+        iF     = inv(F);
+        K      = P(:,mf)*iF;
 
-    if F_singular
-        error('The variance of the forecast error remains singular until the end of the sample')
-    end
-
-    for ii = 1:k
-        tmp0(:,:,ii) = iF*DF(:,:,ii)*iF;
-    end
-    
-    if t < smpl
-        t0 = t+1;
-        while t < smpl
-            t = t+1;
-            v = Y(:,t)-a(mf);
-            for ii = 1:k
-                Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
-                Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
-                if t>=start
-                   DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
-                end
-            end
-            a = T*(a+K*v);
-        end
+        [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K);
         for ii = 1:k
-%             DLIK(ii,1)  = DLIK(ii,1) + (smpl-t0+1)*trace( iF*DF(:,:,ii) );
+            Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
+            Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
+            if t>=start
+                DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
+            end
         end
-        
-    end    
-    
-    DLIK = DLIK/2;
-    
-% end of main function    
-    
-function [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K)
+        a      = T*(a+K*v);
+        P      = T*(P-K*P(mf,:))*transpose(T)+Om;
+        DP     = DP1;
+    end
+    notsteady = max(max(abs(K-oldK))) > riccati_tol;
+    oldK = K;
+end
 
-            k      = size(DT,3);
-            tmp    = P-K*P(mf,:);
+if F_singular
+    error('The variance of the forecast error remains singular until the end of the sample')
+end
 
 for ii = 1:k
-    DF(:,:,ii)  = DP(mf,mf,ii) + DH(:,:,ii); 
+    tmp0(:,:,ii) = iF*DF(:,:,ii)*iF;
+end
+
+if t < smpl
+    t0 = t+1;
+    while t < smpl
+        t = t+1;
+        v = Y(:,t)-a(mf);
+        for ii = 1:k
+            Dv(:,ii)   = -Da(mf,ii)-DYss(mf,ii);
+            Da(:,ii)   = DT(:,:,ii)*(a+K*v) + T*(Da(:,ii)+DK(:,:,ii)*v + K*Dv(:,ii));
+            if t>=start
+                DLIK(ii,1)  = DLIK(ii,1) + trace( iF*DF(:,:,ii) ) + 2*Dv(:,ii)'*iF*v - v'*(iF*DF(:,:,ii)*iF)*v;
+            end
+        end
+        a = T*(a+K*v);
+    end
+    for ii = 1:k
+        %             DLIK(ii,1)  = DLIK(ii,1) + (smpl-t0+1)*trace( iF*DF(:,:,ii) );
+    end
+
+end
+
+DLIK = DLIK/2;
+
+% end of main function
+
+function [DK,DF,DP1] = computeDKalman(T,DT,DOm,P,DP,DH,mf,iF,K)
+
+k      = size(DT,3);
+tmp    = P-K*P(mf,:);
+
+for ii = 1:k
+    DF(:,:,ii)  = DP(mf,mf,ii) + DH(:,:,ii);
     DiF(:,:,ii) = -iF*DF(:,:,ii)*iF;
     DK(:,:,ii)  = DP(:,mf,ii)*iF + P(:,mf)*DiF(:,:,ii);
     Dtmp        = DP(:,:,ii) - DK(:,:,ii)*P(mf,:) - K*DP(mf,:,ii);
@@ -121,6 +121,3 @@ for ii = 1:k
 end
 
 % end of computeDKalman
-
-
-            
\ No newline at end of file
diff --git a/matlab/selec_posterior_draws.m b/matlab/selec_posterior_draws.m
index d89baf6cf..95407609e 100644
--- a/matlab/selec_posterior_draws.m
+++ b/matlab/selec_posterior_draws.m
@@ -20,7 +20,7 @@ function SampleAddress = selec_posterior_draws(SampleSize,drsize)
 %   None.
 %
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -100,6 +100,8 @@ SampleAddress = sortrows(SampleAddress,[3 2]);
 % Selected draws in the posterior distribution, and if drsize>0
 % reduced form solutions, are saved on disk.
 if info
+    %delete old stale files before creating new ones
+    delete_stale_file([BaseName '_posterior_draws*.mat'])
     if  SampleSize*drawsize <= MAX_mega_bytes% The posterior draws are saved in one file.
         pdraws = cell(SampleSize,info);
         old_mhfile = 0;
diff --git a/matlab/select_from_table.m b/matlab/select_from_table.m
index cc657e934..1584cb950 100644
--- a/matlab/select_from_table.m
+++ b/matlab/select_from_table.m
@@ -1,5 +1,5 @@
 function [indices] = select_from_table(table,key,value)
-% Copyright (C) 2010-2011 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -18,7 +18,7 @@ function [indices] = select_from_table(table,key,value)
 candidates = table(strmatch(key,table(:,2),'exact'),:);
 if nargin == 2
     indices = cell2mat( candidates(:,1) );
-    return;
+    return
 end
 indices = candidates(strmatch(value, candidates(:,3), 'exact'),1);
 indices = cell2mat(indices);
diff --git a/matlab/select_qz_criterium_value.m b/matlab/select_qz_criterium_value.m
index 09282747e..574b022b2 100644
--- a/matlab/select_qz_criterium_value.m
+++ b/matlab/select_qz_criterium_value.m
@@ -11,7 +11,7 @@ function options_=select_qz_criterium_value(options_)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2016 Dynare Team
+% Copyright (C) 2016-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,21 +36,40 @@ function options_=select_qz_criterium_value(options_)
 %     set by default options_.qz_criterium to 1+1e-6
 stack = dbstack;
 
-if isequal(options_.lik_init,1)
-    if isempty(options_.qz_criterium)
-        options_.qz_criterium = 1-1e-6;
-    elseif options_.qz_criterium > 1-eps
-        error([stack(2).file ': option qz_criterium is too large for estimating/smoothing ' ...
-               'a stationary model. If your model contains unit roots, use ' ...
-               'option diffuse_filter'])
-    end
-else
-    if isempty(options_.qz_criterium)
-        options_.qz_criterium = 1+1e-6;
-    else
-        if options_.qz_criterium <= 1
-            fprintf('\n%s:: diffuse filter is incompatible with a qz_criterium<=1. Resetting it to 1+1e-6.\n',stack(2).file)
+if options_.particle.status
+    % Non linear filter
+    if isequal(options_.particle.initialization, 3)
+        if isempty(options_.qz_criterium)
             options_.qz_criterium = 1+1e-6;
+        else
+            if options_.qz_criterium <= 1
+                fprintf('\n%s:: You set nonlinear_filter_initialization equal to 3, it is assumed that you try to estimate a non stationary model. Resetting it to 1+1e-6.\n', stack(2).file)
+                options_.qz_criterium = 1+1e-6;
+            end
+        end
+    else
+        if isempty(options_.qz_criterium)
+            options_.qz_criterium = 1-1e-6;
         end
     end
-end
+else
+    % Linear filter
+    if isequal(options_.lik_init,1)
+        if isempty(options_.qz_criterium)
+            options_.qz_criterium = 1-1e-6;
+        elseif options_.qz_criterium > 1-eps
+            error([stack(2).file ': option qz_criterium is too large for estimating/smoothing ' ...
+                   'a stationary model. If your model contains unit roots, use ' ...
+                   'option diffuse_filter'])
+        end
+    else
+        if isempty(options_.qz_criterium)
+            options_.qz_criterium = 1+1e-6;
+        else
+            if options_.qz_criterium <= 1
+                fprintf('\n%s:: diffuse filter is incompatible with a qz_criterium<=1. Resetting it to 1+1e-6.\n',stack(2).file)
+                options_.qz_criterium = 1+1e-6;
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/selif.m b/matlab/selif.m
index 752143aa5..6a79f486c 100644
--- a/matlab/selif.m
+++ b/matlab/selif.m
@@ -1,6 +1,6 @@
 function x = selif(a,b)
 
-% Copyright (C) 2001-2009 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -18,10 +18,9 @@ function x = selif(a,b)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 if size(b,2) ~= 1
-    error ('The second argument in SELIF must be à column vector') ;
+    error ('The second argument in SELIF must be à column vector') ;
 end
 
 x = a(find(b == 1),:) ;
 
 return ;
-
diff --git a/matlab/set_all_parameters.m b/matlab/set_all_parameters.m
index e4daafc37..2f4fcc28e 100644
--- a/matlab/set_all_parameters.m
+++ b/matlab/set_all_parameters.m
@@ -33,7 +33,7 @@ function M = set_all_parameters(xparam1,estim_params,M)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -95,7 +95,7 @@ if ncx
 end
 %build covariance matrix from correlation matrix and variances already on
 %diagonal
-Sigma_e = diag(sqrt(diag(Sigma_e)))*Correlation_matrix*diag(sqrt(diag(Sigma_e))); 
+Sigma_e = diag(sqrt(diag(Sigma_e)))*Correlation_matrix*diag(sqrt(diag(Sigma_e)));
 %if calibrated covariances, set them now to their stored value
 if isfield(estim_params,'calibrated_covariances')
     Sigma_e(estim_params.calibrated_covariances.position)=estim_params.calibrated_covariances.cov_value;
@@ -136,5 +136,5 @@ if nvx || ncx
 end
 if nvn || ncn
     M.H = H;
-    M.Correlation_matrix_ME=Correlation_matrix_ME;    
+    M.Correlation_matrix_ME=Correlation_matrix_ME;
 end
\ No newline at end of file
diff --git a/matlab/set_default_initial_condition_decomposition_options.m b/matlab/set_default_initial_condition_decomposition_options.m
new file mode 100644
index 000000000..07c84d3e6
--- /dev/null
+++ b/matlab/set_default_initial_condition_decomposition_options.m
@@ -0,0 +1,37 @@
+function options = set_default_initial_condition_decomposition_options(options)
+%function options = set_default_initial_condition_decomposition_options(options)
+% sets the default options for prior_shock_decomposition
+%
+% INPUTS
+%    options
+%
+% OUTPUTS
+%    options
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2017 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/>.
+
+options.initial_condition_decomp.detail_plot = 0;
+options.initial_condition_decomp.steadystate = 0;
+options.initial_condition_decomp.write_xls = 0;
+options.initial_condition_decomp.type = '';
+options.initial_condition_decomp.plot_init_date = [];
+options.initial_condition_decomp.plot_end_date = [];
+end
diff --git a/matlab/set_default_option.m b/matlab/set_default_option.m
index 760d74fa8..44976a15a 100644
--- a/matlab/set_default_option.m
+++ b/matlab/set_default_option.m
@@ -1,20 +1,20 @@
 function options=set_default_option(options,field,default)
 
 % function options=set_default_option(options,field,default)
-% Sets the option value 
-% 
+% Sets the option value
+%
 % INPUTS
 %    options
 %    field:   option name
 %    default: assigns a value
-%    
+%
 % OUTPUTS
 %    options
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2009 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/set_default_plot_shock_decomposition_options.m b/matlab/set_default_plot_shock_decomposition_options.m
new file mode 100644
index 000000000..327c047cb
--- /dev/null
+++ b/matlab/set_default_plot_shock_decomposition_options.m
@@ -0,0 +1,51 @@
+function options = set_default_plot_shock_decomposition_options(options)
+%function options = set_default_plot_shock_decomposition_options(options)
+% sets the default options for prior_shock_decomposition
+%
+% INPUTS
+%    options
+%
+% OUTPUTS
+%    options
+%
+% SPECIAL REQUIREMENTS
+%    none
+
+% Copyright (C) 2017 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/>.
+
+options.plot_shock_decomp.use_shock_groups = '';
+options.plot_shock_decomp.colormap = '';
+options.plot_shock_decomp.nodisplay = 0;
+options.plot_shock_decomp.graph_format = 'eps';
+options.plot_shock_decomp.detail_plot = 0;
+options.plot_shock_decomp.interactive = 0;
+options.plot_shock_decomp.screen_shocks = 0;
+options.plot_shock_decomp.steadystate = 0;
+options.plot_shock_decomp.type = '';
+options.plot_shock_decomp.fig_name = '';
+options.plot_shock_decomp.write_xls = 0;
+options.plot_shock_decomp.realtime = 0; % 0 is standard; 1 is realtime
+                                        % (pool/vintage); 2 is conditional
+                                        % (pool/vintage); 3 is forecast
+                                        % (pool/vintage)
+options.plot_shock_decomp.vintage = 0; % 0 pool realtime/conditional; int:
+                                       % forecast/conditional shock
+                                       % decompositions
+options.plot_shock_decomp.plot_init_date = [];
+options.plot_shock_decomp.plot_end_date = [];
+end
diff --git a/matlab/set_dynare_random_generator_state.m b/matlab/set_dynare_random_generator_state.m
index f16ce13ae..a06fdff5d 100644
--- a/matlab/set_dynare_random_generator_state.m
+++ b/matlab/set_dynare_random_generator_state.m
@@ -1,12 +1,12 @@
 function [state_u,state_n] = set_dynare_random_generator_state(state_u,state_n)
 % Wet state of Matlab/Octave random generator depending on matlab
-% (octave) version. 
+% (octave) version.
 % In older versions, Matlab kept one generator for uniformly distributed numbers and
-% one for normally distributed numbers. 
+% one for normally distributed numbers.
 % For backward compatibility, we return two vectors, but, in recent
 % versions of Matlab and in Octave, we return two identical vectors.
-%    
-% Copyright (C) 2010-2012 Dynare Team
+%
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,37 +23,37 @@ function [state_u,state_n] = set_dynare_random_generator_state(state_u,state_n)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    matlab_random_streams = ~(isoctave || matlab_ver_less_than('7.7'));
+matlab_random_streams = ~(isoctave || matlab_ver_less_than('7.7'));
 
-    if matlab_random_streams% Use new matlab interface.
-        if matlab_ver_less_than('7.12')
-            s = RandStream.getDefaultStream();
-        else
-            s = RandStream.getGlobalStream();
-        end
-        if isequal(s.Type,'legacy')
-            rand('state',state_u);
-            randn('state',state_n);
-        else            
-            if ~isequal(state_u,state_n)
-                error(['You are using the new Matlab RandStream mechanism ' ...
-                       'with a single random generator, but the values ' ...
-                       'of the state of the uniformly ' ...
-                       'distributed numbers and of the state of the ' ...
-                       'normally distributed numbers are different. Something must be ' ...
-                       'wrong, such as reloading old Metropolis runs, ' ...
-                       'computed on a different version of Matlab. If you ' ...
-                       'don''t understand the origin of the problem, ' ...
-                       'please, contact Dynare''s development team.'])
-            end
-            s.State = state_u;
-            if matlab_ver_less_than('7.12')
-                RandStream.setDefaultStream(s);
-            else
-                RandStream.setGlobalStream(s);
-            end
-        end
-    else% Use old matlab interface.
+if matlab_random_streams% Use new matlab interface.
+    if matlab_ver_less_than('7.12')
+        s = RandStream.getDefaultStream();
+    else
+        s = RandStream.getGlobalStream();
+    end
+    if isequal(s.Type,'legacy')
         rand('state',state_u);
         randn('state',state_n);
-    end
\ No newline at end of file
+    else
+        if ~isequal(state_u,state_n)
+            error(['You are using the new Matlab RandStream mechanism ' ...
+                   'with a single random generator, but the values ' ...
+                   'of the state of the uniformly ' ...
+                   'distributed numbers and of the state of the ' ...
+                   'normally distributed numbers are different. Something must be ' ...
+                   'wrong, such as reloading old Metropolis runs, ' ...
+                   'computed on a different version of Matlab. If you ' ...
+                   'don''t understand the origin of the problem, ' ...
+                   'please, contact Dynare''s development team.'])
+        end
+        s.State = state_u;
+        if matlab_ver_less_than('7.12')
+            RandStream.setDefaultStream(s);
+        else
+            RandStream.setGlobalStream(s);
+        end
+    end
+else% Use old matlab interface.
+    rand('state',state_u);
+    randn('state',state_n);
+end
\ No newline at end of file
diff --git a/matlab/set_dynare_seed.m b/matlab/set_dynare_seed.m
index 3a71d7236..65c5e0587 100644
--- a/matlab/set_dynare_seed.m
+++ b/matlab/set_dynare_seed.m
@@ -1,8 +1,8 @@
 function set_dynare_seed(a,b)
-% Set seeds depending on matlab (octave) version. This routine is called in dynare_config and can be called by the 
+% Set seeds depending on matlab (octave) version. This routine is called in dynare_config and can be called by the
 % user in the mod file.
-%    
-% Copyright (C) 2010-2014 Dynare Team
+%
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/set_historical_values.m b/matlab/set_historical_values.m
new file mode 100644
index 000000000..d57662f35
--- /dev/null
+++ b/matlab/set_historical_values.m
@@ -0,0 +1,85 @@
+function set_historical_values(ds, initialperiod)
+
+% Builds endo_histval and exo_hsitval from the content of a dseries object.
+%
+% INPUTS
+% - ds                [dseries]    Dataset.
+% - initialperiod     [dates]      Initial period of the simulation.
+%
+% OUTPUTS
+% - none
+% Copyright (C) 2017 Dynare Team
+%
+% This file is part of Dynare.
+%
+% Dynare is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version.
+%
+% Dynare is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+
+global M_
+
+if ischar(ds)
+    ds = evalin('caller', ds);
+end
+
+if ischar(initialperiod)
+    initialperiod = eval(initialperiod);
+end
+
+% Initialize endo_histval.
+M_.endo_histval = zeros(M_.endo_nbr, M_.maximum_endo_lag);
+
+% Fill endo_histval.
+k = 1;
+for i = 1:M_.endo_nbr
+    if i <= M_.orig_endo_nbr
+        if M_.lead_lag_incidence(1,i) > 0
+            if any(strcmp(deblank(M_.endo_names(i,:)),ds.name))
+                M_.endo_histval(i,M_.maximum_endo_lag) = ...
+                    ds{deblank(M_.endo_names(i,:))}(initialperiod-1).data;
+            else
+                error(sprintf('Can''t find %s in dseries', deblank(M_.endo_names(i,:))))
+            end
+        end
+    else
+        a = M_.aux_vars(k);
+        if a.type == 1
+            if any(strcmp(deblank(M_.endo_names(a.orig_index,:)), ds.name))
+                M_.endo_histval(i,M_.maximum_endo_lag) = ...
+                    ds{deblank(M_.endo_names(a.orig_index,:))}(initialperiod-1+a.orig_lead_lag).data;
+            else
+                error(sprintf('Can''t find %s in dseries', deblank(M_.endo_names(a.orig_index,:))))
+            end
+        end
+        k = k + 1;
+    end
+end
+
+% If model has lags on exogenous variables, initialize and fill exo_histval
+if M_.maximum_exo_lag
+    M_.exo_histval = zeros(M_.maximum_exo_lag, M_.exo_nbr);
+    exo_list = cellstr(M_.exo_names);
+    available_exo_variables = ismember(exo_list, ds.name);
+    if any(~available_exo_variables)
+        skipline()
+        disp('Some exogenous variables are not available in the dseries object.')
+        disp('Default value for lagged exogenous variables is zero.')
+        skipline()
+    end
+    for t = 1:M_.maximum_exo_lag
+        for i=1:M_.exo_nbr
+            if available_exo_variables(i)
+                exo_histval(M_.maximum_exo_lag+1-t,i) = ds{exo_list{i}}(initialperiod-t).data;
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/@dynTimeIndex/subsasgn.m b/matlab/set_local_param_value.m
similarity index 74%
rename from matlab/@dynTimeIndex/subsasgn.m
rename to matlab/set_local_param_value.m
index 101468062..52e88341d 100644
--- a/matlab/@dynTimeIndex/subsasgn.m
+++ b/matlab/set_local_param_value.m
@@ -1,6 +1,6 @@
-function val = subsasgn(val, idx, rhs)
+function M = set_local_param_value(pname,value,M)
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,4 +17,11 @@ function val = subsasgn(val, idx, rhs)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-error('dynTimeIndex::subsasgn: Members of dynTimeIndex class are private!')
\ No newline at end of file
+
+i = strmatch(pname,M.param_names,'exact');
+
+if isempty(i)
+    error(['Parameter name ' pname ' doesn''t exist'])
+end
+
+M.params(i) = value;
diff --git a/matlab/set_parameters.m b/matlab/set_parameters.m
index c183bb3d3..15f4175ed 100644
--- a/matlab/set_parameters.m
+++ b/matlab/set_parameters.m
@@ -4,17 +4,17 @@ function set_parameters(xparam1)
 % Sets parameters value (except measurement errors)
 % This is called for computations such as IRF and forecast
 % when measurement errors aren't taken into account
-% 
+%
 % INPUTS
 %    xparam1:   vector of parameters to be estimated (initial values)
-%    
+%
 % OUTPUTS
 %    none
-%        
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2003-2013 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -66,7 +66,7 @@ if ncx
 end
 %build covariance matrix from correlation matrix and variances already on
 %diagonal
-Sigma_e = diag(sqrt(diag(Sigma_e)))*Correlation_matrix*diag(sqrt(diag(Sigma_e))); 
+Sigma_e = diag(sqrt(diag(Sigma_e)))*Correlation_matrix*diag(sqrt(diag(Sigma_e)));
 if isfield(estim_params_,'calibrated_covariances')
     Sigma_e(estim_params_.calibrated_covariances.position)=estim_params_.calibrated_covariances.cov_value;
 end
diff --git a/matlab/set_prior.m b/matlab/set_prior.m
index c6898b413..dc7922916 100644
--- a/matlab/set_prior.m
+++ b/matlab/set_prior.m
@@ -4,21 +4,21 @@ function [xparam1, estim_params_, bayestopt_, lb, ub, M_]=set_prior(estim_params
 %
 % INPUTS
 %    o estim_params_    [structure] characterizing parameters to be estimated.
-%    o M_               [structure] characterizing the model. 
-%    o options_         [structure] 
-%    
+%    o M_               [structure] characterizing the model.
+%    o options_         [structure]
+%
 % OUTPUTS
 %    o xparam1          [double]    vector of parameters to be estimated (initial values)
 %    o estim_params_    [structure] characterizing parameters to be estimated
 %    o bayestopt_       [structure] characterizing priors
-%    o lb               [double]    vector of lower bounds for the estimated parameters. 
+%    o lb               [double]    vector of lower bounds for the estimated parameters.
 %    o ub               [double]    vector of upper bounds for the estimated parameters.
 %    o M_               [structure] characterizing the model.
-%    
+%
 % SPECIAL REQUIREMENTS
 %    None
 
-% Copyright (C) 2003-2013 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -64,7 +64,7 @@ bayestopt_.name = {};
 if nvx
     xparam1 = estim_params_.var_exo(:,2);
     ub = estim_params_.var_exo(:,4);
-    lb = estim_params_.var_exo(:,3); 
+    lb = estim_params_.var_exo(:,3);
     bayestopt_.pshape =  estim_params_.var_exo(:,5);
     bayestopt_.p1 =  estim_params_.var_exo(:,6);
     bayestopt_.p2 =  estim_params_.var_exo(:,7);
@@ -88,8 +88,8 @@ if nvn
         estim_params_.nvn_observable_correspondence(i,1)=obsi_;
     end
     xparam1 = [xparam1; estim_params_.var_endo(:,2)];
-    ub = [ub; estim_params_.var_endo(:,4)]; 
-    lb = [lb; estim_params_.var_endo(:,3)]; 
+    ub = [ub; estim_params_.var_endo(:,4)];
+    lb = [lb; estim_params_.var_endo(:,3)];
     bayestopt_.pshape = [ bayestopt_.pshape; estim_params_.var_endo(:,5)];
     bayestopt_.p1 = [ bayestopt_.p1; estim_params_.var_endo(:,6)];
     bayestopt_.p2 = [ bayestopt_.p2; estim_params_.var_endo(:,7)];
@@ -158,7 +158,7 @@ bayestopt_.p7 = bayestopt_.p6 ;
 %% check for point priors and disallow them as they do not work with MCMC
 if any(bayestopt_.p2 ==0)
     error(sprintf(['Error in prior for %s: you cannot use a point prior in estimation. Either increase the prior standard deviation',...
-        ' or fix the parameter completely.'], bayestopt_.name{bayestopt_.p2 ==0}))
+                   ' or fix the parameter completely.'], bayestopt_.name{bayestopt_.p2 ==0}))
 end
 
 % generalized location parameters by default for beta distribution
@@ -169,12 +169,15 @@ k1 = find(isnan(bayestopt_.p4(k)));
 bayestopt_.p4(k(k1)) = ones(length(k1),1);
 for i=1:length(k)
     [bayestopt_.p6(k(i)), bayestopt_.p7(k(i))] = beta_specification(bayestopt_.p1(k(i)), bayestopt_.p2(k(i))^2, bayestopt_.p3(k(i)), bayestopt_.p4(k(i)), bayestopt_.name{k(i)});
+    if bayestopt_.p6(k(i))<1 || bayestopt_.p7(k(i))<1
+        fprintf('Prior distribution for parameter %s has unbounded density!\n',bayestopt_.name{k(i)})
+    end
     m = compute_prior_mode([ bayestopt_.p6(k(i)) , bayestopt_.p7(k(i)) , bayestopt_.p3(k(i)) , bayestopt_.p4(k(i)) ],1);
     if length(m)==1
         bayestopt_.p5(k(i)) = m;
     else
         disp(['Prior distribution for parameter ' bayestopt_.name{k(i)}  ' has two modes!'])
-        bayestopt_.p5(k(i)) = m(1); 
+        bayestopt_.p5(k(i)) = m(1);
     end
 end
 
@@ -186,6 +189,9 @@ bayestopt_.p3(k(k1)) = zeros(length(k1),1);
 bayestopt_.p4(k(k2)) = Inf(length(k2),1);
 for i=1:length(k)
     [bayestopt_.p6(k(i)), bayestopt_.p7(k(i))] = gamma_specification(bayestopt_.p1(k(i)), bayestopt_.p2(k(i))^2, bayestopt_.p3(k(i)), bayestopt_.name{k(i)});
+    if bayestopt_.p6(k(i))<1
+        fprintf('Prior distribution for parameter %s has unbounded density!\n',bayestopt_.name{k(i)})
+    end
     bayestopt_.p5(k(i)) = compute_prior_mode([ bayestopt_.p6(k(i)) , bayestopt_.p7(k(i)) , bayestopt_.p3(k(i)) ], 2) ;
 end
 
diff --git a/matlab/set_state_space.m b/matlab/set_state_space.m
index a7d108165..de8108f32 100644
--- a/matlab/set_state_space.m
+++ b/matlab/set_state_space.m
@@ -34,7 +34,7 @@ function dr=set_state_space(dr,DynareModel,DynareOptions)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 1996-2013 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -73,7 +73,7 @@ if DynareOptions.block == 1
     order_var = DynareModel.block_structure.variable_reordered;
 else
     order_var = [ stat_var(:); pred_var(:); both_var(:); fwrd_var(:)];
-end;
+end
 inv_order_var(order_var) = (1:endo_nbr);
 
 % building kmask for z state vector in t+1
diff --git a/matlab/shock_decomposition.m b/matlab/shock_decomposition.m
index f3c264edc..1785e8c08 100644
--- a/matlab/shock_decomposition.m
+++ b/matlab/shock_decomposition.m
@@ -1,10 +1,10 @@
-function oo_ = shock_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_params_)
+function [oo_,M_] = shock_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_params_)
 % function z = shock_decomposition(M_,oo_,options_,varlist)
 % Computes shocks contribution to a simulated trajectory. The field set is
 % oo_.shock_decomposition. It is a n_var by nshock+2 by nperiods array. The
 % first nshock columns store the respective shock contributions, column n+1
 % stores the role of the initial conditions, while column n+2 stores the
-% value of the smoothed variables.  Both the variables and shocks are stored 
+% value of the smoothed variables.  Both the variables and shocks are stored
 % in the order of declaration, i.e. M_.endo_names and M_.exo_names, respectively.
 %
 % INPUTS
@@ -17,11 +17,13 @@ function oo_ = shock_decomposition(M_,oo_,options_,varlist,bayestopt_,estim_para
 %
 % OUTPUTS
 %    oo_:         [structure]  Storage of results
+%    M_:          [structure]  Definition of the model; makes sure that
+%                               M_.params is correctly updated
 %
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2009-2016 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -43,7 +45,8 @@ if size(varlist,1) == 0
     varlist = M_.endo_names(1:M_.orig_endo_nbr,:);
 end
 
-[i_var,nvar] = varlist_indices(varlist,M_.endo_names);
+[i_var,nvar,index_uniques] = varlist_indices(varlist,M_.endo_names);
+varlist=varlist(index_uniques,:);
 
 % number of variables
 endo_nbr = M_.endo_nbr;
@@ -56,9 +59,9 @@ parameter_set = options_.parameter_set;
 if isempty(parameter_set)
     if isfield(oo_,'posterior_mean')
         parameter_set = 'posterior_mean';
-    elseif isfield(oo_,'mle_mode') 
+    elseif isfield(oo_,'mle_mode')
         parameter_set = 'mle_mode';
-    elseif isfield(oo_,'posterior') 
+    elseif isfield(oo_,'posterior')
         parameter_set = 'posterior_mode';
     else
         error(['shock_decomposition: option parameter_set is not specified ' ...
@@ -68,10 +71,11 @@ end
 
 
 options_.selected_variables_only = 0; %make sure all variables are stored
-[oo,junk1,junk2,Smoothed_Variables_deviation_from_mean] = evaluate_smoother(parameter_set,varlist,M_,oo_,options_,bayestopt_,estim_params_);
+options_.plot_priors=0;
+[oo_, M_, junk1, junk2, Smoothed_Variables_deviation_from_mean] = evaluate_smoother(parameter_set, varlist, M_, oo_, options_, bayestopt_, estim_params_);
 
 % reduced form
-dr = oo.dr;
+dr = oo_.dr;
 
 % data reordering
 order_var = dr.order_var;
@@ -83,10 +87,10 @@ A = dr.ghx;
 B = dr.ghu;
 
 % initialization
-gend = size(oo.SmoothedShocks.(deblank(M_.exo_names(1,:))),1);
+gend = size(oo_.SmoothedShocks.(deblank(M_.exo_names(1,:))),1);
 epsilon=NaN(nshocks,gend);
 for i=1:nshocks
-    epsilon(i,:) = oo.SmoothedShocks.(deblank(M_.exo_names(i,:)));
+    epsilon(i,:) = oo_.SmoothedShocks.(deblank(M_.exo_names(i,:)));
 end
 
 z = zeros(endo_nbr,nshocks+2,gend);
@@ -94,7 +98,6 @@ z = zeros(endo_nbr,nshocks+2,gend);
 z(:,end,:) = Smoothed_Variables_deviation_from_mean;
 
 maximum_lag = M_.maximum_lag;
-lead_lag_incidence = M_.lead_lag_incidence;
 
 k2 = dr.kstate(find(dr.kstate(:,2) <= maximum_lag+1),[1 2]);
 i_state = order_var(k2(:,1))+(min(i,maximum_lag)+1-k2(:,2))*M_.endo_nbr;
@@ -102,7 +105,7 @@ for i=1:gend
     if i > 1 && i <= maximum_lag+1
         lags = min(i-1,maximum_lag):-1:1;
     end
-    
+
     if i > 1
         tempx = permute(z(:,1:nshocks,lags),[1 3 2]);
         m = min(i-1,maximum_lag);
@@ -111,34 +114,14 @@ for i=1:gend
         lags = lags+1;
     end
 
-    z(:,1:nshocks,i) = z(:,1:nshocks,i) + B(inv_order_var,:).*repmat(epsilon(:,i)',endo_nbr,1);
+    if i > options_.shock_decomp.init_state
+        z(:,1:nshocks,i) = z(:,1:nshocks,i) + B(inv_order_var,:).*repmat(epsilon(:,i)',endo_nbr,1);
+    end
     z(:,nshocks+1,i) = z(:,nshocks+2,i) - sum(z(:,1:nshocks,i),2);
 end
 
-
 oo_.shock_decomposition = z;
 
-if options_.use_shock_groups
-    shock_groups = M_.shock_groups.(options_.use_shock_groups);
-    shock_ind = fieldnames(shock_groups);
-    ngroups = length(shock_ind);
-    shock_names = shock_ind;
-    for i=1:ngroups,
-       shock_names{i} = (shock_groups.(shock_ind{i}).label);
-    end
-    zz = zeros(endo_nbr,ngroups+2,gend);
-    for i=1:ngroups
-        for j = shock_groups.(shock_ind{i}).shocks
-            k = find(strcmp(j,cellstr(M_.exo_names)));
-            zz(:,i,:) = zz(:,i,:) + z(:,k,:);
-        end
-    end
-    zz(:,ngroups+(1:2),:) = z(:,nshocks+(1:2),:);
-    z = zz;
-else
-    shock_names = M_.exo_names;
-end
-        
 if ~options_.no_graph.shock_decomposition
-    graph_decomp(z,shock_names,M_.endo_names,i_var,options_.initial_date,M_,options_)
+    plot_shock_decomposition(M_,oo_,options_,varlist);
 end
\ No newline at end of file
diff --git a/matlab/simulated_moment_uncertainty.m b/matlab/simulated_moment_uncertainty.m
index ad9860fce..14ca70429 100644
--- a/matlab/simulated_moment_uncertainty.m
+++ b/matlab/simulated_moment_uncertainty.m
@@ -11,8 +11,8 @@ function [cmm, mm] = simulated_moment_uncertainty(indx, periods, replic,options_
 % Outputs:
 %   - cmm:      [n_moments by n_moments] covariance matrix of simulated moments
 %   - mm:       [n_moments by replic] matrix of moments
-%  
-% Copyright (C) 2009-2016 Dynare Team
+%
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,7 +67,7 @@ if options_.logged_steady_state %if steady state was previously logged, undo thi
     options_.logged_steady_state=0;
     logged_steady_state_indicator=1;
     evalin('base','options_.logged_steady_state=0;')
-else 
+else
     logged_steady_state_indicator=0;
 end
 
@@ -80,23 +80,31 @@ end
 
 %set starting point of simulations
 if isempty(M_.endo_histval)
-    y0 = oo_.dr.ys;
+    if options_.loglinear
+        y0 = log(oo_.dr.ys);
+    else
+        y0 = oo_.dr.ys;
+    end
 else
-    y0 = M_.endo_histval;
+    if options_.loglinear
+        y0 = log_variable(1:M_.endo_nbr,M_.endo_histval,M_);
+    else
+        y0 = M_.endo_histval;
+    end
 end
 
 
-for j=1:replic;
+for j=1:replic
     [ys, oo_] = simult(y0,oo_.dr,M_,options_,oo_);%do simulation
     oo_=disp_moments(ys,char(options_.varobs),M_,options_,oo_); %get moments
     dum=[oo_.mean; dyn_vech(oo_.var)];
     sd = sqrt(diag(oo_.var));
-    for i=1:options_.ar;
+    for i=1:options_.ar
         dum=[dum; vec(oo_.autocorr{i}.*(sd*sd'))];
     end
     mm(:,j)=dum(indx);
     dyn_waitbar(j/replic,h,['Simulated moment uncertainty. Replic  ',int2str(j),'/',int2str(replic)])
-end;
+end
 dyn_waitbar_close(h);
 
 if logged_steady_state_indicator
diff --git a/matlab/simulated_moments_estimation.m b/matlab/simulated_moments_estimation.m
index 314122d83..b01e5e9d3 100644
--- a/matlab/simulated_moments_estimation.m
+++ b/matlab/simulated_moments_estimation.m
@@ -2,19 +2,19 @@ function [param,sigma] = simulated_moments_estimation(dataset,options,parallel)
 % Performs estimation by Simulated Moments Method.
 %
 % INPUTS:
-%  xparam          [double]  p*1 vector of initial values for the estimated parameters. 
+%  xparam          [double]  p*1 vector of initial values for the estimated parameters.
 %  dataset         [      ]  Structure describing the data set.
 %  options         [      ]  Structure defining options for SMM.
-%  parallel        [      ]  Structure defining the parallel mode settings (optional). 
+%  parallel        [      ]  Structure defining the parallel mode settings (optional).
 %
-% OUTPUTS: 
+% OUTPUTS:
 %  param           [double]  p*1 vector of point estimates for the parameters.
 %  sigma           [double]  p*p covariance matrix of the SMM estimates.
 %
 % SPECIAL REQUIREMENTS
 %  The user has to provide a file where the moment conditions are defined.
 
-% Copyright (C) 2010-2012 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -87,7 +87,7 @@ options.estimated_parameters.upper_bound = [options.estimated_parameters.upper_b
 
 options.number_of_simulated_sample = 0;
 for i=1:length(parallel)
-    options.number_of_simulated_sample = options.number_of_simulated_sample + parallel(i).number_of_jobs*parallel(i).number_of_simulations; 
+    options.number_of_simulated_sample = options.number_of_simulated_sample + parallel(i).number_of_jobs*parallel(i).number_of_simulations;
 end
 
 options.observed_variables_idx = dataset.observed_variables_idx;
@@ -97,7 +97,7 @@ if nargin>2
     if ~isunix
         error('The parallel version of SMM estimation is not implemented for non unix platforms!')
     end
-    [junk,hostname] = unix('hostname --fqdn');    
+    [junk,hostname] = unix('hostname --fqdn');
     hostname = deblank(hostname);
     master_is_running_a_job = 0;
     for i=1:length(parallel)
@@ -204,7 +204,7 @@ end
 skipline()
 
 if options.optimization_routine==1
-    % Set options for csminwel. 
+    % Set options for csminwel.
     H0 = 1e-4*eye(options.estimated_parameters.nb);
     ct = 1e-4;
     it = 1000;
@@ -212,7 +212,7 @@ if options.optimization_routine==1
     % Minimization of the objective function.
     if nargin==2
         [fval,param,grad,hessian_csminwel,itct,fcount,retcodehat] = ...
-            csminwel1('smm_objective',xparam,H0,[],ct,it,2,options_.gradient_epsilon,sample_moments,weighting_matrix,options);    
+            csminwel1('smm_objective',xparam,H0,[],ct,it,2,options_.gradient_epsilon,sample_moments,weighting_matrix,options);
     elseif nargin>2
         [fval,param,grad,hessian_csminwel,itct,fcount,retcodehat] = ...
             csminwel1('smm_objective',xparam,H0,[],ct,it,2,options_.gradient_epsilon,sample_moments,weighting_matrix,options,parallel);
@@ -236,7 +236,7 @@ elseif options.optimization_routine==0% Compute the variance of the SMM estimato
     V = (1+1/options.number_of_simulated_sample)*G'*long_run_covariance*G;
     [param,diag(V)]
 elseif options.optimization_routine<0
-    T = -options.optimization_routine;% length of the simulated time series.            
+    T = -options.optimization_routine;% length of the simulated time series.
     time_series = extended_path(oo_.steady_state,T,1);
     save time_series.mat;
 end
@@ -248,7 +248,7 @@ fid = fopen(['job' int2str(slave_number) '.m'],'w');
 
 fprintf(fid,['% Generated by ' hostname '.\n\n']);
 
-if ( strcmpi(hostname,remotename) && (job_number>1) )  || ~strcmpi(hostname,remotename) 
+if ( strcmpi(hostname,remotename) && (job_number>1) )  || ~strcmpi(hostname,remotename)
     fprintf(fid,'load(''master_variables'');\n');
     fprintf(fid,'assignin(''base'',''M_'',M_);\n');
     fprintf(fid,'assignin(''base'',''oo_'',oo_);\n');
@@ -270,9 +270,9 @@ fprintf(fid,'M_.Sigma_e = diag(tmp);')
 
 fprintf(fid,['stream=RandStream(''mt19937ar'',''Seed'',' int2str(slave_number) ');\n']);
 if matlab_ver_less_than('7.12')
-      fprintf(fid,['RandStream.setDefaultStream(stream);\n\n']);
+    fprintf(fid,['RandStream.setDefaultStream(stream);\n\n']);
 else
-      fprintf(fid,['RandStream.setGlobalStream(stream);\n\n']);
+    fprintf(fid,['RandStream.setGlobalStream(stream);\n\n']);
 end
 
 fprintf(fid,['maxNumCompThreads(' int2str(threads_per_job) ');\n\n']);
@@ -282,7 +282,7 @@ fprintf(fid,['    time_series = extended_path([],' int2str(sample_size) ',1);\n'
 fprintf(fid,['    data = time_series([' int2str(observed_variables_idx) '],' int2str(burn_in_periods) '+1:' int2str(sample_size) ');\n']);
 fprintf(fid,['    eval(''tmp = ' moments_file_name '(data);'');\n']);
 fprintf(fid,['    simulated_moments = simulated_moments + tmp;\n']);
-fprintf(fid,['end;\n\n']);
+fprintf(fid,['end\n\n']);
 
 fprintf(fid,['simulated_moments = simulated_moments/' int2str(number_of_simulations) ';\n']);
 fprintf(fid,['save(''simulated_moments_slave_' int2str(slave_number) '.dat'',''simulated_moments'',''-ascii'');\n']);
@@ -295,7 +295,7 @@ else
     fprintf(fid,['unix(''rm simulated_moments_slave_' int2str(slave_number) '.dat'');\n']);
 end
 
-if ((job_number>1) && strcmpi(hostname,remotename)) || ~strcmpi(hostname,remotename) 
+if ((job_number>1) && strcmpi(hostname,remotename)) || ~strcmpi(hostname,remotename)
     fprintf(fid,'exit');
 end
 
diff --git a/matlab/simult_.m b/matlab/simult_.m
index 31daa3a6c..381bfaf1b 100644
--- a/matlab/simult_.m
+++ b/matlab/simult_.m
@@ -3,7 +3,7 @@ function y_=simult_(y0,dr,ex_,iorder)
 % decision rules.
 %
 % INPUTS
-%    y0       [double]   n*1 vector, initial value (n is the number of declared endogenous variables plus the number 
+%    y0       [double]   n*1 vector, initial value (n is the number of declared endogenous variables plus the number
 %                        of auxilliary variables for lags and leads); must be in declaration order, i.e. as in M_.endo_names
 %    dr       [struct]   matlab's structure where the reduced form solution of the model is stored.
 %    ex_      [double]   T*q matrix of innovations.
@@ -15,7 +15,7 @@ function y_=simult_(y0,dr,ex_,iorder)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2015 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -77,15 +77,15 @@ else
             k2 = dr.state_var;
         else
             k2 = [];
-        end;
+        end
         order_var = 1:endo_nbr;
         dr.order_var = order_var;
     else
         k2 = dr.kstate(find(dr.kstate(:,2) <= M_.maximum_lag+1),[1 2]);
         k2 = k2(:,1)+(M_.maximum_lag+1-k2(:,2))*endo_nbr;
         order_var = dr.order_var;
-    end;
-    
+    end
+
     switch iorder
       case 1
         if isempty(dr.ghu)% For (linearized) deterministic models.
@@ -134,7 +134,7 @@ else
                 y_(dr.order_var,i) = constant + dr.ghx*yhat + dr.ghu*epsilon ...
                     + abcOut1 + abcOut2 + abcOut3;
             end
-         end
+        end
       case 3
         % only with pruning
         % the third moments of the shocks are assumed null. We don't have
@@ -176,7 +176,7 @@ else
             mexErrCheck('A_times_B_kronecker_C', err);
             [gy2u, err] = A_times_B_kronecker_C(ghxu,yhat2,u,threads);
             mexErrCheck('A_times_B_kronecker_C', err);
-            %construct terms of order 3, all based on first order component yhat1              
+            %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,threads);
             mexErrCheck('A_times_B_kronecker_C', err);
@@ -199,6 +199,6 @@ else
             yhat1 = yhat1(ipred);
             yhat2 = yhat2(ipred);
             yhat3 = yhat3(ipred);
-        end   
+        end
     end
 end
diff --git a/matlab/simultxdet.m b/matlab/simultxdet.m
index 032f20588..21f0421e4 100644
--- a/matlab/simultxdet.m
+++ b/matlab/simultxdet.m
@@ -22,7 +22,7 @@ function [y_,int_width,int_width_ME]=simultxdet(y0,ex,ex_det, iorder,var_list,M_
 % The condition size(ex,1)+M_.maximum_lag=size(ex_det,1) must be verified
 %  for consistency.
 
-% Copyright (C) 2008-2016 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -88,7 +88,7 @@ if iorder == 1
         for j=1:min(ykmin+M_.exo_det_length+1-i,M_.exo_det_length)
             y_(dr.order_var,i) = y_(dr.order_var,i) + dr.ghud{j}*(ex_det(i+j-1,:)'-exo_det_steady_state);
         end
-        
+
         k1 = k1+1;
     end
 elseif iorder == 2
@@ -153,7 +153,7 @@ end
 int_width = zeros(iter,nvar);
 for i=1:nvar
     int_width(:,i) = fact*sqrt(var_yf(:,i));
-        if nargout==3
+    if nargout==3
         int_width_ME(:,i) = -fact*sqrt(var_yf_ME(:,i));
-        end
+    end
 end
diff --git a/matlab/skipline.m b/matlab/skipline.m
index 5b311ab93..f148997b8 100644
--- a/matlab/skipline.m
+++ b/matlab/skipline.m
@@ -1,16 +1,16 @@
 function skipline(n, fid)
 % This function prints n newlines to fid
 %
-% INPUTS 
+% INPUTS
 %
 %   n        [integer]    Number of newlines to print
 %   fid      [integer]    file id returned by fopen
-%    
-% OUTPUTS 
+%
+% OUTPUTS
 %   None
 %
 
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -25,7 +25,7 @@ function skipline(n, fid)
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 if nargin < 2
     fid = 1;
diff --git a/matlab/slice_sampler.m b/matlab/slice_sampler.m
index e454d5936..8aa18fb1d 100644
--- a/matlab/slice_sampler.m
+++ b/matlab/slice_sampler.m
@@ -1,123 +1,123 @@
-function [theta, fxsim, neval] = slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin)
-% function [theta, fxsim, neval] = slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin)
-% ----------------------------------------------------------
-% UNIVARIATE SLICE SAMPLER - stepping out (Neal, 2003)
-% W: optimal value in the range (3,10)*std(x)
-%    - see C.Planas and A.Rossi (2014)
-% objective_function(theta,varargin): -log of any unnormalized pdf 
-% with varargin (optional) a vector of auxiliaty parameters
-% to be passed to f( ).
-% ----------------------------------------------------------
-%
-% INPUTS
-%   objective_function:       objective function (expressed as minus the log of a density)
-%   theta:                    last value of theta
-%   thetaprior:               bounds of the theta space
-%   sampler_options:          posterior sampler options
-%   varargin:                 optional input arguments to objective function
-%
-% OUTPUTS
-%   theta:       new theta sample
-%   fxsim:       value of the objective function for the new sample
-%   neval:       number of function evaluations
-%
-% SPECIAL REQUIREMENTS
-%   none
-
-% Copyright (C) 2015 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 sampler_options.rotated %&& ~isempty(sampler_options.V1),
-    [theta, fxsim, neval] = rotated_slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin{:});
-    if isempty(sampler_options.mode), % jumping 
-       return,
-    else
-        nevalR=sum(neval);
-    end    
-end
-    
-theta=theta(:);
-npar = length(theta);
-W1 = sampler_options.W1;
-neval = zeros(npar,1);
-
-for it=1:npar,
-    neval(it) = 0;
-    W = W1(it); 
-    xold  = theta(it);
-   % XLB   = thetaprior(3);
-   % XUB   = thetaprior(4);
-    XLB   = thetaprior(it,1);
-    XUB   = thetaprior(it,2);
-   
-    
-    % -------------------------------------------------------
-    % 1. DRAW Z = ln[f(X0)] - EXP(1) where EXP(1)=-ln(U(0,1))
-    %    THIS DEFINES THE SLICE S={x: z < ln(f(x))}
-    % -------------------------------------------------------
-    fxold = -feval(objective_function,theta,varargin{:});
-    neval(it) = neval(it) + 1;
-    Z = fxold + log(rand(1,1));
-    % -------------------------------------------------------------
-    % 2. FIND I=(L,R) AROUND X0 THAT CONTAINS S AS MUCH AS POSSIBLE
-    %    STEPPING-OUT PROCEDURE
-    % -------------------------------------------------------------
-    u = rand(1,1);
-    L = max(XLB,xold-W*u);
-    R = min(XUB,L+W);
-    while(L > XLB)
-        xsim = L;
-        theta(it) = xsim;
-        fxl = -feval(objective_function,theta,varargin{:});
-        neval(it) = neval(it) + 1;
-        if (fxl <= Z)
-            break;
-        end
-        L = max(XLB,L-W);
-    end
-    while(R < XUB)
-        xsim = R;
-        theta(it) = xsim;
-        fxr = -feval(objective_function,theta,varargin{:});
-        neval(it) = neval(it) + 1;
-        if (fxr <= Z)
-            break;
-        end
-        R = min(XUB,R+W);
-    end
-    % ------------------------------------------------------
-    % 3. SAMPLING FROM THE SET A = (I INTERSECT S) = (LA,RA)
-    % ------------------------------------------------------
-    fxsim = Z-1;
-    while (fxsim < Z)
-        u = rand(1,1);
-        xsim = L + u*(R - L);
-        theta(it) = xsim;
-        fxsim = -feval(objective_function,theta,varargin{:});
-        neval(it) = neval(it) + 1;
-        if (xsim > xold)
-            R = xsim;
-        else
-            L = xsim;
-        end
-    end
-    
-end
-
-if sampler_options.rotated && ~isempty(sampler_options.mode), % jumping
-    neval=sum(neval)+nevalR;
-end
+function [theta, fxsim, neval] = slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin)
+% function [theta, fxsim, neval] = slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin)
+% ----------------------------------------------------------
+% UNIVARIATE SLICE SAMPLER - stepping out (Neal, 2003)
+% W: optimal value in the range (3,10)*std(x)
+%    - see C.Planas and A.Rossi (2014)
+% objective_function(theta,varargin): -log of any unnormalized pdf
+% with varargin (optional) a vector of auxiliaty parameters
+% to be passed to f( ).
+% ----------------------------------------------------------
+%
+% INPUTS
+%   objective_function:       objective function (expressed as minus the log of a density)
+%   theta:                    last value of theta
+%   thetaprior:               bounds of the theta space
+%   sampler_options:          posterior sampler options
+%   varargin:                 optional input arguments to objective function
+%
+% OUTPUTS
+%   theta:       new theta sample
+%   fxsim:       value of the objective function for the new sample
+%   neval:       number of function evaluations
+%
+% SPECIAL REQUIREMENTS
+%   none
+
+% Copyright (C) 2015-2017 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 sampler_options.rotated %&& ~isempty(sampler_options.V1),
+    [theta, fxsim, neval] = rotated_slice_sampler(objective_function,theta,thetaprior,sampler_options,varargin{:});
+    if isempty(sampler_options.mode) % jumping
+        return
+    else
+        nevalR=sum(neval);
+    end
+end
+
+theta=theta(:);
+npar = length(theta);
+W1 = sampler_options.W1;
+neval = zeros(npar,1);
+
+for it=1:npar
+    neval(it) = 0;
+    W = W1(it);
+    xold  = theta(it);
+    % XLB   = thetaprior(3);
+    % XUB   = thetaprior(4);
+    XLB   = thetaprior(it,1);
+    XUB   = thetaprior(it,2);
+
+
+    % -------------------------------------------------------
+    % 1. DRAW Z = ln[f(X0)] - EXP(1) where EXP(1)=-ln(U(0,1))
+    %    THIS DEFINES THE SLICE S={x: z < ln(f(x))}
+    % -------------------------------------------------------
+    fxold = -feval(objective_function,theta,varargin{:});
+    neval(it) = neval(it) + 1;
+    Z = fxold + log(rand(1,1));
+    % -------------------------------------------------------------
+    % 2. FIND I=(L,R) AROUND X0 THAT CONTAINS S AS MUCH AS POSSIBLE
+    %    STEPPING-OUT PROCEDURE
+    % -------------------------------------------------------------
+    u = rand(1,1);
+    L = max(XLB,xold-W*u);
+    R = min(XUB,L+W);
+    while(L > XLB)
+        xsim = L;
+        theta(it) = xsim;
+        fxl = -feval(objective_function,theta,varargin{:});
+        neval(it) = neval(it) + 1;
+        if (fxl <= Z)
+            break
+        end
+        L = max(XLB,L-W);
+    end
+    while(R < XUB)
+        xsim = R;
+        theta(it) = xsim;
+        fxr = -feval(objective_function,theta,varargin{:});
+        neval(it) = neval(it) + 1;
+        if (fxr <= Z)
+            break
+        end
+        R = min(XUB,R+W);
+    end
+    % ------------------------------------------------------
+    % 3. SAMPLING FROM THE SET A = (I INTERSECT S) = (LA,RA)
+    % ------------------------------------------------------
+    fxsim = Z-1;
+    while (fxsim < Z)
+        u = rand(1,1);
+        xsim = L + u*(R - L);
+        theta(it) = xsim;
+        fxsim = -feval(objective_function,theta,varargin{:});
+        neval(it) = neval(it) + 1;
+        if (xsim > xold)
+            R = xsim;
+        else
+            L = xsim;
+        end
+    end
+
+end
+
+if sampler_options.rotated && ~isempty(sampler_options.mode) % jumping
+    neval=sum(neval)+nevalR;
+end
diff --git a/matlab/smm_objective.m b/matlab/smm_objective.m
index 030cb98d9..fc6358205 100644
--- a/matlab/smm_objective.m
+++ b/matlab/smm_objective.m
@@ -2,20 +2,20 @@ function [r,flag] = smm_objective(xparams,sample_moments,weighting_matrix,option
 % Evaluates the objective of the Simulated Moments Method.
 %
 % INPUTS:
-%  xparams          [double]  p*1 vector of estimated parameters. 
+%  xparams          [double]  p*1 vector of estimated parameters.
 %  sample_moments   [double]  n*1 vector of sample moments (n>=p).
 %  weighting_matrix [double]  n*n symetric, positive definite matrix.
 %  options          [      ]  Structure defining options for SMM.
 %  parallel         [      ]  Structure defining the parallel mode settings (optional).
 %
-% OUTPUTS: 
+% OUTPUTS:
 %  r                [double]  scalar, the value of the objective function.
 %  junk             [      ]  empty matrix.
 %
 % SPECIAL REQUIREMENTS
 %  The user has to provide a file where the moment conditions are defined.
 
-% Copyright (C) 2010-2013 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ function [r,flag] = smm_objective(xparams,sample_moments,weighting_matrix,option
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 global M_ options_ oo_
 persistent mainStream mainState
@@ -67,8 +67,8 @@ end
 
 if penalty>0
     flag = 0;
-    r = priorObjectiveValue + penalty; 
-    return;
+    r = priorObjectiveValue + penalty;
+    return
 end
 
 save('estimated_parameters.mat','xparams');
@@ -114,7 +114,7 @@ else% parallel mode.
             end
         end
         for j=1:parallel(i).number_of_jobs
-            if (strcmpi(hostname,machine) && j>1) || ~strcmpi(hostname,machine)  
+            if (strcmpi(hostname,machine) && j>1) || ~strcmpi(hostname,machine)
                 job_number = job_number + 1;
                 unix(['ssh -A ' parallel(i).login '@' machine ' ./call_matlab_session.sh job' int2str(job_number) '.m &']);
             end
@@ -125,7 +125,7 @@ else% parallel mode.
     eval('job1;')
     tElapsedMasterJob = etime(clock, tStartMasterJob);
     TimeLimit = tElapsedMasterJob*1.2;
-    % Master waits for the  slaves' output... 
+    % Master waits for the  slaves' output...
     tStart = clock;
     tElapsed = 0;
     while tElapsed<TimeLimit
@@ -140,7 +140,7 @@ else% parallel mode.
             simulated_moments = load(['./intermediary_results_from_master_and_slaves/simulated_moments_slave_' int2str(i) '.dat'],'-ascii');
             tmp = tmp + simulated_moments;
         end
-        simulated_moments = tmp / job_number;        
+        simulated_moments = tmp / job_number;
     catch
         r = priorObjectiveValue*1.1;
         flag = 0;
diff --git a/matlab/smoother2histval.m b/matlab/smoother2histval.m
index 99b91a9bc..5d6a67f1d 100644
--- a/matlab/smoother2histval.m
+++ b/matlab/smoother2histval.m
@@ -1,10 +1,10 @@
 function smoother2histval(opts)
 % This function takes values from oo_.SmoothedVariables (and possibly
 % oo_.SmoothedShocks) and copies them into M_.histval.
-% 
+%
 % Optional fields in 'opts' structure:
 %    infile:      An optional *_results MAT file created by Dynare.
-%                 If present, oo_.Smoothed{Variables,Shocks} are read from 
+%                 If present, oo_.Smoothed{Variables,Shocks} are read from
 %                 there. Otherwise, they are read from the global workspace.
 %    invars:      An optional char or cell array listing variables to read in
 %                 oo_.SmoothedVariables. If absent, all the endogenous
@@ -24,7 +24,7 @@ function smoother2histval(opts)
 %
 % The function also uses the value of option_.parameter_set
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -64,10 +64,26 @@ end
 tmp = fieldnames(smoothedvars);
 if isstruct(getfield(smoothedvars, tmp{1}))
     post_metropolis = 1;
+    if ~ isstruct(getfield(smoothedvars, tmp{end}))
+        % point and metropolis results are simultaneously present
+        post_metropolis = 2;
+    end
+
+elseif isstruct(getfield(smoothedvars, tmp{end}))
+    % point and metropolis results are simultaneously present
+    post_metropolis = 2;
 else
     post_metropolis = 0;
 end
 
+if post_metropolis
+    tmp = fieldnames(smoothedvars.Mean);
+    tmpexo = fieldnames(smoothedshocks.Mean);
+else
+    tmp = fieldnames(smoothedvars);
+    tmpexo = fieldnames(smoothedshocks);
+end
+
 % If post-Metropolis, select the parameter set
 if isempty(options_.parameter_set)
     if post_metropolis
@@ -78,11 +94,11 @@ if isempty(options_.parameter_set)
 else
     switch options_.parameter_set
       case 'calibration'
-        if post_metropolis
+        if post_metropolis == 1
             error('Option parameter_set=calibration is not consistent with computed smoothed values.')
         end
       case 'posterior_mode'
-        if post_metropolis
+        if post_metropolis == 1
             error('Option parameter_set=posterior_mode is not consistent with computed smoothed values.')
         end
       case 'posterior_mean'
@@ -105,7 +121,6 @@ else
 end
 
 % Determine number of periods
-tmp = fieldnames(smoothedvars);
 n = size(getfield(smoothedvars, tmp{1}));
 
 if n < M_.maximum_endo_lag
@@ -118,7 +133,7 @@ if isfield(opts, 'invars')
         invars = cellstr(invars);
     end
 else
-    invars = [fieldnames(smoothedvars); fieldnames(smoothedshocks)];
+    invars = [tmp; tmpexo];
 end
 
 if isfield(opts, 'period')
diff --git a/matlab/solve1.m b/matlab/solve1.m
index 5d5241fce..5ea2651bf 100644
--- a/matlab/solve1.m
+++ b/matlab/solve1.m
@@ -15,7 +15,7 @@ function [x,check] = solve1(func,x,j1,j2,jacobian_flag,gstep,tolf,tolx,maxit,deb
 %    maxit            maximum number of iterations
 %    debug            debug flag
 %    varargin:        list of extra arguments to the function
-%    
+%
 % OUTPUTS
 %    x:               results
 %    check=1:         the model can not be solved
@@ -23,7 +23,7 @@ function [x,check] = solve1(func,x,j1,j2,jacobian_flag,gstep,tolf,tolx,maxit,deb
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -59,7 +59,7 @@ if ~isempty(i)
           'equation(s) resulted in a non-finite number:'])
     disp(j1(i)')
     check = 1;
-    return;
+    return
 end
 
 f = 0.5*(fvec'*fvec) ;
@@ -80,7 +80,7 @@ for its = 1:maxit
         fjac = fjac(j1,j2);
     else
         dh = max(abs(x(j2)),gstep(1)*ones(nn,1))*eps^(1/3);
-        
+
         for j = 1:nn
             xdh = x ;
             xdh(j2(j)) = xdh(j2(j))+dh(j) ;
@@ -114,7 +114,7 @@ for its = 1:maxit
         disp([its f])
         disp([xold x])
     end
-    
+
     if check > 0
         den = max([f;0.5*nn]) ;
         if max(abs(g).*max([abs(x(j2)') ones(1,nn)])')/den < tolmin
@@ -147,13 +147,3 @@ disp('SOLVE: maxit has been reached')
 % 04/13/01 MJ added test  f < tolf !!
 % 05/11/01 MJ changed tests for 'check' so as to remove 'continue' which is
 %             an instruction which appears only in version 6
-
-
-
-
-
-
-
-
-
-
diff --git a/matlab/solve_one_boundary.m b/matlab/solve_one_boundary.m
index 2ce90c7bc..a579ea67e 100644
--- a/matlab/solve_one_boundary.m
+++ b/matlab/solve_one_boundary.m
@@ -1,7 +1,7 @@
 function [y, info] = solve_one_boundary(fname, y, x, params, steady_state, ...
                                         y_index_eq, nze, periods, is_linear, Block_Num, y_kmin, maxit_, solve_tolf, lambda, cutoff, stack_solve_algo, forward_backward, is_dynamic, verbose, M, options, oo)
 % Computes the deterministic simulation of a block of equation containing
-% lead or lag variables 
+% lead or lag variables
 %
 % INPUTS
 %   fname               [string]        name of the file containing the block
@@ -26,7 +26,7 @@ function [y, info] = solve_one_boundary(fname, y, x, params, steady_state, ...
 %   cutoff              [double]        cutoff to correct the direction in Newton in case
 %                                       of singular jacobian matrix
 %   stack_solve_algo    [integer]       linear solver method used in the
-%                                       Newton algorithm : 
+%                                       Newton algorithm :
 %                                            - 1 sparse LU
 %                                            - 2 GMRES
 %                                            - 3 BicGStab
@@ -43,19 +43,19 @@ function [y, info] = solve_one_boundary(fname, y, x, params, steady_state, ...
 %   indirect_call      [integer]        (0) direct call to the fname
 %                                       (1) indirect call via the
 %                                       local_fname wrapper
-% OUTPUTS                                    
-%   y                  [matrix]         All endogenous variables of the model      
+% OUTPUTS
+%   y                  [matrix]         All endogenous variables of the model
 %   info               [integer]        >=0 no error
 %                                       <0 error
-%  
+%
 % ALGORITHM
 %   Newton with LU or GMRES or BicGstab for dynamic block
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -387,7 +387,7 @@ for it_=start:incr:finish
             oo_.deterministic_simulation.block(Block_Num).status = 0;% Convergency failed.
             oo_.deterministic_simulation.block(Block_Num).error = max_res;
             oo_.deterministic_simulation.block(Block_Num).iterations = iter;
-        end;
+        end
         info = -Block_Num*10;
         return
     end
diff --git a/matlab/solve_perfect_foresight_model.m b/matlab/solve_perfect_foresight_model.m
index 5de112ad8..cedf3e060 100644
--- a/matlab/solve_perfect_foresight_model.m
+++ b/matlab/solve_perfect_foresight_model.m
@@ -1,6 +1,6 @@
 function [flag,endo_simul,err] = solve_perfect_foresight_model(endo_simul,exo_simul,pfm)
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,107 +17,107 @@ function [flag,endo_simul,err] = solve_perfect_foresight_model(endo_simul,exo_si
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    flag = 0;
-    err = 0;
-    stop = 0;
-    nan_flag = 0;
+flag = 0;
+err = 0;
+stop = 0;
+nan_flag = 0;
 
-    model_dynamic = pfm.dynamic_model;
+model_dynamic = pfm.dynamic_model;
 
-    Y = endo_simul(:);
+Y = endo_simul(:);
 
+if pfm.verbose
+    disp (['-----------------------------------------------------']) ;
+    disp (['MODEL SIMULATION :']) ;
+    fprintf('\n') ;
+end
+
+if pfm.use_bytecode
+    [flag, endo_simul]=bytecode(Y, exo_simul, pfm.params);
+    return
+end
+
+z = Y(find(pfm.lead_lag_incidence'));
+[d1,jacobian] = model_dynamic(z,exo_simul,pfm.params,pfm.steady_state,2);
+
+% Initialization of the jacobian of the stacked model.
+A = sparse([],[],[],pfm.periods*pfm.ny,pfm.periods*pfm.ny,pfm.periods*nnz(jacobian));
+
+% Initialization of the Newton residuals.
+res = zeros(pfm.periods*pfm.ny,1);
+
+h1 = clock;
+
+% Newton loop.
+for iter = 1:pfm.maxit_
+    h2 = clock;
+    i_rows = 1:pfm.ny;
+    i_cols = find(pfm.lead_lag_incidence');
+    i_cols_A = i_cols;
+    % Fill the jacobian of the stacked model.
+    for it = 2:(pfm.periods+1)
+        [d1,jacobian] = model_dynamic(Y(i_cols),exo_simul,pfm.params,pfm.steady_state,it);
+        if it == 2
+            A(i_rows,pfm.i_cols_A1) = jacobian(:,pfm.i_cols_1);
+        elseif it == pfm.periods+1
+            A(i_rows,i_cols_A(pfm.i_cols_T)) = jacobian(:,pfm.i_cols_T);
+        else
+            A(i_rows,i_cols_A) = jacobian(:,pfm.i_cols_j);
+        end
+        res(i_rows) = d1;
+        i_rows = i_rows + pfm.ny;
+        i_cols = i_cols + pfm.ny;
+        if it > 2
+            i_cols_A = i_cols_A + pfm.ny;
+        end
+    end
+    % Stop if Newton residuals are zero.
+    err = max(abs(res));
+    if err < pfm.tolerance
+        stop = 1 ;
+        if pfm.verbose
+            fprintf('\n') ;
+            disp([' Total time of simulation        :' num2str(etime(clock,h1))]) ;
+            fprintf('\n') ;
+            disp([' Convergency obtained.']) ;
+            fprintf('\n') ;
+        end
+        flag = 0;% Convergency obtained.
+        endo_simul = reshape(Y,pfm.ny,pfm.periods+2);
+        break
+    end
+    % Compute the Newton step.
+    dy = -A\res;
+    if any(isnan(dy))
+        nan_flag = 1;
+        break
+    end
+    % Update the endogenous variables paths.
+    Y(pfm.i_upd) =   Y(pfm.i_upd) + dy;
+end
+
+if ~stop
     if pfm.verbose
-        disp (['-----------------------------------------------------']) ;
-        disp (['MODEL SIMULATION :']) ;
+        fprintf('\n') ;
+        disp(['     Total time of simulation        :' num2str(etime(clock,h1))]) ;
+        fprintf('\n') ;
+        disp(['WARNING : maximum number of iterations is reached (modify options_.simul.maxit).']) ;
         fprintf('\n') ;
     end
-
-    if pfm.use_bytecode
-        [flag, endo_simul]=bytecode(Y, exo_simul, pfm.params);
-        return;
-    end
-
-    z = Y(find(pfm.lead_lag_incidence'));
-    [d1,jacobian] = model_dynamic(z,exo_simul,pfm.params,pfm.steady_state,2);
-
-    % Initialization of the jacobian of the stacked model.
-    A = sparse([],[],[],pfm.periods*pfm.ny,pfm.periods*pfm.ny,pfm.periods*nnz(jacobian));
-
-    % Initialization of the Newton residuals.
-    res = zeros(pfm.periods*pfm.ny,1);
-
-    h1 = clock;
-    
-    % Newton loop.
-    for iter = 1:pfm.maxit_
-        h2 = clock;
-        i_rows = 1:pfm.ny;
-        i_cols = find(pfm.lead_lag_incidence');
-        i_cols_A = i_cols;
-        % Fill the jacobian of the stacked model.
-        for it = 2:(pfm.periods+1)
-            [d1,jacobian] = model_dynamic(Y(i_cols),exo_simul,pfm.params,pfm.steady_state,it);
-            if it == 2
-                A(i_rows,pfm.i_cols_A1) = jacobian(:,pfm.i_cols_1);
-            elseif it == pfm.periods+1
-                A(i_rows,i_cols_A(pfm.i_cols_T)) = jacobian(:,pfm.i_cols_T);
-            else
-                A(i_rows,i_cols_A) = jacobian(:,pfm.i_cols_j);
-            end
-            res(i_rows) = d1;
-            i_rows = i_rows + pfm.ny;
-            i_cols = i_cols + pfm.ny;
-            if it > 2
-                i_cols_A = i_cols_A + pfm.ny;
-            end
-        end
-        % Stop if Newton residuals are zero.
-        err = max(abs(res)); 
-        if err < pfm.tolerance
-            stop = 1 ;
-            if pfm.verbose
-                fprintf('\n') ;
-                disp([' Total time of simulation        :' num2str(etime(clock,h1))]) ;
-                fprintf('\n') ;
-                disp([' Convergency obtained.']) ;
-                fprintf('\n') ;
-            end
-            flag = 0;% Convergency obtained.
-            endo_simul = reshape(Y,pfm.ny,pfm.periods+2);
-            break
-        end
-        % Compute the Newton step. 
-        dy = -A\res;
-        if any(isnan(dy))
-            nan_flag = 1;
-            break
-        end
-        % Update the endogenous variables paths.
-        Y(pfm.i_upd) =   Y(pfm.i_upd) + dy;
-    end
-
-    if ~stop
-        if pfm.verbose
-            fprintf('\n') ;
-            disp(['     Total time of simulation        :' num2str(etime(clock,h1))]) ;
-            fprintf('\n') ;
-            disp(['WARNING : maximum number of iterations is reached (modify options_.simul.maxit).']) ;
-            fprintf('\n') ;
-        end
-        flag = 1;% more iterations are needed.
-        endo_simul = 1;
-    end
-    if nan_flag
-        if pfm.verbose
-            fprintf('\n') ;
-            disp(['     Total time of simulation        :' num2str(etime(clock,h1))]) ;
-            fprintf('\n') ;
-            disp(['WARNING : NaNs!']) ;
-            fprintf('\n') ;
-        end
-        flag = 1;
-        endo_simul = 1;
-    end
+    flag = 1;% more iterations are needed.
+    endo_simul = 1;
+end
+if nan_flag
     if pfm.verbose
-        disp (['-----------------------------------------------------']) ;
-    end
\ No newline at end of file
+        fprintf('\n') ;
+        disp(['     Total time of simulation        :' num2str(etime(clock,h1))]) ;
+        fprintf('\n') ;
+        disp(['WARNING : NaNs!']) ;
+        fprintf('\n') ;
+    end
+    flag = 1;
+    endo_simul = 1;
+end
+if pfm.verbose
+    disp (['-----------------------------------------------------']) ;
+end
\ No newline at end of file
diff --git a/matlab/solve_two_boundaries.m b/matlab/solve_two_boundaries.m
index 136d3e1ac..4b5904946 100644
--- a/matlab/solve_two_boundaries.m
+++ b/matlab/solve_two_boundaries.m
@@ -1,6 +1,6 @@
 function [y, oo]= solve_two_boundaries(fname, y, x, params, steady_state, y_index, nze, periods, y_kmin_l, y_kmax_l, is_linear, Block_Num, y_kmin, maxit_, solve_tolf, lambda, cutoff, stack_solve_algo,options,M, oo)
 % Computes the deterministic simulation of a block of equation containing
-% both lead and lag variables using relaxation methods 
+% both lead and lag variables using relaxation methods
 %
 % INPUTS
 %   fname               [string]        name of the file containing the block
@@ -27,7 +27,7 @@ function [y, oo]= solve_two_boundaries(fname, y, x, params, steady_state, y_inde
 %   cutoff              [double]        cutoff to correct the direction in Newton in case
 %                                       of singular jacobian matrix
 %   stack_solve_algo    [integer]       linear solver method used in the
-%                                       Newton algorithm : 
+%                                       Newton algorithm :
 %                                            - 1 sprse LU
 %                                            - 2 GMRES
 %                                            - 3 BicGStab
@@ -36,17 +36,17 @@ function [y, oo]= solve_two_boundaries(fname, y, x, params, steady_state, y_inde
 %   oo                  [structure]     Results
 %
 % OUTPUTS
-%   y                   [matrix]        All endogenous variables of the model      
+%   y                   [matrix]        All endogenous variables of the model
 %   oo                  [structure]     Results
 %
 % ALGORITHM
 %   Newton with LU or GMRES or BicGstab
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -92,7 +92,7 @@ while ~(cvg==1 || iter>maxit_)
     [max_res, max_indx]=max(max(abs(r')));
     if ~isreal(r)
         max_res = (-max_res^2)^0.5;
-    end;
+    end
     if ~isreal(max_res) || isnan(max_res)
         cvg = 0;
     elseif(is_linear && iter>0)
@@ -123,7 +123,7 @@ while ~(cvg==1 || iter>maxit_)
                             end
                             dx = (g1aa+correcting_factor*speye(periods*Blck_size))\ba- ya;
                             y(1+y_kmin:periods+y_kmin,y_index)=reshape((ya_save+lambda*dx)',length(y_index),periods)';
-                            continue;
+                            continue
                         else
                             disp('The singularity of the jacobian matrix could not be corrected');
                             return
@@ -178,7 +178,7 @@ while ~(cvg==1 || iter>maxit_)
                 B1_inv = inv(g1a(Elem, Elem));
                 if (t < periods)
                     S1 = B1_inv * g1a(Elem, Elem_1);
-                end;
+                end
                 g1a(Elem, Elem_1) = S1;
                 b(Elem) = B1_inv * b(Elem);
                 g1a(Elem, Elem) = ones(Blck_size, Blck_size);
diff --git a/matlab/steady.m b/matlab/steady.m
index 760fb1d3f..3e0ec0095 100644
--- a/matlab/steady.m
+++ b/matlab/steady.m
@@ -1,17 +1,17 @@
 function steady()
 % function steady()
 % computes and prints the steady state calculations
-%  
+%
 % INPUTS
 %   none
-%  
+%
 % OUTPUTS
 %   none
 %
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2012 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,7 +28,7 @@ function steady()
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-global M_ oo_ options_ ys0_ 
+global M_ oo_ options_ ys0_
 
 test_for_deep_parameters_calibration(M_);
 
@@ -70,14 +70,14 @@ if info(1)
         disp(sprintf('%12s %12.6f',M_.exo_det_names(hv(ixd(i),2),:), ...
                      oo_.exo_det_steady_state(hv(ixd(i),2))))
     end
-    
+
     if options_.homotopy_force_continue
         disp('Option homotopy_continue is set, so I continue ...')
     else
         error('Homotopy step failed')
     end
 end
-    
+
 [steady_state,M_.params,info] = steady_(M_,options_,oo_);
 oo_.steady_state = steady_state;
 
@@ -99,7 +99,7 @@ else
         fprintf('\nThe steady state computation failed. It terminated with the following values:\n')
         for i=1:M_.orig_endo_nbr
             fprintf('%s \t\t %g\n',M_.endo_names(i,:),steady_state(i));
-        end        
+        end
     end
     print_info(info,options_.noprint, options_);
 end
diff --git a/matlab/steady_.m b/matlab/steady_.m
index 02c7c69ed..46c0e3411 100644
--- a/matlab/steady_.m
+++ b/matlab/steady_.m
@@ -1,12 +1,12 @@
 function [steady_state,params,info] = steady_(M_,options_,oo_)
 % function [steady_state,params,info] = steady_(M_,options_,oo_)
-% Computes the steady state 
-%  
+% Computes the steady state
+%
 % INPUTS
 %   M                         struct           model structure
 %   options                   struct           options
 %   oo                        struct           output results
-%  
+%
 % OUTPUTS
 %   steady_state              vector           steady state
 %   params                    vector           parameters (may have been
@@ -18,7 +18,7 @@ function [steady_state,params,info] = steady_(M_,options_,oo_)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/step_length_correction.m b/matlab/step_length_correction.m
index 8950bc764..89710637b 100644
--- a/matlab/step_length_correction.m
+++ b/matlab/step_length_correction.m
@@ -1,6 +1,6 @@
 function c = step_length_correction(x,scale,i)
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,8 +17,8 @@ function c = step_length_correction(x,scale,i)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-    if isempty(scale)
-        c = 10^round(log10(abs(x)));
-    else
-        c = scale(i);
-    end
+if isempty(scale)
+    c = 10^round(log10(abs(x)));
+else
+    c = scale(i);
+end
diff --git a/matlab/stoch_simul.m b/matlab/stoch_simul.m
index d08887ab8..81f8b886a 100644
--- a/matlab/stoch_simul.m
+++ b/matlab/stoch_simul.m
@@ -1,6 +1,6 @@
 function info=stoch_simul(var_list)
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -56,7 +56,8 @@ if size(var_list,1) == 0
     var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
 end
 
-[i_var,nvar] = varlist_indices(var_list,M_.endo_names);
+[i_var,nvar,index_uniques] = varlist_indices(var_list,M_.endo_names);
+var_list=var_list(index_uniques,:);
 
 iter_ = max(options_.periods,1);
 if M_.exo_nbr > 0
@@ -83,7 +84,7 @@ else
     [oo_.dr,info,M_,options_,oo_] = resol(0,M_,options_,oo_);
 end
 
-if options_.loglinear && isfield(oo_.dr,'ys') && options_.logged_steady_state==0 %log steady state for correct display of decision rule    
+if options_.loglinear && isfield(oo_.dr,'ys') && options_.logged_steady_state==0 %log steady state for correct display of decision rule
     oo_.dr.ys=log_variable(1:M_.endo_nbr,oo_.dr.ys,M_);
     oo_.steady_state=log_variable(1:M_.endo_nbr,oo_.steady_state,M_);
     options_old.logged_steady_state = 1; %make sure option is preserved outside of stoch_simul
@@ -150,12 +151,16 @@ if options_.periods > 0 && ~PI_PCL_solver
     if isempty(M_.endo_histval)
         y0 = oo_.dr.ys;
     else
-        y0 = M_.endo_histval;
+        if options_.loglinear
+            y0 = log_variable(1:M_.endo_nbr,M_.endo_histval,M_);
+        else
+            y0 = M_.endo_histval;
+        end
     end
     [ys, oo_] = simult(y0,oo_.dr,M_,options_,oo_);
     oo_.endo_simul = ys;
     if ~options_.minimal_workspace
-      dyn2vec;
+        dyn2vec;
     end
 end
 
@@ -196,7 +201,7 @@ if options_.irf
             else
                 if options_.order>1 && options_.relative_irf % normalize shock to 0.01 before IRF generation for GIRFs; multiply with 100 later
                     y=irf(oo_.dr,cs(M_.exo_names_orig_ord,i)./cs(i,i)/100, options_.irf, options_.drop, ...
-                          options_.replic, options_.order);                
+                          options_.replic, options_.order);
                 else %for linear model, rescaling is done later
                     y=irf(oo_.dr,cs(M_.exo_names_orig_ord,i), options_.irf, options_.drop, ...
                           options_.replic, options_.order);
@@ -249,10 +254,10 @@ if options_.irf
                 if nbplt == 0
                 elseif nbplt == 1
                     if options_.relative_irf
-                        hh = dyn_figure(options_,'Name',['Relative response to' ...
+                        hh = dyn_figure(options_.nodisplay,'Name',['Relative response to' ...
                                             ' orthogonalized shock to ' tit(i,:)]);
                     else
-                        hh = dyn_figure(options_,'Name',['Orthogonalized shock to' ...
+                        hh = dyn_figure(options_.nodisplay,'Name',['Orthogonalized shock to' ...
                                             ' ' tit(i,:)]);
                     end
                     for j = 1:number_of_plots_to_draw
@@ -265,7 +270,7 @@ if options_.irf
                         remove_fractional_xticks;
                         title(deblank(mylist(j,:)),'Interpreter','none');
                     end
-                    dyn_saveas(hh,[M_.fname '_IRF_' deblank(tit(i,:))],options_);
+                    dyn_saveas(hh,[M_.fname '_IRF_' deblank(tit(i,:))],options_.nodisplay,options_.graph_format);
                     if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                         fprintf(fidTeX,'\\begin{figure}[H]\n');
                         for j = 1:number_of_plots_to_draw
@@ -281,10 +286,10 @@ if options_.irf
                 else
                     for fig = 1:nbplt-1
                         if options_.relative_irf
-                            hh = dyn_figure(options_,'Name',['Relative response to orthogonalized shock' ...
+                            hh = dyn_figure(options_.nodisplay,'Name',['Relative response to orthogonalized shock' ...
                                                 ' to ' tit(i,:) ' figure ' int2str(fig)]);
                         else
-                            hh = dyn_figure(options_,'Name',['Orthogonalized shock to ' tit(i,:) ...
+                            hh = dyn_figure(options_.nodisplay,'Name',['Orthogonalized shock to ' tit(i,:) ...
                                                 ' figure ' int2str(fig)]);
                         end
                         for plt = 1:nstar
@@ -297,7 +302,7 @@ if options_.irf
                             remove_fractional_xticks
                             title(deblank(mylist((fig-1)*nstar+plt,:)),'Interpreter','none');
                         end
-                        dyn_saveas(hh,[ M_.fname '_IRF_' deblank(tit(i,:)) int2str(fig)],options_);
+                        dyn_saveas(hh,[ M_.fname '_IRF_' deblank(tit(i,:)) int2str(fig)],options_.nodisplay,options_.graph_format);
                         if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                             fprintf(fidTeX,'\\begin{figure}[H]\n');
                             for j = 1:nstar
@@ -317,9 +322,9 @@ if options_.irf
                             fprintf(fidTeX,' \n');
                         end
                     end
-                    hh = dyn_figure(options_,'Name',['Orthogonalized shock to ' tit(i,:) ' figure ' int2str(nbplt) '.']);
+                    hh = dyn_figure(options_.nodisplay,'Name',['Orthogonalized shock to ' tit(i,:) ' figure ' int2str(nbplt) '.']);
                     m = 0;
-                    for plt = 1:number_of_plots_to_draw-(nbplt-1)*nstar;
+                    for plt = 1:number_of_plots_to_draw-(nbplt-1)*nstar
                         m = m+1;
                         subplot(lr,lc,m);
                         plot(1:options_.irf,transpose(irfs((nbplt-1)*nstar+plt,:)),'-k','linewidth',1);
@@ -330,7 +335,7 @@ if options_.irf
                         remove_fractional_xticks
                         title(deblank(mylist((nbplt-1)*nstar+plt,:)),'Interpreter','none');
                     end
-                    dyn_saveas(hh,[ M_.fname '_IRF_' deblank(tit(i,:)) int2str(nbplt) ],options_);
+                    dyn_saveas(hh,[ M_.fname '_IRF_' deblank(tit(i,:)) int2str(nbplt) ],options_.nodisplay,options_.graph_format);
                     if TeX && any(strcmp('eps',cellstr(options_.graph_format)))
                         fprintf(fidTeX,'\\begin{figure}[H]\n');
                         for j = 1:m
diff --git a/matlab/stochastic_solvers.m b/matlab/stochastic_solvers.m
index 277200143..a51648a43 100644
--- a/matlab/stochastic_solvers.m
+++ b/matlab/stochastic_solvers.m
@@ -1,35 +1,35 @@
 function [dr,info] = stochastic_solvers(dr,task,M_,options_,oo_)
 % function [dr,info,M_,options_,oo_] = stochastic_solvers(dr,task,M_,options_,oo_)
-% computes the reduced form solution of a rational expectations model (first, second or third 
-% order approximation of the stochastic model around the deterministic steady state). 
+% computes the reduced form solution of a rational expectations model (first, second or third
+% order approximation of the stochastic model around the deterministic steady state).
 %
 % INPUTS
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   task       [integer]          if task = 0 then dr1 computes decision rules.
 %                                 if task = 1 then dr1 computes eigenvalues.
-%   M_         [matlab structure] Definition of the model.           
+%   M_         [matlab structure] Definition of the model.
 %   options_   [matlab structure] Global options.
-%   oo_        [matlab structure] Results 
-%    
+%   oo_        [matlab structure] Results
+%
 % OUTPUTS
 %   dr         [matlab structure] Decision rules for stochastic simulations.
 %   info       [integer]          info=1: the model doesn't define current variables uniquely
-%                                 info=2: problem in mjdgges.dll info(2) contains error code. 
+%                                 info=2: problem in mjdgges.dll info(2) contains error code.
 %                                 info=3: BK order condition not satisfied info(2) contains "distance"
 %                                         absence of stable trajectory.
 %                                 info=4: BK order condition not satisfied info(2) contains "distance"
 %                                         indeterminacy.
 %                                 info=5: BK rank condition not satisfied.
-%                                 info=6: The jacobian matrix evaluated at the steady state is complex.        
-%                                 info=9: k_order_pert was unable to compute the solution    
+%                                 info=6: The jacobian matrix evaluated at the steady state is complex.
+%                                 info=9: k_order_pert was unable to compute the solution
 % ALGORITHM
 %   ...
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none.
-%  
+%
 
-% Copyright (C) 1996-2016 Dynare Team
+% Copyright (C) 1996-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -52,17 +52,23 @@ if options_.linear
     options_.order = 1;
 end
 
-if (options_.aim_solver == 1) && (options_.order > 1)
-        error('Option "aim_solver" is incompatible with order >= 2')
+local_order = options_.order;
+if M_.hessian_eq_zero && local_order~=1
+    local_order = 1;
+    warning('stochastic_solvers: using order = 1 because Hessian is equal to zero');
 end
 
-if M_.maximum_endo_lag == 0 
-    if options_.order >= 2
-    fprintf('\nSTOCHASTIC_SOLVER: Dynare does not solve purely forward models at higher order.\n')
-    fprintf('STOCHASTIC_SOLVER: To circumvent this restriction, you can add a backward-looking dummy equation of the form:\n')
-    fprintf('STOCHASTIC_SOLVER: junk=0.9*junk(-1);\n')
-    error(['2nd and 3rd order approximation not implemented for purely ' ...
-           'forward models'])
+if (options_.aim_solver == 1) && (local_order > 1)
+    error('Option "aim_solver" is incompatible with order >= 2')
+end
+
+if M_.maximum_endo_lag == 0
+    if local_order >= 2
+        fprintf('\nSTOCHASTIC_SOLVER: Dynare does not solve purely forward models at higher order.\n')
+        fprintf('STOCHASTIC_SOLVER: To circumvent this restriction, you can add a backward-looking dummy equation of the form:\n')
+        fprintf('STOCHASTIC_SOLVER: junk=0.9*junk(-1);\n')
+        error(['2nd and 3rd order approximation not implemented for purely ' ...
+               'forward models'])
     end
     if M_.exo_det_nbr~=0
         fprintf('\nSTOCHASTIC_SOLVER: Dynare does not solve purely forward models with var_exo_det.\n')
@@ -79,15 +85,18 @@ if M_.maximum_endo_lead==0 && M_.exo_det_nbr~=0
     error(['var_exo_det not implemented for purely backwards models'])
 end
 
-if options_.k_order_solver;
+if options_.k_order_solver
     if options_.risky_steadystate
         [dr,info] = dyn_risky_steadystate_solver(oo_.steady_state,M_,dr, ...
-                                             options_,oo_);
+                                                 options_,oo_);
     else
+        orig_order = options_.order;
+        options_.order = local_order;
         dr = set_state_space(dr,M_,options_);
         [dr,info] = k_order_pert(dr,M_,options_);
+        options_.order = orig_order;
     end
-    return;
+    return
 end
 
 klen = M_.maximum_lag + M_.maximum_lead + 1;
@@ -103,25 +112,25 @@ end
 
 it_ = M_.maximum_lag + 1;
 z = repmat(dr.ys,1,klen);
-if options_.order == 1
+if local_order == 1
     if (options_.bytecode)
         [chck, junk, 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
         [junk,jacobia_] = feval([M_.fname '_dynamic'],z(iyr0),exo_simul, ...
-                            M_.params, dr.ys, it_);
-    end;
-elseif options_.order == 2
+                                M_.params, dr.ys, it_);
+    end
+elseif local_order == 2
     if (options_.bytecode)
         [chck, junk, loc_dr] = bytecode('dynamic','evaluate', z,exo_simul, ...
-                            M_.params, dr.ys, 1);
+                                        M_.params, dr.ys, 1);
         jacobia_ = [loc_dr.g1 loc_dr.g1_x];
     else
         [junk,jacobia_,hessian1] = feval([M_.fname '_dynamic'],z(iyr0),...
                                          exo_simul, ...
                                          M_.params, dr.ys, it_);
-    end;
+    end
     if options_.use_dll
         % In USE_DLL mode, the hessian is in the 3-column sparse representation
         hessian1 = sparse(hessian1(:,1), hessian1(:,2), hessian1(:,3), ...
@@ -129,10 +138,10 @@ elseif options_.order == 2
     end
     [infrow,infcol]=find(isinf(hessian1));
     if options_.debug
-        if ~isempty(infrow)     
-        fprintf('\nSTOCHASTIC_SOLVER: The Hessian of the dynamic model contains Inf.\n')
-        fprintf('STOCHASTIC_SOLVER: Try running model_diagnostics to find the source of the problem.\n')
-        save([M_.fname '_debug.mat'],'hessian1')
+        if ~isempty(infrow)
+            fprintf('\nSTOCHASTIC_SOLVER: The Hessian of the dynamic model contains Inf.\n')
+            fprintf('STOCHASTIC_SOLVER: Try running model_diagnostics to find the source of the problem.\n')
+            save([M_.fname '_debug.mat'],'hessian1')
         end
     end
     if ~isempty(infrow)
@@ -141,7 +150,7 @@ elseif options_.order == 2
     end
     [nanrow,nancol]=find(isnan(hessian1));
     if options_.debug
-        if ~isempty(nanrow)     
+        if ~isempty(nanrow)
             fprintf('\nSTOCHASTIC_SOLVER: The Hessian of the dynamic model contains NaN.\n')
             fprintf('STOCHASTIC_SOLVER: Try running model_diagnostics to find the source of the problem.\n')
             save([M_.fname '_debug.mat'],'hessian1')
@@ -150,16 +159,16 @@ elseif options_.order == 2
     if ~isempty(nanrow)
         info(1)=12;
         return
-    end    
+    end
 end
 
 [infrow,infcol]=find(isinf(jacobia_));
-    
+
 if options_.debug
-    if ~isempty(infrow)     
-    fprintf('\nSTOCHASTIC_SOLVER: The Jacobian of the dynamic model contains Inf. The problem is associated with:\n\n')    
-    display_problematic_vars_Jacobian(infrow,infcol,M_,dr.ys,'dynamic','STOCHASTIC_SOLVER: ')
-    save([M_.fname '_debug.mat'],'jacobia_')
+    if ~isempty(infrow)
+        fprintf('\nSTOCHASTIC_SOLVER: The Jacobian of the dynamic model contains Inf. The problem is associated with:\n\n')
+        display_problematic_vars_Jacobian(infrow,infcol,M_,dr.ys,'dynamic','STOCHASTIC_SOLVER: ')
+        save([M_.fname '_debug.mat'],'jacobia_')
     end
 end
 
@@ -185,18 +194,18 @@ end
 
 [nanrow,nancol]=find(isnan(jacobia_));
 if options_.debug
-    if ~isempty(nanrow)     
-    fprintf('\nSTOCHASTIC_SOLVER: The Jacobian of the dynamic model contains NaN. The problem is associated with:\n\n')    
-    display_problematic_vars_Jacobian(nanrow,nancol,M_,dr.ys,'dynamic','STOCHASTIC_SOLVER: ')
-    save([M_.fname '_debug.mat'],'jacobia_')
+    if ~isempty(nanrow)
+        fprintf('\nSTOCHASTIC_SOLVER: The Jacobian of the dynamic model contains NaN. The problem is associated with:\n\n')
+        display_problematic_vars_Jacobian(nanrow,nancol,M_,dr.ys,'dynamic','STOCHASTIC_SOLVER: ')
+        save([M_.fname '_debug.mat'],'jacobia_')
     end
 end
 
 if ~isempty(nanrow)
-   info(1) = 8;
-   NaN_params=find(isnan(M_.params));
-   info(2:length(NaN_params)+1) =  NaN_params;
-   return
+    info(1) = 8;
+    NaN_params=find(isnan(M_.params));
+    info(2:length(NaN_params)+1) =  NaN_params;
+    return
 end
 
 kstate = dr.kstate;
@@ -218,11 +227,11 @@ b(:,cols_b) = jacobia_(:,cols_j);
 
 if M_.maximum_endo_lead == 0
     % backward models: simplified code exist only at order == 1
-    if options_.order == 1
+    if local_order == 1
         [k1,junk,k2] = find(kstate(:,4));
-        dr.ghx(:,k1) = -b\jacobia_(:,k2); 
+        dr.ghx(:,k1) = -b\jacobia_(:,k2);
         if M_.exo_nbr
-            dr.ghu =  -b\jacobia_(:,nz+1:end); 
+            dr.ghu =  -b\jacobia_(:,nz+1:end);
         end
         dr.eigval = eig(kalman_transition_matrix(dr,nstatic+(1:nspred),1:nspred,M_.exo_nbr));
         dr.full_rank = 1;
@@ -241,8 +250,11 @@ if M_.maximum_endo_lead == 0
                'backward models'])
     end
 elseif options_.risky_steadystate
+    orig_order = options_.order;
+    options_.order = local_order;
     [dr,info] = dyn_risky_steadystate_solver(oo_.steady_state,M_,dr, ...
                                              options_,oo_);
+    options_.order = orig_order;
 else
     % If required, use AIM solver if not check only
     if (options_.aim_solver == 1) && (task == 0)
@@ -251,16 +263,16 @@ else
     else  % use original Dynare solver
         [dr,info] = dyn_first_order_solver(jacobia_,M_,dr,options_,task);
         if info(1) || task
-            return;
+            return
         end
     end
 
-    if options_.order > 1
+    if local_order > 1
         % Second order
         dr = dyn_second_order_solver(jacobia_,hessian1,dr,M_,...
                                      options_.threads.kronecker.A_times_B_kronecker_C,...
                                      options_.threads.kronecker.sparse_hessian_times_B_kronecker_C);
-                                 
+
         % reordering second order derivatives, used for deterministic
         % variables below
         k1 = nonzeros(M_.lead_lag_incidence(:,order_var)');
@@ -287,14 +299,14 @@ if M_.exo_det_nbr > 0
         dr.ghud{i} = -M2*dr.ghud{i-1}(end-nsfwrd+1:end,:);
     end
 
-    if options_.order > 1
+    if local_order > 1
         lead_lag_incidence = M_.lead_lag_incidence;
         k0 = find(lead_lag_incidence(M_.maximum_endo_lag+1,order_var)');
         k1 = find(lead_lag_incidence(M_.maximum_endo_lag+2,order_var)');
         hu = dr.ghu(nstatic+[1:nspred],:);
         hud = dr.ghud{1}(nstatic+1:nstatic+nspred,:);
         zx = [eye(nspred);dr.ghx(k0,:);gx*dr.Gy;zeros(M_.exo_nbr+M_.exo_det_nbr, ...
-                                               nspred)];
+                                                      nspred)];
         zu = [zeros(nspred,M_.exo_nbr); dr.ghu(k0,:); gx*hu; zeros(M_.exo_nbr+M_.exo_det_nbr, ...
                                                           M_.exo_nbr)];
         zud=[zeros(nspred,M_.exo_det_nbr);dr.ghud{1};gx(:,1:nspred)*hud;zeros(M_.exo_nbr,M_.exo_det_nbr);eye(M_.exo_det_nbr)];
@@ -364,9 +376,8 @@ if options_.loglinear
         dr.ghx(il,iklag) = dr.ghx(il,iklag).*repmat(dr.ys(klag1)', ...
                                                     length(il),1);
     end
-    if options_.order>1
-       error('Loglinear options currently only works at order 1')
+    if local_order > 1
+        error('Loglinear options currently only works at order 1')
     end
 end
 end
-
diff --git a/matlab/store_smoother_results.m b/matlab/store_smoother_results.m
index 61af7b6a6..5ef6e1509 100644
--- a/matlab/store_smoother_results.m
+++ b/matlab/store_smoother_results.m
@@ -1,7 +1,7 @@
 function [oo_, yf]=store_smoother_results(M_,oo_,options_,bayestopt_,dataset_,dataset_info,atT,innov,measurement_error,updated_variables,ys,trend_coeff,aK,P,PK,decomp,Trend,state_uncertainty)
 % oo_=store_smoother_results(M_,oo_,options_,bayestopt_,dataset_,atT,innov,measurement_error,updated_variables,ys,trend_coeff,aK,P,PK,decomp,Trend)
 % Writes the smoother results into respective fields in oo_
-% 
+%
 % Inputs:
 %   M_              [structure]     storing the model information
 %   oo_             [structure]     storing the results
@@ -42,19 +42,19 @@ function [oo_, yf]=store_smoother_results(M_,oo_,options_,bayestopt_,dataset_,da
 %                   oo_.SmoothedMeasurementErrors: structure storing the smoothed measurement errors
 %                   oo_.Smoother.State_uncertainty: smoothed state uncertainty (declaration order)
 
-%   yf              [double]    (nvarobs*T) matrix storing the smoothed observed variables (order of options_.varobs)  
-% 
-% Notes: 
+%   yf              [double]    (nvarobs*T) matrix storing the smoothed observed variables (order of options_.varobs)
+%
+% Notes:
 %   m:  number of endogenous variables (M_.endo_nbr)
 %   T:  number of Time periods (options_.nobs)
 %   r:  number of strucural shocks (M_.exo_nbr)
 %   n:  number of observables (length(options_.varobs))
 %   K:  maximum forecast horizon (max(options_.nk))
-% 
+%
 %   First all smoothed variables are saved without trend and constant.
 %       Then trend and constant are added for the observed variables.
 %
-% Copyright (C) 2014-2016 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -76,6 +76,11 @@ if nargin<16
     Trend=zeros(options_.number_of_observed_variables,gend);
 end
 
+if options_.loglinear
+    oo_.Smoother.loglinear = true;
+else
+    oo_.Smoother.loglinear = false;
+end
 %% write variable steady state
 oo_.Smoother.SteadyState = ys;
 
@@ -108,7 +113,7 @@ trend_constant_observables=constant_part+Trend;
 yf = atT(bayestopt_.mf,:)+trend_constant_observables;
 
 if options_.nk > 0
-    %filtered variable E_t(y_t+k) requires to shift trend by k periods    
+    %filtered variable E_t(y_t+k) requires to shift trend by k periods
     filter_steps_required=union(1,options_.filter_step_ahead); % 1 is required for standard filtered variables
     for filter_iter=1:length(filter_steps_required)
         filter_step=filter_steps_required(filter_iter);
@@ -136,7 +141,7 @@ if ~isempty(options_.nk) && options_.nk ~= 0
     end
     % add constant
     oo_.FilteredVariablesKStepAhead = aK(options_.filter_step_ahead,i_endo_in_dr_matrices,:)+constant_all_variables;
-    if ~isempty(PK) %get K-step ahead variances
+    if ~isempty(PK) && options_.filter_covariance %get K-step ahead variances
         oo_.FilteredVariablesKStepAheadVariances = ...
             PK(options_.filter_step_ahead,i_endo_in_dr_matrices,i_endo_in_dr_matrices,:);
     end
@@ -157,18 +162,18 @@ for i_endo_in_bayestopt_smoother_varlist=bayestopt_.smoother_saved_var_list'
     end
     oo_.Smoother.Constant.(deblank(M_.endo_names(i_endo_declaration_order,:)))=constant_current_variable;
     oo_.SmoothedVariables.(deblank(M_.endo_names(i_endo_declaration_order,:)))=atT(i_endo_in_dr,:)'+constant_current_variable;
-    if ~isempty(options_.nk) && options_.nk > 0 && ~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.pshape> 0) && options_.load_mh_file))
+    if ~isempty(options_.nk) && options_.nk > 0 % && ~((any(bayestopt_.pshape > 0) && options_.mh_replic) || (any(bayestopt_.pshape> 0) && options_.load_mh_file))
         oo_.FilteredVariables.(deblank(M_.endo_names(i_endo_declaration_order,:)))=squeeze(aK(1,i_endo_in_dr,2:end-(options_.nk-1)))+constant_current_variable;
     end
     oo_.UpdatedVariables.(deblank(M_.endo_names(i_endo_declaration_order,:)))=updated_variables(i_endo_in_dr,:)'+constant_current_variable;
 end
-    
+
 %% Add trend and constant for observed variables
 for pos_iter=1:length(bayestopt_.mf)
     oo_.Smoother.Constant.(deblank(M_.endo_names(bayestopt_.mfys(pos_iter),:)))=constant_part(pos_iter,:)';
     if ismember(bayestopt_.mf(pos_iter),bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list))
-        oo_.SmoothedVariables.(deblank(M_.endo_names(bayestopt_.mfys(pos_iter),:)))=yf(pos_iter,:)';   
-        if ~isempty(options_.nk) && options_.nk > 0 
+        oo_.SmoothedVariables.(deblank(M_.endo_names(bayestopt_.mfys(pos_iter),:)))=yf(pos_iter,:)';
+        if ~isempty(options_.nk) && options_.nk > 0
             %filtered variable E_t(y_t+1) requires to shift trend by 1 period
             oo_.FilteredVariables.(deblank(M_.endo_names(bayestopt_.mfys(pos_iter),:)))=...
                 squeeze(aK(1,bayestopt_.mf(pos_iter),2:end-(options_.nk-1)))...
@@ -177,7 +182,7 @@ for pos_iter=1:length(bayestopt_.mf)
                 filter_step=options_.filter_step_ahead(filter_iter);
                 oo_.FilteredVariablesKStepAhead(filter_iter,find(i_endo_in_dr_matrices==bayestopt_.mf(pos_iter)),1+filter_step:end-(max(options_.filter_step_ahead)-filter_step)) = ...
                     squeeze(aK(filter_step,bayestopt_.mf(pos_iter),1+filter_step:end-(max(options_.filter_step_ahead)-filter_step)))...
-                    +trend_constant_observables_filtered.(['filter_ahead_' num2str(filter_step)])(pos_iter,:)';    
+                    +trend_constant_observables_filtered.(['filter_ahead_' num2str(filter_step)])(pos_iter,:)';
             end
         end
         %updated variables are E_t(y_t) so no trend shift is required
@@ -191,7 +196,7 @@ if ~isempty(options_.nk) && options_.nk ~= 0
     positions_in_declaration_order=oo_.dr.order_var(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list));
     if ~(options_.selected_variables_only && ~(options_.forecast > 0)) %happens only when selected_variables_only is not used
         oo_.FilteredVariablesKStepAhead(:,positions_in_declaration_order,:)=oo_.FilteredVariablesKStepAhead;
-        if ~isempty(PK) %get K-step ahead variances
+        if ~isempty(PK) && options_.filter_covariance %get K-step ahead variances
             oo_.FilteredVariablesKStepAheadVariances(:,positions_in_declaration_order,positions_in_declaration_order,:)=oo_.FilteredVariablesKStepAheadVariances;
         end
         if ~isempty(decomp)
@@ -201,7 +206,7 @@ if ~isempty(options_.nk) && options_.nk ~= 0
         positions_in_declaration_order=oo_.dr.order_var(bayestopt_.smoother_var_list(bayestopt_.smoother_saved_var_list));
         [junk,sorted_index_declaration_order]=sort(positions_in_declaration_order);
         oo_.FilteredVariablesKStepAhead(:,sorted_index_declaration_order,:)=oo_.FilteredVariablesKStepAhead;
-        if ~isempty(PK) %get K-step ahead variances
+        if ~isempty(PK) && options_.filter_covariance %get K-step ahead variances
             oo_.FilteredVariablesKStepAheadVariances(:,sorted_index_declaration_order,sorted_index_declaration_order,:)=oo_.FilteredVariablesKStepAheadVariances;
         end
         if ~isempty(decomp)
@@ -224,8 +229,8 @@ end
 
 %%  Smoothed measurement errors
 if ~isequal(M_.H,0)
-%     measurement_error_indices=find(diag(M_.H)~=0);
+    %     measurement_error_indices=find(diag(M_.H)~=0);
     for meas_error_iter=1:length(options_.varobs)
-       oo_.SmoothedMeasurementErrors.(options_.varobs{meas_error_iter})= measurement_error(meas_error_iter,:)';
+        oo_.SmoothedMeasurementErrors.(options_.varobs{meas_error_iter})= measurement_error(meas_error_iter,:)';
     end
 end
diff --git a/matlab/subset.m b/matlab/subset.m
index dedbdbfba..946ebdcc5 100644
--- a/matlab/subset.m
+++ b/matlab/subset.m
@@ -1,6 +1,6 @@
 function jndx = subset()
 
-% Copyright (C) 2006-2011 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,8 +54,8 @@ else
     for i = 1:length(ExcludedParamNames)
         tmp = strmatch(ExcludedParamNames{i},M_.exo_names);
         if ~isempty(tmp) && ( strcmpi(info,'All') || strcmpi(info,'StructuralShocks') || ...
-                             strcmpi(info,'StructuralShocksWithoutCorrelations') || ...
-                             strcmpi(info,'AllWithoutMeasurementErrors') )
+                              strcmpi(info,'StructuralShocksWithoutCorrelations') || ...
+                              strcmpi(info,'AllWithoutMeasurementErrors') )
             % The parameter the user wants to exclude is related to the size of the structural innovations.
             if ncx
                 disp(['I cannot exclude some of the structural variances if the'])
@@ -63,10 +63,10 @@ else
                 error
             end
             tt = [tt;tmp];
-        elseif isempty(tmp) && nvn 
+        elseif isempty(tmp) && nvn
             tmp = strmatch(ExcludedParamNames{i},options_.varobs);
             if ~isempty(tmp) && ( strcmpi(info,'All') || strcmpi(info,'MeasurementErrors') || ...
-                                 strcmpi(info,'MeasurementErrorsWithoutCorrelations') )
+                                  strcmpi(info,'MeasurementErrorsWithoutCorrelations') )
                 % The parameter the user wants to exclude is related to the size of the measurement errors variances.
                 tmp = nvx+tmp;
                 if ncn
diff --git a/matlab/supported_octave_version.m b/matlab/supported_octave_version.m
index 9f6f2d633..97e2c4605 100644
--- a/matlab/supported_octave_version.m
+++ b/matlab/supported_octave_version.m
@@ -17,4 +17,4 @@ function v = supported_octave_version()
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-v = '4.2.0';
\ No newline at end of file
+v = '4.2.1';
\ No newline at end of file
diff --git a/matlab/symmetric_matrix_index.m b/matlab/symmetric_matrix_index.m
index 73cf4a50b..60b2afe70 100644
--- a/matlab/symmetric_matrix_index.m
+++ b/matlab/symmetric_matrix_index.m
@@ -1,9 +1,9 @@
 function k = symmetric_matrix_index(i,j,n)
 % function k = symmetric_matrix_index(i,j,n)
-% Returns index number of variable combination (i,j) in vech(A) where A is 
+% Returns index number of variable combination (i,j) in vech(A) where A is
 % an symmetric n by n matrix and vech creates row vector by stacking rows
 % of A on and above the diagonal
-% 
+%
 % Inputs:
 %   i   [scalar]    index of first variable
 %   j   [scalar]    index of second variable
@@ -11,7 +11,7 @@ function k = symmetric_matrix_index(i,j,n)
 % Outputs:
 %   k   [scalar]    index of variable combination in vech(A)
 
-% Copyright (C) 2007-2015 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/test_for_deep_parameters_calibration.m b/matlab/test_for_deep_parameters_calibration.m
index 4dbfca7cd..3cdc831b9 100644
--- a/matlab/test_for_deep_parameters_calibration.m
+++ b/matlab/test_for_deep_parameters_calibration.m
@@ -3,17 +3,17 @@ function info=test_for_deep_parameters_calibration(M_)
 %
 % INPUTS
 %   M_    [structure]   Description of the (simulated or estimated) model.
-%  
+%
 % OUTPUTS
-%   info  [scalar]      0 if no problems detected, 1 otherwise 
-%    
+%   info  [scalar]      0 if no problems detected, 1 otherwise
+%
 % ALGORITHM
 %   none
-%    
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2010-2014 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -28,7 +28,7 @@ function info=test_for_deep_parameters_calibration(M_)
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 plist = list_of_parameters_calibrated_as_NaN(M_);
 if ~isempty(plist)
     info=1;
diff --git a/matlab/th_autocovariances.m b/matlab/th_autocovariances.m
index 966ece834..3cde22f31 100644
--- a/matlab/th_autocovariances.m
+++ b/matlab/th_autocovariances.m
@@ -1,28 +1,28 @@
 function [Gamma_y,stationary_vars] = th_autocovariances(dr,ivar,M_,options_,nodecomposition)
-% Computes the theoretical auto-covariances, Gamma_y, for an AR(p) process 
+% Computes the theoretical auto-covariances, Gamma_y, for an AR(p) process
 % with coefficients dr.ghx and dr.ghu and shock variances Sigma_e
 % for a subset of variables ivar.
 % Theoretical HP-filtering and band-pass filtering is available as an option
-%    
+%
 % INPUTS
 %   dr:               [structure]    Reduced form solution of the DSGE model  (decisions rules)
 %   ivar:             [integer]      Vector of indices for a subset of variables.
 %   M_                [structure]    Global dynare's structure, description of the DSGE model.
 %   options_          [structure]    Global dynare's structure.
-%   nodecomposition   [integer]      Scalar, if different from zero the variance decomposition is not triggered.  
-%    
+%   nodecomposition   [integer]      Scalar, if different from zero the variance decomposition is not triggered.
+%
 % OUTPUTS
-%   Gamma_y           [cell]         Matlab cell of nar+3 (second order approximation) or nar+2 (first order approximation) arrays, 
+%   Gamma_y           [cell]         Matlab cell of nar+3 (second order approximation) or nar+2 (first order approximation) arrays,
 %                                    where nar is the order of the autocorrelation function.
 %                                      Gamma_y{1}       [double]  Covariance matrix.
 %                                      Gamma_y{i+1}     [double]  Autocorrelation function (for i=1,...,options_.nar).
-%                                      Gamma_y{nar+2}   [double]  Variance decomposition.  
-%                                      Gamma_y{nar+3}   [double]  Expectation of the endogenous variables associated with a second 
-%                                                                 order approximation.    
+%                                      Gamma_y{nar+2}   [double]  Variance decomposition.
+%                                      Gamma_y{nar+3}   [double]  Expectation of the endogenous variables associated with a second
+%                                                                 order approximation.
 %   stationary_vars   [integer]      Vector of indices of stationary variables (as a subset of 1:length(ivar))
 %
 % SPECIAL REQUIREMENTS
-%   
+%
 % Algorithms
 %   The means at order=2 are based on the pruned state space as
 %   in Kim, Kim, Schaumburg, Sims (2008): Calculating and using second-order accurate
@@ -34,15 +34,15 @@ function [Gamma_y,stationary_vars] = th_autocovariances(dr,ivar,M_,options_,node
 %   Taking expectations on both sides requires to compute E(x^2)=Var(x), which
 %   can be obtained up to second order from the first order solution
 %   \[
-%       \hat x_t = g_x \hat x_{t - 1} + g_u u_t   
+%       \hat x_t = g_x \hat x_{t - 1} + g_u u_t
 %   \]
-%   by solving the corresponding Lyapunov equation. 
+%   by solving the corresponding Lyapunov equation.
 %   Given Var(x), the above equation can be solved for E(x_t) as
 %   \[
 %   E(x_t) = (I - {g_x}\right)^{- 1} 0.5\left( g_{\sigma\sigma} \sigma^2 + g_{xx} Var(\hat x_t) + g_{uu} Var(u_t) \right)
 %   \]
-% 
-% Copyright (C) 2001-2014 Dynare Team
+%
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -67,6 +67,11 @@ if options_.order >= 3
     error('Theoretical moments not implemented above 2nd order')
 end
 
+local_order = options_.order;
+if M_.hessian_eq_zero && local_order~=1
+    local_order = 1;
+end
+
 endo_nbr = M_.endo_nbr;
 exo_names_orig_ord  = M_.exo_names_orig_ord;
 if isoctave
@@ -114,7 +119,7 @@ else
     trend = 1:M_.endo_nbr;
     inv_order_var = trend(M_.block_structure.variable_reordered);
     ghu1(1:length(dr.state_var),:) = ghu(dr.state_var,:);
-end;
+end
 b = ghu1*M_.Sigma_e*ghu1';
 
 
@@ -122,19 +127,19 @@ if options_.block == 0
     ipred = nstatic+(1:nspred)';
 else
     ipred = dr.state_var;
-end;
+end
 % state space representation for state variables only
 [A,B] = kalman_transition_matrix(dr,ipred,1:nx,M_.exo_nbr);
 % Compute stationary variables (before HP filtering),
 % and compute 2nd order mean correction on stationary variables (in case of
 % HP filtering, this mean correction is computed *before* filtering)
-if options_.order == 2 || options_.hp_filter == 0
+if local_order == 2 || options_.hp_filter == 0
     [vx, u] =  lyapunov_symm(A,B*M_.Sigma_e*B',options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold,[],options_.debug);
     if options_.block == 0
         iky = inv_order_var(ivar);
     else
         iky = ivar;
-    end;
+    end
     stationary_vars = (1:length(ivar))';
     if ~isempty(u)
         x = abs(ghx*u);
@@ -143,8 +148,8 @@ if options_.order == 2 || options_.hp_filter == 0
     end
     aa = ghx(iky,:);
     bb = ghu(iky,:);
-    if options_.order == 2         % mean correction for 2nd order
-        if ~isempty(ikx) 
+    if local_order == 2         % mean correction for 2nd order
+        if ~isempty(ikx)
             Ex = (dr.ghs2(ikx)+dr.ghxx(ikx,:)*vx(:)+dr.ghuu(ikx,:)*M_.Sigma_e(:))/2;
             Ex = (eye(n0)-AS(ikx,:))\Ex;
             Gamma_y{nar+3} = NaN*ones(nvar, 1);
@@ -164,7 +169,7 @@ if options_.hp_filter == 0 && ~options_.bandpass.indicator
     Gamma_y{1} = v;
     % autocorrelations
     if nar > 0
-        vxy = (A*vx*aa'+ghu1*M_.Sigma_e*bb');    
+        vxy = (A*vx*aa'+ghu1*M_.Sigma_e*bb');
         sy = sqrt(diag(Gamma_y{1}));
         sy = sy(stationary_vars);
         sy = sy *sy';
@@ -209,7 +214,7 @@ if options_.hp_filter == 0 && ~options_.bandpass.indicator
     end
 else% ==> Theoretical filters.
     % By construction, all variables are stationary when HP filtered
-    iky = inv_order_var(ivar);  
+    iky = inv_order_var(ivar);
     stationary_vars = (1:length(ivar))';
     aa = ghx(iky,:); %R in Uhlig (2001)
     bb = ghu(iky,:); %S in Uhlig (2001)
@@ -227,22 +232,22 @@ else% ==> Theoretical filters.
         filter_gain(freqs>=2*pi/lowest_periodicity & freqs<=2*pi/highest_periodicity)=1;
         filter_gain(freqs<=-2*pi/lowest_periodicity+2*pi & freqs>=-2*pi/highest_periodicity+2*pi)=1;
     else
-        filter_gain = 4*lambda*(1 - cos(freqs)).^2 ./ (1 + 4*lambda*(1 - cos(freqs)).^2);   %HP transfer function  
+        filter_gain = 4*lambda*(1 - cos(freqs)).^2 ./ (1 + 4*lambda*(1 - cos(freqs)).^2);   %HP transfer function
     end
     mathp_col = NaN(ngrid,length(ivar)^2);
     IA = eye(size(A,1));
     IE = eye(M_.exo_nbr);
     for ig = 1:ngrid
-        if filter_gain(ig)==0,
+        if filter_gain(ig)==0
             f_hp = zeros(length(ivar),length(ivar));
         else
             f_omega  =(1/(2*pi))*([(IA-A*tneg(ig))\ghu1;IE]...
-                                   *M_.Sigma_e*[ghu1'/(IA-A'*tpos(ig)) IE]); % spectral density of state variables; top formula Uhlig (2001), p. 20 with N=0
-            g_omega = [aa*tneg(ig) bb]*f_omega*[aa'*tpos(ig); bb']; % spectral density of selected variables; middle formula Uhlig (2001), p. 20; only middle block, i.e. y_t' 
+                                  *M_.Sigma_e*[ghu1'/(IA-A'*tpos(ig)) IE]); % spectral density of state variables; top formula Uhlig (2001), p. 20 with N=0
+            g_omega = [aa*tneg(ig) bb]*f_omega*[aa'*tpos(ig); bb']; % spectral density of selected variables; middle formula Uhlig (2001), p. 20; only middle block, i.e. y_t'
             f_hp = filter_gain(ig)^2*g_omega; % spectral density of selected filtered series; top formula Uhlig (2001), p. 21;
         end
         mathp_col(ig,:) = (f_hp(:))';    % store as matrix row for ifft
-    end;
+    end
     % Covariance of filtered series
     imathp_col = real(ifft(mathp_col))*(2*pi); % Inverse Fast Fourier Transformation; middle formula Uhlig (2001), p. 21;
     Gamma_y{1} = reshape(imathp_col(1,:),nvar,nvar);
@@ -269,32 +274,32 @@ else% ==> Theoretical filters.
             IA = eye(size(A,1));
             IE = eye(M_.exo_nbr);
             for ig = 1:ngrid
-                if filter_gain(ig)==0,
+                if filter_gain(ig)==0
                     f_hp = zeros(length(ivar),length(ivar));
                 else
                     f_omega  =(1/(2*pi))*( [(IA-A*tneg(ig))\b1;IE]...
                                            *SS*[b1'/(IA-A'*tpos(ig)) IE]); % spectral density of state variables; top formula Uhlig (2001), p. 20 with N=0
-                    g_omega = [aa*tneg(ig) b2]*f_omega*[aa'*tpos(ig); b2']; % spectral density of selected variables; middle formula Uhlig (2001), p. 20; only middle block, i.e. y_t' 
+                    g_omega = [aa*tneg(ig) b2]*f_omega*[aa'*tpos(ig); b2']; % spectral density of selected variables; middle formula Uhlig (2001), p. 20; only middle block, i.e. y_t'
                     f_hp = filter_gain(ig)^2*g_omega;  % spectral density of selected filtered series; top formula Uhlig (2001), p. 21;
                 end
                 mathp_col(ig,:) = (f_hp(:))';    % store as matrix row for ifft
-            end;  
+            end
             imathp_col = real(ifft(mathp_col))*(2*pi);
             vv = diag(reshape(imathp_col(1,:),nvar,nvar));
             for i=1:M_.exo_nbr
                 mathp_col = NaN(ngrid,length(ivar)^2);
                 SSi = cs(:,i)*cs(:,i)';
                 for ig = 1:ngrid
-                    if filter_gain(ig)==0,
+                    if filter_gain(ig)==0
                         f_hp = zeros(length(ivar),length(ivar));
                     else
                         f_omega  =(1/(2*pi))*( [(IA-A*tneg(ig))\b1;IE]...
                                                *SSi*[b1'/(IA-A'*tpos(ig)) IE]); % spectral density of state variables; top formula Uhlig (2001), p. 20 with N=0
-                        g_omega = [aa*tneg(ig) b2]*f_omega*[aa'*tpos(ig); b2']; % spectral density of selected variables; middle formula Uhlig (2001), p. 20; only middle block, i.e. y_t' 
+                        g_omega = [aa*tneg(ig) b2]*f_omega*[aa'*tpos(ig); b2']; % spectral density of selected variables; middle formula Uhlig (2001), p. 20; only middle block, i.e. y_t'
                         f_hp = filter_gain(ig)^2*g_omega; % spectral density of selected filtered series; top formula Uhlig (2001), p. 21;
                     end
                     mathp_col(ig,:) = (f_hp(:))';    % store as matrix row for ifft
-                end;
+                end
                 imathp_col = real(ifft(mathp_col))*(2*pi);
                 Gamma_y{nar+2}(:,i) = abs(diag(reshape(imathp_col(1,:),nvar,nvar)))./vv;
             end
diff --git a/matlab/thet2tau.m b/matlab/thet2tau.m
index 929193ca4..965934e3d 100644
--- a/matlab/thet2tau.m
+++ b/matlab/thet2tau.m
@@ -1,7 +1,7 @@
 function tau = thet2tau(params, estim_params_, M_, oo_, indx, indexo, flagmoments,mf,nlags,useautocorr,iv)
 
 %
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -20,22 +20,22 @@ function tau = thet2tau(params, estim_params_, M_, oo_, indx, indexo, flagmoment
 
 global options_
 
-if nargin==1,
+if nargin==1
     indx = [1:M_.param_nbr];
     indexo = [];
 end
 
-if nargin<7,
+if nargin<7
     flagmoments=0;
 end
-if nargin<10 || isempty(useautocorr),
+if nargin<10 || isempty(useautocorr)
     useautocorr=0;
 end
-if nargin<11 || isempty(iv),
+if nargin<11 || isempty(iv)
     iv=[1:M_.endo_nbr];
 end
 
-if length(params)>length(indx),
+if length(params)>length(indx)
     M_ = set_all_parameters(params,estim_params_,M_);
 else
     M_.params(indx) = params;
@@ -44,21 +44,21 @@ end
 %     M_.Sigma_e(indexo,indexo) = diag(params(1:length(indexo)).^2);
 % end
 [A,B,tele,tubbies,M_,options_,oo_] = dynare_resolve(M_,options_,oo_);
-if flagmoments==0,
+if flagmoments==0
     ys=oo_.dr.ys(oo_.dr.order_var);
     tau = [ys(iv); vec(A(iv,iv)); dyn_vech(B(iv,:)*M_.Sigma_e*B(iv,:)')];
 elseif flagmoments==-1
     [I,J]=find(M_.lead_lag_incidence');
     yy0=oo_.dr.ys(I);
     [residual, g1] = feval([M_.fname,'_dynamic'],yy0, oo_.exo_steady_state', ...
-        M_.params, oo_.dr.ys, 1);
+                           M_.params, oo_.dr.ys, 1);
     tau=[oo_.dr.ys(oo_.dr.order_var); g1(:)];
 
 else
     GAM =  lyapunov_symm(A,B*M_.Sigma_e*B',options_.lyapunov_fixed_point_tol,options_.qz_criterium,options_.lyapunov_complex_threshold,[],options_.debug);
     k = find(abs(GAM) < 1e-12);
     GAM(k) = 0;
-    if useautocorr,
+    if useautocorr
         sy = sqrt(diag(GAM));
         sy = sy*sy';
         sy0 = sy-diag(diag(sy))+eye(length(sy));
@@ -69,7 +69,7 @@ else
     end
     for ii = 1:nlags
         dum = A^(ii)*GAM;
-        if useautocorr,
+        if useautocorr
             dum = dum./sy;
         end
         tau = [tau;vec(dum(mf,mf))];
diff --git a/matlab/trace_plot.m b/matlab/trace_plot.m
index 1073480d6..9fbf38358 100644
--- a/matlab/trace_plot.m
+++ b/matlab/trace_plot.m
@@ -18,7 +18,7 @@ function trace_plot(options_,M_,estim_params_,type,blck,name1,name2)
 %
 % SPECIAL REQUIREMENTS
 
-% Copyright (C) 2003-2016 Dynare Team
+% Copyright (C) 2003-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -95,7 +95,7 @@ if options_.mh_nblck>1
     FigureName = [ FigureName , ' (block number ' int2str(blck)  ').'];
 end
 
-hh=dyn_figure(options_,'Name',FigureName);
+hh=dyn_figure(options_.nodisplay,'Name',FigureName);
 plot(1:TotalNumberOfMhDraws,PosteriorDraws,'Color',[.7 .7 .7]);
 
 
@@ -131,11 +131,11 @@ else
 end
 plot_name=[plot_name,'_blck_',num2str(blck)];
 
-dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'TracePlot_' plot_name],options_)
+dyn_saveas(hh,[M_.fname, filesep, 'graphs', filesep, 'TracePlot_' plot_name],options_.nodisplay,options_.graph_format)
 
 if options_.TeX
     fid=fopen([M_.fname,'/graphs/',M_.fname,'_TracePlot_' plot_name,'.tex'],'w+');
-    
+
     if strcmpi(type,'DeepParameter')
         tex_names=M_.param_names_tex;
         base_names=M_.param_names;
@@ -146,7 +146,7 @@ if options_.TeX
         tex_names=M_.endo_names_tex;
         base_names=M_.endo_names;
     end
-    
+
     if strcmpi(type,'PosteriorDensity')
         FigureName = ['Trace plot for ' TYPE name1];
     else
@@ -159,7 +159,7 @@ if options_.TeX
     if options_.mh_nblck>1
         FigureName = [ FigureName , ' (block number ' int2str(blck)  ').'];
     end
-    
+
     fprintf(fid,'%-s\n','\begin{figure}[H]');
     fprintf(fid,'%-s\n','\centering');
     fprintf(fid,'%-s\n',['  \includegraphics[width=0.8\textwidth]{',[M_.fname, '/graphs/TracePlot_' plot_name],'}\\']);
@@ -167,4 +167,3 @@ if options_.TeX
     fprintf(fid,'%-s\n','\end{figure}');
     fclose(fid);
 end
-
diff --git a/matlab/trust_region.m b/matlab/trust_region.m
index 02acae0c5..13f11bd3d 100644
--- a/matlab/trust_region.m
+++ b/matlab/trust_region.m
@@ -25,7 +25,7 @@ function [x,check,info] = trust_region(fcn,x0,j1,j2,jacobian_flag,gstep,tolf,tol
 %    none
 
 % Copyright (C) 2008-2012 VZLU Prague, a.s.
-% Copyright (C) 2014-2016 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -150,7 +150,7 @@ while (niter < maxiter && ~info)
             else
                 info = -3;
             end
-            break;
+            break
         end
     elseif (abs (1-ratio) <= 0.1)
         delta = 1.4142*sn;
@@ -229,4 +229,3 @@ if (xn > delta)
     x = alpha * x + ((1-alpha) * min (snm, delta)) * s;
 end
 end
-
diff --git a/matlab/uniform_specification.m b/matlab/uniform_specification.m
index 5af782162..6baceb82f 100644
--- a/matlab/uniform_specification.m
+++ b/matlab/uniform_specification.m
@@ -3,20 +3,20 @@ function [m,s,p6,p7] = uniform_specification(m,s,p3,p4)
 %
 % INPUTS
 %    m:      mean
-%    s:      standard deviation 
-%    p3:     lower bound 
-%    p4:     upper bound 
+%    s:      standard deviation
+%    p3:     lower bound
+%    p4:     upper bound
 
 % OUTPUTS
 %    m:      mean
-%    s:      standard deviation 
-%    p1:     lower bound 
-%    p2:     upper bound 
-%        
+%    s:      standard deviation
+%    p1:     lower bound
+%    p2:     upper bound
+%
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2004-2011 Dynare Team
+% Copyright (C) 2004-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/update_last_mh_history_file.m b/matlab/update_last_mh_history_file.m
index d0c4e9ca5..a0e2d4a96 100644
--- a/matlab/update_last_mh_history_file.m
+++ b/matlab/update_last_mh_history_file.m
@@ -5,9 +5,9 @@ function update_last_mh_history_file(MetropolisFolder, ModelName, record)
 %   MetropolisFolder    [char]      Name of the metropolis subfolder
 %   ModelName           [char]      Name of the mod-file
 %   record              [structure] structure storing the MH history
-% Outputs:  none 
+% Outputs:  none
 
-% Copyright (C) 2013-2015 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/user_has_matlab_license.m b/matlab/user_has_matlab_license.m
index 86b8c94bd..c8c681283 100644
--- a/matlab/user_has_matlab_license.m
+++ b/matlab/user_has_matlab_license.m
@@ -11,7 +11,7 @@ function [hasLicense] = user_has_matlab_license(toolbox)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2012 Dynare Team
+% Copyright (C) 2012-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -31,26 +31,26 @@ function [hasLicense] = user_has_matlab_license(toolbox)
 if matlab_ver_less_than('7.12')
     hasLicense = license('test', toolbox);
 else
-    [hasLicense junk] = license('checkout',toolbox);
+    [hasLicense, junk] = license('checkout',toolbox);
 end
 if ~hasLicense
     return
 end
 switch toolbox
     %use function unique to toolbox
-    case 'statistics_toolbox'
-        n = 'gppdf';
-    case 'optimization_toolbox'
-        n='fsolve';
-    case 'GADS_Toolbox'
-        n='simulannealbnd';
-    case 'control_toolbox'
-        n='dlyap';
+  case 'statistics_toolbox'
+    n = 'gppdf';
+  case 'optimization_toolbox'
+    n='fsolve';
+  case 'GADS_Toolbox'
+    n='simulannealbnd';
+  case 'control_toolbox'
+    n='dlyap';
 end
 hasInstallation=check_toolbox_installation(n);
 if ~hasInstallation
     hasLicense=0;
-    return;
+    return
 end
 end
 
@@ -64,7 +64,7 @@ else
     a=ver(ver_string);
     if isempty(a)
         hasInstallation=0;
-    else 
+    else
         hasInstallation=1;
     end
 end
diff --git a/matlab/utilities/dataset/descriptive_statistics.m b/matlab/utilities/dataset/descriptive_statistics.m
index d2b52292d..79d324141 100644
--- a/matlab/utilities/dataset/descriptive_statistics.m
+++ b/matlab/utilities/dataset/descriptive_statistics.m
@@ -3,7 +3,7 @@ function dataset_ = descriptive_statistics(dataset_,statistic,varagin)
 
 %@info:
 %! @deftypefn {Function File} {@var{dataset_} =} descriptive_statistics(@var{dataset_},@var{statistic})
-%! @deftypefn {Function File} {@var{dataset_} =} descriptive_statistics(@var{dataset_},@var{statistic},nlags)    
+%! @deftypefn {Function File} {@var{dataset_} =} descriptive_statistics(@var{dataset_},@var{statistic},nlags)
 %! @anchor{compute_corr}
 %! This function computes various descriptive statistics on the sample (possibly with missing observations).
 %!
@@ -14,15 +14,15 @@ function dataset_ = descriptive_statistics(dataset_,statistic,varagin)
 %! @item statistic
 %! String. The name of the statistic to be computed. Admissible values are:
 %!   @table @var
-%!   @item 'stdv'    
+%!   @item 'stdv'
 %!   Computes the standard deviation of each observed variable.
-%!   @item 'cova'    
-%!   Computes the covariance matrix of the sample.    
+%!   @item 'cova'
+%!   Computes the covariance matrix of the sample.
 %!   @item 'corr'
 %!   Computes the correlation matrix of the sample.
 %!   @item 'acov'
 %!   Computes the (multivariate) auto-covariance function of the sample. In this case a third argument (@code{nlags}) defining the
-%!   maximum number of lags is mandatory.    
+%!   maximum number of lags is mandatory.
 %!   @end table
 %! @item nlags
 %! Integer scalar. The maximum number of lags when computing the autocovariance function.
@@ -33,20 +33,20 @@ function dataset_ = descriptive_statistics(dataset_,statistic,varagin)
 %! @item dataset_
 %! Dynare structure describing the dataset, built by @ref{initialize_dataset}
 %! @end table
-%! 
-%! @strong{This function is called by:} 
+%!
+%! @strong{This function is called by:}
 %! none.
-%! 
+%!
 %! @strong{This function calls:}
 %! @ref{compute_stdv}, @ref{compute_cova}, @ref{compute_corr}, @ref{compute_acov}.
-%!    
+%!
 %! @strong{Remark 1.} On exit, a new field containing the computed statistics is appended to the structure.
-%!    
+%!
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
diff --git a/matlab/utilities/dataset/initialize_dataset.m b/matlab/utilities/dataset/initialize_dataset.m
index 5d992a288..d7e3ed384 100644
--- a/matlab/utilities/dataset/initialize_dataset.m
+++ b/matlab/utilities/dataset/initialize_dataset.m
@@ -1,7 +1,7 @@
 function dataset_ = initialize_dataset(datafile,varobs,first,nobs,logged_data_flag,prefilter,xls)
 % Initializes a structure describing the dataset.
 
-% Copyright (C) 2011-2013 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,7 +55,7 @@ if dataset_.info.nvobs-size(rawdata,2)
 end
 
 if size(rawdata,1)~=dataset_.info.ntobs
-   fprintf('Restricting the sample to observations %d to %d. Using in total %d observations. \n',first,first+dataset_.info.ntobs-1,dataset_.info.ntobs)
+    fprintf('Restricting the sample to observations %d to %d. Using in total %d observations. \n',first,first+dataset_.info.ntobs-1,dataset_.info.ntobs)
 end
 rawdata = rawdata(first:(first+dataset_.info.ntobs-1),:);
 
diff --git a/matlab/utilities/dataset/lagged.m b/matlab/utilities/dataset/lagged.m
new file mode 100644
index 000000000..4f17d7eeb
--- /dev/null
+++ b/matlab/utilities/dataset/lagged.m
@@ -0,0 +1,34 @@
+function xlag = lagged(x, n)
+% xlag = lagged(x, n);
+% applies n-lags backward shift operator to x
+%
+% INPUTS
+% x    = time series
+% n    = number of backward shifts [DEFAULT=1]
+%
+% OUTPUT
+% xlag = backward shifted series
+
+% Copyright (C) 2017 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 nargin==1
+    n=1;
+end
+
+x=x(:);
+xlag=[NaN(n,1); x(1:end-n)];
\ No newline at end of file
diff --git a/matlab/utilities/dataset/makedataset.m b/matlab/utilities/dataset/makedataset.m
index 7e4aedd98..85d86d841 100644
--- a/matlab/utilities/dataset/makedataset.m
+++ b/matlab/utilities/dataset/makedataset.m
@@ -23,6 +23,24 @@ function [DynareDataset, DatasetInfo, newdatainterface] = makedataset(DynareOpti
 %
 % See also dynare_estimation_init
 
+% Copyright (C) 2014-2017 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 nargin<3
     gsa_flag = 0;
 end
@@ -37,7 +55,7 @@ if isempty(DynareOptions.datafile) && isempty(DynareOptions.dataset.file) && ise
     if gsa_flag
         DynareDataset = dseries();
         DatasetInfo = struct('missing', struct('state', 0, 'aindex', [], 'vindex', [], 'number_of_observations', NaN, 'no_more_missing_observations', NaN), ...
-                     'descriptive', struct('mean', [], 'covariance', [], 'correlation', [], 'autocovariance', []));
+                             'descriptive', struct('mean', [], 'covariance', [], 'correlation', [], 'autocovariance', []));
         newdatainterface=0;
         return
     else
@@ -99,11 +117,16 @@ end
 
 % Load the data in a dseries object.
 if ~isempty(datafile)
-    if ~( newdatainterface==0 && strcmp(datafile(end-1:end),'.m'))
+    if ~( newdatainterface==0 && (strcmp(datafile(end-1:end),'.m')|| strcmp(datafile(end-3:end),'.mat')))
         DynareDataset = dseries(datafile);
     else
-        % Load an m file with the old interface.
-        DynareDataset = load_m_file_data_legacy(datafile, DynareOptions.varobs);
+        if strcmp(datafile(end-1:end),'.m')
+            % Load an m file with the old interface.
+            DynareDataset = load_m_file_data_legacy(datafile, DynareOptions.varobs);
+        elseif strcmp(datafile(end-3:end),'.mat')
+            % Load a mat file with the old interface.
+            DynareDataset = load_mat_file_data_legacy(datafile, DynareOptions.varobs);
+        end
     end
 else
     DynareDataset = dseriesobjectforuserdataset;
diff --git a/matlab/utilities/dataset/nanvariance.m b/matlab/utilities/dataset/nanvariance.m
index d4894e8e9..121fb2dda 100644
--- a/matlab/utilities/dataset/nanvariance.m
+++ b/matlab/utilities/dataset/nanvariance.m
@@ -1,4 +1,4 @@
-function variances = nanvariance(data) 
+function variances = nanvariance(data)
 % Compute the standard deviation for each observed variable (possibly with missing observations).
 
 %@info:
@@ -17,21 +17,21 @@ function variances = nanvariance(data)
 %! @item variances
 %! A N*1 vector of real numbers
 %! @end table
-%! 
-%! @strong{This function is called by:} 
+%!
+%! @strong{This function is called by:}
 %! @ref{descriptive_statistics}.
-%! 
+%!
 %! @strong{This function calls:}
 %! @ref{ndim}, @ref{demean}, @ref{nandemean}.
-%!    
-%! @strong{Remark 1.} On exit, a new field is appended to the structure: @code{dataset_.descriptive.stdv} is a 
+%!
+%! @strong{Remark 1.} On exit, a new field is appended to the structure: @code{dataset_.descriptive.stdv} is a
 %! @tex{n\times 1} vector (where @tex{n} is the number of observed variables as defined by @code{dataset_.info.nvobs}).
-%!    
+%!
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2014 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
diff --git a/matlab/utilities/dataset/quarterly2annual.m b/matlab/utilities/dataset/quarterly2annual.m
new file mode 100644
index 000000000..6342c4605
--- /dev/null
+++ b/matlab/utilities/dataset/quarterly2annual.m
@@ -0,0 +1,135 @@
+function [ya, yass, gya, gyass] = quarterly2annual(y,yss,GYTREND0,type,islog,aux)
+% function [ya, yass, gya, gyass] = quarterly2annual(y,yss,GYTREND0,type,islog,aux)
+% transforms quarterly (log-)level time series to annual level and growth rate
+% it accounts for stock/flow/deflator series.
+%
+% INPUTS
+% y        quarterly time series
+% yss      steady state of y
+% GYTREND0 growth rate of y
+% type     1 sum (default)
+%          2 average
+%          3 last period (Q4)
+%          4 geometric average
+%          5 annual price as quantity weighted average
+%          6 annual quantity from average price
+%          7 annual nominal from Q real and deflator
+% islog    0 level (default)
+%          1 log-level
+%          2 growth rate Q frequency
+% aux      optional input used when type>4
+%
+%
+% OUTPUTS
+% ya       annual (log-)level
+% yass     annual steadystate (log-)level
+% gya      annual growth rate
+% gyass    annual growth rate steadystate
+
+% Copyright (C) 2017 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 nargin ==0
+    disp('[ya, yass, gya, gyass] = quarterly2annual(y,yss,GYTREND0,type,islog);')
+    return
+end
+
+if nargin<4 || isempty(type)
+    type=1;
+end
+if nargin<5 || isempty(islog)
+    islog=0;
+end
+if isstruct(aux)
+    yaux=aux.y;
+    yauxss=aux.yss;
+    islogaux=aux.islog;
+    GYTREND0aux=aux.GYTREND0;
+    typeaux=aux.type;
+    if islogaux
+        yaux=exp(yaux+yauxss);
+        yauxss=exp(yauxss);
+        yaux=yaux-yauxss;
+    end
+elseif type > 4
+    error('TYPE>4 requires auxiliary variable!')
+end
+if islog == 2
+    % construct loglevel out of growth rate
+    y = cumsum(y);
+    yss=0;
+    islog=1;
+end
+if islog == 1
+    y=exp(y+yss);
+    yss=exp(yss);
+    y=y-yss;
+end
+switch type
+  case 1
+    yass = yss*(exp(-GYTREND0*3)+exp(-GYTREND0*2)+exp(-GYTREND0)+1);
+    tmp = lagged(y,3)*exp(-GYTREND0*3)+lagged(y,2)*exp(-GYTREND0*2)+lagged(y,1)*exp(-GYTREND0)+y; % annualized level
+    ya = tmp(4:4:end);
+  case 2
+    yass = yss*(exp(-GYTREND0*3)+exp(-GYTREND0*2)+exp(-GYTREND0)+1)/4;
+    tmp = (lagged(y,3)*exp(-GYTREND0*3)+lagged(y,2)*exp(-GYTREND0*2)+lagged(y,1)*exp(-GYTREND0)+y)/4; % annualized level
+    ya = tmp(4:4:end);
+  case 3
+    yass=yss;
+    tmp = y;
+    ya = tmp(4:4:end);
+  case 4
+    yass = yss*(exp(-GYTREND0*3/2));
+    tmp = (lagged(y+yss,3)*exp(-GYTREND0*3).*lagged(y+yss,2)*exp(-GYTREND0*2).*lagged(y+yss,1)*exp(-GYTREND0).*(y+yss)).^(1/4); % annualized level
+    tmp = tmp - yass;
+    ya = tmp(4:4:end);
+  case 5
+    % nominal series
+    yn = (y+yss).*(yaux+yauxss) - yss.*yauxss;
+    [yna, ynass] = quarterly2annual(yn,yss.*yauxss,GYTREND0+GYTREND0aux,typeaux,0,0);
+    % real series
+    [yra, yrass] = quarterly2annual(yaux,yauxss,GYTREND0aux,typeaux,0,0);
+    % deflator
+    yass = ynass/yrass;
+    ya = (yna+ynass)./(yr+yrass)-yass;
+  case 6
+    % nominal series
+    yn = (y+yss).*(yaux+yauxss) - yss.*yauxss;
+    [yna, ynass] = quarterly2annual(yn,yss.*yauxss,GYTREND0+GYTREND0aux,typeaux,0,0);
+    % deflator
+    [pa, pass] = quarterly2annual(yaux,yauxss,GYTREND0aux,2,0,0);
+    % real series
+    yass = ynass/pass;
+    ya = (yna+ynass)./(pa+pass)-yass;
+  case 7
+    % nominal series
+    yn = (y+yss).*(yaux+yauxss) - yss.*yauxss;
+    [ya, yass] = quarterly2annual(yn,yss.*yauxss,GYTREND0+GYTREND0aux,typeaux,0,0);
+    GYTREND0=GYTREND0+GYTREND0aux;
+  otherwise
+    error('Wrong type input')
+end
+
+% annual growth rate
+gyass = GYTREND0*4;
+gya = (ya+yass)./(lagged(ya,1)+yass).*exp(4*GYTREND0)-1-gyass;
+
+if islog
+    ya=log(ya+yass);
+    yass=log(yass);
+    ya=ya-yass;
+end
diff --git a/matlab/utilities/doc/dynInfo.m b/matlab/utilities/doc/dynInfo.m
index 952c5bbe1..85c964974 100644
--- a/matlab/utilities/doc/dynInfo.m
+++ b/matlab/utilities/doc/dynInfo.m
@@ -31,7 +31,7 @@ function dynInfo(fun)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2013 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/doc/get_internal_doc_block.m b/matlab/utilities/doc/get_internal_doc_block.m
index 718b2a28d..96dda6d6f 100644
--- a/matlab/utilities/doc/get_internal_doc_block.m
+++ b/matlab/utilities/doc/get_internal_doc_block.m
@@ -1,8 +1,8 @@
 function block = get_internal_doc_block(fname,fpath)
 % Extract doc sections from matlab's routine.
- 
-% Copyright (C) 2011-2012 Dynare Team
-%    
+
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
@@ -22,7 +22,7 @@ function block = get_internal_doc_block(fname,fpath)
 
 % Default output
 block = [];
-    
+
 % Open the matlab file.
 mid = fopen([fpath '/' fname '.m'],'r');
 
@@ -43,14 +43,14 @@ if ( isempty(b1) && isempty(b2) && isempty(b) )
     return
 else
     if ( (~isempty(b1) && isempty(b2) && isempty(b)) || ...
-            (isempty(b1) && ~isempty(b2) && isempty(b)) || ...
-            (isempty(b1) && isempty(b2) && ~isempty(b)) || ...
-            (isempty(b1) && ~isempty(b2) && ~isempty(b)) || ...
-            (~isempty(b1) && isempty(b2) && ~isempty(b)) || ...
-            (~isempty(b1) && ~isempty(b2) && isempty(b)) )
+         (isempty(b1) && ~isempty(b2) && isempty(b)) || ...
+         (isempty(b1) && isempty(b2) && ~isempty(b)) || ...
+         (isempty(b1) && ~isempty(b2) && ~isempty(b)) || ...
+         (~isempty(b1) && isempty(b2) && ~isempty(b)) || ...
+         (~isempty(b1) && ~isempty(b2) && isempty(b)) )
         error('get_internal_doc_block:: There is a problem with the internal block definition!')
     end
-    if ( b2~=b(end) || b1~=b(1) || any(b-transpose(b1:1:b2)) ) 
+    if ( b2~=b(end) || b1~=b(1) || any(b-transpose(b1:1:b2)) )
         error('get_internal_doc_block:: There is a problem with the internal block definition!')
     end
 end
diff --git a/matlab/utilities/general/clean_current_folder.m b/matlab/utilities/general/clean_current_folder.m
index e3408bec1..6c302927e 100644
--- a/matlab/utilities/general/clean_current_folder.m
+++ b/matlab/utilities/general/clean_current_folder.m
@@ -1,6 +1,6 @@
-function clean()
+function clean_current_folder()
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/compare_vectors.m b/matlab/utilities/general/compare_vectors.m
index 97e916c75..00ea0c11e 100644
--- a/matlab/utilities/general/compare_vectors.m
+++ b/matlab/utilities/general/compare_vectors.m
@@ -1,5 +1,5 @@
 function C = compare_vectors(f, A, B)  % --*-- Unitary tests --*--
- 
+
 % Performs lexicographical comparison of vectors.
 %
 % INPUTS
@@ -7,13 +7,13 @@ function C = compare_vectors(f, A, B)  % --*-- Unitary tests --*--
 %  o A    vector of real numbers.
 %  o B    vector of real numbers.
 %
-% OUTPUTS 
+% OUTPUTS
 %  o C    integer scalar, 1 or 0.
 %
-% REMARKS 
+% REMARKS
 %  o It is assumed that vectors A and B have the same number of elements.
-    
-% Copyright (C) 2013 Dynare Team
+
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/delete_stale_file.m b/matlab/utilities/general/delete_stale_file.m
index 8ac8b7996..d5e9951e4 100644
--- a/matlab/utilities/general/delete_stale_file.m
+++ b/matlab/utilities/general/delete_stale_file.m
@@ -2,7 +2,7 @@ function delete_stale_file(fname)
 % function delete_old_files(fname)
 % Checks for presence of files and deletes them if necessary
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -23,4 +23,3 @@ Files_info = dir(fname);
 if length(Files_info)>0
     delete(fname)
 end
-
diff --git a/matlab/utilities/general/demean.m b/matlab/utilities/general/demean.m
index 4bf53aaa6..741a2f107 100644
--- a/matlab/utilities/general/demean.m
+++ b/matlab/utilities/general/demean.m
@@ -1,6 +1,6 @@
 function c = demean(x)
 % Removes the mean of each column of a matrix.
- 
+
 %@info:
 %! @deftypefn {Function File} {@var{c} =} demean (@var{x})
 %! @anchor{demean}
@@ -17,18 +17,18 @@ function c = demean(x)
 %! @item c
 %! Matlab matrix (T-by-N). The demeaned x matrix.
 %! @end table
-%! 
-%! @strong{This function is called by:} 
+%!
+%! @strong{This function is called by:}
 %! @ref{compute_cova}, @ref{compute_acov}, @ref{compute_std}.
-%! 
-%! @strong{This function calls:} 
+%!
+%! @strong{This function calls:}
 %! @ref{ndim},
-%!    
+%!
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
@@ -45,7 +45,7 @@ function c = demean(x)
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 % Original author: stephane DOT adjemian AT univ DASH lemans DOT fr
-   
+
 if ndim(x)==1
     c = x-mean(x);
 elseif ndim(x)==2
diff --git a/matlab/utilities/general/disp_verbose.m b/matlab/utilities/general/disp_verbose.m
index 09c09e4d7..6ea4e702e 100644
--- a/matlab/utilities/general/disp_verbose.m
+++ b/matlab/utilities/general/disp_verbose.m
@@ -1,8 +1,8 @@
 function disp_verbose(input_string,Verbose)
 % function disp_verbose(input_string,Verbose)
 % Prints input_string unless Verbose=0 is requested
-% 
-% Copyright (C) 2015 Dynare Team
+%
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/dyn_mex.m b/matlab/utilities/general/dyn_mex.m
index 7892ee9be..ec682aebb 100644
--- a/matlab/utilities/general/dyn_mex.m
+++ b/matlab/utilities/general/dyn_mex.m
@@ -1,21 +1,21 @@
 function dyn_mex(win_compiler,basename,force)
 
 % Compile Dynare model dlls when model option use_dll is used
-% if C file is fresher than mex file 
+% if C file is fresher than mex file
 %
 % INPUTS
-%  o win_compiler  str  compiler used under Windows (unused under Linux or OSX): 
+%  o win_compiler  str  compiler used under Windows (unused under Linux or OSX):
 %                       'msvc' (MS Visual C)
 %                        'cygwin'
 %  o basename      str  filenames base
-%  o force         bool recompile if 1 
-%  
-% OUTPUTS 
+%  o force         bool recompile if 1
+%
+% OUTPUTS
 %  none
 %
 
-    
-% Copyright (C) 2015-2016 Dynare Team
+
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -47,26 +47,26 @@ end
 if ~exist('OCTAVE_VERSION')
     % Some mex commands are enclosed in an eval(), because otherwise it will make Octave fail
     if ispc
-      if strcmp(win_compiler,'msvc')
-          % MATLAB/Windows + Microsoft Visual C++
-          % Add /TP flag as fix for #1227
-          eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Dynamic" COMPFLAGS="/TP" ' basename '_dynamic.c ' basename '_dynamic_mex.c'])
-          eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Static" COMPFLAGS="/TP" ' basename '_static.c ' basename '_static_mex.c'])
-      elseif strcmp(win_compiler,'mingw')
-          eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Dynamic" ' basename '_dynamic.c ' basename '_dynamic_mex.c'])
-          eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Static"  ' basename '_static.c ' basename '_static_mex.c'])
-      elseif strcmp(win_compiler,'cygwin') %legacy support for Cygwin with mexopts.bat
-          % MATLAB/Windows + Cygwin g++
-          eval(['mex -O PRELINK_CMDS1="echo EXPORTS > mex.def & echo ' ...
-                'mexFunction >> mex.def & echo Dynamic >> mex.def" ' ...
-                basename '_dynamic.c ' basename '_dynamic_mex.c'])
-          eval(['mex -O PRELINK_CMDS1="echo EXPORTS > mex.def & echo ' ...
-                'mexFunction >> mex.def & echo Dynamic >> mex.def" ' ...
-                basename '_static.c ' basename '_static_mex.c'])
-      else
-        error(['When using the USE_DLL option, you must give either ' ...
-               '''cygwin'', ''mingw'' or ''msvc'' option to the ''dynare'' command'])
-      end
+        if strcmp(win_compiler,'msvc')
+            % MATLAB/Windows + Microsoft Visual C++
+            % Add /TP flag as fix for #1227
+            eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Dynamic" COMPFLAGS="/TP" ' basename '_dynamic.c ' basename '_dynamic_mex.c'])
+            eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Static" COMPFLAGS="/TP" ' basename '_static.c ' basename '_static_mex.c'])
+        elseif strcmp(win_compiler,'mingw')
+            eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Dynamic" ' basename '_dynamic.c ' basename '_dynamic_mex.c'])
+            eval(['mex -O LINKFLAGS="$LINKFLAGS /export:Static"  ' basename '_static.c ' basename '_static_mex.c'])
+        elseif strcmp(win_compiler,'cygwin') %legacy support for Cygwin with mexopts.bat
+                                             % MATLAB/Windows + Cygwin g++
+            eval(['mex -O PRELINK_CMDS1="echo EXPORTS > mex.def & echo ' ...
+                  'mexFunction >> mex.def & echo Dynamic >> mex.def" ' ...
+                  basename '_dynamic.c ' basename '_dynamic_mex.c'])
+            eval(['mex -O PRELINK_CMDS1="echo EXPORTS > mex.def & echo ' ...
+                  'mexFunction >> mex.def & echo Dynamic >> mex.def" ' ...
+                  basename '_static.c ' basename '_static_mex.c'])
+        else
+            error(['When using the USE_DLL option, you must give either ' ...
+                   '''cygwin'', ''mingw'' or ''msvc'' option to the ''dynare'' command'])
+        end
     elseif isunix && ~ismac
         % MATLAB/Linux
         if matlab_ver_less_than('8.3')
diff --git a/matlab/utilities/general/get_all_variables_but_lagged_leaded_exogenous.m b/matlab/utilities/general/get_all_variables_but_lagged_leaded_exogenous.m
index 37697e723..1e092e0ac 100644
--- a/matlab/utilities/general/get_all_variables_but_lagged_leaded_exogenous.m
+++ b/matlab/utilities/general/get_all_variables_but_lagged_leaded_exogenous.m
@@ -9,8 +9,8 @@ function k = get_all_variables_but_lagged_leaded_exogenous(M)
 % k: vector of variable indices
 %
 
-% Copyright (C) 2011-2016 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
@@ -31,5 +31,5 @@ if isempty(M.aux_vars)
 else
     type = [M.aux_vars.type];
     k = [1:M.orig_endo_nbr, M.orig_endo_nbr ...
-         + find((type ~= 2) & (type ~= 3))]; 
+         + find((type ~= 2) & (type ~= 3))];
 end
\ No newline at end of file
diff --git a/matlab/utilities/general/indices_lagged_leaded_exogenous_variables.m b/matlab/utilities/general/indices_lagged_leaded_exogenous_variables.m
index 6b3f0b416..a199b4b0f 100644
--- a/matlab/utilities/general/indices_lagged_leaded_exogenous_variables.m
+++ b/matlab/utilities/general/indices_lagged_leaded_exogenous_variables.m
@@ -12,8 +12,8 @@ function [il,l1,ik,k1] = indices_lagged_leaded_exogenous_variables(k,M)
 % ik: indices of non lagged or leaded variable in vector k
 % k1: value of non lagged or leaded variable in vector k
 
-% Copyright (C) 2011-2016 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
diff --git a/matlab/utilities/general/isaletter.m b/matlab/utilities/general/isaletter.m
index 054ced91d..f562a320a 100644
--- a/matlab/utilities/general/isaletter.m
+++ b/matlab/utilities/general/isaletter.m
@@ -1,7 +1,7 @@
 function info = isaletter(str)
 % Returns 1 if the string str has at least one letter, 0 otherwise.
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/isconst.m b/matlab/utilities/general/isconst.m
index 37ee23532..28001ce4e 100644
--- a/matlab/utilities/general/isconst.m
+++ b/matlab/utilities/general/isconst.m
@@ -1,6 +1,6 @@
 function aa = isconst(y)
 % Returns 1 if vector y is constant, 0 otherwise.
-%  
+%
 % INPUTS:
 %   yy        [double]    n*1 vector.
 %
@@ -10,7 +10,7 @@ function aa = isconst(y)
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2008-2009 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/isdiagonal.m b/matlab/utilities/general/isdiagonal.m
index f76e43797..a8c1a4cf8 100644
--- a/matlab/utilities/general/isdiagonal.m
+++ b/matlab/utilities/general/isdiagonal.m
@@ -1,6 +1,6 @@
 function b = isdiagonal(A) % --*-- Unitary tests --*--
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2014-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -60,5 +60,3 @@ end
 %$ t = isdiagonal(A);
 %$ T = all(t);
 %@eof:5
-
-
diff --git a/matlab/utilities/general/isestimation.m b/matlab/utilities/general/isestimation.m
index f86ffb32c..9e17d4b03 100644
--- a/matlab/utilities/general/isestimation.m
+++ b/matlab/utilities/general/isestimation.m
@@ -1,8 +1,8 @@
-function a = isestimation()
+function b = isestimation(option)
 
-% Returns 1 if we are currently estimating a model, 0 otherwise.
+% Returns true if we are currently estimating a model.
 
-% Copyright (C) 2014 Dynare Team
+% Copyright (C) 2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -19,14 +19,8 @@ function a = isestimation()
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-a = 0;
+b = false;
 
-tmp = struct2cell(dbstack);
-list_of_previously_called_routines = transpose(tmp(2,:));
-
-if ~isempty(strmatch('dsge_likelihood', list_of_previously_called_routines, 'exact')) || ...
-    ~isempty(strmatch('dsge_var_likelihood', list_of_previously_called_routines, 'exact')) || ...
-    ~isempty(strmatch('non_linear_dsge_likelihood', list_of_previously_called_routines, 'exact')) || ...
-    ~isempty(strmatch('simulated_moments_estimation', list_of_previously_called_routines, 'exact'))
-    a = 1;
+if ischar(option.mode_compute) || option.mode_compute || option.mh_replic
+    b = true;
 end
\ No newline at end of file
diff --git a/matlab/utilities/general/isinestimationobjective.m b/matlab/utilities/general/isinestimationobjective.m
new file mode 100644
index 000000000..023e4cb14
--- /dev/null
+++ b/matlab/utilities/general/isinestimationobjective.m
@@ -0,0 +1,32 @@
+function b = isinestimationobjective()
+
+% Returns true iff the caller function is called by a routine defining the objective of an estimation algorithm.
+
+% Copyright (C) 2014-2017 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/>.
+
+b = false;
+
+tmp = struct2cell(dbstack);
+list_of_previously_called_routines = transpose(tmp(2,:));
+
+if ~isempty(strmatch('dsge_likelihood', list_of_previously_called_routines, 'exact')) || ...
+        ~isempty(strmatch('dsge_var_likelihood', list_of_previously_called_routines, 'exact')) || ...
+        ~isempty(strmatch('non_linear_dsge_likelihood', list_of_previously_called_routines, 'exact')) || ...
+        ~isempty(strmatch('simulated_moments_estimation', list_of_previously_called_routines, 'exact'))
+    b = true;
+end
diff --git a/matlab/utilities/general/isint.m b/matlab/utilities/general/isint.m
index 9f59a5e91..c40ef792e 100644
--- a/matlab/utilities/general/isint.m
+++ b/matlab/utilities/general/isint.m
@@ -1,21 +1,21 @@
 function [b,c,d] = isint(a)
 %  This function tests if the input argument is an integer.
 %
-%  INPUT 
+%  INPUT
 %    a    [double]   m*n matrix.
 %
-%  OUTPUT 
-%    b    [integer]  m*n matrix of 0 and 1. b(i,j)=1 if a(i,j) is an integer.    
+%  OUTPUT
+%    b    [integer]  m*n matrix of 0 and 1. b(i,j)=1 if a(i,j) is an integer.
 %    c    [integer]  p*1 vector of indices pointing to the integer elements of a.
 %    d    [integer]  q*1 vector of indices pointing to the non integer elements of a.
-%    
+%
 %  SPECIAL REQUIREMENTS
 %    None.
-%    
-%  NOTES 
+%
+%  NOTES
 %    p+q is equal to the product of m by n.
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/ispd.m b/matlab/utilities/general/ispd.m
index e319a47a1..7ddd73e8a 100644
--- a/matlab/utilities/general/ispd.m
+++ b/matlab/utilities/general/ispd.m
@@ -24,7 +24,7 @@ function [test, penalty] = ispd(A)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2007-2009, 2013 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -44,7 +44,7 @@ function [test, penalty] = ispd(A)
 if ~isquare(A)
     error(['ispd:: Input argument ' inputname(1) ' has to be a square matrix!'])
 end
-    
+
 [cholA, info] = chol(A);
 test = ~info;
 
diff --git a/matlab/utilities/general/isquare.m b/matlab/utilities/general/isquare.m
index da47ac62e..693417c35 100644
--- a/matlab/utilities/general/isquare.m
+++ b/matlab/utilities/general/isquare.m
@@ -22,7 +22,7 @@ function info = isquare(A)
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/utilities/general/log_variable.m b/matlab/utilities/general/log_variable.m
index 74a6aa126..98956a77c 100644
--- a/matlab/utilities/general/log_variable.m
+++ b/matlab/utilities/general/log_variable.m
@@ -12,8 +12,8 @@ function y = log_variable(ivar,x,M)
 %       for lagged/leaded exogenous variables
 %
 
-% Copyright (C) 2011-2016 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
diff --git a/matlab/utilities/general/ndim.m b/matlab/utilities/general/ndim.m
index 1c4d003bb..95dda019d 100644
--- a/matlab/utilities/general/ndim.m
+++ b/matlab/utilities/general/ndim.m
@@ -3,7 +3,7 @@ function n = ndim(x)
 
 %@info:
 %! @deftypefn {Function File} {@var{n} =} ndim (@var{x})
-%! @anchor{ndim}    
+%! @anchor{ndim}
 %! This function reports the number of non singleton dimensions of a matlab array.
 %!
 %! @strong{Inputs}
@@ -17,18 +17,18 @@ function n = ndim(x)
 %! @item n
 %! Integer scalar. The number of non singleton dimensions of a matlab array.
 %! @end table
-%!    
-%! @strong{This function is called by:} 
+%!
+%! @strong{This function is called by:}
 %! @ref{demean}, @ref{nandemean}.
-%!    
+%!
 %! @strong{This function calls:}
 %! none.
-%!    
+%!
 %! @end deftypefn
 %@eod:
 
-% Copyright (C) 2011-2012 Dynare Team
-%    
+% Copyright (C) 2011-2017 Dynare Team
+%
 % This file is part of Dynare.
 %
 % Dynare is free software: you can redistribute it and/or modify
diff --git a/matlab/utilities/general/remove_fractional_xticks.m b/matlab/utilities/general/remove_fractional_xticks.m
index 19eab7a04..5cf6f33fd 100644
--- a/matlab/utilities/general/remove_fractional_xticks.m
+++ b/matlab/utilities/general/remove_fractional_xticks.m
@@ -2,7 +2,7 @@ function remove_fractional_xticks
 % function remove_fractional_xticks
 % removes non-integer xtick-labels
 
-% Copyright (C) 2001-2016 Dynare Team
+% Copyright (C) 2001-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -17,7 +17,7 @@ function remove_fractional_xticks
 % 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/>.    
+% along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 xticks=get(gca,'xtick');
 fractional_periods=find(rem(xticks,1)~=0);
diff --git a/matlab/utilities/graphics/colorspace.m b/matlab/utilities/graphics/colorspace.m
new file mode 100644
index 000000000..a83aee2ff
--- /dev/null
+++ b/matlab/utilities/graphics/colorspace.m
@@ -0,0 +1,508 @@
+function varargout = colorspace(Conversion,varargin)
+%COLORSPACE  Transform a color image between color representations.
+%   B = COLORSPACE(S,A) transforms the color representation of image A
+%   where S is a string specifying the conversion.  The input array A
+%   should be a real full double array of size Mx3 or MxNx3.  The output B
+%   is the same size as A.
+%
+%   S tells the source and destination color spaces, S = 'dest<-src', or
+%   alternatively, S = 'src->dest'.  Supported color spaces are
+%
+%     'RGB'              sRGB IEC 61966-2-1
+%     'YCbCr'            Luma + Chroma ("digitized" version of Y'PbPr)
+%     'JPEG-YCbCr'       Luma + Chroma space used in JFIF JPEG
+%     'YDbDr'            SECAM Y'DbDr Luma + Chroma
+%     'YPbPr'            Luma (ITU-R BT.601) + Chroma
+%     'YUV'              NTSC PAL Y'UV Luma + Chroma
+%     'YIQ'              NTSC Y'IQ Luma + Chroma
+%     'HSV' or 'HSB'     Hue Saturation Value/Brightness
+%     'HSL' or 'HLS'     Hue Saturation Luminance
+%     'HSI'              Hue Saturation Intensity
+%     'XYZ'              CIE 1931 XYZ
+%     'Lab'              CIE 1976 L*a*b* (CIELAB)
+%     'Luv'              CIE L*u*v* (CIELUV)
+%     'LCH'              CIE L*C*H* (CIELCH)
+%     'CAT02 LMS'        CIE CAT02 LMS
+%
+%  All conversions assume 2 degree observer and D65 illuminant.
+%
+%  Color space names are case insensitive and spaces are ignored.  When
+%  sRGB is the source or destination, it can be omitted. For example
+%  'yuv<-' is short for 'yuv<-rgb'.
+%
+%  For sRGB, the values should be scaled between 0 and 1.  Beware that
+%  transformations generally do not constrain colors to be "in gamut."
+%  Particularly, transforming from another space to sRGB may obtain
+%  R'G'B' values outside of the [0,1] range.  So the result should be
+%  clamped to [0,1] before displaying:
+%     image(min(max(B,0),1));  % Clamp B to [0,1] and display
+%
+%  sRGB (Red Green Blue) is the (ITU-R BT.709 gamma-corrected) standard
+%  red-green-blue representation of colors used in digital imaging.  The
+%  components should be scaled between 0 and 1.  The space can be
+%  visualized geometrically as a cube.
+%
+%  Y'PbPr, Y'CbCr, Y'DbDr, Y'UV, and Y'IQ are related to sRGB by linear
+%  transformations.  These spaces separate a color into a grayscale
+%  luminance component Y and two chroma components.  The valid ranges of
+%  the components depends on the space.
+%
+%  HSV (Hue Saturation Value) is related to sRGB by
+%     H = hexagonal hue angle   (0 <= H < 360),
+%     S = C/V                   (0 <= S <= 1),
+%     V = max(R',G',B')         (0 <= V <= 1),
+%  where C = max(R',G',B') - min(R',G',B').  The hue angle H is computed on
+%  a hexagon.  The space is geometrically a hexagonal cone.
+%
+%  HSL (Hue Saturation Lightness) is related to sRGB by
+%     H = hexagonal hue angle                (0 <= H < 360),
+%     S = C/(1 - |2L-1|)                     (0 <= S <= 1),
+%     L = (max(R',G',B') + min(R',G',B'))/2  (0 <= L <= 1),
+%  where H and C are the same as in HSV.  Geometrically, the space is a
+%  double hexagonal cone.
+%
+%  HSI (Hue Saturation Intensity) is related to sRGB by
+%     H = polar hue angle        (0 <= H < 360),
+%     S = 1 - min(R',G',B')/I    (0 <= S <= 1),
+%     I = (R'+G'+B')/3           (0 <= I <= 1).
+%  Unlike HSV and HSL, the hue angle H is computed on a circle rather than
+%  a hexagon.
+%
+%  CIE XYZ is related to sRGB by inverse gamma correction followed by a
+%  linear transform.  Other CIE color spaces are defined relative to XYZ.
+%
+%  CIE L*a*b*, L*u*v*, and L*C*H* are nonlinear functions of XYZ.  The L*
+%  component is designed to match closely with human perception of
+%  lightness.  The other two components describe the chroma.
+%
+%  CIE CAT02 LMS is the linear transformation of XYZ using the MCAT02
+%  chromatic adaptation matrix.  The space is designed to model the
+%  response of the three types of cones in the human eye, where L, M, S,
+%  correspond respectively to red ("long"), green ("medium"), and blue
+%  ("short").
+
+% Copyright (C) 2005-2010 Pascal Getreuer
+% Copyright (C) 2017 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/>.
+
+%%% Input parsing %%%
+if nargin < 2, error('Not enough input arguments.'); end
+[SrcSpace,DestSpace] = parse(Conversion);
+
+if nargin == 2
+    Image = varargin{1};
+elseif nargin >= 3
+    Image = cat(3,varargin{:});
+else
+    error('Invalid number of input arguments.');
+end
+
+FlipDims = (size(Image,3) == 1);
+
+if FlipDims, Image = permute(Image,[1,3,2]); end
+if ~isa(Image,'double'), Image = double(Image)/255; end
+if size(Image,3) ~= 3, error('Invalid input size.'); end
+
+SrcT = gettransform(SrcSpace);
+DestT = gettransform(DestSpace);
+
+if ~ischar(SrcT) && ~ischar(DestT)
+    % Both source and destination transforms are affine, so they
+    % can be composed into one affine operation
+    T = [DestT(:,1:3)*SrcT(:,1:3),DestT(:,1:3)*SrcT(:,4)+DestT(:,4)];
+    Temp = zeros(size(Image));
+    Temp(:,:,1) = T(1)*Image(:,:,1) + T(4)*Image(:,:,2) + T(7)*Image(:,:,3) + T(10);
+    Temp(:,:,2) = T(2)*Image(:,:,1) + T(5)*Image(:,:,2) + T(8)*Image(:,:,3) + T(11);
+    Temp(:,:,3) = T(3)*Image(:,:,1) + T(6)*Image(:,:,2) + T(9)*Image(:,:,3) + T(12);
+    Image = Temp;
+elseif ~ischar(DestT)
+    Image = rgb(Image,SrcSpace);
+    Temp = zeros(size(Image));
+    Temp(:,:,1) = DestT(1)*Image(:,:,1) + DestT(4)*Image(:,:,2) + DestT(7)*Image(:,:,3) + DestT(10);
+    Temp(:,:,2) = DestT(2)*Image(:,:,1) + DestT(5)*Image(:,:,2) + DestT(8)*Image(:,:,3) + DestT(11);
+    Temp(:,:,3) = DestT(3)*Image(:,:,1) + DestT(6)*Image(:,:,2) + DestT(9)*Image(:,:,3) + DestT(12);
+    Image = Temp;
+else
+    Image = feval(DestT,Image,SrcSpace);
+end
+
+%%% Output format %%%
+if nargout > 1
+    varargout = {Image(:,:,1),Image(:,:,2),Image(:,:,3)};
+else
+    if FlipDims, Image = permute(Image,[1,3,2]); end
+    varargout = {Image};
+end
+
+return
+
+
+function [SrcSpace,DestSpace] = parse(Str)
+% Parse conversion argument
+
+if ischar(Str)
+    Str = lower(strrep(strrep(Str,'-',''),'=',''));
+    k = find(Str == '>');
+
+    if length(k) == 1         % Interpret the form 'src->dest'
+        SrcSpace = Str(1:k-1);
+        DestSpace = Str(k+1:end);
+    else
+        k = find(Str == '<');
+
+        if length(k) == 1      % Interpret the form 'dest<-src'
+            DestSpace = Str(1:k-1);
+            SrcSpace = Str(k+1:end);
+        else
+            error(['Invalid conversion, ''',Str,'''.']);
+        end
+    end
+
+    SrcSpace = alias(SrcSpace);
+    DestSpace = alias(DestSpace);
+else
+    SrcSpace = 1;             % No source pre-transform
+    DestSpace = Conversion;
+    if any(size(Conversion) ~= 3), error('Transformation matrix must be 3x3.'); end
+end
+return
+
+
+function Space = alias(Space)
+Space = strrep(strrep(Space,'cie',''),' ','');
+
+if isempty(Space)
+    Space = 'rgb';
+end
+
+switch Space
+  case {'ycbcr','ycc'}
+    Space = 'ycbcr';
+  case {'hsv','hsb'}
+    Space = 'hsv';
+  case {'hsl','hsi','hls'}
+    Space = 'hsl';
+  case {'rgb','yuv','yiq','ydbdr','ycbcr','jpegycbcr','xyz','lab','luv','lch'}
+    return
+end
+return
+
+
+function T = gettransform(Space)
+% Get a colorspace transform: either a matrix describing an affine transform,
+% or a string referring to a conversion subroutine
+switch Space
+  case 'ypbpr'
+    T = [0.299,0.587,0.114,0;-0.1687367,-0.331264,0.5,0;0.5,-0.418688,-0.081312,0];
+  case 'yuv'
+    % sRGB to NTSC/PAL YUV
+    % Wikipedia: http://en.wikipedia.org/wiki/YUV
+    T = [0.299,0.587,0.114,0;-0.147,-0.289,0.436,0;0.615,-0.515,-0.100,0];
+  case 'ydbdr'
+    % sRGB to SECAM YDbDr
+    % Wikipedia: http://en.wikipedia.org/wiki/YDbDr
+    T = [0.299,0.587,0.114,0;-0.450,-0.883,1.333,0;-1.333,1.116,0.217,0];
+  case 'yiq'
+    % sRGB in [0,1] to NTSC YIQ in [0,1];[-0.595716,0.595716];[-0.522591,0.522591];
+    % Wikipedia: http://en.wikipedia.org/wiki/YIQ
+    T = [0.299,0.587,0.114,0;0.595716,-0.274453,-0.321263,0;0.211456,-0.522591,0.311135,0];
+  case 'ycbcr'
+    % sRGB (range [0,1]) to ITU-R BRT.601 (CCIR 601) Y'CbCr
+    % Wikipedia: http://en.wikipedia.org/wiki/YCbCr
+    % Poynton, Equation 3, scaling of R'G'B to Y'PbPr conversion
+    T = [65.481,128.553,24.966,16;-37.797,-74.203,112.0,128;112.0,-93.786,-18.214,128];
+  case 'jpegycbcr'
+    % Wikipedia: http://en.wikipedia.org/wiki/YCbCr
+    T = [0.299,0.587,0.114,0;-0.168736,-0.331264,0.5,0.5;0.5,-0.418688,-0.081312,0.5]*255;
+  case {'rgb','xyz','hsv','hsl','lab','luv','lch','cat02lms'}
+    T = Space;
+  otherwise
+    error(['Unknown color space, ''',Space,'''.']);
+end
+return
+
+
+function Image = rgb(Image,SrcSpace)
+% Convert to sRGB from 'SrcSpace'
+switch SrcSpace
+  case 'rgb'
+    return
+  case 'hsv'
+    % Convert HSV to sRGB
+    Image = huetorgb((1 - Image(:,:,2)).*Image(:,:,3),Image(:,:,3),Image(:,:,1));
+  case 'hsl'
+    % Convert HSL to sRGB
+    L = Image(:,:,3);
+    Delta = Image(:,:,2).*min(L,1-L);
+    Image = huetorgb(L-Delta,L+Delta,Image(:,:,1));
+  case {'xyz','lab','luv','lch','cat02lms'}
+    % Convert to CIE XYZ
+    Image = xyz(Image,SrcSpace);
+    % Convert XYZ to RGB
+    T = [3.2406, -1.5372, -0.4986; -0.9689, 1.8758, 0.0415; 0.0557, -0.2040, 1.057];
+    R = T(1)*Image(:,:,1) + T(4)*Image(:,:,2) + T(7)*Image(:,:,3);  % R
+    G = T(2)*Image(:,:,1) + T(5)*Image(:,:,2) + T(8)*Image(:,:,3);  % G
+    B = T(3)*Image(:,:,1) + T(6)*Image(:,:,2) + T(9)*Image(:,:,3);  % B
+                                                                    % Desaturate and rescale to constrain resulting RGB values to [0,1]
+    AddWhite = -min(min(min(R,G),B),0);
+    R = R + AddWhite;
+    G = G + AddWhite;
+    B = B + AddWhite;
+    % Apply gamma correction to convert linear RGB to sRGB
+    Image(:,:,1) = gammacorrection(R);  % R'
+    Image(:,:,2) = gammacorrection(G);  % G'
+    Image(:,:,3) = gammacorrection(B);  % B'
+  otherwise  % Conversion is through an affine transform
+    T = gettransform(SrcSpace);
+    temp = inv(T(:,1:3));
+    T = [temp,-temp*T(:,4)];
+    R = T(1)*Image(:,:,1) + T(4)*Image(:,:,2) + T(7)*Image(:,:,3) + T(10);
+    G = T(2)*Image(:,:,1) + T(5)*Image(:,:,2) + T(8)*Image(:,:,3) + T(11);
+    B = T(3)*Image(:,:,1) + T(6)*Image(:,:,2) + T(9)*Image(:,:,3) + T(12);
+    Image(:,:,1) = R;
+    Image(:,:,2) = G;
+    Image(:,:,3) = B;
+end
+
+% Clip to [0,1]
+Image = min(max(Image,0),1);
+return
+
+
+function Image = xyz(Image,SrcSpace)
+% Convert to CIE XYZ from 'SrcSpace'
+WhitePoint = [0.950456,1,1.088754];
+
+switch SrcSpace
+  case 'xyz'
+    return
+  case 'luv'
+    % Convert CIE L*uv to XYZ
+    WhitePointU = (4*WhitePoint(1))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
+    WhitePointV = (9*WhitePoint(2))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
+    L = Image(:,:,1);
+    Y = (L + 16)/116;
+    Y = invf(Y)*WhitePoint(2);
+    U = Image(:,:,2)./(13*L + 1e-6*(L==0)) + WhitePointU;
+    V = Image(:,:,3)./(13*L + 1e-6*(L==0)) + WhitePointV;
+    Image(:,:,1) = -(9*Y.*U)./((U-4).*V - U.*V);                  % X
+    Image(:,:,2) = Y;                                             % Y
+    Image(:,:,3) = (9*Y - (15*V.*Y) - (V.*Image(:,:,1)))./(3*V);  % Z
+  case {'lab','lch'}
+    Image = lab(Image,SrcSpace);
+    % Convert CIE L*ab to XYZ
+    fY = (Image(:,:,1) + 16)/116;
+    fX = fY + Image(:,:,2)/500;
+    fZ = fY - Image(:,:,3)/200;
+    Image(:,:,1) = WhitePoint(1)*invf(fX);  % X
+    Image(:,:,2) = WhitePoint(2)*invf(fY);  % Y
+    Image(:,:,3) = WhitePoint(3)*invf(fZ);  % Z
+  case 'cat02lms'
+    % Convert CAT02 LMS to XYZ
+    T = inv([0.7328, 0.4296, -0.1624;-0.7036, 1.6975, 0.0061; 0.0030, 0.0136, 0.9834]);
+    L = Image(:,:,1);
+    M = Image(:,:,2);
+    S = Image(:,:,3);
+    Image(:,:,1) = T(1)*L + T(4)*M + T(7)*S;  % X
+    Image(:,:,2) = T(2)*L + T(5)*M + T(8)*S;  % Y
+    Image(:,:,3) = T(3)*L + T(6)*M + T(9)*S;  % Z
+  otherwise   % Convert from some gamma-corrected space
+              % Convert to sRGB
+    Image = rgb(Image,SrcSpace);
+    % Undo gamma correction
+    R = invgammacorrection(Image(:,:,1));
+    G = invgammacorrection(Image(:,:,2));
+    B = invgammacorrection(Image(:,:,3));
+    % Convert RGB to XYZ
+    T = inv([3.2406, -1.5372, -0.4986; -0.9689, 1.8758, 0.0415; 0.0557, -0.2040, 1.057]);
+    Image(:,:,1) = T(1)*R + T(4)*G + T(7)*B;  % X
+    Image(:,:,2) = T(2)*R + T(5)*G + T(8)*B;  % Y
+    Image(:,:,3) = T(3)*R + T(6)*G + T(9)*B;  % Z
+end
+return
+
+
+function Image = hsv(Image,SrcSpace)
+% Convert to HSV
+Image = rgb(Image,SrcSpace);
+V = max(Image,[],3);
+S = (V - min(Image,[],3))./(V + (V == 0));
+Image(:,:,1) = rgbtohue(Image);
+Image(:,:,2) = S;
+Image(:,:,3) = V;
+return
+
+
+function Image = hsl(Image,SrcSpace)
+% Convert to HSL
+switch SrcSpace
+  case 'hsv'
+    % Convert HSV to HSL
+    MaxVal = Image(:,:,3);
+    MinVal = (1 - Image(:,:,2)).*MaxVal;
+    L = 0.5*(MaxVal + MinVal);
+    temp = min(L,1-L);
+    Image(:,:,2) = 0.5*(MaxVal - MinVal)./(temp + (temp == 0));
+    Image(:,:,3) = L;
+  otherwise
+    Image = rgb(Image,SrcSpace);  % Convert to sRGB
+                                  % Convert sRGB to HSL
+    MinVal = min(Image,[],3);
+    MaxVal = max(Image,[],3);
+    L = 0.5*(MaxVal + MinVal);
+    temp = min(L,1-L);
+    S = 0.5*(MaxVal - MinVal)./(temp + (temp == 0));
+    Image(:,:,1) = rgbtohue(Image);
+    Image(:,:,2) = S;
+    Image(:,:,3) = L;
+end
+return
+
+
+function Image = lab(Image,SrcSpace)
+% Convert to CIE L*a*b* (CIELAB)
+WhitePoint = [0.950456,1,1.088754];
+
+switch SrcSpace
+  case 'lab'
+    return
+  case 'lch'
+    % Convert CIE L*CH to CIE L*ab
+    C = Image(:,:,2);
+    Image(:,:,2) = cos(Image(:,:,3)*pi/180).*C;  % a*
+    Image(:,:,3) = sin(Image(:,:,3)*pi/180).*C;  % b*
+  otherwise
+    Image = xyz(Image,SrcSpace);  % Convert to XYZ
+                                  % Convert XYZ to CIE L*a*b*
+    X = Image(:,:,1)/WhitePoint(1);
+    Y = Image(:,:,2)/WhitePoint(2);
+    Z = Image(:,:,3)/WhitePoint(3);
+    fX = f(X);
+    fY = f(Y);
+    fZ = f(Z);
+    Image(:,:,1) = 116*fY - 16;    % L*
+    Image(:,:,2) = 500*(fX - fY);  % a*
+    Image(:,:,3) = 200*(fY - fZ);  % b*
+end
+return
+
+
+function Image = luv(Image,SrcSpace)
+% Convert to CIE L*u*v* (CIELUV)
+WhitePoint = [0.950456,1,1.088754];
+WhitePointU = (4*WhitePoint(1))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
+WhitePointV = (9*WhitePoint(2))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
+
+Image = xyz(Image,SrcSpace); % Convert to XYZ
+Denom = Image(:,:,1) + 15*Image(:,:,2) + 3*Image(:,:,3);
+U = (4*Image(:,:,1))./(Denom + (Denom == 0));
+V = (9*Image(:,:,2))./(Denom + (Denom == 0));
+Y = Image(:,:,2)/WhitePoint(2);
+L = 116*f(Y) - 16;
+Image(:,:,1) = L;                        % L*
+Image(:,:,2) = 13*L.*(U - WhitePointU);  % u*
+Image(:,:,3) = 13*L.*(V - WhitePointV);  % v*
+return
+
+
+function Image = lch(Image,SrcSpace)
+% Convert to CIE L*ch
+Image = lab(Image,SrcSpace);  % Convert to CIE L*ab
+H = atan2(Image(:,:,3),Image(:,:,2));
+H = H*180/pi + 360*(H < 0);
+Image(:,:,2) = sqrt(Image(:,:,2).^2 + Image(:,:,3).^2);  % C
+Image(:,:,3) = H;                                        % H
+return
+
+
+function Image = cat02lms(Image,SrcSpace)
+% Convert to CAT02 LMS
+Image = xyz(Image,SrcSpace);
+T = [0.7328, 0.4296, -0.1624;-0.7036, 1.6975, 0.0061; 0.0030, 0.0136, 0.9834];
+X = Image(:,:,1);
+Y = Image(:,:,2);
+Z = Image(:,:,3);
+Image(:,:,1) = T(1)*X + T(4)*Y + T(7)*Z;  % L
+Image(:,:,2) = T(2)*X + T(5)*Y + T(8)*Z;  % M
+Image(:,:,3) = T(3)*X + T(6)*Y + T(9)*Z;  % S
+return
+
+
+function Image = huetorgb(m0,m2,H)
+% Convert HSV or HSL hue to RGB
+N = size(H);
+H = min(max(H(:),0),360)/60;
+m0 = m0(:);
+m2 = m2(:);
+F = H - round(H/2)*2;
+M = [m0, m0 + (m2-m0).*abs(F), m2];
+Num = length(m0);
+j = [2 1 0;1 2 0;0 2 1;0 1 2;1 0 2;2 0 1;2 1 0]*Num;
+k = floor(H) + 1;
+Image = reshape([M(j(k,1)+(1:Num).'),M(j(k,2)+(1:Num).'),M(j(k,3)+(1:Num).')],[N,3]);
+return
+
+
+function H = rgbtohue(Image)
+% Convert RGB to HSV or HSL hue
+[M,i] = sort(Image,3);
+i = i(:,:,3);
+Delta = M(:,:,3) - M(:,:,1);
+Delta = Delta + (Delta == 0);
+R = Image(:,:,1);
+G = Image(:,:,2);
+B = Image(:,:,3);
+H = zeros(size(R));
+k = (i == 1);
+H(k) = (G(k) - B(k))./Delta(k);
+k = (i == 2);
+H(k) = 2 + (B(k) - R(k))./Delta(k);
+k = (i == 3);
+H(k) = 4 + (R(k) - G(k))./Delta(k);
+H = 60*H + 360*(H < 0);
+H(Delta == 0) = nan;
+return
+
+
+function Rp = gammacorrection(R)
+Rp = zeros(size(R));
+i = (R <= 0.0031306684425005883);
+Rp(i) = 12.92*R(i);
+Rp(~i) = real(1.055*R(~i).^0.416666666666666667 - 0.055);
+return
+
+
+function R = invgammacorrection(Rp)
+R = zeros(size(Rp));
+i = (Rp <= 0.0404482362771076);
+R(i) = Rp(i)/12.92;
+R(~i) = real(((Rp(~i) + 0.055)/1.055).^2.4);
+return
+
+
+function fY = f(Y)
+fY = real(Y.^(1/3));
+i = (Y < 0.008856);
+fY(i) = Y(i)*(841/108) + (4/29);
+return
+
+
+function Y = invf(fY)
+Y = fY.^3;
+i = (Y < 0.008856);
+Y(i) = (fY(i) - 4/29)*(108/841);
+return
diff --git a/matlab/utilities/graphics/distinguishable_colors.m b/matlab/utilities/graphics/distinguishable_colors.m
new file mode 100644
index 000000000..027ad2cb6
--- /dev/null
+++ b/matlab/utilities/graphics/distinguishable_colors.m
@@ -0,0 +1,168 @@
+function colors = distinguishable_colors(n_colors,bg,func)
+% DISTINGUISHABLE_COLORS: pick colors that are maximally perceptually distinct
+%
+% When plotting a set of lines, you may want to distinguish them by color.
+% By default, Matlab chooses a small set of colors and cycles among them,
+% and so if you have more than a few lines there will be confusion about
+% which line is which. To fix this problem, one would want to be able to
+% pick a much larger set of distinct colors, where the number of colors
+% equals or exceeds the number of lines you want to plot. Because our
+% ability to distinguish among colors has limits, one should choose these
+% colors to be "maximally perceptually distinguishable."
+%
+% This function generates a set of colors which are distinguishable
+% by reference to the "Lab" color space, which more closely matches
+% human color perception than RGB. Given an initial large list of possible
+% colors, it iteratively chooses the entry in the list that is farthest (in
+% Lab space) from all previously-chosen entries. While this "greedy"
+% algorithm does not yield a global maximum, it is simple and efficient.
+% Moreover, the sequence of colors is consistent no matter how many you
+% request, which facilitates the users' ability to learn the color order
+% and avoids major changes in the appearance of plots when adding or
+% removing lines.
+%
+% Syntax:
+%   colors = distinguishable_colors(n_colors)
+% Specify the number of colors you want as a scalar, n_colors. This will
+% generate an n_colors-by-3 matrix, each row representing an RGB
+% color triple. If you don't precisely know how many you will need in
+% advance, there is no harm (other than execution time) in specifying
+% slightly more than you think you will need.
+%
+%   colors = distinguishable_colors(n_colors,bg)
+% This syntax allows you to specify the background color, to make sure that
+% your colors are also distinguishable from the background. Default value
+% is white. bg may be specified as an RGB triple or as one of the standard
+% "ColorSpec" strings. You can even specify multiple colors:
+%     bg = {'w','k'}
+% or
+%     bg = [1 1 1; 0 0 0]
+% will only produce colors that are distinguishable from both white and
+% black.
+%
+%   colors = distinguishable_colors(n_colors,bg,rgb2labfunc)
+% By default, distinguishable_colors uses the image processing toolbox's
+% color conversion functions makecform and applycform. Alternatively, you
+% can supply your own color conversion function.
+%
+% Example:
+%   c = distinguishable_colors(25);
+%   figure
+%   image(reshape(c,[1 size(c)]))
+%
+% Example using the file exchange's 'colorspace':
+%   func = @(x) colorspace('RGB->Lab',x);
+%   c = distinguishable_colors(25,'w',func);
+    
+% Copyright (C) 2005-2010 2010-2011 by Timothy E. Holy
+% Copyright (C) 2017 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/>.
+
+% Parse the inputs
+if (nargin < 2)
+    bg = [1 1 1];  % default white background
+else
+    if iscell(bg)
+        % User specified a list of colors as a cell aray
+        bgc = bg;
+        for i = 1:length(bgc)
+            bgc{i} = parsecolor(bgc{i});
+        end
+        bg = cat(1,bgc{:});
+    else
+        % User specified a numeric array of colors (n-by-3)
+        bg = parsecolor(bg);
+    end
+end
+
+% Generate a sizable number of RGB triples. This represents our space of
+% possible choices. By starting in RGB space, we ensure that all of the
+% colors can be generated by the monitor.
+n_grid = 30;  % number of grid divisions along each axis in RGB space
+x = linspace(0,1,n_grid);
+[R,G,B] = ndgrid(x,x,x);
+rgb = [R(:) G(:) B(:)];
+if (n_colors > size(rgb,1)/3)
+    error('You can''t readily distinguish that many colors');
+end
+
+% Convert to Lab color space, which more closely represents human
+% perception
+if (nargin > 2)
+    lab = func(rgb);
+    bglab = func(bg);
+else
+    C = makecform('srgb2lab');
+    lab = applycform(rgb,C);
+    bglab = applycform(bg,C);
+end
+
+% If the user specified multiple background colors, compute distances
+% from the candidate colors to the background colors
+mindist2 = inf(size(rgb,1),1);
+for i = 1:size(bglab,1)-1
+    dX = bsxfun(@minus,lab,bglab(i,:)); % displacement all colors from bg
+    dist2 = sum(dX.^2,2);  % square distance
+    mindist2 = min(dist2,mindist2);  % dist2 to closest previously-chosen color
+end
+
+% Iteratively pick the color that maximizes the distance to the nearest
+% already-picked color
+colors = zeros(n_colors,3);
+lastlab = bglab(end,:);   % initialize by making the "previous" color equal to background
+for i = 1:n_colors
+    dX = bsxfun(@minus,lab,lastlab); % displacement of last from all colors on list
+    dist2 = sum(dX.^2,2);  % square distance
+    mindist2 = min(dist2,mindist2);  % dist2 to closest previously-chosen color
+    [~,index] = max(mindist2);  % find the entry farthest from all previously-chosen colors
+    colors(i,:) = rgb(index,:);  % save for output
+    lastlab = lab(index,:);  % prepare for next iteration
+end
+end
+
+function c = parsecolor(s)
+if ischar(s)
+    c = colorstr2rgb(s);
+elseif isnumeric(s) && size(s,2) == 3
+    c = s;
+else
+    error('MATLAB:InvalidColorSpec','Color specification cannot be parsed.');
+end
+end
+
+function c = colorstr2rgb(c)
+% Convert a color string to an RGB value.
+% This is cribbed from Matlab's whitebg function.
+% Why don't they make this a stand-alone function?
+rgbspec = [1 0 0;0 1 0;0 0 1;1 1 1;0 1 1;1 0 1;1 1 0;0 0 0];
+cspec = 'rgbwcmyk';
+k = find(cspec==c(1));
+if isempty(k)
+    error('MATLAB:InvalidColorString','Unknown color string.');
+end
+if k~=3 || length(c)==1
+    c = rgbspec(k,:);
+elseif length(c)>2
+    if strcmpi(c(1:3),'bla')
+        c = [0 0 0];
+    elseif strcmpi(c(1:3),'blu')
+        c = [0 0 1];
+    else
+        error('MATLAB:UnknownColorString', 'Unknown color string.');
+    end
+end
+end
diff --git a/matlab/utilities/tests b/matlab/utilities/tests
index b2a8b9c05..fe65c7727 160000
--- a/matlab/utilities/tests
+++ b/matlab/utilities/tests
@@ -1 +1 @@
-Subproject commit b2a8b9c059b1e2cb119e8d5fa92b4388fd93c9dd
+Subproject commit fe65c7727f4d1b91355b62b2cc58f5775c287afd
diff --git a/matlab/variance_decomposition_mc_analysis.m b/matlab/variance_decomposition_mc_analysis.m
index cfaf71c9a..4621f25d3 100644
--- a/matlab/variance_decomposition_mc_analysis.m
+++ b/matlab/variance_decomposition_mc_analysis.m
@@ -25,7 +25,7 @@ function oo_ = variance_decomposition_mc_analysis(NumberOfSimulations,type,dname
 
 
 
-% Copyright (C) 2008-2013 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -94,7 +94,7 @@ if options_.estimation.moments_posterior_density.indicator
         posterior_moments(tmp,1,mh_conf_sig);
 else
     [p_mean, p_median, p_var, hpd_interval, p_deciles] = ...
-        posterior_moments(tmp,0,mh_conf_sig);        
+        posterior_moments(tmp,0,mh_conf_sig);
 end
 
 oo_.([TYPE, 'TheoreticalMoments']).dsge.VarianceDecomposition.Mean.(var).(exo) = p_mean;
diff --git a/matlab/varlist_indices.m b/matlab/varlist_indices.m
index 1299e54d5..4347f9af4 100644
--- a/matlab/varlist_indices.m
+++ b/matlab/varlist_indices.m
@@ -1,10 +1,10 @@
 function [i_var,nvar,index_uniques] = varlist_indices(sublist,list)
-% function [i_var,nvar] = varlist_indices(sublist,list)
+% function [i_var,nvar,index_uniques] = varlist_indices(sublist,list)
 % returns the indices of a list of endogenous variables
 %
 % INPUT
 %   sublist:    sublist of variables
-%   list:       list of variables 
+%   list:       list of variables
 %
 % OUTPUT
 %   i_var:      variable indices in M_.endo_names
@@ -14,7 +14,7 @@ function [i_var,nvar,index_uniques] = varlist_indices(sublist,list)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2010-2014 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/ver_greater_than.m b/matlab/ver_greater_than.m
index 1fef34bf2..7bd973f45 100644
--- a/matlab/ver_greater_than.m
+++ b/matlab/ver_greater_than.m
@@ -12,7 +12,7 @@ function tf = ver_greater_than(ver1, ver2)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,27 +36,27 @@ ver2 = strsplit(ver2, {'.', '-'});
 maj_ver1 = str2double(ver1{1});
 maj_ver2 = str2double(ver2{1});
 if maj_ver1 > maj_ver2
-    return;
+    return
 end
 
 min_ver1 = str2double(ver1{2});
 min_ver2 = str2double(ver2{2});
 if (maj_ver1 == maj_ver2) && (min_ver1 > min_ver2)
-    return;
+    return
 end
 
 if (length(ver1) == length(ver2) && length(ver1) == 3)
     ismaster1 = isnan(str2double(ver1{3}));
     ismaster2 = isnan(str2double(ver2{3}));
     if (maj_ver1 == maj_ver2) && (min_ver1 == min_ver2) && (ismaster1 && ~ismaster2)
-        return;
+        return
     end
 
     if ~ismaster1 && ~ismaster2
         rev_ver1 = str2double(ver1{3});
         rev_ver2 = str2double(ver2{3});
         if (maj_ver1 == maj_ver2) && (min_ver1 == min_ver2) && (rev_ver1 > rev_ver2)
-            return;
+            return
         end
     end
 end
diff --git a/matlab/ver_less_than.m b/matlab/ver_less_than.m
index e953ed8a2..c71d163be 100644
--- a/matlab/ver_less_than.m
+++ b/matlab/ver_less_than.m
@@ -12,7 +12,7 @@ function tf = ver_less_than(ver1, ver2)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -36,27 +36,27 @@ ver2 = strsplit(ver2, {'.', '-'});
 maj_ver1 = str2double(ver1{1});
 maj_ver2 = str2double(ver2{1});
 if maj_ver1 < maj_ver2
-    return;
+    return
 end
 
 min_ver1 = str2double(ver1{2});
 min_ver2 = str2double(ver2{2});
 if (maj_ver1 == maj_ver2) && (min_ver1 < min_ver2)
-    return;
+    return
 end
 
 if (length(ver1) == length(ver2) && length(ver1) == 3)
     ismaster1 = isnan(str2double(ver1{3}));
     ismaster2 = isnan(str2double(ver2{3}));
     if (maj_ver1 == maj_ver2) && (min_ver1 == min_ver2) && (~ismaster1 && ismaster2)
-        return;
+        return
     end
 
     if ~ismaster1 && ~ismaster2
         rev_ver1 = str2double(ver1{3});
         rev_ver2 = str2double(ver2{3});
         if (maj_ver1 == maj_ver2) && (min_ver1 == min_ver2) && (rev_ver1 < rev_ver2)
-            return;
+            return
         end
     end
 end
diff --git a/matlab/vnorm.m b/matlab/vnorm.m
index b6bb123d9..5d3cdadd6 100644
--- a/matlab/vnorm.m
+++ b/matlab/vnorm.m
@@ -35,7 +35,7 @@ function y = vnorm(A,varargin)
 %       vnorm(A,[],inf)     % Correct
 %
 %
-% Copyright (C) 2009-2011 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -71,7 +71,7 @@ if isempty(dim)
     idx = find(size(A)~=1);
     dim = idx(1);
 end
-    
+
 if isempty(ntype)
     y = sqrt(sum( abs(A).^2 , dim) );
 elseif ntype==1
@@ -88,4 +88,3 @@ elseif ntype~=floor(ntype) || ntype<1
 else
     y = (sum( abs(A).^ntype , dim) ).^(1/ntype);
 end
-
diff --git a/matlab/warning_config.m b/matlab/warning_config.m
index 3b9f45d63..a7cbaab92 100644
--- a/matlab/warning_config.m
+++ b/matlab/warning_config.m
@@ -3,14 +3,14 @@ function warning_config()
 %
 % INPUTS
 %   none
-%             
+%
 % OUTPUTS
 %   none
-%        
+%
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright (C) 2008-2015 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/write_latex_definitions.m b/matlab/write_latex_definitions.m
index 2bf3acf36..e9345ac6a 100644
--- a/matlab/write_latex_definitions.m
+++ b/matlab/write_latex_definitions.m
@@ -12,7 +12,7 @@ function write_latex_definitions
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -65,9 +65,9 @@ for i=1:length(tables)
     long = eval([M_var_root{i} '_names_long']);
     for j=1:size(names,1)
         fprintf(fid, '\\texttt{%s} & $%s$ & %s\\\\\n', ...
-            regexprep(strtrim(names(j,:)), '_', '\\_'), ...
-            strtrim(tex(j,:)), ...
-            regexprep(strtrim(long(j,:)), '_', '\\_'));
+                regexprep(strtrim(names(j,:)), '_', '\\_'), ...
+                strtrim(tex(j,:)), ...
+                regexprep(strtrim(long(j,:)), '_', '\\_'));
     end
     fprintf(fid, '\\hline%%\n');
     fprintf(fid, '\\end{longtable}\n');
diff --git a/matlab/write_latex_parameter_table.m b/matlab/write_latex_parameter_table.m
index c2d739801..92374d77c 100644
--- a/matlab/write_latex_parameter_table.m
+++ b/matlab/write_latex_parameter_table.m
@@ -12,7 +12,7 @@ function write_latex_parameter_table
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -29,7 +29,7 @@ function write_latex_parameter_table
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-global M_;
+global M_
 
 if ~isequal(M_.param_names,M_.param_names_long)
     Long_names_present=1;
@@ -38,7 +38,7 @@ else
 end
 fid = fopen([M_.fname '_latex_parameters.tex'], 'w');
 fprintf(fid, '\\begin{center}\n');
-if Long_names_present==1;
+if Long_names_present==1
     fprintf(fid, '\\begin{longtable}{ccc}\n');
 else
     fprintf(fid, '\\begin{longtable}{cc}\n');
@@ -48,7 +48,7 @@ fprintf(fid, ['\\caption{Parameter Values}\\\\%%\n']);
 fprintf(fid, '\\toprule%%\n');
 fprintf(fid, '\\multicolumn{1}{c}{\\textbf{Parameter}} &\n');
 fprintf(fid, '\\multicolumn{1}{c}{\\textbf{Value}} ');
-if Long_names_present==1;
+if Long_names_present==1
     fprintf(fid, '&\n \\multicolumn{1}{c}{\\textbf{Description}}\\\\%%\n');
 else
     fprintf(fid, ' \\\\%%\n');
@@ -56,7 +56,7 @@ end
 fprintf(fid, '\\midrule%%\n');
 fprintf(fid, '\\endfirsthead\n');
 
-if Long_names_present==1;
+if Long_names_present==1
     fprintf(fid, '\\multicolumn{3}{c}{{\\tablename} \\thetable{} -- Continued}\\\\%%\n');
 else
     fprintf(fid, '\\multicolumn{2}{c}{{\\tablename} \\thetable{} -- Continued}\\\\%%\n');
@@ -64,7 +64,7 @@ end
 fprintf(fid, '\\midrule%%\n');
 fprintf(fid, '\\multicolumn{1}{c}{\\textbf{Parameter}} &\n');
 fprintf(fid, '\\multicolumn{1}{c}{\\textbf{Value}} ');
-if Long_names_present==1;
+if Long_names_present==1
     fprintf(fid, '&\n  \\multicolumn{1}{c}{\\textbf{Description}}\\\\%%\n');
 else
     fprintf(fid, '\\\\%%\n');
@@ -75,20 +75,20 @@ fprintf(fid, '\\endhead\n');
 tex = M_.param_names_tex;
 long = M_.param_names_long;
 for j=1:size(tex,1)
-if Long_names_present==1;
-    % replace underscores
-    long_names_temp=regexprep(strtrim(long(j,:)), '_', '\\_');
-    % replace percent
-    long_names_temp=regexprep(long_names_temp, '%', '\\%');
-    fprintf(fid, '$%s$ \t & \t %4.3f \t & \t %s\\\\\n', ...
-        strtrim(tex(j,:)), ...
-        M_.params(j,:),...
-        long_names_temp);
-else
-    fprintf(fid, '$%s$ \t & \t %4.3f \\\\\n', ...
-        strtrim(tex(j,:)), ...
-        M_.params(j,:));
-end
+    if Long_names_present==1
+        % replace underscores
+        long_names_temp=regexprep(strtrim(long(j,:)), '_', '\\_');
+        % replace percent
+        long_names_temp=regexprep(long_names_temp, '%', '\\%');
+        fprintf(fid, '$%s$ \t & \t %4.3f \t & \t %s\\\\\n', ...
+                strtrim(tex(j,:)), ...
+                M_.params(j,:),...
+                long_names_temp);
+    else
+        fprintf(fid, '$%s$ \t & \t %4.3f \\\\\n', ...
+                strtrim(tex(j,:)), ...
+                M_.params(j,:));
+    end
 end
 fprintf(fid, '\\bottomrule%%\n');
 fprintf(fid, '\\end{longtable}\n');
diff --git a/matlab/write_latex_prior_table.m b/matlab/write_latex_prior_table.m
index 46a5e3bf5..2fb738bd7 100644
--- a/matlab/write_latex_prior_table.m
+++ b/matlab/write_latex_prior_table.m
@@ -11,7 +11,7 @@ function write_latex_prior_table
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2015-16 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -37,11 +37,11 @@ end
 
 if (size(estim_params_.var_endo,1) || size(estim_params_.corrn,1))
     % Prior over measurement errors are defined...
-   if ((isfield(options_,'varobs') && isempty(options_.varobs)) || ~isfield(options_,'varobs'))
-       % ... But the list of observed variabled is not yet defined.
-       fprintf(['\nwrite_latex_prior_table:: varobs should be declared before. Skipping table creation.\n'])
-       return
-   end
+    if ((isfield(options_,'varobs') && isempty(options_.varobs)) || ~isfield(options_,'varobs'))
+        % ... But the list of observed variabled is not yet defined.
+        fprintf(['\nwrite_latex_prior_table:: varobs should be declared before. Skipping table creation.\n'])
+        return
+    end
 end
 
 % Fill or update bayestopt_ structure
@@ -115,56 +115,56 @@ for i=1:size(BayesOptions.name,1)
     PriorMode = BayesOptions.p5(i);
     PriorStandardDeviation = BayesOptions.p2(i);
     switch BayesOptions.pshape(i)
-        case { 1 , 5 }
+      case { 1 , 5 }
+        LowerBound = BayesOptions.p3(i);
+        UpperBound = BayesOptions.p4(i);
+        if ~isinf(lb(i))
+            LowerBound=max(LowerBound,lb(i));
+        end
+        if ~isinf(ub(i))
+            UpperBound=min(UpperBound,ub(i));
+        end
+      case { 2 , 4 , 6, 8 }
+        LowerBound = BayesOptions.p3(i);
+        if ~isinf(lb(i))
+            LowerBound=max(LowerBound,lb(i));
+        end
+        if ~isinf(ub(i))
+            UpperBound=ub(i);
+        else
+            UpperBound = '$\infty$';
+        end
+      case 3
+        if isinf(BayesOptions.p3(i)) && isinf(lb(i))
+            LowerBound = '$-\infty$';
+        else
             LowerBound = BayesOptions.p3(i);
-            UpperBound = BayesOptions.p4(i);
             if ~isinf(lb(i))
                 LowerBound=max(LowerBound,lb(i));
             end
+        end
+        if isinf(BayesOptions.p4(i)) && isinf(ub(i))
+            UpperBound = '$\infty$';
+        else
+            UpperBound = BayesOptions.p4(i);
             if ~isinf(ub(i))
                 UpperBound=min(UpperBound,ub(i));
             end
-        case { 2 , 4 , 6, 8 }
-            LowerBound = BayesOptions.p3(i);
-            if ~isinf(lb(i))
-                LowerBound=max(LowerBound,lb(i));
-            end
-            if ~isinf(ub(i))
-                UpperBound=ub(i);
-            else
-                UpperBound = '$\infty$';
-            end
-        case 3
-            if isinf(BayesOptions.p3(i)) && isinf(lb(i))
-                LowerBound = '$-\infty$';
-            else
-                LowerBound = BayesOptions.p3(i);
-                if ~isinf(lb(i))
-                    LowerBound=max(LowerBound,lb(i));
-                end
-            end
-            if isinf(BayesOptions.p4(i)) && isinf(ub(i))
-                UpperBound = '$\infty$';
-            else
-                UpperBound = BayesOptions.p4(i);
-                if ~isinf(ub(i))
-                    UpperBound=min(UpperBound,ub(i));
-                end
-            end
-        otherwise
-            error('write_latex_prior_table:: Dynare bug!')
+        end
+      otherwise
+        error('write_latex_prior_table:: Dynare bug!')
     end
     format_string = build_format_string(PriorMode, PriorStandardDeviation,LowerBound,UpperBound);
     fprintf(fidTeX,format_string, ...
-        TexName, ...
-        PriorShape, ...
-        PriorMean, ...
-        PriorMode, ...
-        PriorStandardDeviation, ...
-        LowerBound, ...
-        UpperBound, ...
-        PriorIntervals.lb(i), ...
-        PriorIntervals.ub(i) );
+            TexName, ...
+            PriorShape, ...
+            PriorMean, ...
+            PriorMode, ...
+            PriorStandardDeviation, ...
+            LowerBound, ...
+            UpperBound, ...
+            PriorIntervals.lb(i), ...
+            PriorIntervals.ub(i) );
 end
 fprintf(fidTeX,'\\end{longtable}\n ');
 fprintf(fidTeX,'\\end{center}\n');
diff --git a/matlab/write_mh_history_file.m b/matlab/write_mh_history_file.m
index 00984c26c..72ce6a22e 100644
--- a/matlab/write_mh_history_file.m
+++ b/matlab/write_mh_history_file.m
@@ -5,10 +5,10 @@ function i = write_mh_history_file(MetropolisFolder, ModelName, record)
 %   MetropolisFolder    [char]      Name of the metropolis subfolder
 %   ModelName           [char]      Name of the mod-file
 %   record              [structure] structure storing the MH history
-% Outputs:  
+% Outputs:
 %   i                   [scalar]    number of the mh_history file
 
-% Copyright (C) 2013-2015 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/writecellofchar.m b/matlab/writecellofchar.m
index be636e6f1..c08f4bb50 100644
--- a/matlab/writecellofchar.m
+++ b/matlab/writecellofchar.m
@@ -2,13 +2,13 @@ function str = writecellofchar(c)
 
 % Writes a two dimensional cell of char in a string.
 %
-% INPUTS 
+% INPUTS
 % - c   [cell] cell of char.
 %
-% OUTPUTS 
+% OUTPUTS
 % - str [char]
 %
-% EXAMPLES 
+% EXAMPLES
 % >> writecellofchar({'a', {'b'; 'c'}})
 %
 % ans =
@@ -19,9 +19,9 @@ function str = writecellofchar(c)
 %
 % ans =
 %
-%{'a', '['b'; 'c']', 'd'}   
+%{'a', '['b'; 'c']', 'd'}
 
-% Copyright (C) 2015 Dynare Team
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -37,27 +37,27 @@ function str = writecellofchar(c)
 %
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-    
+
 str = '{';
 for i=1:size(c, 1)
-    for j=1:size(c, 2)
-        if iscell(c{i,j})
-            str = sprintf('%s%s', str, writecellofchar(c{i, j}));
-        elseif ischar(c{i, j})
-            if size(c{i, j}, 1)>1
-                str = sprintf('%s''%s''', str, writematrixofchar(c{i, j}));
-            else
-                str = sprintf('%s''%s''', str, c{i, j});
-            end
-        else
-            error('Type not implemenented!')
-        end
-        if j<size(c, 2)
-            str = sprintf('%s, ', str);
-        end
-    end
-    if i<size(c, 1)
-        str = sprintf('%s; ', str);
-    end
+for j=1:size(c, 2)
+if iscell(c{i,j})
+str = sprintf('%s%s', str, writecellofchar(c{i, j}));
+elseif ischar(c{i, j})
+if size(c{i, j}, 1)>1
+str = sprintf('%s''%s''', str, writematrixofchar(c{i, j}));
+else
+str = sprintf('%s''%s''', str, c{i, j});
+end
+else
+error('Type not implemenented!')
+end
+if j<size(c, 2)
+str = sprintf('%s, ', str);
+end
+end
+if i<size(c, 1)
+str = sprintf('%s; ', str);
+end
 end
 str = sprintf('%s}', str);
\ No newline at end of file
diff --git a/matlab/writedata.m b/matlab/writedata.m
index 112d7f130..c714728fc 100644
--- a/matlab/writedata.m
+++ b/matlab/writedata.m
@@ -1,6 +1,6 @@
 function writedata(fname)
 % function writedata(fname)
-% store endogenous and exogenous variables in a XLS spreadsheet file 
+% store endogenous and exogenous variables in a XLS spreadsheet file
 % INPUT
 %   fname: name of the XLS file
 % OUTPUT
@@ -10,7 +10,7 @@ function writedata(fname)
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2007-2014 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/matlab/writedata_text.m b/matlab/writedata_text.m
index 5af543e9c..0fa0f7ac2 100644
--- a/matlab/writedata_text.m
+++ b/matlab/writedata_text.m
@@ -1,6 +1,6 @@
 function writedata_text(fname)
 % function writedata(fname)
-% store endogenous and exogenous variables in a text file 
+% store endogenous and exogenous variables in a text file
 % INPUT
 %   fname: name of the text file
 % OUTPUT
@@ -10,7 +10,7 @@ function writedata_text(fname)
 % SPECIAL REQUIREMENT
 %   none
 
-% Copyright (C) 2007-2009 Dynare Team
+% Copyright (C) 2007-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,7 +32,7 @@ S=[fname '_endo.dat'];
 fid = fopen(S,'w');
 for i = 1:size(M_.endo_names,1)
     fprintf(fid,'%s ',M_.endo_names(i,:)');
-end;
+end
 fprintf(fid,'\n');
 for i = 1:size(oo_.endo_simul,2)
     fprintf(fid,'%15.7f ',oo_.endo_simul(:,i));
@@ -44,11 +44,10 @@ S=[fname '_exo.dat'];
 fid = fopen(S,'w');
 for i = 1:size(M_.exo_names,1)
     fprintf(fid,'%s ',M_.exo_names(i,:));
-end;
+end
 fprintf(fid,'\n');
 for i = 1:size(oo_.exo_simul,1)
     fprintf(fid,'%15.7f ',oo_.exo_simul(i,:));
     fprintf(fid,'\n');
 end
-fclose(fid);
-return;
\ No newline at end of file
+fclose(fid);
\ No newline at end of file
diff --git a/matlab/writematrixofchar.m b/matlab/writematrixofchar.m
index 6f230e554..5f3f26359 100644
--- a/matlab/writematrixofchar.m
+++ b/matlab/writematrixofchar.m
@@ -2,13 +2,13 @@ function str = writematrixofchar(m)
 
 % Writes a matrix of char in a string.
 %
-% INPUTS 
+% INPUTS
 % - m   [char] matrix of char.
 %
-% OUTPUTS 
+% OUTPUTS
 % - str [char]
 %
-% EXAMPLE 
+% EXAMPLE
 % >> writematrixofchar(['a'; 'b'])
 %
 % ans =
@@ -16,8 +16,8 @@ function str = writematrixofchar(m)
 % ['a'; 'b']
 %
 % where the returned argument is a string which can be evaluated or printed.
-    
-% Copyright (C) 2015 Dynare Team
+
+% Copyright (C) 2015-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/mex/build/matlab/configure.ac b/mex/build/matlab/configure.ac
index 5bc631690..5fd9aa04d 100644
--- a/mex/build/matlab/configure.ac
+++ b/mex/build/matlab/configure.ac
@@ -18,7 +18,7 @@ dnl You should have received a copy of the GNU General Public License
 dnl along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 AC_PREREQ([2.62])
-AC_INIT([dynare], [4.5-unstable])
+AC_INIT([dynare], [4.6-unstable])
 AC_CONFIG_SRCDIR([configure.ac])
 AM_INIT_AUTOMAKE([-Wall -Wno-portability foreign])
 
diff --git a/mex/build/octave/configure.ac b/mex/build/octave/configure.ac
index fd563e61c..54351c003 100755
--- a/mex/build/octave/configure.ac
+++ b/mex/build/octave/configure.ac
@@ -18,7 +18,7 @@ dnl You should have received a copy of the GNU General Public License
 dnl along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
 AC_PREREQ([2.62])
-AC_INIT([dynare], [4.5-unstable])
+AC_INIT([dynare], [4.6-unstable])
 AC_CONFIG_SRCDIR([configure.ac])
 AM_INIT_AUTOMAKE([-Wall -Wno-portability foreign])
 
diff --git a/mex/sources/block_kalman_filter/block_kalman_filter.cc b/mex/sources/block_kalman_filter/block_kalman_filter.cc
index 6104feb12..4da025ce7 100644
--- a/mex/sources/block_kalman_filter/block_kalman_filter.cc
+++ b/mex/sources/block_kalman_filter/block_kalman_filter.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -30,11 +30,11 @@ using namespace std;
 //#define CUBLAS
 
 #ifdef CUBLAS
-  #include <cuda_runtime.h>
-  #include <cublas_v2.h>
+# include <cuda_runtime.h>
+# include <cublas_v2.h>
 #endif
 void
-mexDisp(mxArray* P)
+mexDisp(mxArray *P)
 {
   unsigned int n = mxGetN(P);
   unsigned int m = mxGetM(P);
@@ -44,97 +44,95 @@ mexDisp(mxArray* P)
   for (unsigned int i = 0; i < m; i++)
     {
       for (unsigned int j = 0; j < n; j++)
-        mexPrintf(" %9.4f",M[i+ j * m]);
+        mexPrintf(" %9.4f", M[i+ j * m]);
       mexPrintf("\n");
     }
   mexEvalString("drawnow;");
 }
 
-
 void
-mexDisp(double* M, int m, int n)
+mexDisp(double *M, int m, int n)
 {
   mexPrintf("%d x %d\n", m, n);
   mexEvalString("drawnow;");
   for (int i = 0; i < m; i++)
     {
       for (int j = 0; j < n; j++)
-        mexPrintf(" %9.4f",M[i+ j * m]);
+        mexPrintf(" %9.4f", M[i+ j * m]);
       mexPrintf("\n");
     }
   mexEvalString("drawnow;");
 }
 /*if block
-    %nz_state_var = M_.nz_state_var;
-    while notsteady && t<smpl
-        t  = t+1;
-        v  = Y(:,t)-a(mf);
-        F  = P(mf,mf) + H;
-        if rcond(F) < kalman_tol
-            if ~all(abs(F(:))<kalman_tol)
-                return
-            else
-                a = T*a;
-                P = T*P*transpose(T)+QQ;
-            end
-        else
-            F_singular = 0;
-            dF     = det(F);
-            iF     = inv(F);
-            lik(t) = log(dF)+transpose(v)*iF*v;
-            K      = P(:,mf)*iF;
-            a      = T*(a+K*v);
-            P = block_pred_Vcov_KF(mf, P, K, T, QQ);
-            %P      = T*(P-K*P(mf,:))*transpose(T)+QQ;
-            notsteady = max(abs(K(:)-oldK)) > riccati_tol;
-            oldK = K(:);
-        end
-    end;
-else
-    while notsteady && t<smpl
-        t  = t+1;
-        v  = Y(:,t)-a(mf);
-        F  = P(mf,mf) + H;
-        if rcond(F) < kalman_tol
-            if ~all(abs(F(:))<kalman_tol)
-                return
-            else
-                a = T*a;
-                P = T*P*transpose(T)+QQ;
-            end
-        else
-            F_singular = 0;
-            dF     = det(F);
-            iF     = inv(F);
-            lik(t) = log(dF)+transpose(v)*iF*v;
-            K      = P(:,mf)*iF;
-            a      = T*(a+K*v);
-            P      = T*(P-K*P(mf,:))*transpose(T)+QQ;
-            notsteady = max(abs(K(:)-oldK)) > riccati_tol;
-            oldK = K(:);
-        
-        end
-    end
-end
+  %nz_state_var = M_.nz_state_var;
+  while notsteady && t<smpl
+  t  = t+1;
+  v  = Y(:,t)-a(mf);
+  F  = P(mf,mf) + H;
+  if rcond(F) < kalman_tol
+  if ~all(abs(F(:))<kalman_tol)
+  return
+  else
+  a = T*a;
+  P = T*P*transpose(T)+QQ;
+  end
+  else
+  F_singular = 0;
+  dF     = det(F);
+  iF     = inv(F);
+  lik(t) = log(dF)+transpose(v)*iF*v;
+  K      = P(:,mf)*iF;
+  a      = T*(a+K*v);
+  P = block_pred_Vcov_KF(mf, P, K, T, QQ);
+  %P      = T*(P-K*P(mf,:))*transpose(T)+QQ;
+  notsteady = max(abs(K(:)-oldK)) > riccati_tol;
+  oldK = K(:);
+  end
+  end;
+  else
+  while notsteady && t<smpl
+  t  = t+1;
+  v  = Y(:,t)-a(mf);
+  F  = P(mf,mf) + H;
+  if rcond(F) < kalman_tol
+  if ~all(abs(F(:))<kalman_tol)
+  return
+  else
+  a = T*a;
+  P = T*P*transpose(T)+QQ;
+  end
+  else
+  F_singular = 0;
+  dF     = det(F);
+  iF     = inv(F);
+  lik(t) = log(dF)+transpose(v)*iF*v;
+  K      = P(:,mf)*iF;
+  a      = T*(a+K*v);
+  P      = T*(P-K*P(mf,:))*transpose(T)+QQ;
+  notsteady = max(abs(K(:)-oldK)) > riccati_tol;
+  oldK = K(:);
+
+  end
+  end
+  end
 */
 
 bool
-not_all_abs_F_bellow_crit(double* F, int size, double crit)
+not_all_abs_F_bellow_crit(double *F, int size, double crit)
 {
-   int i = 0;
-   while (i < size && abs(F[i])<crit)
-     {
-       i++;
-     }
-   if (i < size)
-     return false;
-   else
-     return true;
+  int i = 0;
+  while (i < size && abs(F[i]) < crit)
+    {
+      i++;
+    }
+  if (i < size)
+    return false;
+  else
+    return true;
 }
 
-
 double
-det(double* F, int dim, lapack_int* ipiv)
+det(double *F, int dim, lapack_int *ipiv)
 {
   double det = 1.0;
   for (int i = 0; i < dim; i++)
@@ -145,27 +143,25 @@ det(double* F, int dim, lapack_int* ipiv)
   return det;
 }
 
-
-
 BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], double *P_mf[], double *v_pp[], double *K[], double *v_n[], double *a[], double *K_P[], double *P_t_t1[], double *tmp[], double *P[])
 {
   if (nlhs > 3)
     DYN_MEX_FUNC_ERR_MSG_TXT("block_kalman_filter provides at most 3 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.");
-  if (nrhs == 16) 
+  if (nrhs == 16)
     missing_observations = true;
   else
     missing_observations = false;
   if (missing_observations)
     {
-      if (! mxIsCell (prhs[0]))
+      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.");
       pdata_index = prhs[0];
-      if (! mxIsDouble (prhs[1]))
+      if (!mxIsDouble(prhs[1]))
         DYN_MEX_FUNC_ERR_MSG_TXT("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]))
+      if (!mxIsDouble(prhs[2]))
         DYN_MEX_FUNC_ERR_MSG_TXT("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]);
@@ -175,10 +171,10 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
       pP = mxDuplicateArray(prhs[7]);
       pY = mxDuplicateArray(prhs[8]);
       start = mxGetScalar(prhs[9]);
-      mfd = (double*)mxGetData(prhs[10]);
+      mfd = (double *) mxGetData(prhs[10]);
       kalman_tol = mxGetScalar(prhs[11]);
       riccati_tol = mxGetScalar(prhs[12]);
-      nz_state_var = (double*)mxGetData(prhs[13]);
+      nz_state_var = (double *) mxGetData(prhs[13]);
       n_diag = mxGetScalar(prhs[14]);
       pure_obs = mxGetScalar(prhs[15]);
     }
@@ -196,10 +192,10 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
       n   = mxGetN(pT);           // Number of state variables.
       pp   = mxGetM(pY);          // Maximum number of observed variables.
       smpl = mxGetN(pY);          // Sample size.          ;
-      mfd = (double*)mxGetData(prhs[7]);
+      mfd = (double *) mxGetData(prhs[7]);
       kalman_tol = mxGetScalar(prhs[8]);
       riccati_tol = mxGetScalar(prhs[9]);
-      nz_state_var = (double*)mxGetData(prhs[10]);
+      nz_state_var = (double *) mxGetData(prhs[10]);
       n_diag = mxGetScalar(prhs[11]);
       pure_obs = mxGetScalar(prhs[12]);
     }
@@ -209,35 +205,32 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
   H = mxGetPr(pH);
   *P = mxGetPr(pP);
   Y = mxGetPr(pY);
-  
+
   n   = mxGetN(pT);           // Number of state variables.
   pp   = mxGetM(pY);          // Maximum number of observed variables.
   smpl = mxGetN(pY);          // Sample size.          ;
   n_state = n - pure_obs;
 
-  
-  
   /*mexPrintf("T\n");
-  mexDisp(pT);*/
+    mexDisp(pT);*/
 
   H_size = mxGetN(pH) * mxGetM(pH);
-  
-  
+
   n_shocks = mxGetM(pQ);
-  
+
   if (missing_observations)
-    if (mxGetNumberOfElements(pdata_index) != (unsigned int)smpl)
+    if (mxGetNumberOfElements(pdata_index) != (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");
-  
-  i_nz_state_var = (int*)mxMalloc(n*sizeof(int));
+
+  i_nz_state_var = (int *) mxMalloc(n*sizeof(int));
   for (int i = 0; i < n; i++)
     i_nz_state_var[i] = nz_state_var[i];
 
   pa = mxCreateDoubleMatrix(n, 1, mxREAL);         // State vector.
   *a = mxGetPr(pa);
-  tmp_a = (double*)mxMalloc(n * sizeof(double));
+  tmp_a = (double *) mxMalloc(n * sizeof(double));
   dF = 0.0;                                            // det(F).
-  
+
   p_tmp1 = mxCreateDoubleMatrix(n, n_shocks, mxREAL);
   tmp1 = mxGetPr(p_tmp1);
   t = 0;                                               // Initialization of the time index.
@@ -247,13 +240,13 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
   LIK  = 0.0;                                          // Default value of the log likelihood.
   notsteady   = true;                                 // Steady state flag.
   F_singular  = true;
-  *v_pp = (double*)mxMalloc(pp * sizeof(double));
-  *v_n = (double*)mxMalloc(n * sizeof(double));
-  mf = (int*)mxMalloc(pp * sizeof(int));
+  *v_pp = (double *) mxMalloc(pp * sizeof(double));
+  *v_n = (double *) mxMalloc(n * sizeof(double));
+  mf = (int *) mxMalloc(pp * sizeof(int));
   for (int i = 0; i < pp; i++)
     mf[i] = mfd[i] - 1;
-  pi = atan2((double)0.0,(double)-1.0);
-  
+  pi = atan2((double) 0.0, (double) -1.0);
+
   /*compute QQ = R*Q*transpose(R)*/                        // Variance of R times the vector of structural innovations.;
   // tmp = R * Q;
   for (int i = 0; i < n; i++)
@@ -277,7 +270,7 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
         QQ[i + j * n] = QQ[j + i * n] = res;
       }
   mxDestroyArray(p_tmp1);
-  
+
   pv = mxCreateDoubleMatrix(pp, 1, mxREAL);
   v = mxGetPr(pv);
   pF =  mxCreateDoubleMatrix(pp, pp, mxREAL);
@@ -285,9 +278,9 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
   piF =  mxCreateDoubleMatrix(pp, pp, mxREAL);
   iF = mxGetPr(piF);
   lw = pp * 4;
-  w = (double*)mxMalloc(lw * sizeof(double));
-  iw = (lapack_int*)mxMalloc(pp * sizeof(lapack_int));
-  ipiv = (lapack_int*)mxMalloc(pp * sizeof(lapack_int));
+  w = (double *) mxMalloc(lw * sizeof(double));
+  iw = (lapack_int *) mxMalloc(pp * sizeof(lapack_int));
+  ipiv = (lapack_int *) mxMalloc(pp * sizeof(lapack_int));
   info = 0;
 #if defined(BLAS) || defined(CUBLAS)
   p_tmp = mxCreateDoubleMatrix(n, n, mxREAL);
@@ -298,8 +291,8 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
   *K = mxGetPr(pK);
   p_K_P = mxCreateDoubleMatrix(n, n, mxREAL);
   *K_P = mxGetPr(p_K_P);
-  oldK  = (double*)mxMalloc(n * n * sizeof(double));
-  *P_mf = (double*)mxMalloc(n * n * sizeof(double));
+  oldK  = (double *) mxMalloc(n * n * sizeof(double));
+  *P_mf = (double *) mxMalloc(n * n * sizeof(double));
   for (int i = 0; i < n  * n; i++)
     oldK[i] = Inf;
 #else
@@ -311,14 +304,14 @@ BlockKalmanFilter::BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const
   *K = mxGetPr(pK);
   p_K_P = mxCreateDoubleMatrix(n_state, n_state, mxREAL);
   *K_P = mxGetPr(p_K_P);
-  oldK  = (double*)mxMalloc(n * pp * sizeof(double));
-  *P_mf = (double*)mxMalloc(n * pp * sizeof(double));
+  oldK  = (double *) mxMalloc(n * pp * sizeof(double));
+  *P_mf = (double *) mxMalloc(n * pp * sizeof(double));
   for (int i = 0; i < n  * pp; i++)
     oldK[i] = Inf;
 #endif
 }
 
-void 
+void
 BlockKalmanFilter::block_kalman_filter_ss(double *P_mf, double *v_pp, double *K, double *v_n, double *a, double *K_P, double *P_t_t1, double *tmp, double *P)
 {
   if (t+1 < smpl)
@@ -328,7 +321,7 @@ BlockKalmanFilter::block_kalman_filter_ss(double *P_mf, double *v_pp, double *K,
           //v = Y(:,t)-a(mf);
           for (int i = 0; i < pp; i++)
             v[i]  = Y[i + t * pp] - a[mf[i]];
-          
+
           //a = T*(a+K*v);
           for (int i = pure_obs; i < n; i++)
             {
@@ -344,7 +337,7 @@ BlockKalmanFilter::block_kalman_filter_ss(double *P_mf, double *v_pp, double *K,
                 res += T[j  * n + i] * v_n[j];
               a[i] = res;
             }
-        
+
           //lik(t) = transpose(v)*iF*v;
           for (int i = 0; i < pp; i++)
             {
@@ -371,19 +364,19 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
 {
   while (notsteady && t < smpl)
     {
-      if(missing_observations)
+      if (missing_observations)
         {
 
           // retrieve the d_index
-          pd_index = mxGetCell( pdata_index, t);
-          dd_index = (double*)mxGetData(pd_index);
+          pd_index = mxGetCell(pdata_index, t);
+          dd_index = (double *) mxGetData(pd_index);
           size_d_index = mxGetM(pd_index);
           d_index.resize(size_d_index);
           for (int i = 0; i < size_d_index; i++)
             {
               d_index[i] = ceil(dd_index[i]) - 1;
             }
-          
+
           //v = Y(:,t) - a(mf)
           int i_i = 0;
           //#pragma omp parallel for shared(v, i_i, d_index) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
@@ -393,8 +386,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
               v[i_i]  = Y[*i + t * pp] - a[mf[*i]];
               i_i++;
             }
-            
-          
+
           //F  = P(mf,mf) + H;
           i_i = 0;
           if (H_size == 1)
@@ -417,16 +409,16 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                     iF[i_i + j_j * size_d_index] = F[i_i + j_j * size_d_index] = P[mf[*i] + mf[*j] * n] + H[*i + *j * pp];
                 }
             }
-            
+
         }
       else
         {
           size_d_index = pp;
-          
+
           //v = Y(:,t) - a(mf)
           for (int i = 0; i < pp; i++)
             v[i]  = Y[i + t * pp] - a[mf[i]];
-          
+
           //F  = P(mf,mf) + H;
           if (H_size == 1)
             {
@@ -441,20 +433,21 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                   iF[i + j * pp] = F[i + j * pp] = P[mf[i] + mf[j] * n] + H[i + j * pp];
             }
         }
-      
-     
+
       /* Computes the norm of iF */
       double anorm = dlange("1", &size_d_index, &size_d_index, iF, &size_d_index, w);
       //mexPrintf("anorm = %f\n",anorm);
 
       /* Modifies F in place with a LU decomposition */
       dgetrf(&size_d_index, &size_d_index, iF, &size_d_index, ipiv, &info);
-      if (info != 0) mexPrintf("dgetrf failure with error %d\n", (int) info);
- 
+      if (info != 0)
+        mexPrintf("dgetrf failure with error %d\n", (int) info);
+
       /* Computes the reciprocal norm */
       dgecon("1", &size_d_index, iF, &size_d_index, &anorm, &rcond, w, iw, &info);
-      if (info != 0) mexPrintf("dgecon failure with error %d\n", (int) info);
-      
+      if (info != 0)
+        mexPrintf("dgecon failure with error %d\n", (int) info);
+
       if (rcond < kalman_tol)
         if (not_all_abs_F_bellow_crit(F, size_d_index * size_d_index, kalman_tol))   //~all(abs(F(:))<kalman_tol)
           {
@@ -481,55 +474,56 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                   res += T[i + j *n] * a[j];
                 tmp_a[i] = res;
               }
-           memcpy(a, tmp_a, n * sizeof(double));
+            memcpy(a, tmp_a, n * sizeof(double));
 
-           //P = T*P*transpose(T)+QQ;
-           memset(tmp, 0, n * n_state * sizeof(double));
+            //P = T*P*transpose(T)+QQ;
+            memset(tmp, 0, n * n_state * sizeof(double));
 
-           for (int i = 0; i < n; i++)
-            for (int j = pure_obs; j < n; j++)
+            for (int i = 0; i < n; i++)
+              for (int j = pure_obs; j < n; j++)
+                {
+                  int j1 = j - pure_obs;
+                  int j1_n_state = j1 * n_state - pure_obs;
+                  for (int k = pure_obs; k < i_nz_state_var[i]; k++)
+                    tmp[i + j1 * n ] += T[i + k * n] * P[k + j1_n_state];
+                }
+
+            memset(P, 0, n * n * sizeof(double));
+            int n_n_obs = n * pure_obs;
+            for (int i = 0; i < n; i++)
+              for (int j = i; j < n; j++)
+                {
+                  for (int k = pure_obs; k < i_nz_state_var[j]; k++)
+                    {
+                      int k_n = k * n;
+                      P[i * n + j] += tmp[i + k_n - n_n_obs] * T[j + k_n];
+                    }
+                }
+
+            for (int i = 0; i < n; i++)
               {
-                int j1 = j - pure_obs;
-                int j1_n_state = j1 * n_state - pure_obs;
-                for (int k = pure_obs; k < i_nz_state_var[i]; k++)
-                  tmp[i + j1 * n ] += T[i + k * n] * P[k + j1_n_state];
+                for (int j = i; j < n; j++)
+                  P[j + i * n] += QQ[j + i * n];
+                for (int j = i + 1; j < n; j++)
+                  P[i + j * n] = P[j + i * n];
               }
-
-          memset(P, 0, n * n * sizeof(double));
-          int n_n_obs = n * pure_obs;
-          for (int i = 0; i < n; i++)
-            for (int j = i; j < n; j++)
-              {
-                for (int k = pure_obs; k < i_nz_state_var[j]; k++)
-                  {
-                    int k_n = k * n;
-                    P[i * n + j] += tmp[i + k_n - n_n_obs] * T[j + k_n];
-                  }
-              }
-          
-          for ( int i = 0; i < n; i++)
-            {
-              for ( int j = i ; j < n; j++)
-                P[j + i * n] += QQ[j + i * n];
-              for ( int j = i + 1; j < n; j++)
-                P[i + j * n] = P[j + i * n];
-            }
-         }
+          }
       else
         {
           F_singular = false;
-          
+
           //dF     = det(F);
           dF     = det(iF, size_d_index, ipiv);
 
           //iF     = inv(F);
           //int lwork = 4/*2*/* pp;
           dgetri(&size_d_index, iF, &size_d_index, ipiv, w, &lw, &info);
-          if (info != 0) mexPrintf("dgetri failure with error %d\n", (int) info);
+          if (info != 0)
+            mexPrintf("dgetri failure with error %d\n", (int) info);
 
           //lik(t) = log(dF)+transpose(v)*iF*v;
 #ifdef USE_OMP
-#pragma omp parallel for shared(v_pp) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# pragma omp parallel for shared(v_pp) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
 #endif
           for (int i = 0; i < size_d_index; i++)
             {
@@ -550,7 +544,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
             {
               //K      = P(:,mf)*iF;
 #ifdef USE_OMP
-#pragma omp parallel for shared(P_mf) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# pragma omp parallel for shared(P_mf) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
 #endif
               for (int i = 0; i < n; i++)
                 {
@@ -567,9 +561,9 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 for (int j = 0; j < pp; j++)
                   P_mf[i + j * n] = P[i + mf[j] * n];
             }
-          
+
 #ifdef USE_OMP
-#pragma omp parallel for shared(K) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# pragma omp parallel for shared(K) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
 #endif
           for (int i = 0; i < n; i++)
             for (int j = 0; j < size_d_index; j++)
@@ -580,10 +574,10 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                   res += P_mf[i + k * n] * iF[j_pp + k];
                 K[i + j * n] = res;
               }
-          
+
           //a      = T*(a+K*v);
 #ifdef USE_OMP
-#pragma omp parallel for shared(v_n) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# pragma omp parallel for shared(v_n) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
 #endif
           for (int i = pure_obs; i < n; i++)
             {
@@ -592,9 +586,9 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 res += K[j  * n + i] * v[j];
               v_n[i] = res + a[i];
             }
-          
+
 #ifdef USE_OMP
-#pragma omp parallel for shared(a) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# pragma omp parallel for shared(a) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
 #endif
           for (int i = 0; i < n; i++)
             {
@@ -603,7 +597,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 res += T[j  * n + i] * v_n[j];
               a[i] = res;
             }
-          
+
           if (missing_observations)
             {
               //P      = T*(P-K*P(mf,:))*transpose(T)+QQ;
@@ -617,17 +611,17 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
             {
               //P      = T*(P-K*P(mf,:))*transpose(T)+QQ;
 #ifdef USE_OMP
-#pragma omp parallel for shared(P_mf) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# pragma omp parallel for shared(P_mf) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
 #endif
               for (int i = 0; i < pp; i++)
                 for (int j = pure_obs; j < n; j++)
                   P_mf[i + j * pp] = P[mf[i] + j * n];
             }
-          
+
 #ifdef BLAS
-#ifdef USE_OMP
-#pragma omp parallel for shared(K_P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
-#endif
+# ifdef USE_OMP
+#  pragma omp parallel for shared(K_P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+# endif
           for (int i = 0; i < n; i++)
             for (int j = i; j < n; j++)
               {
@@ -649,7 +643,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
           memcpy(P, QQ, n * n *sizeof(double));
           blas_int n_b = n;
           /*mexPrintf("sizeof(n_b)=%d, n_b=%d, sizeof(n)=%d, n=%d\n",sizeof(n_b),n_b,sizeof(n),n);
-          mexEvalString("drawnow;");*/
+            mexEvalString("drawnow;");*/
           dsymm("R", "U", &n_b, &n_b,
                 &one, P_t_t1, &n_b,
                 T, &n_b, &zero,
@@ -659,8 +653,8 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 T, &n_b, &one,
                 P, &n_b);
 #else
-#ifdef CUBLAS
-         for (int i = 0; i < n; i++)
+# ifdef CUBLAS
+          for (int i = 0; i < n; i++)
             for (int j = i; j < n; j++)
               {
                 double res = 0.0;
@@ -689,29 +683,29 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
               return false;
             }
           /*int device;
-          cudaGetDevice(&device);*/
+            cudaGetDevice(&device);*/
           int n2 = n * n;
-          double* d_A = 0;
-          double* d_B = 0;
-          double* d_C = 0;
-          double* d_D = 0;
+          double *d_A = 0;
+          double *d_B = 0;
+          double *d_C = 0;
+          double *d_D = 0;
           // Allocate device memory for the matrices
-          if (cudaMalloc((void**)&d_A, n2 * sizeof(double)) != cudaSuccess)
+          if (cudaMalloc((void **) &d_A, n2 * sizeof(double)) != cudaSuccess)
             {
               mexPrintf("!!!! device memory allocation error (allocate A)\n");
               return false;
             }
-          if (cudaMalloc((void**)&d_B, n2 * sizeof(d_B[0])) != cudaSuccess)
+          if (cudaMalloc((void **) &d_B, n2 * sizeof(d_B[0])) != cudaSuccess)
             {
               mexPrintf("!!!! device memory allocation error (allocate B)\n");
               return false;
             }
-          if (cudaMalloc((void**)&d_C, n2 * sizeof(d_C[0])) != cudaSuccess)
+          if (cudaMalloc((void **) &d_C, n2 * sizeof(d_C[0])) != cudaSuccess)
             {
               mexPrintf("!!!! device memory allocation error (allocate C)\n");
               return false;
             }
-          if (cudaMalloc((void**)&d_D, n2 * sizeof(d_D[0])) != cudaSuccess)
+          if (cudaMalloc((void **) &d_D, n2 * sizeof(d_D[0])) != cudaSuccess)
             {
               mexPrintf("!!!! device memory allocation error (allocate D)\n");
               return false;
@@ -734,7 +728,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
             {
               mexPrintf("!!!! device access error (write C)\n");
               return false;
-           }
+            }
           mexPrintf("just before calling\n");
           mexEvalString("drawnow;");
           status = cublasSetVector(n2, sizeof(QQ[0]), QQ, 1, d_D, 1);
@@ -742,22 +736,22 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
             {
               mexPrintf("!!!! device access error (write D)\n");
               return false;
-           }
+            }
 
           // Performs operation using plain C code
 
           cublasDsymm(handle, CUBLAS_SIDE_RIGHT, CUBLAS_FILL_MODE_UPPER, n, n,
-                &one, d_A, n,
-                d_B, n, &zero,
-                d_C, n);
+                      &one, d_A, n,
+                      d_B, n, &zero,
+                      d_C, n);
           /*dgemm("N", "T", &n_b, &n_b,
-                &n_b, &one, tmp, &n_b,
-                T, &n_b, &one,
-                P, &n_b);*/
+            &n_b, &one, tmp, &n_b,
+            T, &n_b, &one,
+            P, &n_b);*/
           cublasDgemm(handle, CUBLAS_OP_N, CUBLAS_OP_T, n, n,
-                n, &one, d_C, n,
-                d_B, n, &one,
-                d_D, n);
+                      n, &one, d_C, n,
+                      d_B, n, &one,
+                      d_D, n);
           //double_symm(n, &one, h_A, h_B, &zero, h_C);
 
           status = cublasGetVector(n2, sizeof(P[0]), d_D, 1, P, 1);
@@ -767,14 +761,14 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
               return false;
             }
 
-#else
-#ifdef USE_OMP
-#pragma omp parallel for shared(K_P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
-#endif
+# else
+#  ifdef USE_OMP
+#   pragma omp parallel for shared(K_P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+#  endif
           for (int i = pure_obs; i < n; i++)
             {
               unsigned int i1 = i - pure_obs;
-              for (int j = i ; j < n; j++)
+              for (int j = i; j < n; j++)
                 {
                   unsigned int j1 = j - pure_obs;
                   double res = 0.0;
@@ -785,9 +779,9 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 }
             }
 
-#ifdef USE_OMP
-#pragma omp parallel for shared(P_t_t1) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
-#endif
+#  ifdef USE_OMP
+#   pragma omp parallel for shared(P_t_t1) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+#  endif
           for (int i = pure_obs; i < n; i++)
             {
               unsigned int i1 = i - pure_obs;
@@ -801,9 +795,9 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
 
           memset(tmp, 0, n * n_state * sizeof(double));
 
-#ifdef USE_OMP
-#pragma omp parallel for shared(tmp) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
-#endif
+#  ifdef USE_OMP
+#   pragma omp parallel for shared(tmp) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+#  endif
           for (int i = 0; i < n; i++)
             {
               int max_k = i_nz_state_var[i];
@@ -811,7 +805,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 {
                   int j1 = j - pure_obs;
                   int j1_n_state = j1 * n_state - pure_obs;
-                  int indx_tmp = i + j1 * n ;
+                  int indx_tmp = i + j1 * n;
                   for (int k = pure_obs; k < max_k; k++)
                     tmp[indx_tmp] += T[i + k * n] * P_t_t1[k + j1_n_state];
                 }
@@ -819,10 +813,10 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
 
           memset(P, 0, n * n * sizeof(double));
 
-          int n_n_obs = - n * pure_obs;
-#ifdef USE_OMP
-#pragma omp parallel for shared(P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
-#endif
+          int n_n_obs = -n * pure_obs;
+#  ifdef USE_OMP
+#   pragma omp parallel for shared(P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+#  endif
           for (int i = 0; i < n; i++)
             {
               for (int j = i; j < n; j++)
@@ -837,17 +831,17 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
                 }
             }
 
-#ifdef USE_OMP
-#pragma omp parallel for shared(P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
-#endif
-          for ( int i = 0; i < n; i++)
+#  ifdef USE_OMP
+#   pragma omp parallel for shared(P) num_threads(atoi(getenv("DYNARE_NUM_THREADS")))
+#  endif
+          for (int i = 0; i < n; i++)
             {
-              for ( int j = i ; j < n; j++)
+              for (int j = i; j < n; j++)
                 P[j + i * n] += QQ[j + i * n];
-              for ( int j = i + 1; j < n; j++)
+              for (int j = i + 1; j < n; j++)
                 P[i + j * n] = P[j + i * n];
             }
-#endif
+# endif
 #endif
           if (t >= no_more_missing_observations)
             {
@@ -861,7 +855,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
               notsteady = max_abs > riccati_tol;
 
               //oldK = K(:);
-             
+
               memcpy(oldK, K, n * pp * sizeof(double));
             }
         }
@@ -875,8 +869,7 @@ BlockKalmanFilter::block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf,
   return true;
 }
 
-
-void 
+void
 BlockKalmanFilter::return_results_and_clean(int nlhs, mxArray *plhs[], double *P_mf[], double *v_pp[], double *K[], double *v_n[], double *a[], double *K_P[], double *P_t_t1[], double *tmp[], double *P[])
 {
   plhs[0] = mxCreateDoubleScalar(0);
@@ -884,7 +877,7 @@ BlockKalmanFilter::return_results_and_clean(int nlhs, mxArray *plhs[], double *P
   if (nlhs >= 2)
     {
       plhs[1] = mxCreateDoubleMatrix(1, 1, mxREAL);
-      double* pind = mxGetPr(plhs[1]);
+      double *pind = mxGetPr(plhs[1]);
       pind[0] = LIK;
     }
 
@@ -903,7 +896,7 @@ BlockKalmanFilter::return_results_and_clean(int nlhs, mxArray *plhs[], double *P
   mxFree(ipiv);
   mxFree(oldK);
   //mxFree(P_mf);
-  
+
   mxDestroyArray(pa);
   mxDestroyArray(p_tmp);
   mxDestroyArray(pQQ);
@@ -918,9 +911,8 @@ BlockKalmanFilter::return_results_and_clean(int nlhs, mxArray *plhs[], double *P
 void
 mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
 {
-  double *P_mf, * v_pp, *v_n, *a, *K, *K_P, *P_t_t1, *tmp, *P;
+  double *P_mf, *v_pp, *v_n, *a, *K, *K_P, *P_t_t1, *tmp, *P;
   BlockKalmanFilter block_kalman_filter(nlhs, plhs, nrhs, prhs, &P_mf, &v_pp, &K, &v_n, &a, &K_P, &P_t_t1, &tmp, &P);
   if (block_kalman_filter.block_kalman_filter(nlhs, plhs, P_mf, v_pp, K, K_P, a, K_P, P_t_t1, tmp, P))
     block_kalman_filter.return_results_and_clean(nlhs, plhs, &P_mf, &v_pp, &K, &K_P, &a, &K_P, &P_t_t1, &tmp, &P);
 }
-
diff --git a/mex/sources/block_kalman_filter/block_kalman_filter.h b/mex/sources/block_kalman_filter/block_kalman_filter.h
index 98803e024..28cb75396 100644
--- a/mex/sources/block_kalman_filter/block_kalman_filter.h
+++ b/mex/sources/block_kalman_filter/block_kalman_filter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2012 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -32,30 +32,30 @@ using namespace std;
 
 class BlockKalmanFilter
 {
-  public:
-  mxArray *pT , *pR, *pQ, *pH, *pP, *pY, *pQQ, *pv, *pF, *piF, *p_P_t_t1, *pK, *p_K_P;
-  double *T , *R, *Q , *H, *Y, *mfd, *QQ, *v, *F, *iF;
+public:
+  mxArray *pT, *pR, *pQ, *pH, *pP, *pY, *pQQ, *pv, *pF, *piF, *p_P_t_t1, *pK, *p_K_P;
+  double *T, *R, *Q, *H, *Y, *mfd, *QQ, *v, *F, *iF;
   int start, pure_obs, smpl, n, n_state, n_shocks, H_size;
   double kalman_tol, riccati_tol, dF, LIK, Inf, pi;
   lapack_int pp, lw, info;
 
-  double* nz_state_var;
+  double *nz_state_var;
   int *i_nz_state_var, *mf;
   int n_diag, t;
   mxArray *M_;
-  mxArray* pa, *p_tmp, *p_tmp1, *plik;
+  mxArray *pa, *p_tmp, *p_tmp1, *plik;
   double *tmp_a, *tmp1, *lik, *v_n, *w, *oldK;
   bool notsteady, F_singular, missing_observations;
   lapack_int *iw, *ipiv;
   double anorm, rcond;
   lapack_int size_d_index;
   int no_more_missing_observations, number_of_observations;
-  const mxArray* pdata_index;
+  const mxArray *pdata_index;
   vector<int> d_index;
-  const mxArray* pd_index;
-  double* dd_index;
+  const mxArray *pd_index;
+  double *dd_index;
 
-  public:
+public:
   BlockKalmanFilter(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], double *P_mf[], double *v_pp[], double *K[], double *v_n[], double *a[], double *K_P[], double *P_t_t1[], double *tmp[], double *P[]);
   bool block_kalman_filter(int nlhs, mxArray *plhs[], double *P_mf, double *v_pp, double *K, double *v_n, double *a, double *K_P, double *P_t_t1, double *tmp, double *P);
   void block_kalman_filter_ss(double *P_mf, double *v_pp, double *K, double *v_n, double *a, double *K_P, double *P_t_t1, double *tmp, double *P);
diff --git a/mex/sources/bytecode/ErrorHandling.hh b/mex/sources/bytecode/ErrorHandling.hh
index 760d0ec7c..82d4b2c8c 100644
--- a/mex/sources/bytecode/ErrorHandling.hh
+++ b/mex/sources/bytecode/ErrorHandling.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2015 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -24,8 +24,20 @@
 #include <iostream>
 #include <sstream>
 #include <map>
+#include <stack>
 #define BYTE_CODE
 #include "CodeInterpreter.hh"
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#ifndef M_PI
+# define M_PI (3.14159265358979323846)
+#endif
+
+#ifndef M_SQRT2
+# define M_SQRT2 1.41421356237309504880
+#endif
+
 #ifdef DEBUG_EX
 # include <math.h>
 # include "mex_interface.hh"
@@ -37,124 +49,115 @@
 # define CHAR_LENGTH 2
 #endif
 
-//Work around for: https://sourceware.org/bugzilla/show_bug.cgi?id=19439
-#ifndef __builtin_isnan
-# define isnan(x) std::isnan(x)
-#endif
-
-#ifndef __builtin_isinf
-# define isinf(x) std::isinf(x)
-#endif
-
 #ifdef _MSC_VER
-#include <limits>
-#define M_E 2.71828182845904523536
-#define M_LOG2E 1.44269504088896340736
-#define M_LOG10E 0.434294481903251827651
-#define M_LN2 0.693147180559945309417
-#define M_LN10 2.30258509299404568402
-#define M_PI 3.14159265358979323846
-#define M_PI_2 1.57079632679489661923
-#define M_PI_4 0.785398163397448309616
-#define M_1_PI 0.318309886183790671538
-#define M_2_PI 0.636619772367581343076
-#define M_1_SQRTPI 0.564189583547756286948
-#define M_2_SQRTPI 1.12837916709551257390
-#define M_SQRT2 1.41421356237309504880
-#define M_SQRT_2 0.707106781186547524401
-#define NAN numeric_limits<double>::quiet_NaN()
+# include <limits>
+# define M_E 2.71828182845904523536
+# define M_LOG2E 1.44269504088896340736
+# define M_LOG10E 0.434294481903251827651
+# define M_LN2 0.693147180559945309417
+# define M_LN10 2.30258509299404568402
+# define M_PI 3.14159265358979323846
+# define M_PI_2 1.57079632679489661923
+# define M_PI_4 0.785398163397448309616
+# define M_1_PI 0.318309886183790671538
+# define M_2_PI 0.636619772367581343076
+# define M_1_SQRTPI 0.564189583547756286948
+# define M_2_SQRTPI 1.12837916709551257390
+# define M_SQRT2 1.41421356237309504880
+# define M_SQRT_2 0.707106781186547524401
+# define NAN numeric_limits<double>::quiet_NaN()
 
-#define isnan(x) _isnan(x)
-#define isinf(x) (!_finite(x))
-#define fpu_error(x) (isinf(x) || isnan(x))
+# define isnan(x) _isnan(x)
+# define isinf(x) (!_finite(x))
+# define fpu_error(x) (isinf(x) || isnan(x))
 
-#define finite(x) _finite(x)
+# define finite(x) _finite(x)
 
 class MSVCpp_missings
 {
-  public:
+public:
   inline double
   asinh(double x) const
-    {
-      if(x==0.0)
-        return 0.0;
-      double ax = abs(x);
-      return log(x+ax*sqrt(1.+1./(ax*ax)));
-    }
+  {
+    if (x == 0.0)
+      return 0.0;
+    double ax = abs(x);
+    return log(x+ax*sqrt(1.+1./(ax*ax)));
+  }
 
   inline double
   acosh(double x) const
-    {
-      if(x==0.0)
-        return 0.0;
-      double ax = abs(x);
-      return log(x+ax*sqrt(1.-1./(ax*ax)));
-    }
+  {
+    if (x == 0.0)
+      return 0.0;
+    double ax = abs(x);
+    return log(x+ax*sqrt(1.-1./(ax*ax)));
+  }
 
   inline double
   atanh(double x) const
-    {
-      return log((1+x)/(1-x))/2;
-    }
+  {
+    return log((1+x)/(1-x))/2;
+  }
 
   inline double
   erf(double x) const
-    {
-      const double a1 = -1.26551223,   a2 = 1.00002368,
-                   a3 =  0.37409196,   a4 = 0.09678418,
-                   a5 = -0.18628806,   a6 = 0.27886807,
-                   a7 = -1.13520398,   a8 = 1.48851587,
-                   a9 = -0.82215223,  a10 = 0.17087277;
-     double v = 1;
-     double z = abs(x);
-     if (z <= 0)
-       return v;
-     double t = 1 / (1 + 0.5 * z);
-     v = t*exp((-z*z) +a1+t*(a2+t*(a3+t*(a4+t*(a5+t*(a6+t*(a7+t*(a8+t*(a9+t*a10)))))))));
-     if (x < 0)
-       v = 2 - v;
-     return 1 - v;
-    }
+  {
+    const double a1 = -1.26551223,   a2 = 1.00002368,
+      a3 =  0.37409196,   a4 = 0.09678418,
+      a5 = -0.18628806,   a6 = 0.27886807,
+      a7 = -1.13520398,   a8 = 1.48851587,
+      a9 = -0.82215223,  a10 = 0.17087277;
+    double v = 1;
+    double z = abs(x);
+    if (z <= 0)
+      return v;
+    double t = 1 / (1 + 0.5 * z);
+    v = t*exp((-z*z) +a1+t*(a2+t*(a3+t*(a4+t*(a5+t*(a6+t*(a7+t*(a8+t*(a9+t*a10)))))))));
+    if (x < 0)
+      v = 2 - v;
+    return 1 - v;
+  }
 
   inline double
   nearbyint(double x) const
-    {
-      return floor(x + 0.5);
-    }
+  {
+    return floor(x + 0.5);
+  }
 
   inline double
   fmax(double x, double y) const
-    {
-      if (x > y)
-        return x;
-      else
-        return y;
-   }
+  {
+    if (x > y)
+      return x;
+    else
+      return y;
+  }
 
   inline double
   fmin(double x, double y) const
-    {
-      if (x < y)
-        return x;
-      else
-        return y;
-    }
+  {
+    if (x < y)
+      return x;
+    else
+      return y;
+  }
 
 };
 #endif
 
 #ifdef __MINGW32__
-#define __CROSS_COMPILATION__
+# define __CROSS_COMPILATION__
 #endif
 
 #ifdef __MINGW64__
-#define __CROSS_COMPILATION__
+# define __CROSS_COMPILATION__
 #endif
 
 #ifdef __CROSS_COMPILATION__
-#define M_PI 3.14159265358979323846
-#define M_SQRT2 1.41421356237309504880
-#define finite(x) !std::isfinite(x)
+# define M_PI 3.14159265358979323846
+# define M_SQRT2 1.41421356237309504880
+# define finite(x) !std::isfinite(x)
 #endif
 
 //#define DEBUG
@@ -163,11 +166,9 @@ using namespace std;
 const int NO_ERROR_ON_EXIT = 0;
 const int ERROR_ON_EXIT = 1;
 
-
 typedef vector<pair<Tags, void * > > code_liste_type;
 typedef code_liste_type::const_iterator it_code_type;
 
-
 class GeneralExceptionHandling
 {
   string ErrorMsg;
@@ -250,7 +251,7 @@ public:
                                                                value2(value2_arg)
   {
     ostringstream tmp;
-    if (abs(value1) > 1e-10 )
+    if (fabs(value1) > 1e-10)
       tmp << " with X=" << value1 << "\n";
     else
       tmp << " with X=" << value1 << " and a=" << value2 << "\n";
@@ -289,11 +290,11 @@ struct s_plan
 };
 
 struct table_conditional_local_type
-        {
-          bool is_cond;
-          int var_exo, var_endo;
-          double constrained_value;
-        };
+{
+  bool is_cond;
+  int var_exo, var_endo;
+  double constrained_value;
+};
 typedef vector<table_conditional_local_type> vector_table_conditional_local_type;
 typedef map< int, vector_table_conditional_local_type > table_conditional_global_type;
 #ifdef MATLAB_MEX_FILE
@@ -313,7 +314,7 @@ public:
   double *y, *ya;
   int y_size;
   double *T;
-  int nb_row_xd, nb_row_x, col_x;
+  int nb_row_xd, nb_row_x, col_x, col_y;
   int y_kmin, y_kmax, periods;
   double *x, *params;
   double *u;
@@ -327,9 +328,9 @@ public:
 
   ExpressionType EQN_type;
   it_code_type it_code_expr;
-  /*unsigned int*/size_t nb_endo, nb_exo, nb_param;
+  /*unsigned int*/ size_t nb_endo, nb_exo, nb_param;
   char *P_endo_names, *P_exo_names, *P_param_names;
-  size_t/*unsigned int*/ endo_name_length, exo_name_length, param_name_length;
+  size_t /*unsigned int*/ endo_name_length, exo_name_length, param_name_length;
   unsigned int EQN_equation, EQN_block, EQN_block_number;
   unsigned int EQN_dvar1, EQN_dvar2, EQN_dvar3;
   vector<pair<string, pair<SymbolType, unsigned int> > > Variable_list;
@@ -385,7 +386,7 @@ public:
     string tmp_n(str.length(), ' ');
     string dollar, pound, tilde;
     dollar = "$";
-    pound = "£";
+    pound = "£";
     tilde = "~";
     for (unsigned int i = 0; i < str.length(); i++)
       {
@@ -394,9 +395,9 @@ public:
         else
           {
             if (dollar.compare(&str[i]) == 0)
-              pos1 = int(temp.length());
+              pos1 = int (temp.length());
             else
-              pos2 = int(temp.length());
+              pos2 = int (temp.length());
             if (pos1 >= 0 && pos2 >= 0)
               {
                 tmp_n.erase(pos1, pos2-pos1+1);
@@ -413,14 +414,14 @@ public:
   load_variable_list()
   {
     ostringstream res;
-    for (unsigned int variable_num = 0; variable_num < (unsigned int)nb_endo; variable_num++)
+    for (unsigned int variable_num = 0; variable_num < (unsigned int) nb_endo; variable_num++)
       {
         for (unsigned int i = 0; i < endo_name_length; i++)
           if (P_endo_names[CHAR_LENGTH*(variable_num+i*nb_endo)] != ' ')
             res << P_endo_names[CHAR_LENGTH*(variable_num+i*nb_endo)];
         Variable_list.push_back(make_pair(res.str(), make_pair(eEndogenous, variable_num)));
       }
-    for (unsigned int variable_num = 0; variable_num < (unsigned int)nb_exo; variable_num++)
+    for (unsigned int variable_num = 0; variable_num < (unsigned int) nb_exo; variable_num++)
       {
         for (unsigned int i = 0; i < exo_name_length; i++)
           if (P_exo_names[CHAR_LENGTH*(variable_num+i*nb_exo)] != ' ')
@@ -450,7 +451,7 @@ public:
           }
         i++;
       }
-    return(-1);
+    return (-1);
   }
 
   inline string
@@ -631,8 +632,8 @@ public:
     while (go_on)
       {
 #ifdef MATLAB_MEX_FILE
-	      if ( utIsInterruptPending() )
-		      throw UserExceptionHandling();
+        if (utIsInterruptPending())
+          throw UserExceptionHandling();
 #endif
         switch (it_code->first)
           {
@@ -698,7 +699,7 @@ public:
                 var = ((FLDV_ *) it_code->second)->get_pos();
 #ifdef DEBUG
                 mexPrintf("FLDV_ Param var=%d\n", var);
-                mexPrintf("get_variable(eParameter, var)=%s\n",get_variable(eParameter, var).c_str());
+                mexPrintf("get_variable(eParameter, var)=%s\n", get_variable(eParameter, var).c_str());
                 mexEvalString("drawnow;");
 #endif
                 Stack.push(get_variable(eParameter, var));
@@ -710,7 +711,7 @@ public:
                 lag = ((FLDV_ *) it_code->second)->get_lead_lag();
 #ifdef DEBUG
                 mexPrintf("FLDV_ endo var=%d, lag=%d\n", var, lag);
-                mexPrintf("get_variable(eEndogenous, var)=%s, compute=%d\n",get_variable(eEndogenous, var).c_str(), compute);
+                mexPrintf("get_variable(eEndogenous, var)=%s, compute=%d\n", get_variable(eEndogenous, var).c_str(), compute);
                 mexPrintf("it_=%d, lag=%d, y_size=%d, var=%d, y=%x\n", it_, lag, y_size, var, y);
                 mexEvalString("drawnow;");
 #endif
@@ -1328,7 +1329,7 @@ public:
                       tmp_out << "$";
                     tmp_out << " / ";
                     if (isinf(r))
-                      tmp_out << "£";
+                      tmp_out << "£";
                   }
                 else
                   tmp_out << " / ";
@@ -1491,7 +1492,7 @@ public:
                 if (compute)
                   {
                     if (isnan(r))
-                      tmp_out << "$ ^ " << "£";
+                      tmp_out << "$ ^ " << "£";
                     else
                       tmp_out << " ^ ";
                   }
@@ -1511,7 +1512,7 @@ public:
                   Stack.pop();
                   if (compute)
                     {
-                      int derivOrder = int(nearbyint(Stackf.top()));
+                      int derivOrder = int (nearbyint(Stackf.top()));
                       Stackf.pop();
                       if (fabs(v1f) < NEAR_ZERO && v2f > 0
                           && derivOrder > v2f
@@ -1533,7 +1534,7 @@ public:
                   if (compute)
                     {
                       if (isnan(r))
-                        tmp_out << "$ PowerDeriv " << "£";
+                        tmp_out << "$ PowerDeriv " << "£";
                       else
                         tmp_out << "PowerDeriv";
                     }
@@ -1607,7 +1608,7 @@ public:
                 if (compute)
                   {
                     if (isnan(r))
-                      tmp_out << "$log" << "£" << "(" << v1 << ")";
+                      tmp_out << "$log" << "£" << "(" << v1 << ")";
                     else
                       tmp_out << "log(" << v1 << ")";
                   }
@@ -1625,7 +1626,7 @@ public:
                 if (compute)
                   {
                     if (isnan(r))
-                      tmp_out << "$log10" << "£" << "(" << v1 << ")";
+                      tmp_out << "$log10" << "£" << "(" << v1 << ")";
                     else
                       tmp_out << "log10(" << v1 << ")";
                   }
@@ -2231,6 +2232,18 @@ public:
     it_code_ret = it_code;
     return (tmp_out.str());
   }
+  void
+
+  inline
+  test_mxMalloc(void *z, int line, string file, string func, int amount)
+  {
+    if (z == NULL && (amount > 0))
+      {
+        ostringstream tmp;
+        tmp << " mxMalloc: out of memory " << amount << " bytes required at line " << line << " in function " << func << " (file " << file;
+        throw FatalExceptionHandling(tmp.str());
+      }
+  }
 
 };
 
diff --git a/mex/sources/bytecode/Evaluate.cc b/mex/sources/bytecode/Evaluate.cc
index b0208bc0e..16b4e4d22 100644
--- a/mex/sources/bytecode/Evaluate.cc
+++ b/mex/sources/bytecode/Evaluate.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Dynare Team
+ * Copyright (C) 2013-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -35,8 +35,8 @@ Evaluate::Evaluate()
   block = -1;
 }
 
-Evaluate::Evaluate(const int y_size_arg, const int y_kmin_arg, const int y_kmax_arg, const bool print_it_arg, const bool steady_state_arg, const int periods_arg, const int minimal_solving_periods_arg, const double slowc_arg):
-print_it(print_it_arg),  minimal_solving_periods(minimal_solving_periods_arg)
+Evaluate::Evaluate(const int y_size_arg, const int y_kmin_arg, const int y_kmax_arg, const bool print_it_arg, const bool steady_state_arg, const int periods_arg, const int minimal_solving_periods_arg, const double slowc_arg) :
+  print_it(print_it_arg),  minimal_solving_periods(minimal_solving_periods_arg)
 {
   symbol_table_endo_nbr = 0;
   Block_List_Max_Lag = 0;
@@ -107,7 +107,6 @@ Evaluate::log10_1(double a)
   return r;
 }
 
-
 void
 Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int block_num, const int size, const bool steady_state,*/ const bool no_derivative)
 {
@@ -137,14 +136,14 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
         }
     }
 #ifdef MATLAB_MEX_FILE
-	if ( utIsInterruptPending() )
-		throw UserExceptionHandling();
+  if (utIsInterruptPending())
+    throw UserExceptionHandling();
 #endif
-  
+
   while (go_on)
     {
 #ifdef DEBUG
-      mexPrintf("it_code->first=%d\n",it_code->first);
+      mexPrintf("it_code->first=%d\n", it_code->first);
 #endif
       switch (it_code->first)
         {
@@ -738,7 +737,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               pos_col = ((FSTPG3_ *) it_code->second)->get_col_pos();
 #ifdef DEBUG
               mexPrintf("Endo eq=%d, pos_col=%d, size=%d, jacob=%x\n", eq, pos_col, size, jacob);
-              mexPrintf("jacob=%x\n",jacob);
+              mexPrintf("jacob=%x\n", jacob);
 #endif
               jacob[eq + size*pos_col] = rr;
               break;
@@ -843,7 +842,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
             case oLess:
               Stack.push(double (v1 < v2));
 #ifdef DEBUG
-              mexPrintf("v1=%f v2=%f v1 < v2 = %f\n",v1,v2,double(v1 < v2));
+              mexPrintf("v1=%f v2=%f v1 < v2 = %f\n", v1, v2, double (v1 < v2));
 #endif
               break;
             case oGreater:
@@ -897,7 +896,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               break;
             case oPowerDeriv:
               {
-                int derivOrder = int(nearbyint(Stack.top()));
+                int derivOrder = int (nearbyint(Stack.top()));
                 Stack.pop();
                 try
                   {
@@ -1172,6 +1171,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               case ExternalFunctionWithFirstandSecondDerivative:
                 {
                   input_arguments = (mxArray **) mxMalloc(nb_input_arguments * sizeof(mxArray *));
+                  test_mxMalloc(input_arguments, __LINE__, __FILE__, __func__, nb_input_arguments * sizeof(mxArray *));
 #ifdef DEBUG
                   mexPrintf("Stack.size()=%d\n", Stack.size());
                   mexEvalString("drawnow;");
@@ -1188,7 +1188,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
                       tmp << " external function: " << function_name << " not found";
                       throw FatalExceptionHandling(tmp.str());
                     }
- 
+
                   double *rr = mxGetPr(output_arguments[0]);
                   Stack.push(*rr);
                   if (function_type == ExternalFunctionWithFirstDerivative || function_type == ExternalFunctionWithFirstandSecondDerivative)
@@ -1215,6 +1215,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               case ExternalFunctionNumericalFirstDerivative:
                 {
                   input_arguments = (mxArray **) mxMalloc((nb_input_arguments+1+nb_add_input_arguments) * sizeof(mxArray *));
+                  test_mxMalloc(input_arguments, __LINE__, __FILE__, __func__, (nb_input_arguments+1+nb_add_input_arguments) * sizeof(mxArray *));
                   mxArray *vv = mxCreateString(arg_func_name.c_str());
                   input_arguments[0] = vv;
                   vv = mxCreateDoubleScalar(fc->get_row());
@@ -1254,6 +1255,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               case ExternalFunctionFirstDerivative:
                 {
                   input_arguments = (mxArray **) mxMalloc(nb_input_arguments * sizeof(mxArray *));
+                  test_mxMalloc(input_arguments, __LINE__, __FILE__, __func__, nb_input_arguments * sizeof(mxArray *));
                   for (unsigned int i = 0; i < nb_input_arguments; i++)
                     {
                       mxArray *vv = mxCreateDoubleScalar(Stack.top());
@@ -1277,6 +1279,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               case ExternalFunctionNumericalSecondDerivative:
                 {
                   input_arguments = (mxArray **) mxMalloc((nb_input_arguments+1+nb_add_input_arguments) * sizeof(mxArray *));
+                  test_mxMalloc(input_arguments, __LINE__, __FILE__, __func__, (nb_input_arguments+1+nb_add_input_arguments) * sizeof(mxArray *));
                   mxArray *vv = mxCreateString(arg_func_name.c_str());
                   input_arguments[0] = vv;
                   vv = mxCreateDoubleScalar(fc->get_row());
@@ -1315,6 +1318,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
               case ExternalFunctionSecondDerivative:
                 {
                   input_arguments = (mxArray **) mxMalloc(nb_input_arguments * sizeof(mxArray *));
+                  test_mxMalloc(input_arguments, __LINE__, __FILE__, __func__, nb_input_arguments * sizeof(mxArray *));
                   for (unsigned int i = 0; i < nb_input_arguments; i++)
                     {
                       mxArray *vv = mxCreateDoubleScalar(Stack.top());
@@ -1484,7 +1488,7 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
           throw FatalExceptionHandling(tmp.str());
         }
 #ifdef DEBUG
-      mexPrintf("it_code++=%d\n",it_code);
+      mexPrintf("it_code++=%d\n", it_code);
 #endif
       it_code++;
     }
@@ -1494,8 +1498,6 @@ Evaluate::compute_block_time(const int Per_u_, const bool evaluate, /*const int
 #endif
 }
 
-
-
 void
 Evaluate::evaluate_over_periods(const bool forward)
 {
@@ -1528,7 +1530,7 @@ Evaluate::solve_simple_one_periods()
 {
   bool cvg = false;
   int iter = 0;
-  double ya ;
+  double ya;
   double slowc_save = slowc;
   res1 = 0;
   while (!(cvg || (iter > maxit_)))
@@ -1537,14 +1539,14 @@ Evaluate::solve_simple_one_periods()
       Per_y_ = it_*y_size;
       ya = y[Block_Contain[0].Variable + Per_y_];
       compute_block_time(0, false, false);
-      if (!finite(res1))
+      if (!isfinite(res1))
         {
           res1 = NAN;
-          while ((isinf(res1) || isnan(res1)) && (slowc > 1e-9) )
+          while ((isinf(res1) || isnan(res1)) && (slowc > 1e-9))
             {
               it_code = start_code;
               compute_block_time(0, false, false);
-              if (!finite(res1))
+              if (!isfinite(res1))
                 {
                   slowc /= 1.5;
                   mexPrintf("Reducing the path length in Newton step slowc=%f\n", slowc);
@@ -1560,7 +1562,7 @@ Evaluate::solve_simple_one_periods()
         continue;
       try
         {
-          y[Block_Contain[0].Variable + Per_y_] += - slowc * divide(rr, g1[0]);
+          y[Block_Contain[0].Variable + Per_y_] += -slowc *divide(rr, g1[0]);
         }
       catch (FloatingPointExceptionHandling &fpeh)
         {
@@ -1578,12 +1580,13 @@ Evaluate::solve_simple_one_periods()
     }
 }
 
-
 void
 Evaluate::solve_simple_over_periods(const bool forward)
 {
   g1 = (double *) mxMalloc(sizeof(double));
+  test_mxMalloc(g1, __LINE__, __FILE__, __func__, sizeof(double));
   r = (double *) mxMalloc(sizeof(double));
+  test_mxMalloc(r, __LINE__, __FILE__, __func__, sizeof(double));
   start_code = it_code;
   if (steady_state)
     {
@@ -1605,7 +1608,7 @@ Evaluate::solve_simple_over_periods(const bool forward)
 
 void
 Evaluate::set_block(const int size_arg, const int type_arg, string file_name_arg, string bin_base_name_arg, const int block_num_arg,
-          const bool is_linear_arg, const int symbol_table_endo_nbr_arg, const int Block_List_Max_Lag_arg, const int Block_List_Max_Lead_arg, const int u_count_int_arg, const int block_arg)
+                    const bool is_linear_arg, const int symbol_table_endo_nbr_arg, const int Block_List_Max_Lag_arg, const int Block_List_Max_Lead_arg, const int u_count_int_arg, const int block_arg)
 {
   size = size_arg;
   type = type_arg;
@@ -1627,7 +1630,6 @@ Evaluate::evaluate_complete(const bool no_derivatives)
   compute_block_time(0, false, no_derivatives);
 }
 
-
 void
 Evaluate::compute_complete_2b(const bool no_derivatives, double *_res1, double *_res2, double *_max_res, int *_max_res_idx)
 {
@@ -1644,21 +1646,21 @@ Evaluate::compute_complete_2b(const bool no_derivatives, double *_res1, double *
       compute_block_time(Per_u_, false, no_derivatives);
       if (!(isnan(res1) || isinf(res1)))
         {
-            {
-              for (int i = 0; i < size; i++)
-                {
-                  double rr;
-                  rr = r[i];
-                  res[i+shift] = rr;
-                  if (max_res < fabs(rr))
-                    {
-                      *_max_res = fabs(rr);
-                      *_max_res_idx = i;
-                    }
-                  *_res2 += rr*rr;
-                  *_res1 += fabs(rr);
-                }
-            }
+          {
+            for (int i = 0; i < size; i++)
+              {
+                double rr;
+                rr = r[i];
+                res[i+shift] = rr;
+                if (max_res < fabs(rr))
+                  {
+                    *_max_res = fabs(rr);
+                    *_max_res_idx = i;
+                  }
+                *_res2 += rr*rr;
+                *_res1 += fabs(rr);
+              }
+          }
         }
       else
         return;
@@ -1666,7 +1668,6 @@ Evaluate::compute_complete_2b(const bool no_derivatives, double *_res1, double *
   return;
 }
 
-
 bool
 Evaluate::compute_complete(const bool no_derivatives, double &_res1, double &_res2, double &_max_res, int &_max_res_idx)
 {
@@ -1676,23 +1677,23 @@ Evaluate::compute_complete(const bool no_derivatives, double &_res1, double &_re
   compute_block_time(0, false, no_derivatives);
   if (!(isnan(res1) || isinf(res1)))
     {
-        {
-          _res1 = 0;
-          _res2 = 0;
-          _max_res = 0;
-          for (int i = 0; i < size; i++)
-            {
-              double rr;
-              rr = r[i];
-              if (max_res < fabs(rr))
-                {
-                  _max_res = fabs(rr);
-                  _max_res_idx = i;
-                }
-              _res2 += rr*rr;
-              _res1 += fabs(rr);
-            }
-        }
+      {
+        _res1 = 0;
+        _res2 = 0;
+        _max_res = 0;
+        for (int i = 0; i < size; i++)
+          {
+            double rr;
+            rr = r[i];
+            if (max_res < fabs(rr))
+              {
+                _max_res = fabs(rr);
+                _max_res_idx = i;
+              }
+            _res2 += rr*rr;
+            _res1 += fabs(rr);
+          }
+      }
       result = true;
     }
   else
@@ -1700,7 +1701,6 @@ Evaluate::compute_complete(const bool no_derivatives, double &_res1, double &_re
   return result;
 }
 
-
 bool
 Evaluate::compute_complete(double lambda, double *crit)
 {
@@ -1721,10 +1721,10 @@ Evaluate::compute_complete(double lambda, double *crit)
         {
           res2_ = res2;
           /*res1_ = res1;
-          if (max_res > max_res_)
+            if (max_res > max_res_)
             {
-              max_res = max_res_;
-              max_res_idx = max_res_idx_;
+            max_res = max_res_;
+            max_res_idx = max_res_idx_;
             }*/
         }
       else
@@ -1758,7 +1758,7 @@ Evaluate::compute_complete(double lambda, double *crit)
             return false;
         }
     }
-    mexPrintf("  lambda=%e, res2=%e\n", lambda, res2_);
+  mexPrintf("  lambda=%e, res2=%e\n", lambda, res2_);
   *crit = res2_/2;
   return true;
 }
diff --git a/mex/sources/bytecode/Evaluate.hh b/mex/sources/bytecode/Evaluate.hh
index 33621b7a4..bcf62824b 100644
--- a/mex/sources/bytecode/Evaluate.hh
+++ b/mex/sources/bytecode/Evaluate.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -87,7 +87,7 @@ public:
   Evaluate(const int y_size_arg, const int y_kmin_arg, const int y_kmax_arg, const bool print_it_arg, const bool steady_state_arg, const int periods_arg, const int minimal_solving_periods_arg, const double slowc);
   //typedef  void (Interpreter::*InterfpreterMemFn)(const int block_num, const int size, const bool steady_state, int it);
   void set_block(const int size_arg, const int type_arg, string file_name_arg, string bin_base_name_arg, const int block_num_arg,
-          const bool is_linear_arg, const int symbol_table_endo_nbr_arg, const int Block_List_Max_Lag_arg, const int Block_List_Max_Lead_arg, const int u_count_int_arg, const int block_arg);
+                 const bool is_linear_arg, const int symbol_table_endo_nbr_arg, const int Block_List_Max_Lag_arg, const int Block_List_Max_Lead_arg, const int u_count_int_arg, const int block_arg);
   void evaluate_complete(const bool no_derivatives);
   bool compute_complete(const bool no_derivatives, double &res1, double &res2, double &max_res, int &max_res_idx);
   void compute_complete_2b(const bool no_derivatives, double *_res1, double *_res2, double *_max_res, int *_max_res_idx);
diff --git a/mex/sources/bytecode/Interpreter.cc b/mex/sources/bytecode/Interpreter.cc
index f85c9e709..1c36f5a86 100644
--- a/mex/sources/bytecode/Interpreter.cc
+++ b/mex/sources/bytecode/Interpreter.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -35,16 +35,16 @@ Interpreter::Interpreter(double *params_arg, double *y_arg, double *ya_arg, doub
                          int maxit_arg_, double solve_tolf_arg, size_t size_of_direction_arg, double slowc_arg, int y_decal_arg, double markowitz_c_arg,
                          string &filename_arg, int minimal_solving_periods_arg, int stack_solve_algo_arg, int solve_algo_arg,
                          bool global_temporary_terms_arg, bool print_arg, bool print_error_arg, mxArray *GlobalTemporaryTerms_arg,
-                         bool steady_state_arg, bool print_it_arg, int col_x_arg
+                         bool steady_state_arg, bool print_it_arg, int col_x_arg, int col_y_arg
 #ifdef CUDA
                          , const int CUDA_device_arg, cublasHandle_t cublas_handle_arg, cusparseHandle_t cusparse_handle_arg, cusparseMatDescr_t descr_arg
 #endif
                          )
-                         : dynSparseMatrix(y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg, slowc_arg
+: dynSparseMatrix(y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg, slowc_arg
 #ifdef CUDA
-                                        , CUDA_device_arg, cublas_handle_arg, cusparse_handle_arg, descr_arg
+                  , CUDA_device_arg, cublas_handle_arg, cusparse_handle_arg, descr_arg
 #endif
-                                        )
+                  )
 {
   params = params_arg;
   y = y_arg;
@@ -74,6 +74,7 @@ Interpreter::Interpreter(double *params_arg, double *y_arg, double *ya_arg, doub
   global_temporary_terms = global_temporary_terms_arg;
   print = print_arg;
   col_x = col_x_arg;
+  col_y = col_y_arg;
   GlobalTemporaryTerms = GlobalTemporaryTerms_arg;
   print_error = print_error_arg;
   //steady_state = steady_state_arg;
@@ -91,7 +92,7 @@ Interpreter::evaluate_a_block(bool initialization)
     case EVALUATE_FORWARD:
       if (steady_state)
         {
-          compute_block_time(0, true, /*block_num, size, steady_state, */false);
+          compute_block_time(0, true, /*block_num, size, steady_state, */ false);
           if (block >= 0)
             for (int j = 0; j < size; j++)
               residual[j] = y[Block_Contain[j].Variable] - ya[Block_Contain[j].Variable];
@@ -106,7 +107,7 @@ Interpreter::evaluate_a_block(bool initialization)
             {
               it_code = begining;
               Per_y_ = it_*y_size;
-              compute_block_time(0, true, /*block_num, size, steady_state, */false);
+              compute_block_time(0, true, /*block_num, size, steady_state, */ false);
               if (block >= 0)
                 for (int j = 0; j < size; j++)
                   residual[it_*size+j] = y[it_*y_size+Block_Contain[j].Variable] - ya[it_*y_size+Block_Contain[j].Variable];
@@ -118,7 +119,9 @@ Interpreter::evaluate_a_block(bool initialization)
       break;
     case SOLVE_FORWARD_SIMPLE:
       g1 = (double *) mxMalloc(size*size*sizeof(double));
+      test_mxMalloc(g1, __LINE__, __FILE__, __func__, size*size*sizeof(double));
       r = (double *) mxMalloc(size*sizeof(double));
+      test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
       if (steady_state)
         {
           compute_block_time(0, true, /*block_num, size, steady_state,*/ false);
@@ -150,14 +153,15 @@ Interpreter::evaluate_a_block(bool initialization)
       break;
     case SOLVE_FORWARD_COMPLETE:
       if (initialization)
-         {
-           fixe_u(&u, u_count_int, u_count_int);
-           Read_SparseMatrix(bin_base_name, size, 1, 0, 0, false, stack_solve_algo, solve_algo);
-         }
+        {
+          fixe_u(&u, u_count_int, u_count_int);
+          Read_SparseMatrix(bin_base_name, size, 1, 0, 0, false, stack_solve_algo, solve_algo);
+        }
 #ifdef DEBUG
       mexPrintf("in SOLVE_FORWARD_COMPLETE r = mxMalloc(%d*sizeof(double))\n", size);
 #endif
       r = (double *) mxMalloc(size*sizeof(double));
+      test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
       if (steady_state)
         {
           compute_block_time(0, true, /*block_num, size, steady_state,*/ false);
@@ -216,7 +220,9 @@ Interpreter::evaluate_a_block(bool initialization)
       break;
     case SOLVE_BACKWARD_SIMPLE:
       g1 = (double *) mxMalloc(size*size*sizeof(double));
+      test_mxMalloc(g1, __LINE__, __FILE__, __func__, size*size*sizeof(double));
       r = (double *) mxMalloc(size*sizeof(double));
+      test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
       if (steady_state)
         {
           compute_block_time(0, true, /*block_num, size, steady_state,*/ false);
@@ -253,6 +259,7 @@ Interpreter::evaluate_a_block(bool initialization)
           Read_SparseMatrix(bin_base_name, size, 1, 0, 0, false, stack_solve_algo, solve_algo);
         }
       r = (double *) mxMalloc(size*sizeof(double));
+      test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
       if (steady_state)
         {
           compute_block_time(0, true, /*block_num, size, steady_state,*/ false);
@@ -270,7 +277,7 @@ Interpreter::evaluate_a_block(bool initialization)
             {
               it_code = begining;
               Per_y_ = it_*y_size;
-              compute_block_time(0, true, /*block_num, size, steady_state, */false);
+              compute_block_time(0, true, /*block_num, size, steady_state, */ false);
               if (block < 0)
                 for (int j = 0; j < size; j++)
                   residual[Per_y_+Block_Contain[j].Equation] = r[j];
@@ -290,6 +297,7 @@ Interpreter::evaluate_a_block(bool initialization)
         }
       u_count = u_count_int*(periods+y_kmax+y_kmin);
       r = (double *) mxMalloc(size*sizeof(double));
+      test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
       begining = it_code;
       for (it_ = y_kmin; it_ < periods+y_kmin; it_++)
         {
@@ -309,8 +317,6 @@ Interpreter::evaluate_a_block(bool initialization)
     }
 }
 
-
-
 int
 Interpreter::simulate_a_block(vector_table_conditional_local_type vector_table_conditional_local)
 {
@@ -330,14 +336,14 @@ Interpreter::simulate_a_block(vector_table_conditional_local_type vector_table_c
       mexPrintf("EVALUATE_FORWARD\n");
       mexEvalString("drawnow;");
 #endif
-        evaluate_over_periods(true);
+      evaluate_over_periods(true);
       break;
     case EVALUATE_BACKWARD:
 #ifdef DEBUG
       mexPrintf("EVALUATE_BACKWARD\n");
       mexEvalString("drawnow;");
 #endif
-        evaluate_over_periods(false);
+      evaluate_over_periods(false);
       break;
     case SOLVE_FORWARD_SIMPLE:
 #ifdef DEBUG
@@ -431,8 +437,11 @@ Interpreter::simulate_a_block(vector_table_conditional_local_type vector_table_c
         }
       u_count = u_count_int*(periods+y_kmax+y_kmin);
       r = (double *) mxMalloc(size*sizeof(double));
+      test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
       res = (double *) mxMalloc(size*periods*sizeof(double));
+      test_mxMalloc(res, __LINE__, __FILE__, __func__, size*periods*sizeof(double));
       y_save = (double *) mxMalloc(y_size*sizeof(double)*(periods+y_kmax+y_kmin));
+      test_mxMalloc(y_save, __LINE__, __FILE__, __func__, y_size*sizeof(double)*(periods+y_kmax+y_kmin));
       start_code = it_code;
       iter = 0;
       if (!is_linear)
@@ -450,14 +459,14 @@ Interpreter::simulate_a_block(vector_table_conditional_local_type vector_table_c
               memcpy(y_save, y, y_size*sizeof(double)*(periods+y_kmax+y_kmin));
               if (vector_table_conditional_local.size())
                 {
-                  for (vector_table_conditional_local_type::iterator it1 = vector_table_conditional_local.begin(); it1 != vector_table_conditional_local.end() ; it1++)
+                  for (vector_table_conditional_local_type::iterator it1 = vector_table_conditional_local.begin(); it1 != vector_table_conditional_local.end(); it1++)
                     {
                       if (it1->is_cond)
                         {
                           //mexPrintf("y[%d] = %f\n", it1->var_endo + y_kmin * size, y[it1->var_endo + y_kmin * size]);
                           y[it1->var_endo + y_kmin * size] = it1->constrained_value;
                         }
-                        
+
                     }
                 }
               compute_complete_2b(false, &res1, &res2, &max_res, &max_res_idx);
@@ -465,7 +474,7 @@ Interpreter::simulate_a_block(vector_table_conditional_local_type vector_table_c
               if (!(isnan(res1) || isinf(res1)))
                 cvg = (max_res < solve_tolf);
               if (isnan(res1) || isinf(res1) || (stack_solve_algo == 4 && iter > 0))
-                  memcpy(y, y_save, y_size*sizeof(double)*(periods+y_kmax+y_kmin));
+                memcpy(y, y_save, y_size*sizeof(double)*(periods+y_kmax+y_kmin));
               u_count = u_count_saved;
               int prev_iter = iter;
               Simulate_Newton_Two_Boundaries(block_num, symbol_table_endo_nbr, y_kmin, y_kmax, size, periods, cvg, minimal_solving_periods, stack_solve_algo, endo_name_length, P_endo_names, vector_table_conditional_local);
@@ -499,12 +508,18 @@ Interpreter::simulate_a_block(vector_table_conditional_local_type vector_table_c
           max_res = 0; max_res_idx = 0;
         }
       it_code = end_code;
-      mxFree(r);
-      mxFree(y_save);
-      mxFree(u);
-      mxFree(index_vara);
-      mxFree(index_equa);
-      mxFree(res);
+      if (r)
+        mxFree(r);
+      if (y_save)
+        mxFree(y_save);
+      if (u)
+        mxFree(u);
+      if (index_vara)
+        mxFree(index_vara);
+      if (index_equa)
+        mxFree(index_equa);
+      if (res)
+        mxFree(res);
       memset(direction, 0, size_of_direction);
       End_Solver();
       break;
@@ -558,14 +573,14 @@ Interpreter::print_a_block()
     }
 }
 
-void 
+void
 Interpreter::ReadCodeFile(string file_name, CodeLoad &code)
 {
   if (steady_state)
     file_name += "_static";
   else
     file_name += "_dynamic";
- 
+
   //First read and store in memory the code
   code_liste = code.get_op_code(file_name);
   EQN_block_number = code.get_block_number();
@@ -584,9 +599,8 @@ Interpreter::ReadCodeFile(string file_name, CodeLoad &code)
 
 }
 
-
 void
-Interpreter::check_for_controlled_exo_validity(FBEGINBLOCK_ *fb,vector<s_plan> sconstrained_extended_path)
+Interpreter::check_for_controlled_exo_validity(FBEGINBLOCK_ *fb, vector<s_plan> sconstrained_extended_path)
 {
   vector<unsigned int> exogenous = fb->get_exogenous();
   vector<int> endogenous = fb->get_endogenous();
@@ -615,8 +629,6 @@ Interpreter::check_for_controlled_exo_validity(FBEGINBLOCK_ *fb,vector<s_plan> s
     previous_block_exogenous.push_back(*it);
 }
 
-
-
 bool
 Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int block, bool last_call, bool constrained, vector<s_plan> sconstrained_extended_path, vector_table_conditional_local_type vector_table_conditional_local)
 {
@@ -653,9 +665,7 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
             Block_Contain = fb->get_Block_Contain();
             it_code++;
             if (constrained)
-              {
-                check_for_controlled_exo_validity(fb,sconstrained_extended_path);
-              }
+              check_for_controlled_exo_validity(fb, sconstrained_extended_path);
             set_block(fb->get_size(), fb->get_type(), file_name, bin_basename, Block_Count, fb->get_is_linear(), fb->get_endo_nbr(), fb->get_Max_Lag(), fb->get_Max_Lead(), fb->get_u_count_int(), block);
             if (print)
               print_a_block();
@@ -690,7 +700,7 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
 #ifdef DEBUG
                 mexPrintf("endo in Block_Count=%d, block=%d, type=%d, steady_state=%d, print_it=%d, Block_Count=%d, fb->get_is_linear()=%d, fb->get_endo_nbr()=%d, fb->get_Max_Lag()=%d, fb->get_Max_Lead()=%d, fb->get_u_count_int()=%d\n",
                           Block_Count, fb->get_size(), fb->get_type(), steady_state, print_it, Block_Count, fb->get_is_linear(), fb->get_endo_nbr(), fb->get_Max_Lag(), fb->get_Max_Lead(), fb->get_u_count_int());
-#endif      
+#endif
                 bool result;
                 if (sconstrained_extended_path.size())
                   {
@@ -702,7 +712,7 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
                     jacobian_other_endo_block.push_back(mxCreateDoubleMatrix(fb->get_size(), fb->get_nb_col_other_endo_jacob(), mxREAL));
                     residual = vector<double>(fb->get_size()*(periods+y_kmin));
                     result = simulate_a_block(vector_table_conditional_local);
-                    
+
                     mxDestroyArray(jacobian_block.back());
                     jacobian_block.pop_back();
                     mxDestroyArray(jacobian_exo_block.back());
@@ -713,10 +723,7 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
                     jacobian_other_endo_block.pop_back();
                   }
                 else
-                  {
-                    result = simulate_a_block(vector_table_conditional_local);
-                  }
-                  
+                  result = simulate_a_block(vector_table_conditional_local);
                 //mexPrintf("OKe\n");
                 if (max_res > max_res_local)
                   {
@@ -751,6 +758,7 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
           if (T)
             mxFree(T);
           T = (double *) mxMalloc(var*(periods+y_kmin+y_kmax)*sizeof(double));
+          test_mxMalloc(T, __LINE__, __FILE__, __func__, var*(periods+y_kmin+y_kmax)*sizeof(double));
           if (block >= 0)
             {
               it_code = code_liste.begin() + code.get_begin_block(block);
@@ -776,7 +784,10 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
               T = mxGetPr(GlobalTemporaryTerms);
             }
           else
-            T = (double *) mxMalloc(var*sizeof(double));
+            {
+              T = (double *) mxMalloc(var*sizeof(double));
+              test_mxMalloc(T, __LINE__, __FILE__, __func__, var*sizeof(double));
+            }
 
           if (block >= 0)
             it_code = code_liste.begin() + code.get_begin_block(block);
@@ -789,7 +800,7 @@ Interpreter::MainLoop(string bin_basename, CodeLoad code, bool evaluate, int blo
           throw FatalExceptionHandling(tmp.str());
         }
     }
-  max_res = max_res_local ;
+  max_res = max_res_local;
   max_res_idx = max_res_idx_local;
   Close_SaveCode();
   return true;
@@ -808,13 +819,13 @@ Interpreter::elastic(string str, unsigned int len, bool left)
           if (left)
             {
               //mexPrintf("(1) diff=%d\n",diff);
-              str.insert(str.end(),diff-1,' ');
-              str.insert(str.begin(),1,' ');
+              str.insert(str.end(), diff-1, ' ');
+              str.insert(str.begin(), 1, ' ');
             }
           else
             {
-              str.insert(str.end(),diff/2,' ');
-              str.insert(str.begin(),diff/2,' ');
+              str.insert(str.end(), diff/2, ' ');
+              str.insert(str.begin(), diff/2, ' ');
             }
         }
       else
@@ -822,13 +833,13 @@ Interpreter::elastic(string str, unsigned int len, bool left)
           if (left)
             {
               //mexPrintf("(2) diff=%d\n",diff);
-              str.insert(str.end(),diff-1,' ');
-              str.insert(str.begin(),1,' ');
+              str.insert(str.end(), diff-1, ' ');
+              str.insert(str.begin(), 1, ' ');
             }
           else
             {
-              str.insert(str.end(),ceil(diff/2),' ');
-              str.insert(str.begin(),ceil(diff/2+1),' ');
+              str.insert(str.end(), ceil(diff/2), ' ');
+              str.insert(str.begin(), ceil(diff/2+1), ' ');
             }
         }
       return str;
@@ -839,12 +850,19 @@ bool
 Interpreter::extended_path(string file_name, string bin_basename, bool evaluate, int block, int &nb_blocks, int nb_periods, vector<s_plan> sextended_path, vector<s_plan> sconstrained_extended_path, vector<string> dates, table_conditional_global_type table_conditional_global)
 {
   CodeLoad code;
+
   ReadCodeFile(file_name, code);
   it_code = code_liste.begin();
   it_code_type Init_Code = code_liste.begin();
-  size_t size_of_direction = y_size*(periods + y_kmax + y_kmin)*sizeof(double);
+  /*size_t size_of_direction = y_size*(periods + y_kmax + y_kmin)*sizeof(double);
+    double *y_save = (double *) mxMalloc(size_of_direction);
+    double *x_save = (double *) mxMalloc((periods + y_kmax + y_kmin) * col_x *sizeof(double));*/
+  size_t size_of_direction = y_size*col_y*sizeof(double);
   double *y_save = (double *) mxMalloc(size_of_direction);
-  double *x_save = (double *) mxMalloc((periods + y_kmax + y_kmin) * col_x *sizeof(double));
+  test_mxMalloc(y_save, __LINE__, __FILE__, __func__, size_of_direction);
+  double *x_save = (double *) mxMalloc(nb_row_x * col_x *sizeof(double));
+  test_mxMalloc(x_save, __LINE__, __FILE__, __func__, nb_row_x * col_x *sizeof(double));
+
   vector_table_conditional_local_type vector_table_conditional_local;
   vector_table_conditional_local.clear();
 
@@ -855,9 +873,9 @@ Interpreter::extended_path(string file_name, string bin_basename, bool evaluate,
       x[j] = 0;
     }
   for (int j = 0; j < col_x; j++)
-    x[y_kmin + j * nb_row_x] = x_save[1 + y_kmin + j * nb_row_x];
-  for (int i = 0; i < (y_size*(periods + y_kmax + y_kmin)); i++)
-    y_save[i]  = y[i];
+    x[y_kmin + j * nb_row_x] = x_save[y_kmin + j * nb_row_x];
+  for (int i = 0; i < y_size * col_y; i++)
+    y_save[i] = y[i];
   if (endo_name_length_l < 8)
     endo_name_length_l = 8;
   bool old_print_it = print_it;
@@ -868,16 +886,16 @@ Interpreter::extended_path(string file_name, string bin_basename, bool evaluate,
   int date_length = dates[0].length();
   int table_length = 2 + date_length + 3 + endo_name_length_l + 3 + real_max_length + 3 + 3 + 2 + 6 + 2;
   string line;
-  line.insert(line.begin(),table_length,'-');
-  line.insert(line.length(),"\n");
+  line.insert(line.begin(), table_length, '-');
+  line.insert(line.length(), "\n");
   if (old_print_it)
     {
-       mexPrintf("\nExtended Path simulation:\n");
-       mexPrintf("-------------------------\n");
-       mexPrintf(line.c_str());
-       string title = "|" + elastic("date",date_length+2, false) + "|" + elastic("variable",endo_name_length_l+2, false) + "|" + elastic("max. value",real_max_length+2, false) + "| iter. |" + elastic("cvg",5, false) + "|\n";
-       mexPrintf(title.c_str());
-       mexPrintf(line.c_str());
+      mexPrintf("\nExtended Path simulation:\n");
+      mexPrintf("-------------------------\n");
+      mexPrintf(line.c_str());
+      string title = "|" + elastic("date", date_length+2, false) + "|" + elastic("variable", endo_name_length_l+2, false) + "|" + elastic("max. value", real_max_length+2, false) + "| iter. |" + elastic("cvg", 5, false) + "|\n";
+      mexPrintf(title.c_str());
+      mexPrintf(line.c_str());
     }
   for (int t = 0; t < nb_periods; t++)
     {
@@ -885,18 +903,21 @@ Interpreter::extended_path(string file_name, string bin_basename, bool evaluate,
       previous_block_exogenous.clear();
       if (old_print_it)
         {
-          mexPrintf("|%s|",elastic(dates[t], date_length+2, false).c_str());
+          mexPrintf("|%s|", elastic(dates[t], date_length+2, false).c_str());
           mexEvalString("drawnow;");
         }
       for (vector<s_plan>::const_iterator it = sextended_path.begin(); it != sextended_path.end(); it++)
-        x[y_kmin + (it->exo_num - 1) * (periods + y_kmax + y_kmin)] = it->value[t];
+        {
+          x[y_kmin + (it->exo_num - 1) * /*(nb_periods + y_kmax + y_kmin)*/ nb_row_x] = it->value[t];
+        }
+
       it_code = Init_Code;
       vector_table_conditional_local.clear();
       if (table_conditional_global.size())
         vector_table_conditional_local = table_conditional_global[t];
       if (t < nb_periods)
         MainLoop(bin_basename, code, evaluate, block, false, true, sconstrained_extended_path, vector_table_conditional_local);
-      else 
+      else
         MainLoop(bin_basename, code, evaluate, block, true, true, sconstrained_extended_path, vector_table_conditional_local);
       for (int j = 0; j < y_size; j++)
         {
@@ -907,35 +928,38 @@ Interpreter::extended_path(string file_name, string bin_basename, bool evaluate,
       for (int j = 0; j < col_x; j++)
         {
           x_save[t + y_kmin + j * nb_row_x] = x[y_kmin + j * nb_row_x];
-          x[y_kmin + j * nb_row_x] = x_save[t + 1 + y_kmin + j * nb_row_x];
+          if (t < nb_periods)
+            x[y_kmin + j * nb_row_x] = x_save[t + 1 + y_kmin + j * nb_row_x];
         }
-        
+
       if (old_print_it)
         {
           ostringstream res, res1;
           for (unsigned int i = 0; i < endo_name_length; i++)
             if (P_endo_names[CHAR_LENGTH*(max_res_idx+i*y_size)] != ' ')
               res << P_endo_names[CHAR_LENGTH*(max_res_idx+i*y_size)];
-           res1 << std::scientific << max_res;
-          mexPrintf("%s|%s| %4d  |  x  |\n",elastic(res.str(),endo_name_length_l+2, true).c_str(), elastic(res1.str(), real_max_length+2, false).c_str(), iter);
+          res1 << std::scientific << max_res;
+          mexPrintf("%s|%s| %4d  |  x  |\n", elastic(res.str(), endo_name_length_l+2, true).c_str(), elastic(res1.str(), real_max_length+2, false).c_str(), iter);
           mexPrintf(line.c_str());
           mexEvalString("drawnow;");
         }
     }
   print_it = old_print_it;
-  for (int j = 0; j < y_size; j++)
+  /*for (int j = 0; j < y_size; j++)
     {
-      for(int k = nb_periods; k < periods; k++)
-        y_save[j + (k + y_kmin) * y_size] = y[ j +  ( k - (nb_periods-1) + y_kmin) * y_size];
-    }
-  for (int i = 0; i < (y_size*(periods + y_kmax + y_kmin)); i++)
+    for(int k = nb_periods; k < periods; k++)
+    y_save[j + (k + y_kmin) * y_size] = y[ j +  ( k - (nb_periods-1) + y_kmin) * y_size];
+    }*/
+  for (int i = 0; i < y_size * col_y; i++)
     y[i]  = y_save[i];
-  for (int j = 0; j < col_x* nb_row_x; j++)
+  for (int j = 0; j < col_x * nb_row_x; j++)
     x[j] = x_save[j];
-    
-  mxFree(Init_Code->second);
-  mxFree(y_save);
-  mxFree(x_save);
+  if (Init_Code->second)
+    mxFree(Init_Code->second);
+  if (y_save)
+    mxFree(y_save);
+  if (x_save)
+    mxFree(x_save);
   nb_blocks = Block_Count+1;
   if (T && !global_temporary_terms)
     mxFree(T);
@@ -947,7 +971,7 @@ Interpreter::compute_blocks(string file_name, string bin_basename, bool evaluate
 {
   CodeLoad code;
   ReadCodeFile(file_name, code);
-  
+
   //The big loop on intructions
   it_code = code_liste.begin();
   it_code_type Init_Code = it_code;
@@ -955,8 +979,7 @@ Interpreter::compute_blocks(string file_name, string bin_basename, bool evaluate
   vector_table_conditional_local_type vector_table_conditional_local_junk;
 
   MainLoop(bin_basename, code, evaluate, block, true, false, s_plan_junk, vector_table_conditional_local_junk);
-  
-  
+
   mxFree(Init_Code->second);
   nb_blocks = Block_Count+1;
   if (T && !global_temporary_terms)
diff --git a/mex/sources/bytecode/Interpreter.hh b/mex/sources/bytecode/Interpreter.hh
index a3d9973ef..d41e0c8cd 100644
--- a/mex/sources/bytecode/Interpreter.hh
+++ b/mex/sources/bytecode/Interpreter.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -41,11 +41,10 @@
 
 using namespace std;
 
-
 class Interpreter : public dynSparseMatrix
 {
 private:
-vector<int> previous_block_exogenous;
+  vector<int> previous_block_exogenous;
 protected:
   void evaluate_a_block(bool initialization);
   int simulate_a_block(vector_table_conditional_local_type vector_table_conditional_local);
@@ -59,14 +58,14 @@ public:
               int maxit_arg_, double solve_tolf_arg, size_t size_of_direction_arg, double slowc_arg, int y_decal_arg, double markowitz_c_arg,
               string &filename_arg, int minimal_solving_periods_arg, int stack_solve_algo_arg, int solve_algo_arg,
               bool global_temporary_terms_arg, bool print_arg, bool print_error_arg, mxArray *GlobalTemporaryTerms_arg,
-              bool steady_state_arg, bool print_it_arg, int col_x_arg
+              bool steady_state_arg, bool print_it_arg, int col_x_arg, int col_y_arg
 #ifdef CUDA
               , const int CUDA_device, cublasHandle_t cublas_handle_arg, cusparseHandle_t cusparse_handle_arg, cusparseMatDescr_t descr_arg
 #endif
               );
   bool extended_path(string file_name, string bin_basename, bool evaluate, int block, int &nb_blocks, int nb_periods, vector<s_plan> sextended_path, vector<s_plan> sconstrained_extended_path, vector<string> dates, table_conditional_global_type table_conditional_global);
   bool compute_blocks(string file_name, string bin_basename, bool evaluate, int block, int &nb_blocks);
-  void check_for_controlled_exo_validity(FBEGINBLOCK_ *fb,vector<s_plan> sconstrained_extended_path);
+  void check_for_controlled_exo_validity(FBEGINBLOCK_ *fb, vector<s_plan> sconstrained_extended_path);
   bool MainLoop(string bin_basename, CodeLoad code, bool evaluate, int block, bool last_call, bool constrained, vector<s_plan> sconstrained_extended_path, vector_table_conditional_local_type vector_table_conditional_local);
   void ReadCodeFile(string file_name, CodeLoad &code);
 
diff --git a/mex/sources/bytecode/Mem_Mngr.cc b/mex/sources/bytecode/Mem_Mngr.cc
index b239b60df..52a2ab905 100644
--- a/mex/sources/bytecode/Mem_Mngr.cc
+++ b/mex/sources/bytecode/Mem_Mngr.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2011 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -24,15 +24,16 @@ Mem_Mngr::Mem_Mngr()
   swp_f = false;
   swp_f_b = 0;
 }
-void
-Mem_Mngr::Print_heap()
-{
+/*void
+  Mem_Mngr::Print_heap()
+  {
   unsigned int i;
   mexPrintf("i   :");
   for (i = 0; i < CHUNK_SIZE; i++)
-    mexPrintf("%3d ", i);
+  mexPrintf("%3d ", i);
   mexPrintf("\n");
-}
+  }
+*/
 
 void
 Mem_Mngr::init_Mem()
@@ -49,7 +50,7 @@ Mem_Mngr::init_Mem()
 void
 Mem_Mngr::fixe_file_name(string filename_arg)
 {
-  filename = filename_arg;
+  filename_mem = filename_arg;
 }
 
 void
@@ -78,25 +79,25 @@ Mem_Mngr::mxMalloc_NZE()
       CHUNK_SIZE += CHUNK_BLCK_SIZE;
       Nb_CHUNK++;
       NZE_Mem = (NonZeroElem *) mxMalloc(CHUNK_BLCK_SIZE*sizeof(NonZeroElem));      /*The block of memory allocated*/
+      error_msg.test_mxMalloc(NZE_Mem, __LINE__, __FILE__, __func__, CHUNK_BLCK_SIZE*sizeof(NonZeroElem));
       NZE_Mem_Allocated.push_back(NZE_Mem);
       if (!NZE_Mem)
-        {
-          mexPrintf("Not enough memory available\n");
-          mexEvalString("drawnow;");
-        }
+        mexPrintf("Not enough memory available\n");
       if (NZE_Mem_add)
-        NZE_Mem_add = (NonZeroElem **) mxRealloc(NZE_Mem_add, CHUNK_SIZE*sizeof(NonZeroElem *));                                                                                                     /*We have to redefine the size of pointer on the memory*/
+        {
+          NZE_Mem_add = (NonZeroElem **) mxRealloc(NZE_Mem_add, CHUNK_SIZE*sizeof(NonZeroElem *));                                                                                                     /*We have to redefine the size of pointer on the memory*/
+          error_msg.test_mxMalloc(NZE_Mem_add, __LINE__, __FILE__, __func__, CHUNK_SIZE*sizeof(NonZeroElem *));
+        }
       else
-        NZE_Mem_add = (NonZeroElem **) mxMalloc(CHUNK_SIZE*sizeof(NonZeroElem *));                                                                                       /*We have to define the size of pointer on the memory*/
+        {
+          NZE_Mem_add = (NonZeroElem **) mxMalloc(CHUNK_SIZE*sizeof(NonZeroElem *));                                                                                       /*We have to define the size of pointer on the memory*/
+          error_msg.test_mxMalloc(NZE_Mem_add, __LINE__, __FILE__, __func__, CHUNK_SIZE*sizeof(NonZeroElem *));
+        }
+
       if (!NZE_Mem_add)
-        {
-          mexPrintf("Not enough memory available\n");
-          mexEvalString("drawnow;");
-        }
+        mexPrintf("Not enough memory available\n");
       for (i = CHUNK_heap_pos; i < CHUNK_SIZE; i++)
-        {
-          NZE_Mem_add[i] = (NonZeroElem *) (NZE_Mem+(i-CHUNK_heap_pos));
-        }
+        NZE_Mem_add[i] = (NonZeroElem *) (NZE_Mem+(i-CHUNK_heap_pos));
       i = CHUNK_heap_pos++;
       return (NZE_Mem_add[i]);
     }
diff --git a/mex/sources/bytecode/Mem_Mngr.hh b/mex/sources/bytecode/Mem_Mngr.hh
index be3c3c404..4bde597a0 100644
--- a/mex/sources/bytecode/Mem_Mngr.hh
+++ b/mex/sources/bytecode/Mem_Mngr.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2010 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -20,6 +20,7 @@
 #ifndef MEM_MNGR_HH_INCLUDED
 #define MEM_MNGR_HH_INCLUDED
 
+#include "ErrorHandling.hh"
 #include <vector>
 #include <fstream>
 #ifndef DEBUG_EX
@@ -27,7 +28,7 @@
 #else
 # include "mex_interface.hh"
 #endif
-using namespace std;
+//using namespace std;
 
 struct NonZeroElem
 {
@@ -41,7 +42,7 @@ typedef vector<NonZeroElem *> v_NonZeroElem;
 class Mem_Mngr
 {
 public:
-  void Print_heap();
+  //void Print_heap();
   void init_Mem();
   void mxFree_NZE(void *pos);
   NonZeroElem *mxMalloc_NZE();
@@ -50,6 +51,7 @@ public:
   Mem_Mngr();
   void fixe_file_name(string filename_arg);
   bool swp_f;
+  ErrorMsg error_msg;
 private:
   v_NonZeroElem Chunk_Stack;
   unsigned int CHUNK_SIZE, CHUNK_BLCK_SIZE, Nb_CHUNK;
@@ -59,7 +61,7 @@ private:
   vector<NonZeroElem *> NZE_Mem_Allocated;
   int swp_f_b;
   fstream  SaveCode_swp;
-  string filename;
+  string filename_mem;
 };
 
 #endif
diff --git a/mex/sources/bytecode/SparseMatrix.cc b/mex/sources/bytecode/SparseMatrix.cc
index 840f302a6..7db7341cb 100644
--- a/mex/sources/bytecode/SparseMatrix.cc
+++ b/mex/sources/bytecode/SparseMatrix.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -28,67 +28,64 @@
 #include "SparseMatrix.hh"
 
 #ifdef CUDA
-#include "SparseMatrix_kernel.cu"
+# include "SparseMatrix_kernel.cu"
 #endif
 
 using namespace std;
 #ifdef _MSC_VER
-#include <windows.h>
+# include <windows.h>
 HINSTANCE hinstLib;
 
-#define UMFPACK_INFO 90
-#define UMFPACK_CONTROL 20
+# define UMFPACK_INFO 90
+# define UMFPACK_CONTROL 20
 /* used in all UMFPACK_report_* routines: */
-#define UMFPACK_PRL 0			/* print level */
+# define UMFPACK_PRL 0                   /* print level */
 /* returned by all routines that use Info: */
-#define UMFPACK_OK (0)
-#define UMFPACK_STATUS 0	/* UMFPACK_OK, or other result */
+# define UMFPACK_OK (0)
+# define UMFPACK_STATUS 0        /* UMFPACK_OK, or other result */
 
 typedef void (*t_umfpack_dl_free_numeric)(void **Numeric);
 t_umfpack_dl_free_numeric umfpack_dl_free_numeric;
 typedef void (*t_umfpack_dl_free_symbolic)(void **Symbolic);
 t_umfpack_dl_free_symbolic umfpack_dl_free_symbolic;
 typedef int64_t (*t_umfpack_dl_solve)(int64_t sys,
-                                      const int64_t Ap [ ],
-                                      const int64_t Ai [ ],
-                                      const double Ax [ ],
-                                      double X [ ],
-                                      const double B [ ],
+                                      const int64_t Ap [],
+                                      const int64_t Ai [],
+                                      const double Ax [],
+                                      double X [],
+                                      const double B [],
                                       void *Numeric,
                                       const double Control [UMFPACK_CONTROL],
                                       double Info [UMFPACK_INFO]);
 t_umfpack_dl_solve umfpack_dl_solve;
-typedef int64_t (*t_umfpack_dl_numeric)(const int64_t Ap [ ],
-                                        const int64_t Ai [ ],
-                                        const double Ax [ ],
+typedef int64_t (*t_umfpack_dl_numeric)(const int64_t Ap [],
+                                        const int64_t Ai [],
+                                        const double Ax [],
                                         void *Symbolic,
                                         void **Numeric,
                                         const double Control [UMFPACK_CONTROL],
                                         double Info [UMFPACK_INFO]);
 t_umfpack_dl_numeric umfpack_dl_numeric;
 typedef int64_t (*t_umfpack_dl_symbolic)(int64_t n_row,
-    int64_t n_col,
-    const int64_t Ap [ ],
-    const int64_t Ai [ ],
-    const double Ax [ ],
-    void **Symbolic,
-    const double Control [UMFPACK_CONTROL],
-    double Info [UMFPACK_INFO]);
+                                         int64_t n_col,
+                                         const int64_t Ap [],
+                                         const int64_t Ai [],
+                                         const double Ax [],
+                                         void **Symbolic,
+                                         const double Control [UMFPACK_CONTROL],
+                                         double Info [UMFPACK_INFO]);
 t_umfpack_dl_symbolic umfpack_dl_symbolic;
 typedef void (*t_umfpack_dl_report_info)(const double Control [UMFPACK_CONTROL],
-    const double Info [UMFPACK_INFO]);
+                                         const double Info [UMFPACK_INFO]);
 t_umfpack_dl_report_info umfpack_dl_report_info;
 typedef void (*t_umfpack_dl_report_status)(const double Control [UMFPACK_CONTROL],
-    int64_t status);
+                                           int64_t status);
 t_umfpack_dl_report_status umfpack_dl_report_status;
 typedef void (*t_umfpack_dl_defaults)(double Control [UMFPACK_CONTROL]);
 t_umfpack_dl_defaults umfpack_dl_defaults;
 
 #endif
 
-
-
-
 dynSparseMatrix::dynSparseMatrix()
 {
   pivotva = NULL;
@@ -183,11 +180,11 @@ dynSparseMatrix::dynSparseMatrix()
 }
 
 dynSparseMatrix::dynSparseMatrix(const int y_size_arg, const int y_kmin_arg, const int y_kmax_arg, const bool print_it_arg, const bool steady_state_arg, const int periods_arg,
-                           const int minimal_solving_periods_arg, const double slowc_arg
+                                 const int minimal_solving_periods_arg, const double slowc_arg
 #ifdef CUDA
-                           , const int CUDA_device_arg, cublasHandle_t cublas_handle_arg, cusparseHandle_t cusparse_handle_arg, cusparseMatDescr_t descr_arg
+                                 , const int CUDA_device_arg, cublasHandle_t cublas_handle_arg, cusparseHandle_t cusparse_handle_arg, cusparseMatDescr_t descr_arg
 #endif
-                           ):
+                                 ) :
   Evaluate(y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg, slowc_arg)
 {
   pivotva = NULL;
@@ -286,7 +283,6 @@ dynSparseMatrix::dynSparseMatrix(const int y_size_arg, const int y_kmin_arg, con
 #endif
 }
 
-
 int
 dynSparseMatrix::NRow(int r)
 {
@@ -531,7 +527,7 @@ dynSparseMatrix::Read_SparseMatrix(string file_name, const int Size, int periods
   filename = file_name;
   mem_mngr.fixe_file_name(file_name);
   /*mexPrintf("steady_state=%d, size=%d, solve_algo=%d, stack_solve_algo=%d, two_boundaries=%d\n",steady_state, Size, solve_algo, stack_solve_algo, two_boundaries);
-  mexEvalString("drawnow;");*/
+    mexEvalString("drawnow;");*/
   if (!SaveCode.is_open())
     {
       if (steady_state)
@@ -622,6 +618,7 @@ dynSparseMatrix::Read_SparseMatrix(string file_name, const int Size, int periods
         }
     }
   index_vara = (int *) mxMalloc(Size*(periods+y_kmin+y_kmax)*sizeof(int));
+  test_mxMalloc(index_vara, __LINE__, __FILE__, __func__, Size*(periods+y_kmin+y_kmax)*sizeof(int));
   for (int j = 0; j < Size; j++)
     SaveCode.read(reinterpret_cast<char *>(&index_vara[j]), sizeof(*index_vara));
   if (periods+y_kmin+y_kmax > 1)
@@ -631,6 +628,7 @@ dynSparseMatrix::Read_SparseMatrix(string file_name, const int Size, int periods
           index_vara[j+Size*i] = index_vara[j+Size*(i-1)] + y_size;
       }
   index_equa = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(index_equa, __LINE__, __FILE__, __func__, Size*sizeof(int));
   for (int j = 0; j < Size; j++)
     SaveCode.read(reinterpret_cast<char *>(&index_equa[j]), sizeof(*index_equa));
 }
@@ -642,24 +640,37 @@ dynSparseMatrix::Simple_Init(int Size, map<pair<pair<int, int>, int>, int> &IM,
   map<pair<pair<int, int>, int>, int>::iterator it4;
   NonZeroElem *first;
   pivot = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivot, __LINE__, __FILE__, __func__, Size*sizeof(int));
   pivot_save = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivot_save, __LINE__, __FILE__, __func__, Size*sizeof(int));
   pivotk = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivotk, __LINE__, __FILE__, __func__, Size*sizeof(int));
   pivotv = (double *) mxMalloc(Size*sizeof(double));
+  test_mxMalloc(pivotv, __LINE__, __FILE__, __func__, Size*sizeof(double));
   pivotva = (double *) mxMalloc(Size*sizeof(double));
+  test_mxMalloc(pivotva, __LINE__, __FILE__, __func__, Size*sizeof(double));
   b = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(b, __LINE__, __FILE__, __func__, Size*sizeof(int));
   line_done = (bool *) mxMalloc(Size*sizeof(bool));
+  test_mxMalloc(line_done, __LINE__, __FILE__, __func__, Size*sizeof(bool));
 
   mem_mngr.init_CHUNK_BLCK_SIZE(u_count);
   g_save_op = NULL;
   g_nop_all = 0;
   i = Size*sizeof(NonZeroElem *);
   FNZE_R = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(FNZE_R, __LINE__, __FILE__, __func__, i);
   FNZE_C = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(FNZE_C, __LINE__, __FILE__, __func__, i);
   NonZeroElem **temp_NZE_R = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(temp_NZE_R, __LINE__, __FILE__, __func__, i);
   NonZeroElem **temp_NZE_C = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(temp_NZE_C, __LINE__, __FILE__, __func__, i);
   i = Size*sizeof(int);
   NbNZRow = (int *) mxMalloc(i);
+  test_mxMalloc(NbNZRow, __LINE__, __FILE__, __func__, i);
   NbNZCol = (int *) mxMalloc(i);
+  test_mxMalloc(NbNZCol, __LINE__, __FILE__, __func__, i);
   it4 = IM.begin();
   eq = -1;
   for (i = 0; i < Size; i++)
@@ -833,12 +844,12 @@ dynSparseMatrix::Init_Matlab_Sparse_Simple(int Size, map<pair<pair<int, int>, in
   Aj[Size] = NZE;
 }
 
-
 void
 dynSparseMatrix::Init_UMFPACK_Sparse_Simple(int Size, map<pair<pair<int, int>, int>, int> &IM, SuiteSparse_long **Ap, SuiteSparse_long **Ai, double **Ax, double **b, bool &zero_solution, mxArray *x0_m)
 {
   int eq, var;
-  *b = (double*)mxMalloc(Size * sizeof(double));
+  *b = (double *) mxMalloc(Size * sizeof(double));
+  test_mxMalloc(*b, __LINE__, __FILE__, __func__, Size * sizeof(double));
   if (!(*b))
     {
       ostringstream tmp;
@@ -852,7 +863,8 @@ dynSparseMatrix::Init_UMFPACK_Sparse_Simple(int Size, map<pair<pair<int, int>, i
       tmp << " in Init_UMFPACK_Sparse_Simple, can't retrieve x0 vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  *Ap = (SuiteSparse_long*)mxMalloc((Size+1) * sizeof(SuiteSparse_long));
+  *Ap = (SuiteSparse_long *) mxMalloc((Size+1) * sizeof(SuiteSparse_long));
+  test_mxMalloc(*Ap, __LINE__, __FILE__, __func__, (Size+1) * sizeof(SuiteSparse_long));
   if (!(*Ap))
     {
       ostringstream tmp;
@@ -860,14 +872,16 @@ dynSparseMatrix::Init_UMFPACK_Sparse_Simple(int Size, map<pair<pair<int, int>, i
       throw FatalExceptionHandling(tmp.str());
     }
   size_t prior_nz = IM.size();
-  *Ai = (SuiteSparse_long*)mxMalloc(prior_nz * sizeof(SuiteSparse_long));
+  *Ai = (SuiteSparse_long *) mxMalloc(prior_nz * sizeof(SuiteSparse_long));
+  test_mxMalloc(*Ai, __LINE__, __FILE__, __func__, prior_nz * sizeof(SuiteSparse_long));
   if (!(*Ai))
     {
       ostringstream tmp;
       tmp << " in Init_UMFPACK_Sparse, can't allocate Ai index vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  *Ax = (double*)mxMalloc(prior_nz * sizeof(double));
+  *Ax = (double *) mxMalloc(prior_nz * sizeof(double));
+  test_mxMalloc(*Ax, __LINE__, __FILE__, __func__, prior_nz * sizeof(double));
   if (!(*Ax))
     {
       ostringstream tmp;
@@ -984,13 +998,13 @@ void
 dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Size, map<pair<pair<int, int>, int>, int> &IM, SuiteSparse_long **Ap, SuiteSparse_long **Ai, double **Ax, double **b, mxArray *x0_m, vector_table_conditional_local_type vector_table_conditional_local, int block_num)
 {
   int t, eq, var, lag, ti_y_kmin, ti_y_kmax;
-  double* jacob_exo ;
-  int row_x;
+  double *jacob_exo;
+  int row_x = 0;
 #ifdef DEBUG
   int col_x;
 #endif
   int n = periods * Size;
-  *b = (double*)mxMalloc(n * sizeof(double));
+  *b = (double *) mxMalloc(n * sizeof(double));
   if (!(*b))
     {
       ostringstream tmp;
@@ -1004,7 +1018,8 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
       tmp << " in Init_UMFPACK_Sparse_Simple, can't retrieve x0 vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  *Ap = (SuiteSparse_long*)mxMalloc((n+1) * sizeof(SuiteSparse_long));
+  *Ap = (SuiteSparse_long *) mxMalloc((n+1) * sizeof(SuiteSparse_long));
+  test_mxMalloc(*Ap, __LINE__, __FILE__, __func__, (n+1) * sizeof(SuiteSparse_long));
   if (!(*Ap))
     {
       ostringstream tmp;
@@ -1012,14 +1027,16 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
       throw FatalExceptionHandling(tmp.str());
     }
   size_t prior_nz = IM.size() * periods;
-  *Ai = (SuiteSparse_long*)mxMalloc(prior_nz * sizeof(SuiteSparse_long));
+  *Ai = (SuiteSparse_long *) mxMalloc(prior_nz * sizeof(SuiteSparse_long));
+  test_mxMalloc(*Ai, __LINE__, __FILE__, __func__, prior_nz * sizeof(SuiteSparse_long));
   if (!(*Ai))
     {
       ostringstream tmp;
       tmp << " in Init_UMFPACK_Sparse, can't allocate Ai index vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  *Ax = (double*)mxMalloc(prior_nz * sizeof(double));
+  *Ax = (double *) mxMalloc(prior_nz * sizeof(double));
+  test_mxMalloc(*Ax, __LINE__, __FILE__, __func__, prior_nz * sizeof(double));
   if (!(*Ax))
     {
       ostringstream tmp;
@@ -1047,10 +1064,14 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
       col_x = mxGetN(jacobian_exo_block[block_num]);
 #endif
     }
+  else
+    {
+      jacob_exo = NULL;
+    }
 #ifdef DEBUG
   int local_index;
 #endif
-  
+
   bool fliped = false;
   bool fliped_exogenous_derivatives_updated = false;
   int flip_exo;
@@ -1060,27 +1081,27 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
       last_var = -1;
       it4 = IM.begin();
       var = 0;
-      while (it4 != IM.end()) 
+      while (it4 != IM.end())
         {
           var = it4->first.first.first;
 #ifdef DEBUG
-           if (var < 0 || var >= Size)
-             {
-               ostringstream tmp;
-               tmp << " in Init_UMFPACK_Sparse, var (" << var << ") out of range\n";
-               throw FatalExceptionHandling(tmp.str());
-             }
+          if (var < 0 || var >= Size)
+            {
+              ostringstream tmp;
+              tmp << " in Init_UMFPACK_Sparse, var (" << var << ") out of range\n";
+              throw FatalExceptionHandling(tmp.str());
+            }
 #endif
           eq = it4->first.second+Size*t;
 #ifdef DEBUG
-           if (eq < 0 || eq >= Size)
-             {
-               ostringstream tmp;
-               tmp << " in Init_UMFPACK_Sparse, eq (" << eq << ") out of range\n";
-               throw FatalExceptionHandling(tmp.str());
-             }
+          if (eq < 0 || eq >= Size)
+            {
+              ostringstream tmp;
+              tmp << " in Init_UMFPACK_Sparse, eq (" << eq << ") out of range\n";
+              throw FatalExceptionHandling(tmp.str());
+            }
 #endif
-          lag = - it4->first.first.second;
+          lag = -it4->first.first.second;
           int index = it4->second+ (t-lag) * u_count_init;
           if (var != last_var)
             {
@@ -1117,27 +1138,27 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
                               (*Ax)[NZE] = jacob_exo[k + row_x*flip_exo];
                               (*Ai)[NZE] = k;
                               NZE++;
-                          
+
 #ifdef DEBUG
                               if (local_index < 0 || local_index >= Size * periods)
-                               {
-                                 ostringstream tmp;
-                                 tmp << " in Init_UMFPACK_Sparse, index (" << local_index << ") out of range for b vector\n";
-                                 throw FatalExceptionHandling(tmp.str());
-                               }
-                             if (k + row_x*flip_exo < 0 || k + row_x*flip_exo >= row_x * col_x)
-                               {
-                                 ostringstream tmp;
-                                 tmp << " in Init_UMFPACK_Sparse, index (" << var+Size*(y_kmin+t+lag) << ") out of range for jacob_exo vector\n";
-                                 throw FatalExceptionHandling(tmp.str());
-                               }
-                             if (t+y_kmin+flip_exo*nb_row_x < 0 || t+y_kmin+flip_exo*nb_row_x >= nb_row_x * this->col_x)
-                               {
-                                 ostringstream tmp;
-                                 tmp << " in Init_UMFPACK_Sparse, index (" << index_vara[var+Size*(y_kmin+t+lag)] << ") out of range for x vector max=" << nb_row_x * this->col_x << "\n";
-                                 throw FatalExceptionHandling(tmp.str());
-                               }
-#endif    
+                                {
+                                  ostringstream tmp;
+                                  tmp << " in Init_UMFPACK_Sparse, index (" << local_index << ") out of range for b vector\n";
+                                  throw FatalExceptionHandling(tmp.str());
+                                }
+                              if (k + row_x*flip_exo < 0 || k + row_x*flip_exo >= row_x * col_x)
+                                {
+                                  ostringstream tmp;
+                                  tmp << " in Init_UMFPACK_Sparse, index (" << var+Size*(y_kmin+t+lag) << ") out of range for jacob_exo vector\n";
+                                  throw FatalExceptionHandling(tmp.str());
+                                }
+                              if (t+y_kmin+flip_exo*nb_row_x < 0 || t+y_kmin+flip_exo*nb_row_x >= nb_row_x * this->col_x)
+                                {
+                                  ostringstream tmp;
+                                  tmp << " in Init_UMFPACK_Sparse, index (" << index_vara[var+Size*(y_kmin+t+lag)] << ") out of range for x vector max=" << nb_row_x * this->col_x << "\n";
+                                  throw FatalExceptionHandling(tmp.str());
+                                }
+#endif
                               u[k] -=  jacob_exo[k + row_x*flip_exo] * x[t+y_kmin+flip_exo*nb_row_x];
                             }
                         }
@@ -1146,12 +1167,12 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
             }
           /*if (t==0)
             {
-              if (min_lag > lag)
-                min_lag = lag;
-              if (max_lag < lag)
-                max_lag = lag;
+            if (min_lag > lag)
+            min_lag = lag;
+            if (max_lag < lag)
+            max_lag = lag;
             }*/
-          
+
           if (var < (periods+y_kmax)*Size)
             {
               ti_y_kmin = -min(t, y_kmin);
@@ -1195,16 +1216,16 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
                           tmp << " in Init_UMFPACK_Sparse, index (" << var+Size*(y_kmin+t) << ") out of range for index_vara vector\n";
                           throw FatalExceptionHandling(tmp.str());
                         }
-                      if (index_vara[var+Size*(y_kmin+t/*+lag*/)] < 0 || index_vara[var+Size*(y_kmin+t/*+lag*/)] >= y_size*(periods+y_kmin+y_kmax))
+                      if (index_vara[var+Size*(y_kmin+t /*+lag*/)] < 0 || index_vara[var+Size*(y_kmin+t /*+lag*/)] >= y_size*(periods+y_kmin+y_kmax))
                         {
                           ostringstream tmp;
-                          tmp << " in Init_UMFPACK_Sparse, index (" << index_vara[var+Size*(y_kmin+t/*+lag*/)] << ") out of range for y vector max=" << y_size*(periods+y_kmin+y_kmax) << "\n";
+                          tmp << " in Init_UMFPACK_Sparse, index (" << index_vara[var+Size*(y_kmin+t /*+lag*/)] << ") out of range for y vector max=" << y_size*(periods+y_kmin+y_kmax) << "\n";
                           throw FatalExceptionHandling(tmp.str());
-                          }
+                        }
 #endif
-                      (*b)[eq - lag * Size] += u[index] * y[index_vara[var+Size*(y_kmin+t/*+lag*/)]];
+                      (*b)[eq - lag * Size] += u[index] * y[index_vara[var+Size*(y_kmin+t /*+lag*/)]];
                     }
-                  
+
                 }
               if (lag > ti_y_kmax || lag < ti_y_kmin)
                 {
@@ -1256,17 +1277,17 @@ dynSparseMatrix::Init_UMFPACK_Sparse(int periods, int y_kmin, int y_kmax, int Si
 #ifdef DEBUG
   mexPrintf("*Ax = [");
   for (int i = 0; i < NZE; i++)
-    mexPrintf("%f ",(*Ax)[i]);
+    mexPrintf("%f ", (*Ax)[i]);
   mexPrintf("]\n");
 
   mexPrintf("*Ap = [");
   for (int i = 0; i < n+1; i++)
-    mexPrintf("%d ",(*Ap)[i]);
+    mexPrintf("%d ", (*Ap)[i]);
   mexPrintf("]\n");
 
   mexPrintf("*Ai = [");
   for (int i = 0; i < NZE; i++)
-    mexPrintf("%d ",(*Ai)[i]);
+    mexPrintf("%d ", (*Ai)[i]);
   mexPrintf("]\n");
 #endif
 }
@@ -1276,7 +1297,8 @@ dynSparseMatrix::Init_CUDA_Sparse_Simple(int Size, map<pair<pair<int, int>, int>
 {
   int eq, var;
 
-  *b = (double*)mxMalloc(Size * sizeof(double));
+  *b = (double *) mxMalloc(Size * sizeof(double));
+  test_mxMalloc(*b, __LINE__, __FILE__, __func__, Size * sizeof(double));
   if (!(*b))
     {
       ostringstream tmp;
@@ -1290,7 +1312,8 @@ dynSparseMatrix::Init_CUDA_Sparse_Simple(int Size, map<pair<pair<int, int>, int>
       tmp << " in Init_CUDA_Sparse_Simple, can't retrieve x0 vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  *Ap = (SuiteSparse_long*)mxMalloc((Size+1) * sizeof(SuiteSparse_long));
+  *Ap = (SuiteSparse_long *) mxMalloc((Size+1) * sizeof(SuiteSparse_long));
+  test_mxMalloc(*Ap, __LINE__, __FILE__, __func__, (Size+1) * sizeof(SuiteSparse_long));
   if (!(*Ap))
     {
       ostringstream tmp;
@@ -1298,14 +1321,16 @@ dynSparseMatrix::Init_CUDA_Sparse_Simple(int Size, map<pair<pair<int, int>, int>
       throw FatalExceptionHandling(tmp.str());
     }
   size_t prior_nz = IM.size();
-  *Ai = (SuiteSparse_long*)mxMalloc(prior_nz * sizeof(SuiteSparse_long));
+  *Ai = (SuiteSparse_long *) mxMalloc(prior_nz * sizeof(SuiteSparse_long));
+  test_mxMalloc(*Ai, __LINE__, __FILE__, __func__, prior_nz * sizeof(SuiteSparse_long));
   if (!(*Ai))
     {
       ostringstream tmp;
       tmp << " in Init_CUDA_Sparse, can't allocate Ai index vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  *Ax = (double*)mxMalloc(prior_nz * sizeof(double));
+  *Ax = (double *) mxMalloc(prior_nz * sizeof(double));
+  test_mxMalloc(*Ax, __LINE__, __FILE__, __func__, prior_nz * sizeof(double));
   if (!(*Ax))
     {
       ostringstream tmp;
@@ -1409,9 +1434,9 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
 
   cudaSetDevice(CUDA_device);
 
-
-  double *Host_b = (double*)mxMalloc(n * sizeof(double));
-  cudaChk(cudaMalloc((void**)b, n * sizeof(double)), " in Init_Cuda_Sparse, not enought memory to allocate b vector on the graphic card\n");
+  double *Host_b = (double *) mxMalloc(n * sizeof(double));
+  test_mxMalloc(Host_b, __LINE__, __FILE__, __func__, n * sizeof(double));
+  cudaChk(cudaMalloc((void **) b, n * sizeof(double)), " in Init_Cuda_Sparse, not enought memory to allocate b vector on the graphic card\n");
 
   double *Host_x0 = mxGetPr(x0_m);
   if (!Host_x0)
@@ -1420,39 +1445,41 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
       tmp << " in Init_Cuda_Sparse, can't retrieve x0 vector\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  cudaChk(cudaMalloc((void**)x0, n * sizeof(double)), " in Init_Cuda_Sparse, not enought memory to allocate x0 vector on the graphic card\n");
+  cudaChk(cudaMalloc((void **) x0, n * sizeof(double)), " in Init_Cuda_Sparse, not enought memory to allocate x0 vector on the graphic card\n");
 
-  int* Host_Ap = (int*)mxMalloc((n+1) * sizeof(int));
+  int *Host_Ap = (int *) mxMalloc((n+1) * sizeof(int));
+  test_mxMalloc(Host_Ap, __LINE__, __FILE__, __func__, (n+1) * sizeof(int));
 
+  int *Host_Ai = (int *) mxMalloc(prior_nz * sizeof(int));
+  test_mxMalloc(Host_Ai, __LINE__, __FILE__, __func__, prior_nz * sizeof(int));
 
-  int* Host_Ai = (int*)mxMalloc(prior_nz * sizeof(int));
+  double *Host_Ax = (double *) mxMalloc(prior_nz * sizeof(double));
+  test_mxMalloc(Host_Ax, __LINE__, __FILE__, __func__, prior_nz * sizeof(double));
 
-
-  double* Host_Ax = (double*)mxMalloc(prior_nz * sizeof(double));
-
-  int* Host_Ai_tild, * Host_Ap_tild;
+  int *Host_Ai_tild, *Host_Ap_tild;
   if (preconditioner == 3)
     {
-      Host_Ap_tild = (int*) mxMalloc((n+1)*sizeof(int));
-      Host_Ai_tild = (int*) mxMalloc(prior_nz*sizeof(int));
+      Host_Ap_tild = (int *) mxMalloc((n+1)*sizeof(int));
+      test_mxMalloc(Host_Ap_tild, __LINE__, __FILE__, __func__, (n+1)*sizeof(int));
+      Host_Ai_tild = (int *) mxMalloc(prior_nz*sizeof(int));
+      test_mxMalloc(Host_Ai_tild, __LINE__, __FILE__, __func__, prior_nz*sizeof(int));
       Host_Ap_tild[0] = 0;
     }
 
-
   if (preconditioner == 0)
     preconditioner_size = n;
   else if (preconditioner == 1 || preconditioner == 2 || preconditioner == 3)
     preconditioner_size = prior_nz;
 
-  double *Host_A_tild = (double*)mxMalloc(preconditioner_size * sizeof(double));
-
+  double *Host_A_tild = (double *) mxMalloc(preconditioner_size * sizeof(double));
+  test_mxMalloc(Host_A_tild, __LINE__, __FILE__, __func__, preconditioner_size * sizeof(double));
 
   map<pair<pair<int, int>, int>, int>::iterator it4;
   for (int i = 0; i < y_size*(periods+y_kmin); i++)
     ya[i] = y[i];
-#ifdef DEBUG
+# ifdef DEBUG
   unsigned int max_nze = mxGetNzmax(A_m);
-#endif
+# endif
   unsigned int NZE = 0, NZE_tild = 0;
   int last_eq = 0;
   for (int i = 0; i < periods*Size; i++)
@@ -1473,17 +1500,17 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
           eq = it4->first.first.first;
           if (eq != last_eq)
             {
-#ifdef DEBUG
+# ifdef DEBUG
               if (1+last_eq + t * Size > (n + 1))
                 {
                   ostringstream tmp;
                   tmp << " in Init_CUDA_Sparse, 1+last_eq + t * Size (" << 1+last_eq + t * Size << ") out of range for Host_Ap vector\n";
                   throw FatalExceptionHandling(tmp.str());
                 }
-#endif
+# endif
               Host_Ap[1+last_eq + t * Size] = NZE;
               if (preconditioner == 3 && t == 0)
-                 Host_Ap_tild[1+last_eq ] = NZE_tild;
+                Host_Ap_tild[1+last_eq ] = NZE_tild;
               last_eq = eq;
             }
           var = it4->first.second+Size*t;
@@ -1495,7 +1522,7 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
               ti_y_kmax = min(periods-(t + 1), y_kmax);
               if ((lag <= ti_y_kmax && lag >= ti_y_kmin) || preconditioner == 3)  /*Build the index for sparse matrix containing the jacobian : u*/
                 {
-#ifdef DEBUG
+# ifdef DEBUG
                   if (index < 0 || index >= u_count_alloc || index > (periods-1)* IM.size() + Size * Size + periods * Size)
                     {
                       ostringstream tmp;
@@ -1508,7 +1535,7 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
                       tmp << " in Init_CUDA_Sparse, exceeds the capacity of A_i or A_x sparse matrix\n";
                       throw FatalExceptionHandling(tmp.str());
                     }
-#endif
+# endif
                   bool to_store = true;
                   if (preconditioner == 0)
                     {
@@ -1526,10 +1553,10 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
                         }
                       if (t == 0)
                         {
-                           map<pair<int, int>, int>::const_iterator it = jacob_struct.find(make_pair(eq + t * Size, var));
-                           if (it != jacob_struct.end())
-                             Host_A_tild[it->second] += u[index];
-                           else
+                          map<pair<int, int>, int>::const_iterator it = jacob_struct.find(make_pair(eq + t * Size, var));
+                          if (it != jacob_struct.end())
+                            Host_A_tild[it->second] += u[index];
+                          else
                             {
                               jacob_struct[make_pair(eq, var)] = NZE_tild;
                               Host_A_tild[NZE_tild] = u[index];
@@ -1547,7 +1574,7 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
                 }
               else
                 {
-#ifdef DEBUG
+# ifdef DEBUG
                   if (var < 0 || var >= Size * periods)
                     {
                       ostringstream tmp;
@@ -1566,13 +1593,13 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
                       tmp << " in Init_CUDA_Sparse, index (" << index_vara[var+Size*(y_kmin+lag)] << ") out of range for y vector max=" << y_size*(periods+y_kmin+y_kmax) << "\n";
                       throw FatalExceptionHandling(tmp.str());
                     }
-#endif
+# endif
                   Host_b[eq + t * Size]  += u[index]*y[index_vara[var+Size*(y_kmin+lag)]];
                 }
             }
           else           // ...and store it in the u vector
             {
-#ifdef DEBUG
+# ifdef DEBUG
               if (index < 0 || index >= u_count_alloc)
                 {
                   ostringstream tmp;
@@ -1585,7 +1612,7 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
                   tmp << " in Init_CUDA_Sparse, index (" << var << ") out of range for b vector\n";
                   throw FatalExceptionHandling(tmp.str());
                 }
-#endif
+# endif
               Host_b[var]  += u[index];
             }
           it4++;
@@ -1594,9 +1621,12 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
   Host_Ap[Size*periods] = NZE;
   if (preconditioner == 3)
     {
-      int* tmp_Ap_tild = (int*) mxMalloc((Size + 1) * sizeof(int) );
-      int* tmp_Ai_tild = (int*) mxMalloc(NZE_tild * sizeof(int) );
-      double* tmp_A_tild = (double*) mxMalloc(NZE_tild * sizeof(double) );
+      int *tmp_Ap_tild = (int *) mxMalloc((Size + 1) * sizeof(int));
+      test_mxMalloc(tmp_Ap_tild, __LINE__, __FILE__, __func__, (Size + 1) * sizeof(int));
+      int *tmp_Ai_tild = (int *) mxMalloc(NZE_tild * sizeof(int));
+      test_mxMalloc(tmp_Ai_tild, __LINE__, __FILE__, __func__, NZE_tild * sizeof(int));
+      double *tmp_A_tild = (double *) mxMalloc(NZE_tild * sizeof(double));
+      test_mxMalloc(tmp_A_tild, __LINE__, __FILE__, __func__, NZE_tild * sizeof(double));
       memcpy(tmp_Ap_tild, Host_Ap_tild, (Size + 1) * sizeof(int));
       memcpy(tmp_Ai_tild, Host_Ai_tild, NZE_tild * sizeof(int));
       memcpy(tmp_A_tild, Host_A_tild, NZE_tild * sizeof(double));
@@ -1606,8 +1636,8 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
 
       for (int i = 0; i < Size; i++)
         {
-          for(int j = tmp_Ap_tild[i]; j < tmp_Ap_tild[i+1]; j++)
-            if (abs(tmp_A_tild[j]) > 1.0e-20 )
+          for (int j = tmp_Ap_tild[i]; j < tmp_Ap_tild[i+1]; j++)
+            if (abs(tmp_A_tild[j]) > 1.0e-20)
               {
                 Host_A_tild[NZE_tild] = tmp_A_tild[j];
                 Host_Ai_tild[NZE_tild] = tmp_Ai_tild[j];
@@ -1625,32 +1655,31 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
   if (preconditioner == 1 || preconditioner == 2 || preconditioner == 3)
     preconditioner_size = NZE;
 
-
-#ifdef DEBUG
+# ifdef DEBUG
   mexPrintf("Host_Ax = [");
   for (int i = 0; i < NZE; i++)
-    mexPrintf("%f ",Host_Ax[i]);
+    mexPrintf("%f ", Host_Ax[i]);
   mexPrintf("]\n");
 
   mexPrintf("Host_Ap = [");
   for (int i = 0; i < n+1; i++)
-    mexPrintf("%d ",Host_Ap[i]);
+    mexPrintf("%d ", Host_Ap[i]);
   mexPrintf("]\n");
 
   mexPrintf("Host_Ai = [");
   for (int i = 0; i < NZE; i++)
-    mexPrintf("%d ",Host_Ai[i]);
+    mexPrintf("%d ", Host_Ai[i]);
   mexPrintf("]\n");
-#endif
-  cudaChk(cudaMalloc((void**)Ai, NZE * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ai index vector on the graphic card\n");
-  cudaChk(cudaMalloc((void**)Ax, NZE * sizeof(double)), "  in Init_Cuda_Sparse, can't allocate Ax on the graphic card\n");
-  cudaChk(cudaMalloc((void**)Ap, (n+1) * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ap index vector on the graphic card\n");
+# endif
+  cudaChk(cudaMalloc((void **) Ai, NZE * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ai index vector on the graphic card\n");
+  cudaChk(cudaMalloc((void **) Ax, NZE * sizeof(double)), "  in Init_Cuda_Sparse, can't allocate Ax on the graphic card\n");
+  cudaChk(cudaMalloc((void **) Ap, (n+1) * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ap index vector on the graphic card\n");
   if (preconditioner == 3)
     {
-      cudaChk(cudaMalloc((void**)Ai_tild, NZE_tild * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ai_tild index vector on the graphic card\n");
-      cudaChk(cudaMalloc((void**)Ap_tild, (n+1) * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ap_tild index vector on the graphic card\n");
+      cudaChk(cudaMalloc((void **) Ai_tild, NZE_tild * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ai_tild index vector on the graphic card\n");
+      cudaChk(cudaMalloc((void **) Ap_tild, (n+1) * sizeof(int)), " in Init_Cuda_Sparse, can't allocate Ap_tild index vector on the graphic card\n");
     }
-  cudaChk(cudaMalloc((void**)A_tild, preconditioner_size * sizeof(double)), "  in Init_Cuda_Sparse, can't allocate A_tild on the graphic card\n");
+  cudaChk(cudaMalloc((void **) A_tild, preconditioner_size * sizeof(double)), "  in Init_Cuda_Sparse, can't allocate A_tild on the graphic card\n");
 
   cudaChk(cudaMemcpy(*x0,     Host_x0,     n *                   sizeof(double), cudaMemcpyHostToDevice), " in Init_CUDA_Sparse, cudaMemcpy x0 = Host_x0 failed");
   cudaChk(cudaMemcpy(*b,      Host_b,      n *                   sizeof(double), cudaMemcpyHostToDevice), " in Init_CUDA_Sparse, cudaMemcpy b = Host_b failed");
@@ -1666,15 +1695,15 @@ dynSparseMatrix::Init_CUDA_Sparse(int periods, int y_kmin, int y_kmax, int Size,
 }
 #endif
 
-
 void
-PrintM(int n, double* Ax, mwIndex *Ap, mwIndex *Ai)
+dynSparseMatrix::PrintM(int n, double *Ax, mwIndex *Ap, mwIndex *Ai)
 {
   int nnz = Ap[n];
-  double *A = (double*)mxMalloc(n * n * sizeof(double));
-  memset(A,0,n * n  * sizeof(double));
+  double *A = (double *) mxMalloc(n * n * sizeof(double));
+  test_mxMalloc(A, __LINE__, __FILE__, __func__, n * n * sizeof(double));
+  memset(A, 0, n * n  * sizeof(double));
   int k = 0;
-  for (int i = 0; i< n; i++)
+  for (int i = 0; i < n; i++)
     {
       for (int j = Ap[i]; j < (int) Ap[i + 1]; j++)
         {
@@ -1687,10 +1716,10 @@ PrintM(int n, double* Ax, mwIndex *Ap, mwIndex *Ai)
     mexPrintf("Problem nnz(%d) != number of elements(%d)\n", nnz, k);
   mexPrintf("----------------------\n");
   //mexEvalString("drawnow;");
-  for (int i = 0; i < n ; i++)
+  for (int i = 0; i < n; i++)
     {
       for (int j = 0; j < n; j++)
-        mexPrintf("%-6.3f ",A[i * n + j]);
+        mexPrintf("%-6.3f ", A[i * n + j]);
       mexPrintf("\n");
     }
   mxFree(A);
@@ -1849,23 +1878,36 @@ dynSparseMatrix::Init_GE(int periods, int y_kmin, int y_kmax, int Size, map<pair
   map<pair<pair<int, int>, int>, int>::iterator it4;
   NonZeroElem *first;
   pivot = (int *) mxMalloc(Size*periods*sizeof(int));
+  test_mxMalloc(pivot, __LINE__, __FILE__, __func__, Size*periods*sizeof(int));
   pivot_save = (int *) mxMalloc(Size*periods*sizeof(int));
+  test_mxMalloc(pivot_save, __LINE__, __FILE__, __func__, Size*periods*sizeof(int));
   pivotk = (int *) mxMalloc(Size*periods*sizeof(int));
+  test_mxMalloc(pivotk, __LINE__, __FILE__, __func__, Size*periods*sizeof(int));
   pivotv = (double *) mxMalloc(Size*periods*sizeof(double));
+  test_mxMalloc(pivotv, __LINE__, __FILE__, __func__, Size*periods*sizeof(double));
   pivotva = (double *) mxMalloc(Size*periods*sizeof(double));
+  test_mxMalloc(pivotva, __LINE__, __FILE__, __func__, Size*periods*sizeof(double));
   b = (int *) mxMalloc(Size*periods*sizeof(int));
+  test_mxMalloc(b, __LINE__, __FILE__, __func__, Size*periods*sizeof(int));
   line_done = (bool *) mxMalloc(Size*periods*sizeof(bool));
+  test_mxMalloc(line_done, __LINE__, __FILE__, __func__, Size*periods*sizeof(bool));
   mem_mngr.init_CHUNK_BLCK_SIZE(u_count);
   g_save_op = NULL;
   g_nop_all = 0;
   i = (periods+y_kmax+1)*Size*sizeof(NonZeroElem *);
   FNZE_R = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(FNZE_R, __LINE__, __FILE__, __func__, i);
   FNZE_C = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(FNZE_C, __LINE__, __FILE__, __func__, i);
   NonZeroElem **temp_NZE_R = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(temp_NZE_R, __LINE__, __FILE__, __func__, i);
   NonZeroElem **temp_NZE_C = (NonZeroElem **) mxMalloc(i);
+  test_mxMalloc(temp_NZE_C, __LINE__, __FILE__, __func__, i);
   i = (periods+y_kmax+1)*Size*sizeof(int);
   NbNZRow = (int *) mxMalloc(i);
+  test_mxMalloc(NbNZRow, __LINE__, __FILE__, __func__, i);
   NbNZCol = (int *) mxMalloc(i);
+  test_mxMalloc(NbNZCol, __LINE__, __FILE__, __func__, i);
 
   for (int i = 0; i < periods*Size; i++)
     {
@@ -2029,7 +2071,9 @@ dynSparseMatrix::compare(int *save_op, int *save_opa, int *save_opaa, int beg_t,
   t_save_op_s *save_op_s, *save_opa_s, *save_opaa_s;
   int *diff1, *diff2;
   diff1 = (int *) mxMalloc(nop*sizeof(int));
+  test_mxMalloc(diff1, __LINE__, __FILE__, __func__, nop*sizeof(int));
   diff2 = (int *) mxMalloc(nop*sizeof(int));
+  test_mxMalloc(diff2, __LINE__, __FILE__, __func__, nop*sizeof(int));
   int max_save_ops_first = -1;
   j = i = 0;
   while (i < nop4 && OK)
@@ -2180,8 +2224,10 @@ dynSparseMatrix::complete(int beg_t, int Size, int periods, int *b)
 
   int size_of_save_code = (1+y_kmax)*Size*(Size+1+4)/2*4;
   save_code = (int *) mxMalloc(size_of_save_code*sizeof(int));
+  test_mxMalloc(save_code, __LINE__, __FILE__, __func__, size_of_save_code*sizeof(int));
   int size_of_diff = (1+y_kmax)*Size*(Size+1+4);
   diff = (int *) mxMalloc(size_of_diff*sizeof(int));
+  test_mxMalloc(diff, __LINE__, __FILE__, __func__, size_of_diff*sizeof(int));
   cal_y = y_size*y_kmin;
 
   i = (beg_t+1)*Size-1;
@@ -2439,6 +2485,7 @@ dynSparseMatrix::CheckIt(int y_size, int y_kmin, int y_kmax, int Size, int perio
   mexPrintf("row(2)=%d\n", row);
   double *B;
   B = (double *) mxMalloc(row*sizeof(double));
+  test_mxMalloc(B, __LINE__, __FILE__, __func__, row*sizeof(double));
   for (int i = 0; i < row; i++)
     SaveResult >> B[i];
   SaveResult.close();
@@ -2628,7 +2675,7 @@ dynSparseMatrix::mult_SAT_B(mxArray *A_m, mxArray *B_m)
   double *B_d = mxGetPr(B_m);
   mxArray *C_m = mxCreateDoubleMatrix(m_A, n_B, mxREAL);
   double *C_d = mxGetPr(C_m);
-  for (int j = 0; j < (int)n_B; j++)
+  for (int j = 0; j < (int) n_B; j++)
     {
       for (unsigned int i = 0; i < n_A; i++)
         {
@@ -2780,19 +2827,18 @@ dynSparseMatrix::Sparse_transpose(mxArray *A_m)
   return C_m;
 }
 
-
-#define sign(a,b) ((b) >= 0.0 ? fabs(a) : -fabs(a))
+#define sign(a, b) ((b) >= 0.0 ? fabs(a) : -fabs(a))
 bool
 dynSparseMatrix::mnbrak(double *ax, double *bx, double *cx, double *fa, double *fb, double *fc)
 {
-  const double GOLD=1.618034;
-  const double GLIMIT=100.0;
-  const double TINY=1.0e-20;
+  const double GOLD = 1.618034;
+  const double GLIMIT = 100.0;
+  const double TINY = 1.0e-20;
 
   double tmp;
-  mexPrintf("bracketing *ax=%f, *bx=%f\n",*ax, *bx);
+  mexPrintf("bracketing *ax=%f, *bx=%f\n", *ax, *bx);
   //mexEvalString("drawnow;");
-  double ulim,u,r,q,fu;
+  double ulim, u, r, q, fu;
   if (!compute_complete(*ax, fa))
     return false;
   if (!compute_complete(*bx, fb))
@@ -2807,35 +2853,35 @@ dynSparseMatrix::mnbrak(double *ax, double *bx, double *cx, double *fa, double *
       *fa = *fb;
       *fb = tmp;
     }
-  *cx=(*bx)+GOLD*(*bx-*ax);
+  *cx = (*bx)+GOLD*(*bx-*ax);
   if (!compute_complete(*cx, fc))
     return false;
   while (*fb > *fc)
     {
-      r=(*bx-*ax)*(*fb-*fc);
-      q=(*bx-*cx)*(*fb-*fa);
-      u=(*bx)-((*bx-*cx)*q-(*bx-*ax)*r)/
-        (2.0*sign(fmax(fabs(q-r),TINY),q-r));
-      ulim=(*bx)+GLIMIT*(*cx-*bx);
+      r = (*bx-*ax)*(*fb-*fc);
+      q = (*bx-*cx)*(*fb-*fa);
+      u = (*bx)-((*bx-*cx)*q-(*bx-*ax)*r)
+        /(2.0*sign(fmax(fabs(q-r), TINY), q-r));
+      ulim = (*bx)+GLIMIT*(*cx-*bx);
       if ((*bx-u)*(u-*cx) > 0.0)
         {
           if (!compute_complete(u, &fu))
             return false;
           if (fu < *fc)
             {
-              *ax=(*bx);
-              *bx=u;
-              *fa=(*fb);
-              *fb=fu;
+              *ax = (*bx);
+              *bx = u;
+              *fa = (*fb);
+              *fb = fu;
               return true;
             }
           else if (fu > *fb)
             {
-              *cx=u;
-              *fc=fu;
+              *cx = u;
+              *fc = fu;
               return true;
             }
-          u=(*cx)+GOLD*(*cx-*bx);
+          u = (*cx)+GOLD*(*cx-*bx);
           if (!compute_complete(u, &fu))
             return false;
         }
@@ -2856,13 +2902,13 @@ dynSparseMatrix::mnbrak(double *ax, double *bx, double *cx, double *fa, double *
         }
       else if ((u-ulim)*(ulim-*cx) >= 0.0)
         {
-          u=ulim;
+          u = ulim;
           if (!compute_complete(u, &fu))
             return false;
         }
       else
         {
-          u=(*cx)+GOLD*(*cx-*bx);
+          u = (*cx)+GOLD*(*cx-*bx);
           if (!compute_complete(u, &fu))
             return false;
         }
@@ -2879,23 +2925,23 @@ dynSparseMatrix::mnbrak(double *ax, double *bx, double *cx, double *fa, double *
 bool
 dynSparseMatrix::golden(double ax, double bx, double cx, double tol, double solve_tolf, double *xmin)
 {
-  const double R=0.61803399;
-  const double C=(1.0-R);
+  const double R = 0.61803399;
+  const double C = (1.0-R);
   mexPrintf("golden\n");
   //mexEvalString("drawnow;");
-  double f1,f2,x0,x1,x2,x3;
-  int iter= 0, max_iter= 100;
-  x0=ax;
-  x3=cx;
+  double f1, f2, x0, x1, x2, x3;
+  int iter = 0, max_iter = 100;
+  x0 = ax;
+  x3 = cx;
   if (fabs(cx-bx) > fabs(bx-ax))
     {
-      x1=bx;
-      x2=bx+C*(cx-bx);
+      x1 = bx;
+      x2 = bx+C*(cx-bx);
     }
   else
     {
-      x2=bx;
-      x1=bx-C*(bx-ax);
+      x2 = bx;
+      x1 = bx-C*(bx-ax);
     }
   if (!compute_complete(x1, &f1))
     return false;
@@ -2925,12 +2971,12 @@ dynSparseMatrix::golden(double ax, double bx, double cx, double tol, double solv
     }
   if (f1 < f2)
     {
-      *xmin=x1;
+      *xmin = x1;
       return true;
     }
   else
     {
-      *xmin=x2;
+      *xmin = x2;
       return true;
     }
 }
@@ -3244,12 +3290,11 @@ void
 dynSparseMatrix::End_Matlab_LU_UMFPack()
 {
   if (Symbolic)
-    umfpack_dl_free_symbolic (&Symbolic) ;
+    umfpack_dl_free_symbolic(&Symbolic);
   if (Numeric)
-    umfpack_dl_free_numeric (&Numeric) ;
+    umfpack_dl_free_numeric(&Numeric);
 }
 
-
 void
 dynSparseMatrix::End_Solver()
 {
@@ -3261,17 +3306,17 @@ void
 dynSparseMatrix::Printfull_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b, int n)
 {
   double A[n*n];
-  for (int i = 0 ; i  < n*n ; i++)
+  for (int i = 0; i  < n*n; i++)
     A[i] = 0;
   int k = 0;
   for (int i = 0; i < n; i++)
-      for (int j = Ap[i]; j < Ap[i+1]; j++)
-        A[Ai[j] * n + i] =  Ax[k++];
+    for (int j = Ap[i]; j < Ap[i+1]; j++)
+      A[Ai[j] * n + i] =  Ax[k++];
   for (int i = 0; i < n; i++)
     {
       for (int j = 0; j < n; j++)
-        mexPrintf("%4.1f ",A[i*n+j]);
-      mexPrintf("     %6.3f\n",b[i]);
+        mexPrintf("%4.1f ", A[i*n+j]);
+      mexPrintf("     %6.3f\n", b[i]);
     }
 }
 
@@ -3280,8 +3325,8 @@ dynSparseMatrix::Print_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, doubl
 {
   int k = 0;
   for (int i = 0; i < n; i++)
-      for (int j = Ap[i]; j < Ap[i+1]; j++)
-        mexPrintf("(%d, %d)    %f\n", Ai[j]+1, i+1, Ax[k++]);
+    for (int j = Ap[i]; j < Ap[i+1]; j++)
+      mexPrintf("(%d, %d)    %f\n", Ai[j]+1, i+1, Ax[k++]);
 }
 
 void
@@ -3292,9 +3337,12 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
   double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], res [n];
 #else
   double *Control, *Info, *res;
-  Control = (double*)mxMalloc(UMFPACK_CONTROL * sizeof(double));
-  Info = (double*)mxMalloc(UMFPACK_INFO * sizeof(double));
-  res = (double*)mxMalloc(n * sizeof(double));
+  Control = (double *) mxMalloc(UMFPACK_CONTROL * sizeof(double));
+  test_mxMalloc(Control, __LINE__, __FILE__, __func__, UMFPACK_CONTROL * sizeof(double));
+  Info = (double *) mxMalloc(UMFPACK_INFO * sizeof(double));
+  test_mxMalloc(Info, __LINE__, __FILE__, __func__, UMFPACK_INFO * sizeof(double));
+  res = (double *) mxMalloc(n * sizeof(double));
+  test_mxMalloc(res, __LINE__, __FILE__, __func__, n * sizeof(double));
 #endif
 
   umfpack_dl_defaults(Control);
@@ -3313,8 +3361,8 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
         }
     }
   if (iter > 0)
-    umfpack_dl_free_numeric(&Numeric) ;
-  status = umfpack_dl_numeric (Ap, Ai, Ax, Symbolic, &Numeric, Control, Info);
+    umfpack_dl_free_numeric(&Numeric);
+  status = umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, &Numeric, Control, Info);
   if (status < 0)
     {
       umfpack_dl_report_info(Control, Info);
@@ -3346,9 +3394,9 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
                     {
                       int eq = index_vara[i+Size*(y_kmin)];
                       int flip_exo = vector_table_conditional_local[i].var_exo;
-                      double  yy = -(res[i] + x[y_kmin + flip_exo*/*row_x*/nb_row_x]);
+                      double  yy = -(res[i] + x[y_kmin + flip_exo*nb_row_x]);
                       direction[eq] = 0;
-                      x[flip_exo*/*row_x*/nb_row_x + y_kmin] += slowc_l * yy;
+                      x[flip_exo*nb_row_x + y_kmin] += slowc_l * yy;
                     }
                   else
                     {
@@ -3396,8 +3444,8 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
             direction[eq] = yy;
             y[eq+it_*y_size] += slowc_l * yy;
           }
-      }
-  
+    }
+
   mxFree(Ap);
   mxFree(Ai);
   mxFree(Ax);
@@ -3409,7 +3457,6 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
 #endif
 }
 
-
 void
 dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b, int n, int Size, double slowc_l, bool is_two_boundaries, int  it_)
 {
@@ -3418,9 +3465,12 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
   double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], res [n];
 #else
   double *Control, *Info, *res;
-  Control = (double*)mxMalloc(UMFPACK_CONTROL * sizeof(double));
-  Info = (double*)mxMalloc(UMFPACK_INFO * sizeof(double));
-  res = (double*)mxMalloc(n * sizeof(double));
+  Control = (double *) mxMalloc(UMFPACK_CONTROL * sizeof(double));
+  test_mxMalloc(Control, __LINE__, __FILE__, __func__, UMFPACK_CONTROL * sizeof(double));
+  Info = (double *) mxMalloc(UMFPACK_INFO * sizeof(double));
+  test_mxMalloc(Info, __LINE__, __FILE__, __func__, UMFPACK_INFO * sizeof(double));
+  res = (double *) mxMalloc(n * sizeof(double));
+  test_mxMalloc(res, __LINE__, __FILE__, __func__, n * sizeof(double));
 #endif
 
   umfpack_dl_defaults(Control);
@@ -3439,8 +3489,8 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
         }
     }
   if (iter > 0)
-    umfpack_dl_free_numeric(&Numeric) ;
-  status = umfpack_dl_numeric (Ap, Ai, Ax, Symbolic, &Numeric, Control, Info);
+    umfpack_dl_free_numeric(&Numeric);
+  status = umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, &Numeric, Control, Info);
   if (status < 0)
     {
       umfpack_dl_report_info(Control, Info);
@@ -3486,40 +3536,42 @@ dynSparseMatrix::Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, do
 #endif
 }
 
-
 void
 dynSparseMatrix::Solve_LU_UMFPack(mxArray *A_m, mxArray *b_m, int Size, double slowc_l, bool is_two_boundaries, int  it_)
 {
   SuiteSparse_long n = mxGetM(A_m);
 
-  SuiteSparse_long *Ap = (SuiteSparse_long*)mxGetJc (A_m);
+  SuiteSparse_long *Ap = (SuiteSparse_long *) mxGetJc(A_m);
 
-  SuiteSparse_long *Ai = (SuiteSparse_long*)mxGetIr(A_m);
-  double*  Ax = mxGetPr(A_m);
-  double*  B  = mxGetPr(b_m);
+  SuiteSparse_long *Ai = (SuiteSparse_long *) mxGetIr(A_m);
+  double *Ax = mxGetPr(A_m);
+  double *B  = mxGetPr(b_m);
   SuiteSparse_long status, sys = 0;
 #ifndef _MSC_VER
   double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], res [n];
 #else
   double *Control, *Info, *res;
-  Control = (double*)mxMalloc(UMFPACK_CONTROL * sizeof(double));
-  Info = (double*)mxMalloc(UMFPACK_INFO * sizeof(double));
-  res = (double*)mxMalloc(n * sizeof(double));
+  Control = (double *) mxMalloc(UMFPACK_CONTROL * sizeof(double));
+  test_mxMalloc(Control, __LINE__, __FILE__, __func__, UMFPACK_CONTROL * sizeof(double));
+  Info = (double *) mxMalloc(UMFPACK_INFO * sizeof(double));
+  test_mxMalloc(Info, __LINE__, __FILE__, __func__, UMFPACK_INFO * sizeof(double));
+  res = (double *) mxMalloc(n * sizeof(double));
+  test_mxMalloc(res, __LINE__, __FILE__, __func__, n * sizeof(double));
 #endif
-  void *Symbolic, *Numeric ;
-  umfpack_dl_defaults (Control) ;
+  void *Symbolic, *Numeric;
+  umfpack_dl_defaults(Control);
 
-  status = umfpack_dl_symbolic (n, n, Ap, Ai, Ax, &Symbolic, Control, Info) ;
+  status = umfpack_dl_symbolic(n, n, Ap, Ai, Ax, &Symbolic, Control, Info);
   if (status != UMFPACK_OK)
-    umfpack_dl_report_info ((double*) NULL, Info) ;
+    umfpack_dl_report_info((double *) NULL, Info);
 
-  status = umfpack_dl_numeric (Ap, Ai, Ax, Symbolic, &Numeric, Control, Info) ;
+  status = umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, &Numeric, Control, Info);
   if (status != UMFPACK_OK)
-    umfpack_dl_report_info ((double*) NULL, Info) ;
+    umfpack_dl_report_info((double *) NULL, Info);
 
-  status = umfpack_dl_solve (sys, Ap, Ai, Ax, res, B, Numeric, Control, Info) ;
+  status = umfpack_dl_solve(sys, Ap, Ai, Ax, res, B, Numeric, Control, Info);
   if (status != UMFPACK_OK)
-    umfpack_dl_report_info ((double*) NULL, Info) ;
+    umfpack_dl_report_info((double *) NULL, Info);
   //double *res = mxGetPr(z);
   if (is_two_boundaries)
     for (int i = 0; i < n; i++)
@@ -3547,41 +3599,38 @@ dynSparseMatrix::Solve_LU_UMFPack(mxArray *A_m, mxArray *b_m, int Size, double s
 
 }
 
-
 #ifdef CUDA
 void
-printM(int n,double *Ax, int* Ap, int* Ai,  cusparseMatDescr_t descrA, cusparseHandle_t cusparse_handle)
+printM(int n, double *Ax, int *Ap, int *Ai,  cusparseMatDescr_t descrA, cusparseHandle_t cusparse_handle)
 {
   //cudaError_t cuda_error;
   //cusparseStatus_t cusparse_status;
-  double * A_dense;
-  cudaChk(cudaMalloc((void**) &A_dense, n * n *sizeof(double)), "A_dense cudaMalloc has failed\n");
-
+  double *A_dense;
+  cudaChk(cudaMalloc((void **) &A_dense, n * n *sizeof(double)), "A_dense cudaMalloc has failed\n");
 
   cusparseChk(cusparseDcsr2dense(cusparse_handle, n, n, descrA,
-                                 Ax, Ap,Ai, A_dense, n), "cusparseDcsr2dense has failed\n");
-  double *A_dense_hoste = (double*)mxMalloc(n * n * sizeof(double));
-  cudaChk(cudaMemcpy(A_dense_hoste, A_dense, n * n * sizeof(double),cudaMemcpyDeviceToHost), " cudaMemcpy(A_dense_hoste, A_dense) has failed\n");
+                                 Ax, Ap, Ai, A_dense, n), "cusparseDcsr2dense has failed\n");
+  double *A_dense_hoste = (double *) mxMalloc(n * n * sizeof(double));
+  test_mxMalloc(A_dense_hoste, __LINE__, __FILE__, __func__, n * n * sizeof(double));
+  cudaChk(cudaMemcpy(A_dense_hoste, A_dense, n * n * sizeof(double), cudaMemcpyDeviceToHost), " cudaMemcpy(A_dense_hoste, A_dense) has failed\n");
   mexPrintf("----------------------\n");
-  mexPrintf("FillMode=%d, IndexBase=%d, MatType=%d, DiagType=%d\n",cusparseGetMatFillMode(descrA), cusparseGetMatIndexBase(descrA), cusparseGetMatType(descrA), cusparseGetMatDiagType(descrA));
+  mexPrintf("FillMode=%d, IndexBase=%d, MatType=%d, DiagType=%d\n", cusparseGetMatFillMode(descrA), cusparseGetMatIndexBase(descrA), cusparseGetMatType(descrA), cusparseGetMatDiagType(descrA));
   //mexEvalString("drawnow;");
-  for (int i = 0; i < n ; i++)
+  for (int i = 0; i < n; i++)
     {
       for (int j = 0; j < n; j++)
-        mexPrintf("%-6.3f ",A_dense_hoste[i + j * n]);
+        mexPrintf("%-6.3f ", A_dense_hoste[i + j * n]);
       mexPrintf("\n");
     }
   mxFree(A_dense_hoste);
   cudaChk(cudaFree(A_dense), "cudaFree(A_dense) has failed\n");
 }
 
-
-
 void
-dynSparseMatrix::Solve_CUDA_BiCGStab_Free(double* tmp_vect_host, double* p, double* r, double* v, double* s, double* t, double* y_, double* z, double* tmp_,
-                                       int* Ai, double* Ax, int* Ap, double* x0, double* b, double* A_tild, int* A_tild_i, int* A_tild_p/*, double* Lx, int* Li, int* Lp,
-                                       double* Ux, int* Ui, int* Up, int* device_n*/, cusparseSolveAnalysisInfo_t infoL, cusparseSolveAnalysisInfo_t infoU,
-                                       cusparseMatDescr_t descrL, cusparseMatDescr_t descrU, int preconditioner)
+dynSparseMatrix::Solve_CUDA_BiCGStab_Free(double *tmp_vect_host, double *p, double *r, double *v, double *s, double *t, double *y_, double *z, double *tmp_,
+                                          int *Ai, double *Ax, int *Ap, double *x0, double *b, double *A_tild, int *A_tild_i, int *A_tild_p/*, double* Lx, int* Li, int* Lp,
+                                                                                                                                             double* Ux, int* Ui, int* Up, int* device_n*/, cusparseSolveAnalysisInfo_t infoL, cusparseSolveAnalysisInfo_t infoU,
+                                          cusparseMatDescr_t descrL, cusparseMatDescr_t descrU, int preconditioner)
 {
   //cudaError_t cuda_error;
   //cusparseStatus_t cusparse_status;
@@ -3601,18 +3650,18 @@ dynSparseMatrix::Solve_CUDA_BiCGStab_Free(double* tmp_vect_host, double* p, doub
   cudaChk(cudaFree(b), "  in Solve_Cuda_BiCGStab, can't free b\n");
   /*if (preconditioner == 0)
     {*/
-      cudaChk(cudaFree(A_tild), "  in Solve_Cuda_BiCGStab, can't free A_tild (1)\n");
-      cudaChk(cudaFree(A_tild_i), "  in Solve_Cuda_BiCGStab, can't free A_tild_i (1)\n");
-      cudaChk(cudaFree(A_tild_p), "  in Solve_Cuda_BiCGStab, can't free A_tild_p (1)\n");
-    /*}
-  else
+  cudaChk(cudaFree(A_tild), "  in Solve_Cuda_BiCGStab, can't free A_tild (1)\n");
+  cudaChk(cudaFree(A_tild_i), "  in Solve_Cuda_BiCGStab, can't free A_tild_i (1)\n");
+  cudaChk(cudaFree(A_tild_p), "  in Solve_Cuda_BiCGStab, can't free A_tild_p (1)\n");
+  /*}
+    else
     {
-      cudaChk(cudaFree(Lx), "  in Solve_Cuda_BiCGStab, can't free Lx\n");
-      cudaChk(cudaFree(Li), "  in Solve_Cuda_BiCGStab, can't free Li\n");
-      cudaChk(cudaFree(Lp), "  in Solve_Cuda_BiCGStab, can't free Lp\n");
-      cudaChk(cudaFree(Ux), "  in Solve_Cuda_BiCGStab, can't free Ux\n");
-      cudaChk(cudaFree(Ui), "  in Solve_Cuda_BiCGStab, can't free Ui\n");
-      cudaChk(cudaFree(Up), "  in Solve_Cuda_BiCGStab, can't free Up\n");
+    cudaChk(cudaFree(Lx), "  in Solve_Cuda_BiCGStab, can't free Lx\n");
+    cudaChk(cudaFree(Li), "  in Solve_Cuda_BiCGStab, can't free Li\n");
+    cudaChk(cudaFree(Lp), "  in Solve_Cuda_BiCGStab, can't free Lp\n");
+    cudaChk(cudaFree(Ux), "  in Solve_Cuda_BiCGStab, can't free Ux\n");
+    cudaChk(cudaFree(Ui), "  in Solve_Cuda_BiCGStab, can't free Ui\n");
+    cudaChk(cudaFree(Up), "  in Solve_Cuda_BiCGStab, can't free Up\n");
     }*/
   //cudaChk(cudaFree(device_n), "  in Solve_Cuda_BiCGStab, can't free device_n\n");
   if (preconditioner == 1 || preconditioner == 2 || preconditioner == 3)
@@ -3630,14 +3679,14 @@ dynSparseMatrix::Solve_CUDA_BiCGStab_Free(double* tmp_vect_host, double* p, doub
 #endif
 
 void
-Solve(double* Ax, int* Ap, int* Ai, double *b, int n, bool Lower, double *x)
+Solve(double *Ax, int *Ap, int *Ai, double *b, int n, bool Lower, double *x)
 {
   if (Lower)
     {
       for (int i = 0; i < n; i++)
         {
           double sum = 0;
-          for(int j = Ap[i]; j < Ap[i+1]; j++)
+          for (int j = Ap[i]; j < Ap[i+1]; j++)
             {
               int k = Ai[j];
               if (k < i)
@@ -3648,10 +3697,10 @@ Solve(double* Ax, int* Ap, int* Ai, double *b, int n, bool Lower, double *x)
     }
   else
     {
-      for (int i = n-1 ; i >= 0; i--)
+      for (int i = n-1; i >= 0; i--)
         {
           double sum = 0, mul = 1;
-          for(int j = Ap[i]; j < Ap[i+1]; j++)
+          for (int j = Ap[i]; j < Ap[i+1]; j++)
             {
               int k = Ai[j];
               if (k > i)
@@ -3665,14 +3714,14 @@ Solve(double* Ax, int* Ap, int* Ai, double *b, int n, bool Lower, double *x)
 }
 
 void
-Check(int n, double* Ax, int* Ap, int* Ai, double* b, double *x, bool Lower)
+Check(int n, double *Ax, int *Ap, int *Ai, double *b, double *x, bool Lower)
 {
   if (Lower)
     {
       for (int i = 0; i < n; i++)
         {
           double sum = 0;
-          for(int j = Ap[i]; j < Ap[i+1]; j++)
+          for (int j = Ap[i]; j < Ap[i+1]; j++)
             {
               int k = Ai[j];
               if (k < i)
@@ -3680,15 +3729,15 @@ Check(int n, double* Ax, int* Ap, int* Ai, double* b, double *x, bool Lower)
             }
           double err =  b[i] - sum - x[i];
           if (abs(err) > 1e-10)
-            mexPrintf("error at i=%d\n",i);
+            mexPrintf("error at i=%d\n", i);
         }
     }
   else
     {
-      for (int i = n-1 ; i >= 0; i--)
+      for (int i = n-1; i >= 0; i--)
         {
           double sum = 0;
-          for(int j = Ap[i]; j < Ap[i+1]; j++)
+          for (int j = Ap[i]; j < Ap[i+1]; j++)
             {
               int k = Ai[j];
               if (k >= i)
@@ -3696,7 +3745,7 @@ Check(int n, double* Ax, int* Ap, int* Ai, double* b, double *x, bool Lower)
             }
           double err =  b[i] - sum;
           if (abs(err) > 1e-10)
-            mexPrintf("error at i=%d\n",i);
+            mexPrintf("error at i=%d\n", i);
         }
     }
 }
@@ -3704,7 +3753,7 @@ Check(int n, double* Ax, int* Ap, int* Ai, double* b, double *x, bool Lower)
 #ifdef CUDA
 int
 dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild, int *Ai_tild, double *A_tild, double *b, double *x0, int n, int Size, double slowc_l, bool is_two_boundaries,
-                                  int  it_, int nnz, int nnz_tild, int preconditioner, int max_iterations, int block)
+                                     int  it_, int nnz, int nnz_tild, int preconditioner, int max_iterations, int block)
 {
   cusparseSolveAnalysisInfo_t info, infoL, infoU;
   cusparseMatDescr_t descrL, descrU;
@@ -3721,8 +3770,8 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
   double bnorm;
   double tmp1, tmp2;
   int refinement_needed = 0, stagnation = 0;
-  int max_refinement = min(min(int(floor(double(n)/50)),10),n-max_iterations), max_stagnation = 3;
-  int nblocks = ceil(double(n) / double(1024));
+  int max_refinement = min(min(int (floor(double (n)/50)), 10), n-max_iterations), max_stagnation = 3;
+  int nblocks = ceil(double (n) / double (1024));
   int n_threads;
   if (nblocks == 0)
     n_threads = n;
@@ -3730,9 +3779,10 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
     n_threads = 1024;
   int periods = n / Size;
 
-  double * tmp_vect_host = (double*)mxMalloc(n * sizeof(double));
+  double *tmp_vect_host = (double *) mxMalloc(n * sizeof(double));
+  test_mxMalloc(tmp_vect_host, __LINE__, __FILE__, __func__, n * sizeof(double));
 
-  cublasChk(cublasDnrm2(cublas_handle, n,b, 1, &bnorm),
+  cublasChk(cublasDnrm2(cublas_handle, n, b, 1, &bnorm),
             "  in Solve_Cuda_BiCGStab, cublasDnrm2(b) has failed\n");
 
   double tolb = tol * bnorm;
@@ -3774,26 +3824,26 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
   bool convergence = false;
   double zeros = 0.0, one = 1.0, m_one = -1.0;
 
-  cudaChk(cudaMalloc((void**)&tmp_, n * sizeof(double)), "  in Solve_Cuda_Sparse, can't allocate tmp_ on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &tmp_, n * sizeof(double)), "  in Solve_Cuda_Sparse, can't allocate tmp_ on the graphic card\n");
 
-  cudaChk(cudaMalloc((void**)&r, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate r on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &r, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate r on the graphic card\n");
 
   cudaChk(cudaMemcpy(r, b, n * sizeof(double), cudaMemcpyDeviceToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy r = b has failed\n");
 
   //r = b - A * x0
   cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE, n,
-                                   n, nnz, &m_one,
-                                   CUDA_descr, Ax,
-                                   Ap, Ai,
-                                   x0, &one,
-                                   r), "in Solve_Cuda_BiCGStab, cusparseDcsrmv A * x0 has failed");
+                             n, nnz, &m_one,
+                             CUDA_descr, Ax,
+                             Ap, Ai,
+                             x0, &one,
+                             r), "in Solve_Cuda_BiCGStab, cusparseDcsrmv A * x0 has failed");
 
   cudaChk(cudaMemcpy(tmp_vect_host, r, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = p_tild has failed\n");
   /*mexPrintf("r\n");
-  for (int i = 0; i < n; i++)
+    for (int i = 0; i < n; i++)
     mexPrintf("%f\n",tmp_vect_host[i]);*/
 
-  cudaChk(cudaMalloc((void**)&r0, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate r0 on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &r0, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate r0 on the graphic card\n");
   cudaChk(cudaMemcpy(r0, r, n * sizeof(double), cudaMemcpyDeviceToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy r0 = r has failed\n");
 
   cublasChk(cublasDnrm2(cublas_handle, n, // numerator
@@ -3820,12 +3870,11 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       return 0;
     }
 
-
   if (preconditioner == 0)
     {
       //Apply the Jacobi preconditioner
       /*VecDiv<<<nblocks, n_threads>>>(r_, A_tild, z_, n);
-      cuda_error = cudaMemcpy(zz_, z_, n * sizeof(double), cudaMemcpyDeviceToDevice);*/
+        cuda_error = cudaMemcpy(zz_, z_, n * sizeof(double), cudaMemcpyDeviceToDevice);*/
     }
   else if (preconditioner == 1)
     {
@@ -3845,21 +3894,26 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                   "  in Solve_Cuda_BiCGStab, cusparseDcsrilu0 has failed\n");
 
       //Make a copy of the indexes in A_tild_i and A_tild_p to use it the Bicgstab algorithm
-      cudaChk(cudaMalloc((void**)&A_tild_i, nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_i on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild_i, nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_i on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild_i, Ai, nnz * sizeof(int), cudaMemcpyDeviceToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_i = Ai has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_p on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_p on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild_p, Ap, (n + 1) * sizeof(int), cudaMemcpyDeviceToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_p = Ap has failed\n");
     }
   else if (preconditioner == 2)
     {
       //Because the Jacobian matrix A is store in CSC format in matlab
       // we have to transpose it to get a CSR format used by CUDA
-      mwIndex* Awi, *Awp;
-      double* A_tild_host = (double*)mxMalloc(nnz*sizeof(double));
-      Awi = (mwIndex*)mxMalloc(nnz * sizeof(mwIndex));
-      Awp = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
-      int* Aii = (int*)mxMalloc(nnz * sizeof(int));
-      int* Aip = (int*)mxMalloc((n + 1) * sizeof(int));
+      mwIndex *Awi, *Awp;
+      double *A_tild_host = (double *) mxMalloc(nnz*sizeof(double));
+      test_mxMalloc(A_tild_host, __LINE__, __FILE__, __func__, nnz*sizeof(double));
+      Awi = (mwIndex *) mxMalloc(nnz * sizeof(mwIndex));
+      test_mxMalloc(Awi, __LINE__, __FILE__, __func__, nnz * sizeof(mwIndex));
+      Awp = (mwIndex *) mxMalloc((n + 1) * sizeof(mwIndex));
+      test_mxMalloc(Awp, __LINE__, __FILE__, __func__, (n + 1) * sizeof(mwIndex));
+      int *Aii = (int *) mxMalloc(nnz * sizeof(int));
+      test_mxMalloc(Aii, __LINE__, __FILE__, __func__, nnz * sizeof(int));
+      int *Aip = (int *) mxMalloc((n + 1) * sizeof(int));
+      test_mxMalloc(Aip, __LINE__, __FILE__, __func__, (n + 1) * sizeof(int));
       cudaChk(cudaMemcpy(A_tild_host, A_tild, nnz*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_host = A_tild has failed\n");
       cudaChk(cudaMemcpy(Aii, Ai, nnz*sizeof(int), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy Aii = Ai has failed\n");
       cudaChk(cudaMemcpy(Aip, Ap, (n+1)*sizeof(int), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy Aip = Ai has failed\n");
@@ -3869,7 +3923,7 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
         Awp[i] = Aip[i];
       mxFree(Aii);
       mxFree(Aip);
-      mxArray * At_m = mxCreateSparse(n,n,nnz,mxREAL);
+      mxArray *At_m = mxCreateSparse(n, n, nnz, mxREAL);
       mxSetIr(At_m, Awi);
       mxSetJc(At_m, Awp);
       mxSetPr(At_m, A_tild_host);
@@ -3878,9 +3932,9 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       mxDestroyArray(At_m);
 
       /*mexPrintf("A_m\n");
-      mexCallMATLAB(0, NULL, 1, &A_m, "disp_dense");*/
+        mexCallMATLAB(0, NULL, 1, &A_m, "disp_dense");*/
       /*mxFree(Awi);
-      mxFree(Awp);*/
+        mxFree(Awp);*/
 
       /*[L1, U1] = ilu(g1a=;*/
       const char *field_names[] = {"type", "droptol", "milu", "udiag", "thresh"};
@@ -3889,7 +3943,7 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       const int milu = 2;
       const int udiag = 3;
       const int thresh = 4;
-      mwSize dims[1] = {(mwSize)1 };
+      mwSize dims[1] = {(mwSize) 1 };
       mxArray *Setup = mxCreateStructArray(1, dims, 5, field_names);
       mxSetFieldByNumber(Setup, 0, type, mxCreateString("ilutp"));
       //mxSetFieldByNumber(Setup, 0, type, mxCreateString("nofill"));
@@ -3910,38 +3964,39 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
         }
       mxDestroyArray(Setup);
 
-
- /*     //ILUT preconditionner computed by Matlab (todo: in futur version of cuda replace it by a new equivalent cuda function)
-      const char *field_names[] = {"type", "droptol", "milu", "udiag", "thresh"};
-      const int type = 0;
-      const int droptol = 1;
-      const int milu = 2;
-      const int udiag = 3;
-      const int thresh = 4;
-      mwSize dims[1] = {(mwSize)1 };
-      mxArray *Setup = mxCreateStructArray(1, dims, 5, field_names);
-      mxSetFieldByNumber(Setup, 0, type, mxCreateString("ilutp"));
-      mxSetFieldByNumber(Setup, 0, droptol, mxCreateDoubleScalar(lu_inc_tol));
-      mxSetFieldByNumber(Setup, 0, milu, mxCreateString("off"));
-      mxSetFieldByNumber(Setup, 0, udiag, mxCreateDoubleScalar(0));
-      mxSetFieldByNumber(Setup, 0, thresh, mxCreateDoubleScalar(0));
-      mxArray *lhs0[2], *rhs0[2];
-      rhs0[0] = A_m;
-      rhs0[1] = Setup;
-      mexCallMATLAB(1, lhs0, 2, rhs0, "ilu");
-*/
+      /*     //ILUT preconditionner computed by Matlab (todo: in futur version of cuda replace it by a new equivalent cuda function)
+             const char *field_names[] = {"type", "droptol", "milu", "udiag", "thresh"};
+             const int type = 0;
+             const int droptol = 1;
+             const int milu = 2;
+             const int udiag = 3;
+             const int thresh = 4;
+             mwSize dims[1] = {(mwSize)1 };
+             mxArray *Setup = mxCreateStructArray(1, dims, 5, field_names);
+             mxSetFieldByNumber(Setup, 0, type, mxCreateString("ilutp"));
+             mxSetFieldByNumber(Setup, 0, droptol, mxCreateDoubleScalar(lu_inc_tol));
+             mxSetFieldByNumber(Setup, 0, milu, mxCreateString("off"));
+             mxSetFieldByNumber(Setup, 0, udiag, mxCreateDoubleScalar(0));
+             mxSetFieldByNumber(Setup, 0, thresh, mxCreateDoubleScalar(0));
+             mxArray *lhs0[2], *rhs0[2];
+             rhs0[0] = A_m;
+             rhs0[1] = Setup;
+             mexCallMATLAB(1, lhs0, 2, rhs0, "ilu");
+      */
       // To store the resultng matrix in a CSR format we have to transpose it
       mxArray *Wt = lhs0[0];
-      mwIndex* Wtj = mxGetJc(Wt);
+      mwIndex *Wtj = mxGetJc(Wt);
       nnz = Wtj[n];
-      mxArray* W;
+      mxArray *W;
       mexCallMATLAB(1, &W, 1, &Wt, "transpose");
       mxDestroyArray(Wt);
-      double* pW = mxGetPr(W);
-      mwIndex* Wi = mxGetIr(W);
-      mwIndex* Wp = mxGetJc(W);
-      int *Wii = (int*)mxMalloc(nnz * sizeof(int));
-      int *Wip = (int*)mxMalloc((n + 1) * sizeof(int));
+      double *pW = mxGetPr(W);
+      mwIndex *Wi = mxGetIr(W);
+      mwIndex *Wp = mxGetJc(W);
+      int *Wii = (int *) mxMalloc(nnz * sizeof(int));
+      test_mxMalloc(Wii, __LINE__, __FILE__, __func__, nnz * sizeof(int));
+      int *Wip = (int *) mxMalloc((n + 1) * sizeof(int));
+      test_mxMalloc(Wip, __LINE__, __FILE__, __func__, (n + 1) * sizeof(int));
       for (int i = 0; i < nnz; i++)
         Wii[i] = Wi[i];
       for (int i = 0; i < n + 1; i++)
@@ -3951,27 +4006,32 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
 
       cudaChk(cudaFree(A_tild), "cudaFree(A_tild) has failed\n");
 
-      cudaChk(cudaMalloc((void**)&A_tild, nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild, nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild, pW, nnz * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild = pW has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_i, nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Ai on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild_i, nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Ai on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild_i, Wii, nnz * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_i = A_tild_i_host has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_p on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_p on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild_p, Wip, (n + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_p = A_tild_j_host has failed\n");
       /*mxFree(pW);
-      mxFree(Wi);
-      mxFree(Wj);*/
+        mxFree(Wi);
+        mxFree(Wj);*/
       mxDestroyArray(W);
       mxFree(Wii);
       mxFree(Wip);
     }
   else if (preconditioner == 3)
     {
-      mwIndex* Aowi, *Aowp;
-      double* A_host = (double*)mxMalloc(nnz*sizeof(double));
-      Aowi = (mwIndex*)mxMalloc(nnz * sizeof(mwIndex));
-      Aowp = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
-      int* Aoii = (int*)mxMalloc(nnz * sizeof(int));
-      int* Aoip = (int*)mxMalloc((n + 1) * sizeof(int));
+      mwIndex *Aowi, *Aowp;
+      double *A_host = (double *) mxMalloc(nnz*sizeof(double));
+      test_mxMalloc(A_host, __LINE__, __FILE__, __func__, nnz*sizeof(double));
+      Aowi = (mwIndex *) mxMalloc(nnz * sizeof(mwIndex));
+      test_mxMalloc(Aowi, __LINE__, __FILE__, __func__, nnz * sizeof(mwIndex));
+      Aowp = (mwIndex *) mxMalloc((n + 1) * sizeof(mwIndex));
+      test_mxMalloc(Aowp, __LINE__, __FILE__, __func__, (n + 1) * sizeof(mwIndex));
+      int *Aoii = (int *) mxMalloc(nnz * sizeof(int));
+      test_mxMalloc(Aoii, __LINE__, __FILE__, __func__, nnz * sizeof(int));
+      int *Aoip = (int *) mxMalloc((n + 1) * sizeof(int));
+      test_mxMalloc(Aoip, __LINE__, __FILE__, __func__, (n + 1) * sizeof(int));
       cudaChk(cudaMemcpy(A_host, Ax, nnz*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_host = A_tild has failed\n");
       cudaChk(cudaMemcpy(Aoii, Ai, nnz*sizeof(int), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy Aii = Ai_tild has failed\n");
       cudaChk(cudaMemcpy(Aoip, Ap, (n+1)*sizeof(int), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy Aip = Ap_tild has failed\n");
@@ -3981,25 +4041,30 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
         Aowp[i] = Aoip[i];
       mxFree(Aoii);
       mxFree(Aoip);
-      mxArray * Ao_m = mxCreateSparse(n,n,nnz,mxREAL);
+      mxArray *Ao_m = mxCreateSparse(n, n, nnz, mxREAL);
       mxSetIr(Ao_m, Aowi);
       mxSetJc(Ao_m, Aowp);
       mxSetPr(Ao_m, A_host);
       /*mexPrintf("A_m\n");
-      mxArray *Aoo;
-      mexCallMATLAB(1, &Aoo, 1, &Ao_m, "transpose");
-      mexCallMATLAB(0, NULL, 1, &Aoo, "disp_dense");
-      mxDestroyArray(Ao_m);
-      mxDestroyArray(Aoo);*/
+        mxArray *Aoo;
+        mexCallMATLAB(1, &Aoo, 1, &Ao_m, "transpose");
+        mexCallMATLAB(0, NULL, 1, &Aoo, "disp_dense");
+        mxDestroyArray(Ao_m);
+        mxDestroyArray(Aoo);*/
 
       //Because the Jacobian matrix A is store in CSC format in matlab
       // we have to transpose it to get a CSR format used by CUDA
-      mwIndex* Awi, *Awp;
-      double* A_tild_host = (double*)mxMalloc(nnz_tild*sizeof(double));
-      Awi = (mwIndex*)mxMalloc(nnz_tild * sizeof(mwIndex));
-      Awp = (mwIndex*)mxMalloc((Size + 1) * sizeof(mwIndex));
-      int* Aii = (int*)mxMalloc(nnz_tild * sizeof(int));
-      int* Aip = (int*)mxMalloc((Size + 1) * sizeof(int));
+      mwIndex *Awi, *Awp;
+      double *A_tild_host = (double *) mxMalloc(nnz_tild*sizeof(double));
+      test_mxMalloc(A_tild_host, __LINE__, __FILE__, __func__, nnz_tild*sizeof(double));
+      Awi = (mwIndex *) mxMalloc(nnz_tild * sizeof(mwIndex));
+      test_mxMalloc(Awi, __LINE__, __FILE__, __func__, nnz_tild * sizeof(mwIndex));
+      Awp = (mwIndex *) mxMalloc((Size + 1) * sizeof(mwIndex));
+      test_mxMalloc(Awp, __LINE__, __FILE__, __func__, (Size + 1) * sizeof(mwIndex));
+      int *Aii = (int *) mxMalloc(nnz_tild * sizeof(int));
+      test_mxMalloc(Aii, __LINE__, __FILE__, __func__, nnz_tild * sizeof(int));
+      int *Aip = (int *) mxMalloc((Size + 1) * sizeof(int));
+      test_mxMalloc(Aip, __LINE__, __FILE__, __func__, (Size + 1) * sizeof(int));
       cudaChk(cudaMemcpy(A_tild_host, A_tild, nnz_tild*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_host = A_tild has failed\n");
       cudaChk(cudaMemcpy(Aii, Ai_tild, nnz_tild*sizeof(int), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy Aii = Ai_tild has failed\n");
       cudaChk(cudaMemcpy(Aip, Ap_tild, (Size+1)*sizeof(int), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy Aip = Ap_tild has failed\n");
@@ -4011,14 +4076,14 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
         mexPrintf("%20.17f\n",A_tild_host[i]);*/
       mxFree(Aii);
       mxFree(Aip);
-      mxArray * At_m = mxCreateSparse(Size,Size,nnz_tild,mxREAL);
+      mxArray *At_m = mxCreateSparse(Size, Size, nnz_tild, mxREAL);
       mxSetIr(At_m, Awi);
       mxSetJc(At_m, Awp);
       mxSetPr(At_m, A_tild_host);
       mxArray *A_m;
       mexCallMATLAB(1, &A_m, 1, &At_m, "transpose");
       /*mexPrintf("A_tild_m\n");
-      mexCallMATLAB(0, NULL, 1, &A_m, "disp_dense");*/
+        mexCallMATLAB(0, NULL, 1, &A_m, "disp_dense");*/
       mxDestroyArray(At_m);
       mxArray *P, *Q, *L, *U;
       mxArray *lhs0[4];
@@ -4038,30 +4103,33 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       mxDestroyArray(L0);
       mxDestroyArray(U0);
       /*L = lhs0[0];
-      U = lhs0[1];
-      P = lhs0[2];
-      Q = lhs0[3];*/
+        U = lhs0[1];
+        P = lhs0[2];
+        Q = lhs0[3];*/
 
       /*mexPrintf("L\n");
-      mexCallMATLAB(0, NULL, 1, &L, "disp_dense");
+        mexCallMATLAB(0, NULL, 1, &L, "disp_dense");
 
-      mexPrintf("U\n");
-      mexCallMATLAB(0, NULL, 1, &U, "disp_dense");
+        mexPrintf("U\n");
+        mexCallMATLAB(0, NULL, 1, &U, "disp_dense");
 
-      mexPrintf("P\n");
-      mexCallMATLAB(0, NULL, 1, &P, "disp_dense");
+        mexPrintf("P\n");
+        mexCallMATLAB(0, NULL, 1, &P, "disp_dense");
 
-      mexPrintf("Q\n");
-      mexCallMATLAB(0, NULL, 1, &Q, "disp_dense");*/
+        mexPrintf("Q\n");
+        mexCallMATLAB(0, NULL, 1, &Q, "disp_dense");*/
 
-      mwIndex* Qiw_host = mxGetIr(Q);
-      mwIndex* Qjw_host = mxGetJc(Q);
-      double*  Qx_host = mxGetPr(Q);
+      mwIndex *Qiw_host = mxGetIr(Q);
+      mwIndex *Qjw_host = mxGetJc(Q);
+      double *Qx_host = mxGetPr(Q);
       Q_nnz = Qjw_host[Size];
-      mexPrintf("Q_nnz=%d\n",Q_nnz);
-      int *Qi_host = (int*)mxMalloc(Q_nnz * periods * sizeof(int));
-      double *Q_x_host = (double*)mxMalloc(Q_nnz * periods * sizeof(double));
-      int *Qj_host = (int*)mxMalloc((n + 1) * sizeof(int));
+      mexPrintf("Q_nnz=%d\n", Q_nnz);
+      int *Qi_host = (int *) mxMalloc(Q_nnz * periods * sizeof(int));
+      test_mxMalloc(Qi_host, __LINE__, __FILE__, __func__, Q_nnz * periods * sizeof(int));
+      double *Q_x_host = (double *) mxMalloc(Q_nnz * periods * sizeof(double));
+      test_mxMalloc(Q_x_host, __LINE__, __FILE__, __func__, Q_nnz * periods * sizeof(double));
+      int *Qj_host = (int *) mxMalloc((n + 1) * sizeof(int));
+      test_mxMalloc(Qj_host, __LINE__, __FILE__, __func__, (n + 1) * sizeof(int));
       for (int t = 0; t < periods; t++)
         {
           for (int i = 0; i < Q_nnz; i++)
@@ -4076,52 +4144,51 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
         }
       Qj_host[periods * Size] = periods * Q_nnz;
 
-
       /*mwIndex *Qtiw_host  = (mwIndex*) mxMalloc(Q_nnz * periods * sizeof(mwIndex));
-      double *Qt_x_host = (double*)mxMalloc(Q_nnz * periods * sizeof(double));
-      mwIndex *Qtjw_host = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
-      mexPrintf("n = %d\n",n);
-      for (int i = 0; i < n + 1; i++)
+        double *Qt_x_host = (double*)mxMalloc(Q_nnz * periods * sizeof(double));
+        mwIndex *Qtjw_host = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
+        mexPrintf("n = %d\n",n);
+        for (int i = 0; i < n + 1; i++)
         Qtjw_host[i] = Qj_host[i];
-      for (int i = 0; i < Q_nnz * periods; i++)
+        for (int i = 0; i < Q_nnz * periods; i++)
         {
-          Qtiw_host[i] = Qi_host[i];
-          Qt_x_host[i] = Q_x_host[i];
+        Qtiw_host[i] = Qi_host[i];
+        Qt_x_host[i] = Q_x_host[i];
         }
-      mxArray* Qt_m = mxCreateSparse(n,n,Q_nnz * periods,mxREAL);
-      mxSetIr(Qt_m, Qtiw_host);
-      mxSetJc(Qt_m, Qtjw_host);
-      mxSetPr(Qt_m, Qt_x_host);
-      mexPrintf("Qt_m\n");
-      mexCallMATLAB(0, NULL, 1, &Qt_m, "disp_dense");*/
-
+        mxArray* Qt_m = mxCreateSparse(n,n,Q_nnz * periods,mxREAL);
+        mxSetIr(Qt_m, Qtiw_host);
+        mxSetJc(Qt_m, Qtjw_host);
+        mxSetPr(Qt_m, Qt_x_host);
+        mexPrintf("Qt_m\n");
+        mexCallMATLAB(0, NULL, 1, &Qt_m, "disp_dense");*/
 
       /*mexPrintf("Qtjw_host[periods * Size=%d]=%d\n", periods * Size, Qtjw_host[periods * Size]);
-      for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++)
         for (int j = Qtjw_host[i]; j < Qtjw_host[i+1]; j++)
-           mexPrintf("(i=%d, j=%d) = %f\n", i, Qtiw_host[j], Qt_x_host[j]);*/
+        mexPrintf("(i=%d, j=%d) = %f\n", i, Qtiw_host[j], Qt_x_host[j]);*/
       //mxDestroyArray(Qt_m);
 
-
-      cudaChk(cudaMalloc((void**)&Qx, Q_nnz * periods * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Qx on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &Qx, Q_nnz * periods * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Qx on the graphic card\n");
       cudaChk(cudaMemcpy(Qx, Q_x_host, Q_nnz * periods * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Qx = Qx_host has failed\n");
-      cudaChk(cudaMalloc((void**)&Qi, Q_nnz * periods * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Qi on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &Qi, Q_nnz * periods * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Qi on the graphic card\n");
       cudaChk(cudaMemcpy(Qi, Qi_host, Q_nnz * periods * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Qi = Qi_host has failed\n");
-      cudaChk(cudaMalloc((void**)&Qj, (Size * periods + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Qj on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &Qj, (Size * periods + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Qj on the graphic card\n");
       cudaChk(cudaMemcpy(Qj, Qj_host, (Size * periods + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Qj = Qj_host has failed\n");
       mxFree(Qi_host);
       mxFree(Qj_host);
       mxFree(Q_x_host);
       mxDestroyArray(Q);
 
-
-      mwIndex* Piw_host = mxGetIr(P);
-      mwIndex* Pjw_host = mxGetJc(P);
-      double*  Px_host = mxGetPr(P);
+      mwIndex *Piw_host = mxGetIr(P);
+      mwIndex *Pjw_host = mxGetJc(P);
+      double *Px_host = mxGetPr(P);
       P_nnz = Pjw_host[Size];
-      int *Pi_host = (int*)mxMalloc(P_nnz * periods * sizeof(int));
-      double *P_x_host = (double*)mxMalloc(P_nnz * periods * sizeof(double));
-      int *Pj_host = (int*)mxMalloc((n + 1) * sizeof(int));
+      int *Pi_host = (int *) mxMalloc(P_nnz * periods * sizeof(int));
+      test_mxMalloc(Pi_host, __LINE__, __FILE__, __func__, P_nnz * periods * sizeof(int));
+      double *P_x_host = (double *) mxMalloc(P_nnz * periods * sizeof(double));
+      test_mxMalloc(P_x_host, __LINE__, __FILE__, __func__, P_nnz * periods * sizeof(double));
+      int *Pj_host = (int *) mxMalloc((n + 1) * sizeof(int));
+      test_mxMalloc(Pj_host, __LINE__, __FILE__, __func__, (n + 1) * sizeof(int));
       for (int t = 0; t < periods; t++)
         {
           for (int i = 0; i < P_nnz; i++)
@@ -4135,29 +4202,28 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       Pj_host[periods * Size] = periods * P_nnz;
 
       /*mwIndex *Ptiw_host  = (mwIndex*) mxMalloc(P_nnz * periods * sizeof(mwIndex));
-      double *Pt_x_host = (double*)mxMalloc(P_nnz * periods * sizeof(double));
-      mwIndex *Ptjw_host = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
-      for (int i = 0; i < n + 1; i++)
+        double *Pt_x_host = (double*)mxMalloc(P_nnz * periods * sizeof(double));
+        mwIndex *Ptjw_host = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
+        for (int i = 0; i < n + 1; i++)
         Ptjw_host[i] = Pj_host[i];
-      for (int i = 0; i < P_nnz * periods; i++)
+        for (int i = 0; i < P_nnz * periods; i++)
         {
-          Ptiw_host[i] = Pi_host[i];
-          Pt_x_host[i] = P_x_host[i];
+        Ptiw_host[i] = Pi_host[i];
+        Pt_x_host[i] = P_x_host[i];
         }
-      mxArray* Pt_m = mxCreateSparse(n,n,P_nnz * periods,mxREAL);
-      mxSetIr(Pt_m, Ptiw_host);
-      mxSetJc(Pt_m, Ptjw_host);
-      mxSetPr(Pt_m, Pt_x_host);
-      mexPrintf("Pt_m\n");
-      mexCallMATLAB(0, NULL, 1, &Pt_m, "disp_dense");
-      mxDestroyArray(Pt_m);*/
+        mxArray* Pt_m = mxCreateSparse(n,n,P_nnz * periods,mxREAL);
+        mxSetIr(Pt_m, Ptiw_host);
+        mxSetJc(Pt_m, Ptjw_host);
+        mxSetPr(Pt_m, Pt_x_host);
+        mexPrintf("Pt_m\n");
+        mexCallMATLAB(0, NULL, 1, &Pt_m, "disp_dense");
+        mxDestroyArray(Pt_m);*/
 
-
-      cudaChk(cudaMalloc((void**)&Px, P_nnz * periods * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Px on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &Px, P_nnz * periods * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Px on the graphic card\n");
       cudaChk(cudaMemcpy(Px, P_x_host, P_nnz * periods * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Px = Px_host has failed\n");
-      cudaChk(cudaMalloc((void**)&Pi, P_nnz * periods * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pi on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &Pi, P_nnz * periods * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pi on the graphic card\n");
       cudaChk(cudaMemcpy(Pi, Pi_host, P_nnz * periods * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Pi = Pi_host has failed\n");
-      cudaChk(cudaMalloc((void**)&Pj, (Size * periods + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pj on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &Pj, (Size * periods + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pj on the graphic card\n");
       cudaChk(cudaMemcpy(Pj, Pj_host, (Size * periods + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Pj = Pj_host has failed\n");
       mxFree(Pi_host);
       mxFree(Pj_host);
@@ -4165,49 +4231,52 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       mxDestroyArray(P);
 
       /*mwIndex* Piw_host = mxGetIr(P);
-      mwIndex* Pjw_host = mxGetJc(P);
-      double*  Px_host = mxGetPr(P);
-      P_nnz = Pjw_host[Size];
-      int *Pi_host = (int*)mxMalloc(P_nnz * sizeof(int));
-      int *Pj_host = (int*)mxMalloc((Size + 1) * sizeof(int));
-      for (int i = 0; i < P_nnz; i++)
+        mwIndex* Pjw_host = mxGetJc(P);
+        double*  Px_host = mxGetPr(P);
+        P_nnz = Pjw_host[Size];
+        int *Pi_host = (int*)mxMalloc(P_nnz * sizeof(int));
+        int *Pj_host = (int*)mxMalloc((Size + 1) * sizeof(int));
+        for (int i = 0; i < P_nnz; i++)
         Pi_host[i] = Piw_host[i];
-      for (int i = 0; i < Size + 1; i++)
+        for (int i = 0; i < Size + 1; i++)
         Pj_host[i] = Pjw_host[i];
 
-      cudaChk(cudaMalloc((void**)&Px, P_nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Px on the graphic card\n");
-      cudaChk(cudaMemcpy(Px, Px_host, P_nnz * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Px = Px_host has failed\n");
-      cudaChk(cudaMalloc((void**)&Pi, P_nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pi on the graphic card\n");
-      cudaChk(cudaMemcpy(Pi, Pi_host, P_nnz * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Pi = Pi_host has failed\n");
-      cudaChk(cudaMalloc((void**)&Pj, (Size + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pj on the graphic card\n");
-      cudaChk(cudaMemcpy(Pj, Pj_host, (Size + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Pj = Pj_host has failed\n");
-      mxFree(Pi_host);
-      mxFree(Pj_host);
-      mxDestroyArray(P);*/
+        cudaChk(cudaMalloc((void**)&Px, P_nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Px on the graphic card\n");
+        cudaChk(cudaMemcpy(Px, Px_host, P_nnz * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Px = Px_host has failed\n");
+        cudaChk(cudaMalloc((void**)&Pi, P_nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pi on the graphic card\n");
+        cudaChk(cudaMemcpy(Pi, Pi_host, P_nnz * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Pi = Pi_host has failed\n");
+        cudaChk(cudaMalloc((void**)&Pj, (Size + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pj on the graphic card\n");
+        cudaChk(cudaMemcpy(Pj, Pj_host, (Size + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy Pj = Pj_host has failed\n");
+        mxFree(Pi_host);
+        mxFree(Pj_host);
+        mxDestroyArray(P);*/
 
       /*mexPrintf("L\n");
-      mexCallMATLAB(0, NULL, 1, &L, "disp_dense");
+        mexCallMATLAB(0, NULL, 1, &L, "disp_dense");
 
-      mexPrintf("U\n");
-      mexCallMATLAB(0, NULL, 1, &U, "disp_dense");*/
+        mexPrintf("U\n");
+        mexCallMATLAB(0, NULL, 1, &U, "disp_dense");*/
 
-      mwIndex* Liw_host = mxGetIr(L);
-      mwIndex* Ljw_host = mxGetJc(L);
-      double*  Lx_host = mxGetPr(L);
+      mwIndex *Liw_host = mxGetIr(L);
+      mwIndex *Ljw_host = mxGetJc(L);
+      double *Lx_host = mxGetPr(L);
       int L_nnz = Ljw_host[Size];
 
-      mwIndex* Uiw_host = mxGetIr(U);
-      mwIndex* Ujw_host = mxGetJc(U);
-      double*  Ux_host = mxGetPr(U);
+      mwIndex *Uiw_host = mxGetIr(U);
+      mwIndex *Ujw_host = mxGetJc(U);
+      double *Ux_host = mxGetPr(U);
       int U_nnz = Ujw_host[Size];
 
-      double *pW = (double*)mxMalloc((L_nnz + U_nnz - Size) * periods * sizeof(double));
-      int *Wi = (int*)mxMalloc((L_nnz + U_nnz - Size) * periods * sizeof(int));
-      int *Wj = (int*)mxMalloc((n + 1) * sizeof(int));
+      double *pW = (double *) mxMalloc((L_nnz + U_nnz - Size) * periods * sizeof(double));
+      test_mxMalloc(pW, __LINE__, __FILE__, __func__, (L_nnz + U_nnz - Size) * periods * sizeof(double));
+      int *Wi = (int *) mxMalloc((L_nnz + U_nnz - Size) * periods * sizeof(int));
+      test_mxMalloc(Wi, __LINE__, __FILE__, __func__, (L_nnz + U_nnz - Size) * periods * sizeof(int));
+      int *Wj = (int *) mxMalloc((n + 1) * sizeof(int));
+      test_mxMalloc(Wj, __LINE__, __FILE__, __func__, (n + 1) * sizeof(int));
       Wj[0] = 0;
       W_nnz = 0;
       for (int t = 0; t < periods; t++)
-        for (int i = 0; i < Size ; i++)
+        for (int i = 0; i < Size; i++)
           {
             for (mwIndex l  = Ujw_host[i]; l < Ujw_host[i+1]; l++)
               {
@@ -4229,89 +4298,88 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
             Wj[i + 1 + t * Size] = W_nnz;
           }
       //mexPrintf("Wj[%d] = %d, n=%d\n", periods * Size, Wj[periods * Size], n);
-      cudaChk(cudaMalloc((void**)&A_tild, W_nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Px on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild, W_nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate Px on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild, pW, W_nnz * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild = pW has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_i, W_nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pi on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild_i, W_nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pi on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild_i, Wi, W_nnz * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_i = Wi has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pj on the graphic card\n");
+      cudaChk(cudaMalloc((void **) &A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Pj on the graphic card\n");
       cudaChk(cudaMemcpy(A_tild_p, Wj, (n + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_p = Wj has failed\n");
 
       /*mwIndex *Wwi = (mwIndex*)mxMalloc(W_nnz * sizeof(mwIndex));
-      mwIndex *Wwj = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
-      for (int i = 0; i < W_nnz; i++)
+        mwIndex *Wwj = (mwIndex*)mxMalloc((n + 1) * sizeof(mwIndex));
+        for (int i = 0; i < W_nnz; i++)
         Wwi[i] = Wi[i];
-      for (int i = 0; i < n + 1; i++)
+        for (int i = 0; i < n + 1; i++)
         Wwj[i] = Wj[i];
-      mxFree(Wi);
-      mxFree(Wj);
-      mxArray* Ao_tild = mxCreateSparse(n,n,W_nnz,mxREAL);
-      mxSetIr(Ao_tild, Wwi);
-      mxSetJc(Ao_tild, Wwj);
-      mxSetPr(Ao_tild, pW);
-      mexPrintf("Ao_tild\n");
-      mexCallMATLAB(0, NULL, 1, &Ao_tild, "disp_dense");
-      mxDestroyArray(Ao_tild);*/
-
+        mxFree(Wi);
+        mxFree(Wj);
+        mxArray* Ao_tild = mxCreateSparse(n,n,W_nnz,mxREAL);
+        mxSetIr(Ao_tild, Wwi);
+        mxSetJc(Ao_tild, Wwj);
+        mxSetPr(Ao_tild, pW);
+        mexPrintf("Ao_tild\n");
+        mexCallMATLAB(0, NULL, 1, &Ao_tild, "disp_dense");
+        mxDestroyArray(Ao_tild);*/
 
       /*ostringstream tmp;
-      tmp << "debugging";
-      mexWarnMsgTxt(tmp.str().c_str());
-      return 4;*/
+        tmp << "debugging";
+        mexWarnMsgTxt(tmp.str().c_str());
+        return 4;*/
 
       /* Apply the permutation matrices (P and Q) to the b vector of system to solve :
-       b_tild = P-1 . b  = P' . b */
+         b_tild = P-1 . b  = P' . b */
       /*cudaChk(cudaMalloc((void**)&b_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
-      cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE,
-                                 n, n, nnz, &one, CUDA_descr,
-                                 Px, Pj, Pi,
-                                 b, &zeros,
-                                 b_tild),
-                  "  in Solve_Cuda_BiCGStab, b_tild = cusparseDcsrmv(P', b) has failed\n");
+        cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE,
+        n, n, nnz, &one, CUDA_descr,
+        Px, Pj, Pi,
+        b, &zeros,
+        b_tild),
+        "  in Solve_Cuda_BiCGStab, b_tild = cusparseDcsrmv(P', b) has failed\n");
 
-      cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE,
-                                 n, n, nnz, &one, CUDA_descr,
-                                 Px, Pj, Pi,
-                                 b, &zeros,
-                                 b),
-                  "  in Solve_Cuda_BiCGStab, b = cusparseDcsrmv(P', b) has failed\n");
+        cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE,
+        n, n, nnz, &one, CUDA_descr,
+        Px, Pj, Pi,
+        b, &zeros,
+        b),
+        "  in Solve_Cuda_BiCGStab, b = cusparseDcsrmv(P', b) has failed\n");
       */
       /*mexPrintf("Wt = lu(A_m)\n");
-      mexCallMATLAB(0, NULL, 1, &Wt, "disp_dense");*/
+        mexCallMATLAB(0, NULL, 1, &Wt, "disp_dense");*/
       /*ostringstream tmp;
-      tmp << "debugging";
-      mexWarnMsgTxt(tmp.str().c_str());
-      return 4;*/
+        tmp << "debugging";
+        mexWarnMsgTxt(tmp.str().c_str());
+        return 4;*/
       // To store the resultng matrix in a CSR format we have to transpose it
       /*mwIndex* Wtj = mxGetJc(Wt);
-      nnz = Wtj[n];
-      mxArray* W;
-      mexCallMATLAB(1, &W, 1, &Wt, "transpose");
-      mxDestroyArray(Wt);
-      pW = mxGetPr(W);
-      Wwi = mxGetIr(W);
-      mwIndex* Wp = mxGetJc(W);
-      int *Wii = (int*)mxMalloc(nnz * sizeof(int));
-      int *Wip = (int*)mxMalloc((n + 1) * sizeof(int));
-      for (int i = 0; i < nnz; i++)
+        nnz = Wtj[n];
+        mxArray* W;
+        mexCallMATLAB(1, &W, 1, &Wt, "transpose");
+        mxDestroyArray(Wt);
+        pW = mxGetPr(W);
+        Wwi = mxGetIr(W);
+        mwIndex* Wp = mxGetJc(W);
+        int *Wii = (int*)mxMalloc(nnz * sizeof(int));
+        int *Wip = (int*)mxMalloc((n + 1) * sizeof(int));
+        for (int i = 0; i < nnz; i++)
         Wii[i] = Wi[i];
-      for (int i = 0; i < n + 1; i++)
+        for (int i = 0; i < n + 1; i++)
         Wip[i] = Wp[i];
 
-      //mxFree(A_tild_host);
+        //mxFree(A_tild_host);
 
-      cudaChk(cudaFree(Ai_tild), "  in Solve_Cuda_BiCGStab, cudaFree(Ai_tild) has failed\n");
-      cudaChk(cudaFree(Ap_tild), "  in Solve_Cuda_BiCGStab, cudaFree(Ap_tild) has failed\n");
-      cudaChk(cudaFree(A_tild), "  in Solve_Cuda_BiCGStab, cudaFree(A_tild) has failed\n");
+        cudaChk(cudaFree(Ai_tild), "  in Solve_Cuda_BiCGStab, cudaFree(Ai_tild) has failed\n");
+        cudaChk(cudaFree(Ap_tild), "  in Solve_Cuda_BiCGStab, cudaFree(Ap_tild) has failed\n");
+        cudaChk(cudaFree(A_tild), "  in Solve_Cuda_BiCGStab, cudaFree(A_tild) has failed\n");
 
-      cudaChk(cudaMalloc((void**)&A_tild, nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild on the graphic card\n");
-      cudaChk(cudaMemcpy(A_tild, pW, nnz * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild = pW has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_i, nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Ai on the graphic card\n");
-      cudaChk(cudaMemcpy(A_tild_i, Wii, nnz * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_i = A_tild_i_host has failed\n");
-      cudaChk(cudaMalloc((void**)&A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_p on the graphic card\n");
-      cudaChk(cudaMemcpy(A_tild_p, Wip, (n + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_p = A_tild_j_host has failed\n");
-      mxDestroyArray(W);
-      mxFree(Wii);
-      mxFree(Wip);*/
+        cudaChk(cudaMalloc((void**)&A_tild, nnz * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild on the graphic card\n");
+        cudaChk(cudaMemcpy(A_tild, pW, nnz * sizeof(double), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild = pW has failed\n");
+        cudaChk(cudaMalloc((void**)&A_tild_i, nnz * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate Ai on the graphic card\n");
+        cudaChk(cudaMemcpy(A_tild_i, Wii, nnz * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_i = A_tild_i_host has failed\n");
+        cudaChk(cudaMalloc((void**)&A_tild_p, (n + 1) * sizeof(int)), "  in Solve_Cuda_BiCGStab, can't allocate A_tild_p on the graphic card\n");
+        cudaChk(cudaMemcpy(A_tild_p, Wip, (n + 1) * sizeof(int), cudaMemcpyHostToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy A_tild_p = A_tild_j_host has failed\n");
+        mxDestroyArray(W);
+        mxFree(Wii);
+        mxFree(Wip);*/
     }
   if (preconditioner == 1 || preconditioner == 2 || preconditioner == 3)
     {
@@ -4364,22 +4432,20 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                   "  in Solve_Cuda_BiCGStab, cusparseDcsrsm_analysis for infoU has failed\n");
     }
 
-  cudaChk(cudaMalloc((void**)&v, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate v on the graphic card\n");
-  cudaChk(cudaMalloc((void**)&p, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate p on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &v, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate v on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &p, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate p on the graphic card\n");
   //cudaChk(cudaMemset(p, 0, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, cudaMemset p = 0 has failed\n");
-  cudaChk(cudaMalloc((void**)&s, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate s on the graphic card\n");
-  cudaChk(cudaMalloc((void**)&t, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate t on the graphic card\n");
-  cudaChk(cudaMalloc((void**)&y_, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate y_ on the graphic card\n");
-  cudaChk(cudaMalloc((void**)&z, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate z on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &s, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate s on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &t, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate t on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &y_, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate y_ on the graphic card\n");
+  cudaChk(cudaMalloc((void **) &z, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate z on the graphic card\n");
 
   double rho = 1.0, alpha = 1.0, omega = 1.0;
 
-
   //residual = P*B*Q - L*U;
   //norm(Z,1) should be close to 0
 
-
-  while (iteration < 50/*max_iterations*/ && !convergence)
+  while (iteration < 50 /*max_iterations*/ && !convergence)
     {
       double rho_prev = rho;
       /**store in s previous value of r*/
@@ -4392,7 +4458,7 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                            &rho),
                 "  in Solve_Cuda_BiCGStab, rho = cublasDdot(r0, r) has failed\n");
 
-      mexPrintf("rho=%f\n",rho);
+      mexPrintf("rho=%f\n", rho);
 
       double beta;
 
@@ -4407,9 +4473,9 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
 
           /**p = r + beta * (p - omega * v)*/
           // tmp_ = p - omega * v
-          VecAdd<<<nblocks, n_threads>>>(tmp_, p, -omega, v, n);
+          VecAdd<<< nblocks, n_threads>>> (tmp_, p, -omega, v, n);
           //p = r + beta * tmp_
-          VecAdd<<<nblocks, n_threads>>>(p, r, beta, tmp_, n);
+          VecAdd<<< nblocks, n_threads>>> (p, r, beta, tmp_, n);
         }
 
       /**y_ solution of A_tild * y_ = p <=> L . U . y_ = p*/
@@ -4421,10 +4487,10 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
 
           cudaChk(cudaMemcpy(tmp_vect_host, p, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = p has failed\n");
           /*mexPrintf("p\n");
-          for (int i = 0; i < n; i++)
-             mexPrintf("%f\n",tmp_vect_host[i]);*/
+            for (int i = 0; i < n; i++)
+            mexPrintf("%f\n",tmp_vect_host[i]);*/
 
-          cudaChk(cudaMalloc((void**)&p_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
+          cudaChk(cudaMalloc((void **) &p_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
           cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
                                      n, n, P_nnz * periods, &one, CUDA_descr,
                                      Px, Pj, Pi,
@@ -4433,12 +4499,12 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                       "  in Solve_Cuda_BiCGStab, p_tild = cusparseDcsrmv(P', p) has failed\n");
 
           /*mexPrintf("P\n");
-          printM(n, Px, Pj, Pi, CUDA_descr, cusparse_handle);*/
+            printM(n, Px, Pj, Pi, CUDA_descr, cusparse_handle);*/
 
           cudaChk(cudaMemcpy(tmp_vect_host, p_tild, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = p_tild has failed\n");
           /*mexPrintf("p_tild\n");
-          for (int i = 0; i < n; i++)
-             mexPrintf("%f\n",tmp_vect_host[i]);*/
+            for (int i = 0; i < n; i++)
+            mexPrintf("%f\n",tmp_vect_host[i]);*/
 
           cusparseChk(cusparseDcsrsv_solve(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
                                            n, &one,
@@ -4451,8 +4517,8 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
 
           cudaChk(cudaMemcpy(tmp_vect_host, tmp_, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = v has failed\n");
           /*mexPrintf("tmp_\n");
-          for (int i = 0; i < n; i++)
-             mexPrintf("%f\n",tmp_vect_host[i]);*/
+            for (int i = 0; i < n; i++)
+            mexPrintf("%f\n",tmp_vect_host[i]);*/
         }
       else
         cusparseChk(cusparseDcsrsv_solve(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
@@ -4473,14 +4539,14 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                   "  in Solve_Cuda_BiCGStab, cusparseDcsrsv_solve for U . y_ = tmp_ has failed\n");
 
       /*cudaChk(cudaMemcpy(tmp_vect_host, y_, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = v has failed\n");
-      mexPrintf("y_\n");
-      for (int i = 0; i < n; i++)
+        mexPrintf("y_\n");
+        for (int i = 0; i < n; i++)
         mexPrintf("%f\n",tmp_vect_host[i]);*/
 
       if (preconditioner == 3)
         {
           double *y_tild;
-          cudaChk(cudaMalloc((void**)&y_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
+          cudaChk(cudaMalloc((void **) &y_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
           cudaChk(cudaMemcpy(y_tild, y_, n  * sizeof(double), cudaMemcpyDeviceToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy y_tild = y_ has failed\n");
           cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
                                      n, n, Q_nnz * periods, &one, CUDA_descr,
@@ -4491,8 +4557,8 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
           cudaChk(cudaFree(y_tild), "  in Solve_Cuda_BiCGStab, can't free y_tild\n");
         }
       /*cudaChk(cudaMemcpy(tmp_vect_host, y_, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = v has failed\n");
-      mexPrintf("y_\n");
-      for (int i = 0; i < n; i++)
+        mexPrintf("y_\n");
+        for (int i = 0; i < n; i++)
         mexPrintf("%f\n",tmp_vect_host[i]);*/
       /**v = A*y_*/
       cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
@@ -4503,11 +4569,9 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                   "  in Solve_Cuda_BiCGStab, v = cusparseDcsrmv(A, y_) has failed\n");
       cudaChk(cudaMemcpy(tmp_vect_host, v, n*sizeof(double), cudaMemcpyDeviceToHost), "  in Solve_Cuda_BiCGStab, cudaMemcpy tmp_vect_host = v has failed\n");
       /*mexPrintf("v\n");
-      for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++)
         mexPrintf("%f\n",tmp_vect_host[i]);*/
 
-
-
       /**alpha = rho / (rr0 . v) with rr0 = r0*/
       cublasChk(cublasDdot(cublas_handle, n, // numerator
                            r0, 1,
@@ -4537,17 +4601,17 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
                             x0, 1,
                             &tmp2),
                 "  in Solve_Cuda_BiCGStab, cublasDnrm2(y_) has failed\n");
-      mexPrintf("abs(alpha)*tmp1  = %f, alpha = %f, tmp1 = %f, tmp2 = %f, eps = %f\n",abs(alpha)*tmp1 , alpha, tmp1, tmp2, eps);
+      mexPrintf("abs(alpha)*tmp1  = %f, alpha = %f, tmp1 = %f, tmp2 = %f, eps = %f\n", abs(alpha)*tmp1, alpha, tmp1, tmp2, eps);
       if (abs(alpha)*tmp1  < eps * tmp2)
         stagnation++;
       else
         stagnation = 0;
 
       /**x = x + alpha * y_*/
-      VecInc<<<nblocks, n_threads>>>(x0, alpha, y_, n);
+      VecInc<<< nblocks, n_threads>>> (x0, alpha, y_, n);
 
       /**s = r_prev - alpha *v with r_prev = s*/
-      VecInc<<<nblocks, n_threads>>>(s, -alpha, v, n);
+      VecInc<<< nblocks, n_threads>>> (s, -alpha, v, n);
 
       /**Has BiCGStab converged?*/
       cublasChk(cublasDnrm2(cublas_handle, n, // numerator
@@ -4599,7 +4663,7 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       if (preconditioner == 3)
         {
           double *s_tild;
-          cudaChk(cudaMalloc((void**)&s_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
+          cudaChk(cudaMalloc((void **) &s_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate b_tild on the graphic card\n");
           cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
                                      n, n, P_nnz * periods, &one, CUDA_descr,
                                      Px, Pj, Pi,
@@ -4636,7 +4700,7 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
       if (preconditioner == 3)
         {
           double *z_tild;
-          cudaChk(cudaMalloc((void**)&z_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate z_tild on the graphic card\n");
+          cudaChk(cudaMalloc((void **) &z_tild, n * sizeof(double)), "  in Solve_Cuda_BiCGStab, can't allocate z_tild on the graphic card\n");
           cudaChk(cudaMemcpy(z_tild, z, n  * sizeof(double), cudaMemcpyDeviceToDevice), "  in Solve_Cuda_BiCGStab, cudaMemcpy z_tild = z has failed\n");
           cusparseChk(cusparseDcsrmv(cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
                                      n, n, Q_nnz * periods, &one, CUDA_descr,
@@ -4680,10 +4744,10 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
         }
 
       /**x = x +  omega * z*/
-      VecInc<<<nblocks, n_threads>>>(x0, omega, z, n);
+      VecInc<<< nblocks, n_threads>>> (x0, omega, z, n);
 
       /**r = s - omega * t*/
-      VecAdd<<<nblocks, n_threads>>>(r, s, -omega, t, n);
+      VecAdd<<< nblocks, n_threads>>> (r, s, -omega, t, n);
 
       /**Has BiCGStab converged?*/
       cublasChk(cublasDnrm2(cublas_handle, n, // numerator
@@ -4722,7 +4786,7 @@ dynSparseMatrix::Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild,
               refinement_needed++;
               if (refinement_needed > max_refinement)
                 {
-                  Solve_CUDA_BiCGStab_Free(tmp_vect_host, p, r, v, s, t, y_, z, tmp_, Ai, Ax, Ap, x0, b, A_tild, A_tild_i, A_tild_p, /*Lx, Li, Lp, Ux, Ui, Up, device_n, */infoL, infoU, descrL, descrU, preconditioner);
+                  Solve_CUDA_BiCGStab_Free(tmp_vect_host, p, r, v, s, t, y_, z, tmp_, Ai, Ax, Ap, x0, b, A_tild, A_tild_i, A_tild_p, /*Lx, Li, Lp, Ux, Ui, Up, device_n, */ infoL, infoU, descrL, descrU, preconditioner);
                   ostringstream tmp;
                   mexEvalString("diary off;");
                   tmp << "Error in bytecode: BiCGStab stagnated (Two consecutive iterates were the same.), in block " << block+1;
@@ -4798,7 +4862,7 @@ dynSparseMatrix::Solve_Matlab_GMRES(mxArray *A_m, mxArray *b_m, int Size, double
   rhs[1] = b_m;
   rhs[2] = mxCreateDoubleScalar(Size);
   rhs[3] = mxCreateDoubleScalar(1e-6);
-  rhs[4] = mxCreateDoubleScalar((double)n);
+  rhs[4] = mxCreateDoubleScalar((double) n);
   rhs[5] = L1;
   rhs[6] = U1;
   rhs[7] = x0_m;
@@ -4866,6 +4930,9 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
      precond = 1  => Incomplet LU decomposition*/
   size_t n = mxGetM(A_m);
   mxArray *L1, *U1, *Diag;
+  L1 = NULL;
+  U1 = NULL;
+  Diag = NULL;
 
   mxArray *rhs0[4];
   if (preconditioner == 0)
@@ -4874,8 +4941,8 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
       rhs0[0] = A_m;
       rhs0[1] = mxCreateDoubleScalar(0);
       mexCallMATLAB(1, lhs0, 2, rhs0, "spdiags");
-      mxArray* tmp = lhs0[0];
-      double* tmp_val = mxGetPr(tmp);
+      mxArray *tmp = lhs0[0];
+      double *tmp_val = mxGetPr(tmp);
       Diag = mxCreateSparse(n, n, n, mxREAL);
       mwIndex *Diag_i = mxGetIr(Diag);
       mwIndex *Diag_j = mxGetJc(Diag);
@@ -4897,7 +4964,7 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
       const int milu = 2;
       const int udiag = 3;
       const int thresh = 4;
-      mwSize dims[1] = {(mwSize)1 };
+      mwSize dims[1] = {(mwSize) 1 };
       mxArray *Setup = mxCreateStructArray(1, dims, 5, field_names);
       mxSetFieldByNumber(Setup, 0, type, mxCreateString("ilutp"));
       mxSetFieldByNumber(Setup, 0, droptol, mxCreateDoubleScalar(lu_inc_tol));
@@ -4911,7 +4978,7 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
       if (mexCallMATLAB(2, lhs0, 2, rhs0, "ilu"))
         {
           ostringstream tmp;
-          tmp  << " In BiCGStab, the incomplet LU decomposition (ilu) ahs failed.\n";
+          tmp << " In BiCGStab, the incomplet LU decomposition (ilu) ahs failed.\n";
           throw FatalExceptionHandling(tmp.str());
         }
       L1 = lhs0[0];
@@ -4920,12 +4987,13 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
     }
   double flags = 2;
   mxArray *z;
+  z = NULL;
   if (steady_state)  /*Octave BicStab algorihtm involves a 0 division in case of a preconditionner equal to the LU decomposition of A matrix*/
     {
       mxArray *res = mult_SAT_B(Sparse_transpose(A_m), x0_m);
       double *resid = mxGetPr(res);
       double *b = mxGetPr(b_m);
-      for (int i = 0; i < (int)n; i++)
+      for (int i = 0; i < (int) n; i++)
         resid[i] = b[i] - resid[i];
       mxArray *rhs[2];
       mxArray *lhs[1];
@@ -4938,14 +5006,14 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
       z = lhs[0];
       double *phat = mxGetPr(z);
       double *x0 = mxGetPr(x0_m);
-      for (int i = 0; i < (int)n; i++)
+      for (int i = 0; i < (int) n; i++)
         phat[i] = x0[i] + phat[i];
 
       /*Check the solution*/
       res = mult_SAT_B(Sparse_transpose(A_m), z);
       resid = mxGetPr(res);
       double cum_abs = 0;
-      for (int i = 0; i < (int)n; i++)
+      for (int i = 0; i < (int) n; i++)
         {
           resid[i] = b[i] - resid[i];
           cum_abs += fabs(resid[i]);
@@ -4967,7 +5035,7 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
           rhs[0] = A_m;
           rhs[1] = b_m;
           rhs[2] = mxCreateDoubleScalar(1e-6);
-          rhs[3] = mxCreateDoubleScalar((double)n);
+          rhs[3] = mxCreateDoubleScalar((double) n);
           rhs[4] = Diag;
           //rhs[5] = x0_m;
           mxArray *lhs[2];
@@ -4988,7 +5056,7 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
           rhs[0] = A_m;
           rhs[1] = b_m;
           rhs[2] = mxCreateDoubleScalar(1e-6);
-          rhs[3] = mxCreateDoubleScalar((double)n);
+          rhs[3] = mxCreateDoubleScalar((double) n);
           rhs[4] = L1;
           rhs[5] = U1;
           rhs[6] = x0_m;
@@ -5006,7 +5074,6 @@ dynSparseMatrix::Solve_Matlab_BiCGStab(mxArray *A_m, mxArray *b_m, int Size, dou
         }
     }
 
-
   if (flags > 0)
     {
       ostringstream tmp;
@@ -5077,8 +5144,8 @@ dynSparseMatrix::Singular_display(int block, int Size)
     }
   mxArray *lhs[3];
   mexCallMATLAB(3, lhs, 1, rhs, "svd");
-  mxArray* SVD_u = lhs[0];
-  mxArray* SVD_s = lhs[1];
+  mxArray *SVD_u = lhs[0];
+  mxArray *SVD_s = lhs[1];
   //mxArray* SVD_v = lhs[2];
   double *SVD_ps = mxGetPr(SVD_s);
   double *SVD_pu = mxGetPr(SVD_u);
@@ -5095,35 +5162,35 @@ dynSparseMatrix::Singular_display(int block, int Size)
           for (int j = 0; j < Size; j++)
             {
               double rr = SVD_pu[j + i * Size] / max_u;
-              if ( rr < -1e-10)
+              if (rr < -1e-10)
                 {
                   equ_list.push_back(j);
                   if (rr != -1)
-                    mexPrintf(" - %3.2f*Dequ_%d_dy",abs(rr),j+1);
+                    mexPrintf(" - %3.2f*Dequ_%d_dy", abs(rr), j+1);
                   else
-                    mexPrintf(" - Dequ_%d_dy",j+1);
+                    mexPrintf(" - Dequ_%d_dy", j+1);
                 }
               else if (rr > 1e-10)
                 {
                   equ_list.push_back(j);
                   if (j > 0)
                     if (rr != 1)
-                      mexPrintf(" + %3.2f*Dequ_%d_dy",rr,j+1);
+                      mexPrintf(" + %3.2f*Dequ_%d_dy", rr, j+1);
                     else
-                      mexPrintf(" + Dequ_%d_dy",j+1);
+                      mexPrintf(" + Dequ_%d_dy", j+1);
                   else if (rr != 1)
-                    mexPrintf(" %3.2f*Dequ_%d_dy",rr,j+1);
+                    mexPrintf(" %3.2f*Dequ_%d_dy", rr, j+1);
                   else
-                    mexPrintf(" Dequ_%d_dy",j+1);
+                    mexPrintf(" Dequ_%d_dy", j+1);
                 }
             }
           mexPrintf(" = 0\n");
           /*mexPrintf(" with:\n");
-          it_code = get_begin_block(block);
-          for (int j=0; j < Size; j++)
+            it_code = get_begin_block(block);
+            for (int j=0; j < Size; j++)
             {
-              if (find(equ_list.begin(), equ_list.end(), j) != equ_list.end())
-                mexPrintf("  equ_%d: %s\n",j, print_expression(it_code_expr, false, Size, block, steady_state, 0, 0, it_code, true).c_str());
+            if (find(equ_list.begin(), equ_list.end(), j) != equ_list.end())
+            mexPrintf("  equ_%d: %s\n",j, print_expression(it_code_expr, false, Size, block, steady_state, 0, 0, it_code, true).c_str());
             }*/
         }
     }
@@ -5138,7 +5205,6 @@ dynSparseMatrix::Singular_display(int block, int Size)
   throw FatalExceptionHandling(tmp.str());
 }
 
-
 bool
 dynSparseMatrix::Solve_ByteCode_Sparse_GaussianElimination(int Size, int blck, int it_)
 {
@@ -5151,10 +5217,15 @@ dynSparseMatrix::Solve_ByteCode_Sparse_GaussianElimination(int Size, int blck, i
   double piv_abs;
   NonZeroElem **bc;
   bc = (NonZeroElem **) mxMalloc(Size*sizeof(*bc));
+  test_mxMalloc(bc, __LINE__, __FILE__, __func__, Size*sizeof(*bc));
   piv_v = (double *) mxMalloc(Size*sizeof(double));
+  test_mxMalloc(piv_v, __LINE__, __FILE__, __func__, Size*sizeof(double));
   pivj_v = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivj_v, __LINE__, __FILE__, __func__, Size*sizeof(int));
   pivk_v = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivk_v, __LINE__, __FILE__, __func__, Size*sizeof(int));
   NR = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(NR, __LINE__, __FILE__, __func__, Size*sizeof(int));
 
   for (int i = 0; i < Size; i++)
     {
@@ -5419,30 +5490,36 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
   int tbreak = 0, last_period = periods;
 
   piv_v = (double *) mxMalloc(Size*sizeof(double));
+  test_mxMalloc(piv_v, __LINE__, __FILE__, __func__, Size*sizeof(double));
   pivj_v = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivj_v, __LINE__, __FILE__, __func__, Size*sizeof(int));
   pivk_v = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(pivk_v, __LINE__, __FILE__, __func__, Size*sizeof(int));
   NR = (int *) mxMalloc(Size*sizeof(int));
+  test_mxMalloc(NR, __LINE__, __FILE__, __func__, Size*sizeof(int));
   //clock_t time00 = clock();
   NonZeroElem **bc;
   bc = (NonZeroElem **) mxMalloc(Size*sizeof(first));
+  test_mxMalloc(bc, __LINE__, __FILE__, __func__, Size*sizeof(first));
 
   for (int t = 0; t < periods; t++)
     {
       /*clock_t time11 = clock();
-      mexPrintf("t=%d, record = %d\n",t, record);*/
+        mexPrintf("t=%d, record = %d\n",t, record);*/
 #ifdef MATLAB_MEX_FILE
-    	if ( utIsInterruptPending() )
-		    throw UserExceptionHandling();
+      if (utIsInterruptPending())
+        throw UserExceptionHandling();
 #endif
 
       if (record && symbolic)
         {
           /*if (save_op)
             {
-              mxFree(save_op);
-              save_op = NULL;
+            mxFree(save_op);
+            save_op = NULL;
             }*/
           save_op = (int *) mxMalloc(nop*sizeof(int));
+          test_mxMalloc(save_op, __LINE__, __FILE__, __func__, nop*sizeof(int));
           nopa = nop;
         }
       nop = 0;
@@ -5636,7 +5713,7 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                     bc[nb_eq_todo++] = first;
                   first = first->NZE_C_N;
                 }
-//#pragma omp parallel for num_threads(atoi(getenv("DYNARE_NUM_THREADS"))) shared(nb_var_piva, first_piva, nopa, save_op) reduction(+:nop)
+              //#pragma omp parallel for num_threads(atoi(getenv("DYNARE_NUM_THREADS"))) shared(nb_var_piva, first_piva, nopa, save_op) reduction(+:nop)
               for (int j = 0; j < nb_eq_todo; j++)
                 {
                   t_save_op_s *save_op_s_l;
@@ -5663,7 +5740,7 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                   int sub_c_index = first_sub->c_index;
                   int piv_c_index = first_piv->c_index;
                   int tmp_lag = first_sub->lag_index;
-                  while (l_sub < (nb_var_sub/*=NRow(row)*/) || l_piv < nb_var_piv)
+                  while (l_sub < (nb_var_sub /*=NRow(row)*/) || l_piv < nb_var_piv)
                     {
                       if (l_sub < nb_var_sub && (sub_c_index < piv_c_index || l_piv >= nb_var_piv))
                         {
@@ -5681,9 +5758,9 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                           tmp_u_count = Get_u();
                           lag = first_piv->c_index/Size-row/Size;
                           //#pragma omp critical
-                            {
-                              Insert(row, first_piv->c_index, tmp_u_count, lag);
-                            }
+                          {
+                            Insert(row, first_piv->c_index, tmp_u_count, lag);
+                          }
                           u[tmp_u_count] = -u[first_piv->u_index]*first_elem;
                           if (nop+2 >= nopa)
                             {
@@ -5710,9 +5787,9 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                               NonZeroElem *firsta = first;
                               NonZeroElem *first_suba = first_sub->NZE_R_N;
                               //#pragma omp critical
-                                {
-                                  Delete(first_sub->r_index, first_sub->c_index);
-                                }
+                              {
+                                Delete(first_sub->r_index, first_sub->c_index);
+                              }
                               first = firsta->NZE_C_N;
                               first_sub = first_suba;
                               if (first_sub)
@@ -5771,7 +5848,7 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                   nop += 3;
                 }
             }
-          else if(symbolic)
+          else if (symbolic)
             {
               nop += 2;
               if (piv_abs < eps)
@@ -5805,7 +5882,7 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                     bc[nb_eq_todo++] = first;
                   first = first->NZE_C_N;
                 }
-//#pragma omp parallel for num_threads(atoi(getenv("DYNARE_NUM_THREADS"))) shared(nb_var_piva, first_piva, nopa, save_op) reduction(+:nop)
+              //#pragma omp parallel for num_threads(atoi(getenv("DYNARE_NUM_THREADS"))) shared(nb_var_piva, first_piva, nopa, save_op) reduction(+:nop)
               for (int j = 0; j < nb_eq_todo; j++)
                 {
                   NonZeroElem *first = bc[j];
@@ -5838,9 +5915,9 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                           tmp_u_count = Get_u();
                           lag = first_piv->c_index/Size-row/Size;
                           //#pragma omp critical
-                           {
-                             Insert(row, first_piv->c_index, tmp_u_count, lag);
-                           }
+                          {
+                            Insert(row, first_piv->c_index, tmp_u_count, lag);
+                          }
                           u[tmp_u_count] = -u[first_piv->u_index]*first_elem;
                           nop += 3;
                           first_piv = first_piv->NZE_R_N;
@@ -5857,9 +5934,9 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
                               NonZeroElem *firsta = first;
                               NonZeroElem *first_suba = first_sub->NZE_R_N;
                               //#pragma omp critical
-                                {
-                                  Delete(first_sub->r_index, first_sub->c_index);
-                                }
+                              {
+                                Delete(first_sub->r_index, first_sub->c_index);
+                              }
                               first = firsta->NZE_C_N;
                               first_sub = first_suba;
                               if (first_sub)
@@ -5900,7 +5977,7 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
         }
       if (symbolic)
         {
-		  if (t > int(periods*0.35))
+          if (t > int (periods*0.35))
             {
               symbolic = false;
               mxFree(save_opaa);
@@ -5909,7 +5986,7 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
             }
           else if (record && (nop == nop1))
             {
-              if (t > int(periods*0.35))
+              if (t > int (periods*0.35))
                 {
                   symbolic = false;
                   if (save_opaa)
@@ -5979,8 +6056,8 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
   mxFree(pivk_v);
   mxFree(NR);
   /*mexPrintf("tbreak=%d, periods=%d time required=%f\n",tbreak,periods, (1000.0*(double (clock())-double (time00)))/double (CLOCKS_PER_SEC));
-  mexEvalString("drawnow;");
-  time00 = clock();*/
+    mexEvalString("drawnow;");
+    time00 = clock();*/
   nop_all += nop;
   if (symbolic)
     {
@@ -5999,13 +6076,12 @@ dynSparseMatrix::Solve_ByteCode_Symbolic_Sparse_GaussianElimination(int Size, bo
   slowc_save = slowc;
   bksub(tbreak, last_period, Size, slowc_lbx);
   /*mexPrintf("remaining operations and bksub time required=%f\n",tbreak,periods, (1000.0*(double (clock())-double (time00)))/double (CLOCKS_PER_SEC));
-  mexEvalString("drawnow;");*/
+    mexEvalString("drawnow;");*/
   End_GE(Size);
 }
 
-
 void
-dynSparseMatrix::Grad_f_product(int n, mxArray *b_m, double* vectr, mxArray *A_m, SuiteSparse_long *Ap, SuiteSparse_long *Ai, double* Ax, double* b_)
+dynSparseMatrix::Grad_f_product(int n, mxArray *b_m, double *vectr, mxArray *A_m, SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b_)
 {
   if ((solve_algo == 5 && steady_state) || (stack_solve_algo == 5 && !steady_state))
     {
@@ -6080,9 +6156,9 @@ dynSparseMatrix::Check_and_Correct_Previous_Iteration(int block_num, int y_size,
               y[eq+it_*y_size] = ya[eq+it_*y_size] + slowc_save * direction[eq+it_*y_size];
             }
           /*mexPrintf("reducing solwc_save = %e, it_=%d, y_size=%d, size=%d, y[%d]=%e, ya[%d]=%e,\n y[%d]=%e, ya[%d]=%e\n",slowc_save, it_, y_size, size-1, index_vara[0]+it_*y_size, y[index_vara[0]+it_*y_size], index_vara[0]+it_*y_size, ya[index_vara[0]+it_*y_size]
-                                                                                                       , index_vara[size-1]+it_*y_size, y[index_vara[size-1]+it_*y_size], index_vara[size-1]+it_*y_size, ya[index_vara[size-1]+it_*y_size]);*/
-           //mexPrintf("->slowc_save=%f\n",slowc_save);
-           compute_complete(true, res1, res2, max_res, max_res_idx);
+            , index_vara[size-1]+it_*y_size, y[index_vara[size-1]+it_*y_size], index_vara[size-1]+it_*y_size, ya[index_vara[size-1]+it_*y_size]);*/
+          //mexPrintf("->slowc_save=%f\n",slowc_save);
+          compute_complete(true, res1, res2, max_res, max_res_idx);
         }
 
       while (res2 > g0 && slowc_save > 1e-1)
@@ -6099,7 +6175,7 @@ dynSparseMatrix::Check_and_Correct_Previous_Iteration(int block_num, int y_size,
           compute_complete(true, res1, res2, max_res, max_res_idx);
         }
       double ax = slowc_save-0.001, bx = slowc_save+0.001, cx = slowc_save, fa, fb, fc, xmin;
-      if (false/*slowc_save > 2e-1*/)
+      if (false /*slowc_save > 2e-1*/)
         if (mnbrak(&ax, &bx, &cx, &fa, &fb, &fc))
           if (golden(ax, bx, cx, 1e-1, solve_tolf, &xmin))
             slowc_save = xmin;
@@ -6110,72 +6186,73 @@ dynSparseMatrix::Check_and_Correct_Previous_Iteration(int block_num, int y_size,
       if (false)
         {
 
-          double *p = (double*)mxMalloc(size * sizeof(double));
+          double *p = (double *) mxMalloc(size * sizeof(double));
+          test_mxMalloc(p, __LINE__, __FILE__, __func__, size * sizeof(double));
           Grad_f_product(size, b_m_save, p, A_m_save, Ap_save, Ai_save, Ax_save, b_save);
-          double slope=0.0;
+          double slope = 0.0;
           for (int i = 1; i < size; i++)
-            slope += - direction[i] * p[i];
+            slope += -direction[i] * p[i];
           /*if (slope > 0)
             mexPrintf("Roundoff in lnsearch\n");
-          else*/
-            {
-              prev_slowc_save = 1;
-              double crit_opt = res2/2;
-              double max_try_iteration = 100;
-              double small_ = 1.0e-4;
-              bool try_at_cvg = false;
-              while ((try_at_iteration < max_try_iteration) && (!try_at_cvg) && (abs(prev_slowc_save - slowc_save) > 1e-10))
-                {
-                  crit_opt = res2 / 2;
-                  if (slowc_save < 1e-7)
-                    {
-                      try_at_cvg = true;
-                      continue;
-                    }
-                  else if ((crit_opt <= crit_opt_old + small_ * slowc_save * slope) && !(isnan(res1) || isinf(res1)))
-                    {
-                      try_at_cvg = true;
-                      continue;
-                    }
-                  else if (try_at_iteration == 0)
-                    {
-                      prev_slowc_save = slowc_save;
-                      //slowc_save = max(- top * slope / ( (crit_opt - crit_opt_old - slope)), bottom);
-                      slowc_save /= 1.2;
-                    }
-                  else
-                    {
-                      double t1 = crit_opt - slope * slowc_save - crit_opt_old;
-                      double t2 = glambda2 - slope * prev_slowc_save - crit_opt_old;
-                      double a = (1/(slowc_save * slowc_save) * t1 - 1/(prev_slowc_save * prev_slowc_save) * t2) / (slowc_save - prev_slowc_save);
-                      double b = (-prev_slowc_save/(slowc_save * slowc_save) * t1 + slowc_save/(prev_slowc_save * prev_slowc_save) * t2) / (slowc_save - prev_slowc_save);
-                      if (a == 0)
-                        slowc_save = max(min( - slope/(2 * b) , top * slowc_save), bottom * slowc_save);
-                      else
-                        {
-                          double delta = b*b - 3 * a * slope;
-                          if (delta <= 0)
-                            slowc_save = top * slowc_save;
-                          else if (b <= 0)
-                            slowc_save = max(min(-b + sqrt(delta) / (3 * a), top * slowc_save), bottom * slowc_save);
-                          else
-                            slowc_save = max(min(- slope / (b + sqrt(delta)), top * slowc_save), bottom * slowc_save);
-                        }
-                    }
-                  if (abs(prev_slowc_save - slowc_save) < 1e-10)
-                    slowc_save /= 1.1;
-                  //mexPrintf("=>slowc_save=%f, prev_slowc_save=%f\n",slowc_save, prev_slowc_save);
-                  prev_slowc_save = slowc_save;
-                  glambda2 = crit_opt;
-                  try_at_iteration++;
-                  for (int i = 0; i < size; i++)
-                    {
-                      int eq = index_vara[i];
-                      y[eq+it_*y_size] = ya[eq+it_*y_size] + slowc_save * direction[eq+it_*y_size];
-                    }
-                  compute_complete(true, res1, res2, max_res, max_res_idx);
-                }
-            }
+            else*/
+          {
+            prev_slowc_save = 1;
+            double crit_opt = res2/2;
+            double max_try_iteration = 100;
+            double small_ = 1.0e-4;
+            bool try_at_cvg = false;
+            while ((try_at_iteration < max_try_iteration) && (!try_at_cvg) && (abs(prev_slowc_save - slowc_save) > 1e-10))
+              {
+                crit_opt = res2 / 2;
+                if (slowc_save < 1e-7)
+                  {
+                    try_at_cvg = true;
+                    continue;
+                  }
+                else if ((crit_opt <= crit_opt_old + small_ * slowc_save * slope) && !(isnan(res1) || isinf(res1)))
+                  {
+                    try_at_cvg = true;
+                    continue;
+                  }
+                else if (try_at_iteration == 0)
+                  {
+                    prev_slowc_save = slowc_save;
+                    //slowc_save = max(- top * slope / ( (crit_opt - crit_opt_old - slope)), bottom);
+                    slowc_save /= 1.2;
+                  }
+                else
+                  {
+                    double t1 = crit_opt - slope * slowc_save - crit_opt_old;
+                    double t2 = glambda2 - slope * prev_slowc_save - crit_opt_old;
+                    double a = (1/(slowc_save * slowc_save) * t1 - 1/(prev_slowc_save * prev_slowc_save) * t2) / (slowc_save - prev_slowc_save);
+                    double b = (-prev_slowc_save/(slowc_save * slowc_save) * t1 + slowc_save/(prev_slowc_save * prev_slowc_save) * t2) / (slowc_save - prev_slowc_save);
+                    if (a == 0)
+                      slowc_save = max(min(-slope/(2 * b), top * slowc_save), bottom * slowc_save);
+                    else
+                      {
+                        double delta = b*b - 3 * a * slope;
+                        if (delta <= 0)
+                          slowc_save = top * slowc_save;
+                        else if (b <= 0)
+                          slowc_save = max(min(-b + sqrt(delta) / (3 * a), top * slowc_save), bottom * slowc_save);
+                        else
+                          slowc_save = max(min(-slope / (b + sqrt(delta)), top * slowc_save), bottom * slowc_save);
+                      }
+                  }
+                if (abs(prev_slowc_save - slowc_save) < 1e-10)
+                  slowc_save /= 1.1;
+                //mexPrintf("=>slowc_save=%f, prev_slowc_save=%f\n",slowc_save, prev_slowc_save);
+                prev_slowc_save = slowc_save;
+                glambda2 = crit_opt;
+                try_at_iteration++;
+                for (int i = 0; i < size; i++)
+                  {
+                    int eq = index_vara[i];
+                    y[eq+it_*y_size] = ya[eq+it_*y_size] + slowc_save * direction[eq+it_*y_size];
+                  }
+                compute_complete(true, res1, res2, max_res, max_res_idx);
+              }
+          }
           mxFree(p);
         }
       //if (print_it)
@@ -6208,7 +6285,6 @@ dynSparseMatrix::Simulate_One_Boundary(int block_num, int y_size, int y_kmin, in
   double *Ax = NULL, *b = NULL;
   int preconditioner = 1;
 
-
   try_at_iteration = 0;
   Clear_u();
   bool singular_system = false;
@@ -6277,8 +6353,8 @@ dynSparseMatrix::Simulate_One_Boundary(int block_num, int y_size, int y_kmin, in
               mexPrintf("MODEL STEADY STATE: Sparse LU\n");
               break;
             case 7:
-                mexPrintf(preconditioner_print_out("MODEL STEADY STATE: (method=GMRES)\n", preconditioner, true).c_str());
-                //mexPrintf("MODEL STEADY STATE: (method=GMRES)\n");
+              mexPrintf(preconditioner_print_out("MODEL STEADY STATE: (method=GMRES)\n", preconditioner, true).c_str());
+              //mexPrintf("MODEL STEADY STATE: (method=GMRES)\n");
               break;
             case 8:
               mexPrintf(preconditioner_print_out("MODEL STEADY STATE: (method=BiCGStab)\n", preconditioner, true).c_str());
@@ -6336,8 +6412,10 @@ dynSparseMatrix::Simulate_One_Boundary(int block_num, int y_size, int y_kmin, in
             {
               mxFree(Ai_save);
               mxFree(Ax_save);
-              Ai_save = (SuiteSparse_long*)mxMalloc(Ap[size] * sizeof(SuiteSparse_long));
-              Ax_save = (double*)mxMalloc(Ap[size] * sizeof(double));
+              Ai_save = (SuiteSparse_long *) mxMalloc(Ap[size] * sizeof(SuiteSparse_long));
+              test_mxMalloc(Ai_save, __LINE__, __FILE__, __func__, Ap[size] * sizeof(SuiteSparse_long));
+              Ax_save = (double *) mxMalloc(Ap[size] * sizeof(double));
+              test_mxMalloc(Ax_save, __LINE__, __FILE__, __func__, Ap[size] * sizeof(double));
             }
           memcpy(Ap_save, Ap, (size + 1) * sizeof(SuiteSparse_long));
           memcpy(Ai_save, Ai, Ap[size] * sizeof(SuiteSparse_long));
@@ -6369,9 +6447,6 @@ dynSparseMatrix::Simulate_One_Boundary(int block_num, int y_size, int y_kmin, in
   return singular_system;
 }
 
-
-
-
 bool
 dynSparseMatrix::solve_linear(const int block_num, const int y_size, const int y_kmin, const int y_kmax, const int size, const int iter)
 {
@@ -6420,15 +6495,21 @@ void
 dynSparseMatrix::Simulate_Newton_One_Boundary(const bool forward)
 {
   g1 = (double *) mxMalloc(size*size*sizeof(double));
+  test_mxMalloc(g1, __LINE__, __FILE__, __func__, size*size*sizeof(double));
   r = (double *) mxMalloc(size*sizeof(double));
+  test_mxMalloc(r, __LINE__, __FILE__, __func__, size*sizeof(double));
   iter = 0;
   if ((solve_algo == 6 && steady_state) || ((stack_solve_algo == 0 || stack_solve_algo == 1 || stack_solve_algo == 4) && !steady_state))
     {
-      Ap_save = (SuiteSparse_long*)mxMalloc((size + 1) * sizeof(SuiteSparse_long));
+      Ap_save = (SuiteSparse_long *) mxMalloc((size + 1) * sizeof(SuiteSparse_long));
+      test_mxMalloc(Ap_save, __LINE__, __FILE__, __func__, (size + 1) * sizeof(SuiteSparse_long));
       Ap_save[size] = 0;
-      Ai_save = (SuiteSparse_long*)mxMalloc(1 * sizeof(SuiteSparse_long));
-      Ax_save = (double*)mxMalloc(1 * sizeof(double));
-      b_save = (double*)mxMalloc((size) * sizeof(SuiteSparse_long));
+      Ai_save = (SuiteSparse_long *) mxMalloc(1 * sizeof(SuiteSparse_long));
+      test_mxMalloc(Ai_save, __LINE__, __FILE__, __func__, 1 * sizeof(SuiteSparse_long));
+      Ax_save = (double *) mxMalloc(1 * sizeof(double));
+      test_mxMalloc(Ax_save, __LINE__, __FILE__, __func__, 1 * sizeof(double));
+      b_save = (double *) mxMalloc((size) * sizeof(SuiteSparse_long));
+      test_mxMalloc(b_save, __LINE__, __FILE__, __func__, (size) * sizeof(SuiteSparse_long));
     }
   if (steady_state)
     {
@@ -6480,7 +6561,7 @@ dynSparseMatrix::preconditioner_print_out(string s, int preconditioner, bool ss)
 {
   int n = s.length();
   string tmp = ", preconditioner=";
-  switch(preconditioner)
+  switch (preconditioner)
     {
     case 0:
       if (ss)
@@ -6491,7 +6572,7 @@ dynSparseMatrix::preconditioner_print_out(string s, int preconditioner, bool ss)
     case 1:
       if (ss)
         tmp.append("incomplet lutp on static jacobian");
-      else 
+      else
         tmp.append("incomplet lu0 on dynamic jacobian");
       break;
     case 2:
@@ -6527,7 +6608,6 @@ dynSparseMatrix::Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin
   double *Ax = NULL, *b;
   SuiteSparse_long *Ap = NULL, *Ai = NULL;
 
-
   if (iter > 0)
     {
       if (print_it)
@@ -6541,6 +6621,7 @@ dynSparseMatrix::Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin
     {
       if (iter == 0 || fabs(slowc_save) < 1e-8)
         {
+          mexPrintf("res1 = %f, res2 = %f g0 = %f iter = %d\n", res1, res2, g0, iter);
           for (int j = 0; j < y_size; j++)
             {
               ostringstream res;
@@ -6751,7 +6832,7 @@ dynSparseMatrix::Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin
       mexPrintf("(** %f milliseconds **)\n", 1000.0*(double (t2) - double (t1))/double (CLOCKS_PER_SEC));
       mexEvalString("drawnow;");
     }
-  if ((!steady_state && (stack_solve_algo == 4 /*|| stack_solve_algo == 0*/))/* || steady_state*/)
+  if ((!steady_state && (stack_solve_algo == 4 /*|| stack_solve_algo == 0*/)) /* || steady_state*/)
     {
       clock_t t2 = clock();
       double ax = -0.1, bx = 1.1, cx = 0.5, fa, fb, fc, xmin;
@@ -6781,10 +6862,10 @@ dynSparseMatrix::fixe_u(double **u, int u_count_int, int max_lag_plus_max_lead_p
   mexPrintf("fixe_u : alloc(%d double)\n", u_count_alloc);
 #endif
   (*u) = (double *) mxMalloc(u_count_alloc*sizeof(double));
+  test_mxMalloc(*u, __LINE__, __FILE__, __func__, u_count_alloc*sizeof(double));
 #ifdef DEBUG
   mexPrintf("*u=%d\n", *u);
 #endif
   memset((*u), 0, u_count_alloc*sizeof(double));
   u_count_init = max_lag_plus_max_lead_plus_1;
 }
-
diff --git a/mex/sources/bytecode/SparseMatrix.hh b/mex/sources/bytecode/SparseMatrix.hh
index 82fd5a3ab..087853755 100644
--- a/mex/sources/bytecode/SparseMatrix.hh
+++ b/mex/sources/bytecode/SparseMatrix.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -27,14 +27,14 @@
 #include <ctime>
 #include "dynblas.h"
 #if !(defined _MSC_VER)
-#include "dynumfpack.h"
+# include "dynumfpack.h"
 #endif
 
 #ifdef CUDA
-#include "cuda.h"
-#include "cuda_runtime_api.h"
-#include "cublas_v2.h"
-#include "cusparse_v2.h"
+# include "cuda.h"
+# include "cuda_runtime_api.h"
+# include "cublas_v2.h"
+# include "cusparse_v2.h"
 #endif
 
 #include "Mem_Mngr.hh"
@@ -42,38 +42,38 @@
 //#include "Interpreter.hh"
 #include "Evaluate.hh"
 
-#define cudaChk(x, y) \
-        { \
-          cudaError_t cuda_error = x; \
-          if (cuda_error != cudaSuccess) \
-            { \
-              ostringstream tmp; \
-              tmp << y; \
-              throw FatalExceptionHandling(tmp.str()); \
-            } \
-        };
+#define cudaChk(x, y)                                   \
+  {                                                     \
+    cudaError_t cuda_error = x;                         \
+    if (cuda_error != cudaSuccess)                      \
+      {                                                 \
+        ostringstream tmp;                              \
+        tmp << y;                                       \
+        throw FatalExceptionHandling(tmp.str());        \
+      }                                                 \
+  };
 
-#define cusparseChk(x, y) \
-        { \
-          cusparseStatus_t cusparse_status = x; \
-          if (cusparse_status != CUSPARSE_STATUS_SUCCESS) \
-            { \
-              ostringstream tmp; \
-              tmp << y; \
-              throw FatalExceptionHandling(tmp.str()); \
-            } \
-        };
+#define cusparseChk(x, y)                               \
+  {                                                     \
+    cusparseStatus_t cusparse_status = x;               \
+    if (cusparse_status != CUSPARSE_STATUS_SUCCESS)     \
+      {                                                 \
+        ostringstream tmp;                              \
+        tmp << y;                                       \
+        throw FatalExceptionHandling(tmp.str());        \
+      }                                                 \
+  };
 
-#define cublasChk(x, y) \
-        { \
-          cublasStatus_t cublas_status = x; \
-          if (cublas_status != CUBLAS_STATUS_SUCCESS) \
-            { \
-              ostringstream tmp; \
-              tmp << y; \
-              throw FatalExceptionHandling(tmp.str()); \
-            } \
-        };
+#define cublasChk(x, y)                                 \
+  {                                                     \
+    cublasStatus_t cublas_status = x;                   \
+    if (cublas_status != CUBLAS_STATUS_SUCCESS)         \
+      {                                                 \
+        ostringstream tmp;                              \
+        tmp << y;                                       \
+        throw FatalExceptionHandling(tmp.str());        \
+      }                                                 \
+  };
 
 #define NEW_ALLOC
 #define MARKOVITZ
@@ -99,20 +99,18 @@ const double very_big = 1e24;
 const int alt_symbolic_count_max = 1;
 const double mem_increasing_factor = 1.1;
 
-
-
 class dynSparseMatrix : public Evaluate
 {
 public:
-  #if (defined _MSC_VER)
+#if (defined _MSC_VER)
   typedef int64_t SuiteSparse_long;
-  #endif
+#endif
   dynSparseMatrix();
   dynSparseMatrix(const int y_size_arg, const int y_kmin_arg, const int y_kmax_arg, const bool print_it_arg, const bool steady_state_arg, const int periods_arg, const int minimal_solving_periods_arg, const double slowc_arg
 #ifdef CUDA
-               ,const int CUDA_device_arg, cublasHandle_t cublas_handle_arg, cusparseHandle_t cusparse_handle_arg, cusparseMatDescr_t descr_arg
+                  , const int CUDA_device_arg, cublasHandle_t cublas_handle_arg, cusparseHandle_t cusparse_handle_arg, cusparseMatDescr_t descr_arg
 #endif
-               );
+                  );
   void Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin, int y_kmax, int Size, int periods, bool cvg, int minimal_solving_periods, int stack_solve_algo, unsigned int endo_name_length, char *P_endo_names, vector_table_conditional_local_type vector_table_conditional_local);
   void Simulate_Newton_One_Boundary(bool forward);
   void fixe_u(double **u, int u_count_int, int max_lag_plus_max_lead_plus_1);
@@ -146,17 +144,17 @@ private:
   void Solve_Matlab_LU_UMFPack(mxArray *A_m, mxArray *b_m, int Size, double slowc_l, bool is_two_boundaries, int it_);
   void Print_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, int n);
   void Printfull_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b, int n);
-
+  void PrintM(int n, double *Ax, mwIndex *Ap, mwIndex *Ai);
   void Solve_LU_UMFPack(mxArray *A_m, mxArray *b_m, int Size, double slowc_l, bool is_two_boundaries, int  it_);
   void Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b, int n, int Size, double slowc_l, bool is_two_boundaries, int  it_, vector_table_conditional_local_type vector_table_conditional_local);
   void Solve_LU_UMFPack(SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b, int n, int Size, double slowc_l, bool is_two_boundaries, int  it_);
 
   void End_Matlab_LU_UMFPack();
 #ifdef CUDA
-  void Solve_CUDA_BiCGStab_Free(double* tmp_vect_host, double* p, double* r, double* v, double* s, double* t, double* y_, double* z, double* tmp_,
-                                       int* Ai, double* Ax, int* Ap, double* x0, double* b, double* A_tild, int* A_tild_i, int* A_tild_p,
-                                       cusparseSolveAnalysisInfo_t infoL, cusparseSolveAnalysisInfo_t infoU,
-                                       cusparseMatDescr_t descrL, cusparseMatDescr_t descrU, int preconditioner);
+  void Solve_CUDA_BiCGStab_Free(double *tmp_vect_host, double *p, double *r, double *v, double *s, double *t, double *y_, double *z, double *tmp_,
+                                int *Ai, double *Ax, int *Ap, double *x0, double *b, double *A_tild, int *A_tild_i, int *A_tild_p,
+                                cusparseSolveAnalysisInfo_t infoL, cusparseSolveAnalysisInfo_t infoU,
+                                cusparseMatDescr_t descrL, cusparseMatDescr_t descrU, int preconditioner);
   int Solve_CUDA_BiCGStab(int *Ap, int *Ai, double *Ax, int *Ap_tild, int *Ai_tild, double *A_tild, double *b, double *x0, int n, int Size, double slowc_l, bool is_two_boundaries, int  it_, int nnz, int nnz_tild, int preconditioner, int max_iterations, int block);
 #endif
   void Solve_Matlab_GMRES(mxArray *A_m, mxArray *b_m, int Size, double slowc, int block, bool is_two_boundaries, int it_, mxArray *x0_m);
@@ -171,7 +169,7 @@ private:
                , long int *ndiv, long int *nsub
 #endif
                );
-  void Grad_f_product(int n, mxArray *b_m, double* vectr, mxArray *A_m, SuiteSparse_long *Ap, SuiteSparse_long *Ai, double* Ax, double *b);
+  void Grad_f_product(int n, mxArray *b_m, double *vectr, mxArray *A_m, SuiteSparse_long *Ap, SuiteSparse_long *Ai, double *Ax, double *b);
   void Insert(const int r, const int c, const int u_index, const int lag_index);
   void Delete(const int r, const int c);
   int At_Row(int r, NonZeroElem **first);
@@ -186,15 +184,15 @@ private:
   void Delete_u(int pos);
   void Clear_u();
   void Print_u();
-  void *Symbolic, *Numeric ;
+  void *Symbolic, *Numeric;
   void CheckIt(int y_size, int y_kmin, int y_kmax, int Size, int periods);
   void Check_the_Solution(int periods, int y_kmin, int y_kmax, int Size, double *u, int *pivot, int *b);
   int complete(int beg_t, int Size, int periods, int *b);
   void bksub(int tbreak, int last_period, int Size, double slowc_l
 #ifdef PROFILER
-               , long int *nmul
+             , long int *nmul
 #endif
-               );
+             );
   void simple_bksub(int it_, int Size, double slowc_l);
   mxArray *Sparse_transpose(mxArray *A_m);
   mxArray *Sparse_mult_SAT_SB(mxArray *A_m, mxArray *B_m);
@@ -254,7 +252,7 @@ protected:
   int restart;
   double g_lambda1, g_lambda2, gp_0;
   double lu_inc_tol;
-//private:
+  //private:
   SuiteSparse_long *Ap_save, *Ai_save;
   double *Ax_save, *b_save;
   mxArray *A_m_save, *b_m_save;
diff --git a/mex/sources/bytecode/bytecode.cc b/mex/sources/bytecode/bytecode.cc
index 25260c82b..80ba1b450 100644
--- a/mex/sources/bytecode/bytecode.cc
+++ b/mex/sources/bytecode/bytecode.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2013 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -22,46 +22,42 @@
 #include <ctime>
 #include <math.h>
 #ifdef DYN_MEX_FUNC_ERR_MSG_TXT
-  #undef 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;                                                                                             \
+#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
 
 using namespace std;
 # include <sstream>
 
-
-
-
 string
 Get_Argument(const char *argv)
 {
@@ -73,7 +69,6 @@ Get_Argument(const char *argv)
 
 void (*prev_fn)(int);
 
-
 string
 Get_Argument(const mxArray *prhs)
 {
@@ -90,10 +85,8 @@ Get_Argument(const mxArray *prhs)
 }
 #endif
 
-
-//#include <windows.h> 
-#include <stdio.h> 
- 
+//#include <windows.h>
+#include <stdio.h>
 
 #ifdef CUDA
 int
@@ -103,7 +96,7 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
   int device_count, device, version, version_max = 0;
   cublasStatus_t cublas_status;
   cudaError_t cuda_error;
-  *descr=0;
+  *descr = 0;
 
   /* ask cuda how many devices it can find */
   cudaGetDeviceCount(&device_count);
@@ -124,9 +117,9 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
           cuda_error = cudaGetDeviceProperties(&deviceProp, i);
           if (cuda_error != cudaSuccess)
             {
-               ostringstream tmp;
-               tmp << "  bytecode cudaGetDeviceProperties failed\n";
-               throw FatalExceptionHandling(tmp.str());
+              ostringstream tmp;
+              tmp << "  bytecode cudaGetDeviceProperties failed\n";
+              throw FatalExceptionHandling(tmp.str());
             }
           mexPrintf("> GPU device %d: \"%s\" has:\n   - %d Multi-Processors,\n   - %d threads per multiprocessor,\n", i, deviceProp.name, deviceProp.multiProcessorCount, deviceProp.maxThreadsPerMultiProcessor);
           mexEvalString("drawnow;");
@@ -136,7 +129,7 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
               device = i;
               version_max = version;
             }
-          mexPrintf("   - %4.2fMhz clock rate,\n   - %2.0fMb of memory,\n   - %d.%d compute capabilities.\n", double(deviceProp.clockRate) / (1024 * 1024), double(deviceProp.totalGlobalMem) / (1024 * 1024), deviceProp.major, deviceProp.minor);
+          mexPrintf("   - %4.2fMhz clock rate,\n   - %2.0fMb of memory,\n   - %d.%d compute capabilities.\n", double (deviceProp.clockRate) / (1024 * 1024), double (deviceProp.totalGlobalMem) / (1024 * 1024), deviceProp.major, deviceProp.minor);
           mexEvalString("drawnow;");
         }
     }
@@ -146,17 +139,17 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
   cuda_error = cudaSetDevice(device);
   if (cuda_error != cudaSuccess)
     {
-       ostringstream tmp;
-       tmp << "  bytecode cudaSetDevice failed\n";
-       throw FatalExceptionHandling(tmp.str());
+      ostringstream tmp;
+      tmp << "  bytecode cudaSetDevice failed\n";
+      throw FatalExceptionHandling(tmp.str());
     }
 
-  if(version_max < 0x11)
+  if (version_max < 0x11)
     {
-       ostringstream tmp;
-       tmp << "  bytecode requires a minimum CUDA compute 1.1 capability\n";
-       cudaDeviceReset();
-       throw FatalExceptionHandling(tmp.str());
+      ostringstream tmp;
+      tmp << "  bytecode requires a minimum CUDA compute 1.1 capability\n";
+      cudaDeviceReset();
+      throw FatalExceptionHandling(tmp.str());
     }
 
   // Initialize CuBlas library
@@ -164,16 +157,16 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
   if (cublas_status != CUBLAS_STATUS_SUCCESS)
     {
       ostringstream tmp;
-      switch(cublas_status)
+      switch (cublas_status)
         {
-          case CUBLAS_STATUS_NOT_INITIALIZED:
-            tmp << " the CUBLAS initialization failed.\n";
-            break;
-          case CUBLAS_STATUS_ALLOC_FAILED:
-            tmp << " the resources could not be allocated.\n";
-            break;
-          default:
-            tmp << " unknown error during the initialization of cusparse library.\n";
+        case CUBLAS_STATUS_NOT_INITIALIZED:
+          tmp << " the CUBLAS initialization failed.\n";
+          break;
+        case CUBLAS_STATUS_ALLOC_FAILED:
+          tmp << " the resources could not be allocated.\n";
+          break;
+        default:
+          tmp << " unknown error during the initialization of cusparse library.\n";
         }
       throw FatalExceptionHandling(tmp.str());
     }
@@ -184,19 +177,19 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
   if (cusparse_status != CUSPARSE_STATUS_SUCCESS)
     {
       ostringstream tmp;
-      switch(cusparse_status)
+      switch (cusparse_status)
         {
-          case CUSPARSE_STATUS_NOT_INITIALIZED:
-            tmp << " the CUDA Runtime initialization failed.\n";
-            break;
-          case CUSPARSE_STATUS_ALLOC_FAILED:
-            tmp <<  " the resources could not be allocated.\n";
-            break;
-          case CUSPARSE_STATUS_ARCH_MISMATCH:
-            tmp <<  " the device compute capability (CC) is less than 1.1. The CC of at least 1.1 is required.\n";
-            break;
-          default:
-            tmp << " unknown error during the initialization of cusparse library.\n";
+        case CUSPARSE_STATUS_NOT_INITIALIZED:
+          tmp << " the CUDA Runtime initialization failed.\n";
+          break;
+        case CUSPARSE_STATUS_ALLOC_FAILED:
+          tmp <<  " the resources could not be allocated.\n";
+          break;
+        case CUSPARSE_STATUS_ARCH_MISMATCH:
+          tmp <<  " the device compute capability (CC) is less than 1.1. The CC of at least 1.1 is required.\n";
+          break;
+        default:
+          tmp << " unknown error during the initialization of cusparse library.\n";
         }
       throw FatalExceptionHandling(tmp.str());
     }
@@ -221,7 +214,7 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
       tmp << " cudaGetVersion has failed\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  mexPrintf("   - CUDA version %5.3f\n", double(cuda_version) / 1000);
+  mexPrintf("   - CUDA version %5.3f\n", double (cuda_version) / 1000);
   int cublas_version;
   cublas_status = cublasGetVersion(*cublas_handle, &cublas_version);
   if (cublas_status != CUBLAS_STATUS_SUCCESS)
@@ -230,7 +223,7 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
       tmp << " cublasGetVersion has failed\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  mexPrintf("   - CUBLAS version %5.3f\n", double(cublas_version) / 1000);
+  mexPrintf("   - CUBLAS version %5.3f\n", double (cublas_version) / 1000);
   int cusparse_version;
   cusparse_status = cusparseGetVersion(*cusparse_handle, &cusparse_version);
   if (cusparse_status != CUSPARSE_STATUS_SUCCESS)
@@ -239,7 +232,7 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
       tmp << " cusparseGetVersion has failed\n";
       throw FatalExceptionHandling(tmp.str());
     }
-  mexPrintf("   - CUSPARSE version %5.3f\n", double(cusparse_version) / 1000);
+  mexPrintf("   - CUSPARSE version %5.3f\n", double (cusparse_version) / 1000);
   mexPrintf("-----------------------------------------\n");
   return device;
 }
@@ -247,16 +240,16 @@ GPU_Test_and_Info(cublasHandle_t *cublas_handle, cusparseHandle_t *cusparse_hand
 void
 GPU_close(cublasHandle_t cublas_handle, cusparseHandle_t cusparse_handle, cusparseMatDescr_t descr)
 {
-  cublasChk(cublasDestroy(cublas_handle),"in bytecode cublasDestroy failed\n");
+  cublasChk(cublasDestroy(cublas_handle), "in bytecode cublasDestroy failed\n");
   cusparseChk(cusparseDestroyMatDescr(descr), "in bytecode cusparseDestroyMatDescr failed\n");
-  cusparseChk(cusparseDestroy(cusparse_handle),"in bytecode cusparseDestroy failed\n");
+  cusparseChk(cusparseDestroy(cusparse_handle), "in bytecode cusparseDestroy failed\n");
 }
 
 #endif
 string
 deblank(string x)
 {
-  for(int i = 0; i < (int) x.length(); i++)
+  for (int i = 0; i < (int) x.length(); i++)
     if (x[i] == ' ')
       x.erase(i--, 1);
   return x;
@@ -317,7 +310,7 @@ Get_Arguments_and_global_variables(int nrhs,
                 steady_col_y = mxGetN(prhs[i]);
                 break;
               case 4:
-                periods = int(mxGetScalar(prhs[i]));
+                periods = int (mxGetScalar(prhs[i]));
                 break;
               case 5:
                 *block_structur = mxDuplicateArray(prhs[i]);
@@ -327,7 +320,7 @@ Get_Arguments_and_global_variables(int nrhs,
                 *GlobalTemporaryTerms = mxDuplicateArray(prhs[i]);
                 break;
               default:
-                mexPrintf("Unknown argument count_array_argument=%d\n",count_array_argument);
+                mexPrintf("Unknown argument count_array_argument=%d\n", count_array_argument);
                 break;
               }
             count_array_argument++;
@@ -358,7 +351,7 @@ Get_Arguments_and_global_variables(int nrhs,
                     pos += 5;
                   block =  atoi(Get_Argument(prhs[i]).substr(pos, string::npos).c_str())-1;
                 }
-              else if (Get_Argument(prhs[i]).substr(0,13) == "extended_path")
+              else if (Get_Argument(prhs[i]).substr(0, 13) == "extended_path")
                 {
                   *extended_path = true;
                   if ((i+1) >= nrhs)
@@ -430,7 +423,6 @@ Get_Arguments_and_global_variables(int nrhs,
     }
 }
 
-
 #ifdef DEBUG_EX
 int
 main(int nrhs, const char *prhs[])
@@ -450,6 +442,7 @@ main(int nrhs, const char *prhs[])
   load_global((char *) prhs[1]);
 #endif
   mxArray *pfplan_struct = NULL;
+  ErrorMsg error_msg;
   size_t i, row_y = 0, col_y = 0, row_x = 0, col_x = 0, nb_row_xd = 0;
   size_t steady_row_y, steady_col_y;
   int y_kmin = 0, y_kmax = 0, y_decal = 0;
@@ -466,7 +459,7 @@ main(int nrhs, const char *prhs[])
   double *steady_yd = NULL, *steady_xd = NULL;
   string plan, pfplan;
   bool extended_path;
-  mxArray* extended_path_struct;
+  mxArray *extended_path_struct;
 
   table_conditional_local_type conditional_local;
   vector<s_plan> splan, spfplan, sextended_path, sconditional_extended_path;
@@ -519,76 +512,76 @@ main(int nrhs, const char *prhs[])
           string tmp = "The 'extended_path' option must be followed by the extended_path descriptor";
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* date_str = mxGetField(extended_path_struct, 0, "date_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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
       int nb_periods = mxGetM(date_str) * mxGetN(date_str);
-      
-      mxArray* constrained_vars_ = mxGetField(extended_path_struct, 0, "constrained_vars_");
+
+      mxArray *constrained_vars_ = mxGetField(extended_path_struct, 0, "constrained_vars_");
       if (constrained_vars_ == NULL)
         {
           string tmp = "constrained_vars_";
-          tmp.insert(0,"The extended_path description structure does not contain the member: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* constrained_paths_ = mxGetField(extended_path_struct, 0, "constrained_paths_");
+      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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* constrained_int_date_ = mxGetField(extended_path_struct, 0, "constrained_int_date_");
+      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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* constrained_perfect_foresight_ = mxGetField(extended_path_struct, 0, "constrained_perfect_foresight_");
+      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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      
-      mxArray* shock_var_ = mxGetField(extended_path_struct, 0, "shock_vars_");
+
+      mxArray *shock_var_ = mxGetField(extended_path_struct, 0, "shock_vars_");
       if (shock_var_ == NULL)
         {
           string tmp = "shock_vars_";
-          tmp.insert(0,"The extended_path description structure does not contain the member: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* shock_paths_ = mxGetField(extended_path_struct, 0, "shock_paths_");
+      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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* shock_int_date_ = mxGetField(extended_path_struct, 0, "shock_int_date_");
+      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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
-      mxArray* shock_str_date_ = mxGetField(extended_path_struct, 0, "shock_str_date_");
+      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: ");
+          tmp.insert(0, "The extended_path description structure does not contain the member: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
       int nb_constrained = mxGetM(constrained_vars_) * mxGetN(constrained_vars_);
       int nb_controlled = 0;
-      mxArray* options_cond_fcst_ = mxGetField(extended_path_struct, 0, "options_cond_fcst_");
-      mxArray* controlled_varexo = NULL;
+      mxArray *options_cond_fcst_ = mxGetField(extended_path_struct, 0, "options_cond_fcst_");
+      mxArray *controlled_varexo = NULL;
       if (options_cond_fcst_  != NULL)
         {
           controlled_varexo = mxGetField(options_cond_fcst_, 0, "controlled_varexo");
@@ -598,13 +591,13 @@ main(int nrhs, const char *prhs[])
               DYN_MEX_FUNC_ERR_MSG_TXT("The number of exogenized variables and the number of exogenous controlled variables should be equal.");
             }
         }
-      double * controlled_varexo_value = NULL;
+      double *controlled_varexo_value = NULL;
       if (controlled_varexo != NULL)
         controlled_varexo_value = mxGetPr(controlled_varexo);
-      double * constrained_var_value = mxGetPr(constrained_vars_);
+      double *constrained_var_value = mxGetPr(constrained_vars_);
       sconditional_extended_path.resize(nb_constrained);
       max_periods = 0;
-      if ( nb_constrained)
+      if (nb_constrained)
         {
           conditional_local.is_cond = false;
           conditional_local.var_exo = 0;
@@ -621,28 +614,29 @@ main(int nrhs, const char *prhs[])
               table_conditional_global[i] = vector_conditional_local;
             }
         }
-      
+
       vector_table_conditional_local_type vv3 = table_conditional_global[0];
       for (int i = 0; i < nb_constrained; i++)
         {
           sconditional_extended_path[i].exo_num = ceil(constrained_var_value[i]);
           sconditional_extended_path[i].var_num = ceil(controlled_varexo_value[i]);
-          mxArray* Array_constrained_paths_ = mxGetCell(constrained_paths_, i);
+          mxArray *Array_constrained_paths_ = mxGetCell(constrained_paths_, i);
           double *specific_constrained_paths_ = mxGetPr(Array_constrained_paths_);
           double *specific_constrained_int_date_ = mxGetPr(mxGetCell(constrained_int_date_, i));
           int nb_local_periods = mxGetM(Array_constrained_paths_) * mxGetN(Array_constrained_paths_);
-          int* constrained_int_date = (int*)mxMalloc(nb_local_periods * sizeof(int));
+          int *constrained_int_date = (int *) mxMalloc(nb_local_periods * sizeof(int));
+          error_msg.test_mxMalloc(constrained_int_date, __LINE__, __FILE__, __func__, nb_local_periods * sizeof(int));
           if (nb_periods < nb_local_periods)
             {
               ostringstream oss;
               oss << nb_periods;
               string tmp = oss.str();
-              tmp.insert(0,"The total number of simulation periods (");
+              tmp.insert(0, "The total number of simulation periods (");
               tmp.append(") is lesser than the number of periods in the shock definitions (");
               oss << nb_local_periods;
               string tmp1 = oss.str();
               tmp.append(tmp1);
-              tmp.append(")");  
+              tmp.append(")");
               DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
             }
           (sconditional_extended_path[i]).per_value.resize(nb_local_periods);
@@ -651,7 +645,7 @@ main(int nrhs, const char *prhs[])
             sconditional_extended_path[i].value[j] = 0;
           for (int j = 0; j < nb_local_periods; j++)
             {
-              constrained_int_date[j] = int(specific_constrained_int_date_[j]) - 1;
+              constrained_int_date[j] = int (specific_constrained_int_date_[j]) - 1;
               conditional_local.is_cond = true;
               conditional_local.var_exo = sconditional_extended_path[i].var_num - 1;
               conditional_local.var_endo = sconditional_extended_path[i].exo_num - 1;
@@ -660,18 +654,18 @@ main(int nrhs, const char *prhs[])
               sconditional_extended_path[i].per_value[j] = make_pair(constrained_int_date[j], specific_constrained_paths_[j]);
               sconditional_extended_path[i].value[constrained_int_date[j]] = specific_constrained_paths_[j];
               if (max_periods < constrained_int_date[j] + 1)
-                  max_periods = constrained_int_date[j] + 1;
+                max_periods = constrained_int_date[j] + 1;
             }
           mxFree(constrained_int_date);
         }
       vector_table_conditional_local_type vv = table_conditional_global[0];
-      double * shock_var_value = mxGetPr(shock_var_);
+      double *shock_var_value = mxGetPr(shock_var_);
       int nb_shocks = mxGetM(shock_var_) * mxGetN(shock_var_);
       sextended_path.resize(nb_shocks);
       for (int i = 0; i < nb_shocks; i++)
         {
           sextended_path[i].exo_num = ceil(shock_var_value[i]);
-          mxArray* Array_shock_paths_ = mxGetCell(shock_paths_, i);
+          mxArray *Array_shock_paths_ = mxGetCell(shock_paths_, i);
           double *specific_shock_paths_ = mxGetPr(Array_shock_paths_);
           double *specific_shock_int_date_ = mxGetPr(mxGetCell(shock_int_date_, i));
           int nb_local_periods = mxGetM(Array_shock_paths_) * mxGetN(Array_shock_paths_);
@@ -680,12 +674,12 @@ main(int nrhs, const char *prhs[])
               ostringstream oss;
               oss << nb_periods;
               string tmp = oss.str();
-              tmp.insert(0,"The total number of simulation periods (");
+              tmp.insert(0, "The total number of simulation periods (");
               tmp.append(") is lesser than the number of periods in the shock definitions (");
               oss << nb_local_periods;
               string tmp1 = oss.str();
               tmp.append(tmp1);
-              tmp.append(")");  
+              tmp.append(")");
               DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
             }
           (sextended_path[i]).per_value.resize(nb_local_periods);
@@ -694,16 +688,16 @@ main(int nrhs, const char *prhs[])
             sextended_path[i].value[j] = 0;
           for (int j = 0; j < nb_local_periods; j++)
             {
-              sextended_path[i].per_value[j] = make_pair(int(specific_shock_int_date_[j]), specific_shock_paths_[j]);
-              sextended_path[i].value[int(specific_shock_int_date_[j]-1)] = specific_shock_paths_[j];
-              if (max_periods < int(specific_shock_int_date_[j]) )
-                  max_periods = int(specific_shock_int_date_[j]);
+              sextended_path[i].per_value[j] = make_pair(int (specific_shock_int_date_[j]), specific_shock_paths_[j]);
+              sextended_path[i].value[int (specific_shock_int_date_[j]-1)] = specific_shock_paths_[j];
+              if (max_periods < int (specific_shock_int_date_[j]))
+                max_periods = int (specific_shock_int_date_[j]);
             }
         }
-      for (int i=0; i < nb_periods; i++)
+      for (int i = 0; i < nb_periods; i++)
         {
           int buflen = mxGetNumberOfElements(mxGetCell(date_str, i)) + 1;
-          char* buf = (char*)mxCalloc(buflen, sizeof(char));
+          char *buf = (char *) mxCalloc(buflen, sizeof(char));
           int info = mxGetString(mxGetCell(date_str, i), buf, buflen);
           if (info)
             {
@@ -714,13 +708,13 @@ main(int nrhs, const char *prhs[])
           mxFree(buf);
         }
     }
-  if (plan.length()>0)
+  if (plan.length() > 0)
     {
-      mxArray* plan_struct = mexGetVariable("base", plan.c_str());
+      mxArray *plan_struct = mexGetVariable("base", plan.c_str());
       if (plan_struct == NULL)
         {
           string tmp = plan;
-          tmp.insert(0,"Can't find the plan: ");
+          tmp.insert(0, "Can't find the plan: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
       size_t n_plan = mxGetN(plan_struct);
@@ -729,7 +723,7 @@ main(int nrhs, const char *prhs[])
         {
           splan[i].var = "";
           splan[i].exo = "";
-          mxArray* tmp = mxGetField(plan_struct, i, "exo");
+          mxArray *tmp = mxGetField(plan_struct, i, "exo");
           if (tmp)
             {
               char name [100];
@@ -742,7 +736,7 @@ main(int nrhs, const char *prhs[])
               else
                 {
                   string tmp = name;
-                  tmp.insert(0,"the variable '");
+                  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());
                 }
@@ -760,7 +754,7 @@ main(int nrhs, const char *prhs[])
               else
                 {
                   string tmp = name;
-                  tmp.insert(0,"the variable '");
+                  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());
                 }
@@ -770,7 +764,7 @@ main(int nrhs, const char *prhs[])
             {
               size_t num_shocks = mxGetM(tmp);
               (splan[i]).per_value.resize(num_shocks);
-              double * per_value = mxGetPr(tmp);
+              double *per_value = mxGetPr(tmp);
               for (int j = 0; j < (int) num_shocks; j++)
                 (splan[i]).per_value[j] = make_pair(ceil(per_value[j]), per_value[j + num_shocks]);
             }
@@ -786,19 +780,19 @@ main(int nrhs, const char *prhs[])
             mexPrintf(" plan shocks on var=%s for the following periods and with the following values:\n", it->var.c_str());
           for (vector<pair<int, double> >::iterator it1 = it->per_value.begin(); it1 != it->per_value.end(); it1++)
             {
-              mexPrintf("  %3d %10.5f\n",it1->first, it1->second);
+              mexPrintf("  %3d %10.5f\n", it1->first, it1->second);
             }
           i++;
         }
     }
 
-  if (pfplan.length()>0)
+  if (pfplan.length() > 0)
     {
       pfplan_struct = mexGetVariable("base", pfplan.c_str());
       if (!pfplan_struct)
         {
           string tmp = pfplan;
-          tmp.insert(0,"Can't find the pfplan: ");
+          tmp.insert(0, "Can't find the pfplan: ");
           DYN_MEX_FUNC_ERR_MSG_TXT(tmp.c_str());
         }
       size_t n_plan = mxGetN(pfplan_struct);
@@ -807,7 +801,7 @@ main(int nrhs, const char *prhs[])
         {
           spfplan[i].var = "";
           spfplan[i].exo = "";
-          mxArray* tmp = mxGetField(pfplan_struct, i, "var");
+          mxArray *tmp = mxGetField(pfplan_struct, i, "var");
           if (tmp)
             {
               char name [100];
@@ -820,7 +814,7 @@ main(int nrhs, const char *prhs[])
               else
                 {
                   string tmp = name;
-                  tmp.insert(0,"the variable '");
+                  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());
                 }
@@ -838,7 +832,7 @@ main(int nrhs, const char *prhs[])
               else
                 {
                   string tmp = name;
-                  tmp.insert(0,"the variable '");
+                  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());
                 }
@@ -847,7 +841,7 @@ main(int nrhs, const char *prhs[])
           if (tmp)
             {
               size_t num_shocks = mxGetM(tmp);
-              double * per_value = mxGetPr(tmp);
+              double *per_value = mxGetPr(tmp);
               (spfplan[i]).per_value.resize(num_shocks);
               for (int j = 0; j < (int) num_shocks; j++)
                 spfplan[i].per_value[j] = make_pair(ceil(per_value[j]), per_value[j+ num_shocks]);
@@ -864,14 +858,12 @@ main(int nrhs, const char *prhs[])
             mexPrintf(" plan shocks on var=%s (%d) for the following periods and with the following values:\n", it->var.c_str(), it->var_num);
           for (vector<pair<int, double> >::iterator it1 = it->per_value.begin(); it1 != it->per_value.end(); it1++)
             {
-              mexPrintf("  %3d %10.5f\n",it1->first, it1->second);
+              mexPrintf("  %3d %10.5f\n", it1->first, it1->second);
             }
           i++;
         }
     }
 
-
-
   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_");
@@ -891,11 +883,11 @@ main(int nrhs, const char *prhs[])
 
       if (!count_array_argument)
         {
-          mxArray* endo_sim_arr = mxGetFieldByNumber(oo_, 0, field_endo_simul);
+          mxArray *endo_sim_arr = mxGetFieldByNumber(oo_, 0, field_endo_simul);
           yd = mxGetPr(endo_sim_arr);
           row_y = mxGetM(endo_sim_arr);
           col_y = mxGetN(endo_sim_arr);
-          mxArray* exo_sim_arr = mxGetFieldByNumber(oo_, 0, field_exo_simul);
+          mxArray *exo_sim_arr = mxGetFieldByNumber(oo_, 0, field_exo_simul);
           xd = mxGetPr(exo_sim_arr);
           row_x = mxGetM(exo_sim_arr);
           col_x = mxGetN(exo_sim_arr);
@@ -926,9 +918,9 @@ main(int nrhs, const char *prhs[])
             DYN_MEX_FUNC_ERR_MSG_TXT("options_ is not a field of options_");
         }
 
-      if (!steady_yd )
+      if (!steady_yd)
         {
-          mxArray* steady_state_arr = mxGetFieldByNumber(oo_, 0, field_steady_state);
+          mxArray *steady_state_arr = mxGetFieldByNumber(oo_, 0, field_steady_state);
           steady_yd = mxGetPr(steady_state_arr);
           steady_row_y = mxGetM(steady_state_arr);
           steady_col_y = mxGetN(steady_state_arr);
@@ -939,12 +931,12 @@ main(int nrhs, const char *prhs[])
     {
       if (!count_array_argument)
         {
-          mxArray* steady_state_arr = mxGetFieldByNumber(oo_, 0, field_steady_state);
+          mxArray *steady_state_arr = mxGetFieldByNumber(oo_, 0, field_steady_state);
           yd = mxGetPr(steady_state_arr);
           row_y = mxGetM(steady_state_arr);
           col_y = mxGetN(steady_state_arr);
 
-          mxArray* exo_steady_state_arr = mxGetFieldByNumber(oo_, 0, field_exo_steady_state);
+          mxArray *exo_steady_state_arr = mxGetFieldByNumber(oo_, 0, field_exo_steady_state);
           xd = mxGetPr(exo_steady_state_arr);
           row_x = mxGetM(exo_steady_state_arr);
           col_x = mxGetN(exo_steady_state_arr);
@@ -954,7 +946,7 @@ main(int nrhs, const char *prhs[])
   int field = mxGetFieldNumber(options_, "verbosity");
   int verbose = 0;
   if (field >= 0)
-    verbose = int(*mxGetPr((mxGetFieldByNumber(options_, 0, field))));
+    verbose = int (*mxGetPr((mxGetFieldByNumber(options_, 0, field))));
   else
     DYN_MEX_FUNC_ERR_MSG_TXT("verbosity is not a field of options_");
   if (verbose)
@@ -974,7 +966,7 @@ main(int nrhs, const char *prhs[])
         DYN_MEX_FUNC_ERR_MSG_TXT("steady is not a field of options_");
     }
   field = mxGetFieldNumber(temporaryfield, "maxit");
-  if (field<0)
+  if (field < 0)
     {
       if (!steady_state)
         DYN_MEX_FUNC_ERR_MSG_TXT("maxit is not a field of options_.simul");
@@ -1025,7 +1017,7 @@ main(int nrhs, const char *prhs[])
         DYN_MEX_FUNC_ERR_MSG_TXT("dynatol is not a field of options_");
       field = mxGetFieldNumber(dynatol, "f");
       if (field >= 0)
-        solve_tolf= *mxGetPr((mxGetFieldByNumber(dynatol, 0, field)));
+        solve_tolf = *mxGetPr((mxGetFieldByNumber(dynatol, 0, field)));
       else
         DYN_MEX_FUNC_ERR_MSG_TXT("f is not a field of options_.dynatol");
     }
@@ -1038,7 +1030,7 @@ main(int nrhs, const char *prhs[])
   size_t buflen = mxGetM(mxa) * mxGetN(mxa) + 1;
   char *fname;
   fname = (char *) mxCalloc(buflen+1, sizeof(char));
-  size_t status = mxGetString(mxa, fname, int(buflen));
+  size_t status = mxGetString(mxa, fname, int (buflen));
   fname[buflen] = ' ';
   if (status != 0)
     mexWarnMsgTxt("Not enough space. Filename is truncated.");
@@ -1058,13 +1050,17 @@ main(int nrhs, const char *prhs[])
   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");
 #endif
-
   size_t size_of_direction = col_y*row_y*sizeof(double);
   double *y = (double *) mxMalloc(size_of_direction);
+  error_msg.test_mxMalloc(y, __LINE__, __FILE__, __func__, size_of_direction);
   double *ya = (double *) mxMalloc(size_of_direction);
+  error_msg.test_mxMalloc(ya, __LINE__, __FILE__, __func__, size_of_direction);
   direction = (double *) mxMalloc(size_of_direction);
+  error_msg.test_mxMalloc(direction, __LINE__, __FILE__, __func__, size_of_direction);
   memset(direction, 0, size_of_direction);
+  /*mexPrintf("col_x : %d, row_x : %d\n",col_x, row_x);*/
   double *x = (double *) mxMalloc(col_x*row_x*sizeof(double));
+  error_msg.test_mxMalloc(x, __LINE__, __FILE__, __func__, col_x*row_x*sizeof(double));
   for (i = 0; i < row_x*col_x; i++)
     {
       x[i] = double (xd[i]);
@@ -1076,10 +1072,11 @@ main(int nrhs, const char *prhs[])
     }
   size_t y_size = row_y;
   size_t nb_row_x = row_x;
+
   clock_t t0 = clock();
   Interpreter interprete(params, y, ya, x, steady_yd, steady_xd, direction, y_size, nb_row_x, nb_row_xd, periods, y_kmin, y_kmax, maxit_, solve_tolf, size_of_direction, slowc, y_decal,
                          markowitz_c, file_name, minimal_solving_periods, stack_solve_algo, solve_algo, global_temporary_terms, print, print_error, GlobalTemporaryTerms, steady_state,
-                         print_it, col_x
+                         print_it, col_x, col_y
 #ifdef CUDA
                          , CUDA_device, cublas_handle, cusparse_handle, descr
 #endif
@@ -1089,27 +1086,28 @@ main(int nrhs, const char *prhs[])
   int nb_blocks = 0;
   double *pind;
   bool no_error = true;
+
   if (extended_path)
     {
-        try
-          {
-            interprete.extended_path(f, f, evaluate, block, nb_blocks, max_periods, sextended_path, sconditional_extended_path, dates, table_conditional_global);
-          }
-        catch (GeneralExceptionHandling &feh)
-          {
-            DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
-          }
+      try
+        {
+          interprete.extended_path(f, f, evaluate, block, nb_blocks, max_periods, sextended_path, sconditional_extended_path, dates, table_conditional_global);
+        }
+      catch (GeneralExceptionHandling &feh)
+        {
+          DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
+        }
     }
   else
     {
-        try
-          {
-            interprete.compute_blocks(f, f, evaluate, block, nb_blocks);
-          }
-        catch (GeneralExceptionHandling &feh)
-          {
-            DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
-          }
+      try
+        {
+          interprete.compute_blocks(f, f, evaluate, block, nb_blocks);
+        }
+      catch (GeneralExceptionHandling &feh)
+        {
+          DYN_MEX_FUNC_ERR_MSG_TXT(feh.GetErrorMsg().c_str());
+        }
     }
 
 #ifdef CUDA
@@ -1137,22 +1135,32 @@ main(int nrhs, const char *prhs[])
               if (evaluate)
                 {
                   vector<double> residual = interprete.get_residual();
-                  plhs[1] = mxCreateDoubleMatrix(int(residual.size()/double(col_y)), int(col_y), mxREAL);
+                  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
                 {
-                  plhs[1] = mxCreateDoubleMatrix(int(row_y), int(col_y), mxREAL);
+                  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 < row_y*col_y; i++)
+                  for (i = 0; i < out_periods*col_y; i++)
                     pind[i] = y[i];
                 }
             }
           else
             {
-              plhs[1] = mxCreateDoubleMatrix(int(row_y), int(col_y), mxREAL);
+              int out_periods;
+              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)
                 {
@@ -1161,7 +1169,7 @@ main(int nrhs, const char *prhs[])
                     pind[i] = residual[i];
                 }
               else
-                for (i = 0; i < row_y*col_y; i++)
+                for (i = 0; i < row_y*out_periods; i++)
                   pind[i] = y[i];
             }
           if (nlhs > 2)
@@ -1176,7 +1184,7 @@ main(int nrhs, const char *prhs[])
                       jacob_exo_field_number = 1;
                       jacob_exo_det_field_number = 2;
                       jacob_other_endo_field_number = 3;
-                      mwSize dims[1] = {(mwSize)nb_blocks };
+                      mwSize dims[1] = {(mwSize) nb_blocks };
                       plhs[2] = mxCreateStructArray(1, dims, 4, field_names);
                     }
                   else if (!mxIsStruct(block_structur))
@@ -1217,14 +1225,17 @@ main(int nrhs, const char *prhs[])
                 }
               else
                 {
-                  plhs[2] = mxCreateDoubleMatrix(int(row_x), int(col_x), mxREAL);
+                  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];
+                    {
+                      pind[i] = x[i];
+                    }
+
                 }
               if (nlhs > 3)
                 {
-                  plhs[3] = mxCreateDoubleMatrix(int(row_y), int(col_y), mxREAL);
+                  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];
@@ -1232,7 +1243,7 @@ main(int nrhs, const char *prhs[])
                     {
                       mxArray *GlobalTemporaryTerms = interprete.get_Temporary_Terms();
                       size_t nb_temp_terms = mxGetM(GlobalTemporaryTerms);
-                      plhs[4] = mxCreateDoubleMatrix(int(nb_temp_terms), 1, mxREAL);
+                      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++)
diff --git a/mex/sources/bytecode/testing/mex_interface.hh b/mex/sources/bytecode/testing/mex_interface.hh
index 9ae11800e..aaee45edf 100644
--- a/mex/sources/bytecode/testing/mex_interface.hh
+++ b/mex/sources/bytecode/testing/mex_interface.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2011 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -142,7 +142,7 @@ mxCreateStructArray(unsigned int rows, mwSize *cols, int nfields, const string &
   return mxCreateStructMatrix(rows, *cols, nfields, fieldnames);
 };
 mxArray *mxCreatNULLMatrix();
-void mexCallMATLAB(unsigned int n_lhs, mxArray* lhs[], unsigned int n_rhs, mxArray* rhs[], const char *function);
+void mexCallMATLAB(unsigned int n_lhs, mxArray *lhs[], unsigned int n_rhs, mxArray *rhs[], const char *function);
 void mxDestroyArray(mxArray *A_m);
 mxArray *read_struct(FILE *fid);
 mxArray *read_Array(FILE *fid);
diff --git a/mex/sources/dynumfpack.h b/mex/sources/dynumfpack.h
index 60182c471..1eb5511d3 100644
--- a/mex/sources/dynumfpack.h
+++ b/mex/sources/dynumfpack.h
@@ -3,7 +3,7 @@
  */
 
 /*
- * Copyright (C) 2013 Dynare Team
+ * Copyright (C) 2013-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -28,60 +28,60 @@
 extern "C" {
 #endif
 
-/* -------------------------------------------------------------------------- */
-/* size of Info and Control arrays */
-/* -------------------------------------------------------------------------- */
+  /* -------------------------------------------------------------------------- */
+  /* size of Info and Control arrays */
+  /* -------------------------------------------------------------------------- */
 
-/* These might be larger in future versions, since there are only 3 unused
- * entries in Info, and no unused entries in Control. */
+  /* These might be larger in future versions, since there are only 3 unused
+   * entries in Info, and no unused entries in Control. */
 
 #define UMFPACK_INFO 90
 #define UMFPACK_CONTROL 20
-/* used in all UMFPACK_report_* routines: */
-#define UMFPACK_PRL 0			/* print level */
-/* returned by all routines that use Info: */
+  /* used in all UMFPACK_report_* routines: */
+#define UMFPACK_PRL 0                   /* print level */
+  /* returned by all routines that use Info: */
 #define UMFPACK_OK (0)
-#define UMFPACK_STATUS 0	/* UMFPACK_OK, or other result */
+#define UMFPACK_STATUS 0        /* UMFPACK_OK, or other result */
 
 #ifdef _WIN64
-typedef long long int SuiteSparse_long;
+  typedef long long int SuiteSparse_long;
 #else
-typedef long SuiteSparse_long;
+  typedef long SuiteSparse_long;
 #endif
 
-void umfpack_dl_defaults(double Control[UMFPACK_CONTROL]);
+  void umfpack_dl_defaults(double Control[UMFPACK_CONTROL]);
 
-SuiteSparse_long umfpack_dl_symbolic(SuiteSparse_long n_row, SuiteSparse_long n_col,
-                                     const SuiteSparse_long Ap [ ], const SuiteSparse_long Ai [ ],
-                                     const double Ax [ ], void **Symbolic,
-                                     const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO]);
+  SuiteSparse_long umfpack_dl_symbolic(SuiteSparse_long n_row, SuiteSparse_long n_col,
+                                       const SuiteSparse_long Ap [], const SuiteSparse_long Ai [],
+                                       const double Ax [], void **Symbolic,
+                                       const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO]);
 
-SuiteSparse_long umfpack_dl_numeric(const SuiteSparse_long Ap [ ], const SuiteSparse_long Ai [ ],
-                                    const double Ax [ ], void *Symbolic, void **Numeric,
+  SuiteSparse_long umfpack_dl_numeric(const SuiteSparse_long Ap [], const SuiteSparse_long Ai [],
+                                      const double Ax [], void *Symbolic, void **Numeric,
+                                      const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO]);
+
+  SuiteSparse_long umfpack_dl_solve(SuiteSparse_long sys, const SuiteSparse_long Ap [],
+                                    const SuiteSparse_long Ai [], const double Ax [],
+                                    double X [], const double B [], void *Numeric,
                                     const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO]);
 
-SuiteSparse_long umfpack_dl_solve(SuiteSparse_long sys, const SuiteSparse_long Ap [ ],
-                                  const SuiteSparse_long Ai [ ], const double Ax [ ],
-                                  double X [ ], const double B [ ], void *Numeric,
-                                  const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO]);
+  void umfpack_dl_report_info(const double Control [UMFPACK_CONTROL],
+                              const double Info [UMFPACK_INFO]);
 
-void umfpack_dl_report_info(const double Control [UMFPACK_CONTROL],
-                            const double Info [UMFPACK_INFO]);
+  void umfpack_dl_report_status(const double Control [UMFPACK_CONTROL],
+                                SuiteSparse_long status);
 
-void umfpack_dl_report_status(const double Control [UMFPACK_CONTROL],
-                              SuiteSparse_long status);
+  void umfpack_dl_free_symbolic(void **Symbolic);
 
-void umfpack_dl_free_symbolic(void **Symbolic);
+  void umfpack_dl_free_numeric(void **Numeric);
 
-void umfpack_dl_free_numeric(void **Numeric);
+  SuiteSparse_long umfpack_dl_load_symbolic(void **Symbolic, char *filename);
 
-SuiteSparse_long umfpack_dl_load_symbolic (void **Symbolic, char *filename) ;
+  SuiteSparse_long umfpack_dl_load_numeric(void **Numeric, char *filename);
 
-SuiteSparse_long umfpack_dl_load_numeric (void **Numeric, char *filename) ;
+  SuiteSparse_long umfpack_dl_save_symbolic(void *Symbolic, char *filename);
 
-SuiteSparse_long umfpack_dl_save_symbolic (void *Symbolic, char *filename) ;
-
-SuiteSparse_long umfpack_dl_save_numeric (void *Numeric, char *filename) ;
+  SuiteSparse_long umfpack_dl_save_numeric(void *Numeric, char *filename);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/mex/sources/estimation/DecisionRules.cc b/mex/sources/estimation/DecisionRules.cc
index 48f5c236c..41c095925 100644
--- a/mex/sources/estimation/DecisionRules.cc
+++ b/mex/sources/estimation/DecisionRules.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -213,4 +213,3 @@ operator<<(std::ostream &out, const DecisionRules::BlanchardKahnException &e)
     out << "The Blanchard Kahn rank condition is not satisfied";
   return out;
 }
-
diff --git a/mex/sources/estimation/DecisionRules.hh b/mex/sources/estimation/DecisionRules.hh
index 22e30bdf1..65b965aea 100644
--- a/mex/sources/estimation/DecisionRules.hh
+++ b/mex/sources/estimation/DecisionRules.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -49,7 +49,9 @@ public:
     //! True if the model fails the order condition. False if it fails the rank condition.
     const bool order;
     const int n_fwrd_vars, n_explosive_eigenvals;
-    BlanchardKahnException(bool order_arg, int n_fwrd_vars_arg, int n_explosive_eigenvals_arg) : order(order_arg), n_fwrd_vars(n_fwrd_vars_arg), n_explosive_eigenvals(n_explosive_eigenvals_arg) {};
+    BlanchardKahnException(bool order_arg, int n_fwrd_vars_arg, int n_explosive_eigenvals_arg) : order(order_arg), n_fwrd_vars(n_fwrd_vars_arg), n_explosive_eigenvals(n_explosive_eigenvals_arg)
+    {
+    };
   };
   /*!
     The zetas are supposed to follow C convention (first vector index is zero).
@@ -57,7 +59,9 @@ public:
   DecisionRules(size_t n_arg, size_t p_arg, const std::vector<size_t> &zeta_fwrd_arg,
                 const std::vector<size_t> &zeta_back_arg, const std::vector<size_t> &zeta_mixed_arg,
                 const std::vector<size_t> &zeta_static_arg, double qz_criterium);
-  virtual ~DecisionRules(){};
+  virtual ~DecisionRules()
+  {
+  };
 
   /*!
     \param jacobian First columns are backetermined vars at t-1 (in the order of zeta_back_mixed), then all vars at t (in the orig order), then forward vars at t+1 (in the order of zeta_fwrd_mixed), then exogenous vars.
diff --git a/mex/sources/estimation/DetrendData.cc b/mex/sources/estimation/DetrendData.cc
index 6349932c9..f9fa1b76d 100644
--- a/mex/sources/estimation/DetrendData.cc
+++ b/mex/sources/estimation/DetrendData.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -44,4 +44,3 @@ DetrendData::detrend(const VectorView &SteadyState, const MatrixConstView &dataV
           detrendedDataView(i, j) = dataView(i, j) - SteadyState(varobs[i]);
     }
 };
-
diff --git a/mex/sources/estimation/DetrendData.hh b/mex/sources/estimation/DetrendData.hh
index 59cfc3d0f..408b14a11 100644
--- a/mex/sources/estimation/DetrendData.hh
+++ b/mex/sources/estimation/DetrendData.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -31,7 +31,9 @@ class DetrendData
 {
 
 public:
-  virtual ~DetrendData(){};
+  virtual ~DetrendData()
+  {
+  };
   DetrendData(const std::vector<size_t> &varobs_arg, bool noconstant_arg);
   void detrend(const VectorView &SteadyState, const MatrixConstView &dataView, MatrixView &detrendedDataView);
 
diff --git a/mex/sources/estimation/EstimatedParameter.cc b/mex/sources/estimation/EstimatedParameter.cc
index bf59ae156..5fd2bad2b 100644
--- a/mex/sources/estimation/EstimatedParameter.cc
+++ b/mex/sources/estimation/EstimatedParameter.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -37,4 +37,3 @@ EstimatedParameter::EstimatedParameter(const EstimatedParameter::pType type_arg,
 EstimatedParameter::~EstimatedParameter()
 {
 }
-
diff --git a/mex/sources/estimation/EstimatedParameter.hh b/mex/sources/estimation/EstimatedParameter.hh
index e323b125b..52cc26187 100644
--- a/mex/sources/estimation/EstimatedParameter.hh
+++ b/mex/sources/estimation/EstimatedParameter.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -33,19 +33,20 @@ struct EstimatedParameter
 public:
   // parameter types
   enum pType
-  {
-    shock_SD = 1, // standard deviation of a structural shock
-    measureErr_SD = 2, // standard deviation of a measurement error
-    shock_Corr = 3, // correlation betwwen two structural shocks
-    measureErr_Corr = 4, // correlation between two measurement errors
-    deepPar = 5 // deep parameter
-  };
+    {
+      shock_SD = 1, // standard deviation of a structural shock
+      measureErr_SD = 2, // standard deviation of a measurement error
+      shock_Corr = 3, // correlation betwwen two structural shocks
+      measureErr_Corr = 4, // correlation between two measurement errors
+      deepPar = 5 // deep parameter
+    };
 
   EstimatedParameter(const EstimatedParameter::pType type,
                      size_t ID1, size_t ID2, const std::vector<size_t> &subSampleIDs,
                      double lower_bound, double upper_bound, Prior *prior
                      );
-  virtual ~EstimatedParameter();
+  virtual
+  ~EstimatedParameter();
 
   enum pType ptype;
   size_t ID1;
diff --git a/mex/sources/estimation/EstimatedParametersDescription.hh b/mex/sources/estimation/EstimatedParametersDescription.hh
index 0e4a14fac..2fc2ad8ea 100644
--- a/mex/sources/estimation/EstimatedParametersDescription.hh
+++ b/mex/sources/estimation/EstimatedParametersDescription.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2010 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -45,7 +45,8 @@
 class EstimatedParametersDescription
 {
 public:
-  virtual ~EstimatedParametersDescription();
+  virtual
+  ~EstimatedParametersDescription();
   EstimatedParametersDescription(std::vector<EstimationSubsample> &estSubsamples, std::vector<EstimatedParameter> &estParams);
   std::vector<EstimationSubsample> estSubsamples;
   std::vector<EstimatedParameter> estParams;
diff --git a/mex/sources/estimation/EstimationSubsample.cc b/mex/sources/estimation/EstimationSubsample.cc
index f8e937377..a8dba8039 100644
--- a/mex/sources/estimation/EstimationSubsample.cc
+++ b/mex/sources/estimation/EstimationSubsample.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2010 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -33,4 +33,3 @@ EstimationSubsample::EstimationSubsample(size_t INstartPeriod, size_t INendPerio
 EstimationSubsample::~EstimationSubsample()
 {
 }
-
diff --git a/mex/sources/estimation/EstimationSubsample.hh b/mex/sources/estimation/EstimationSubsample.hh
index 5d76e1293..d8c90723a 100644
--- a/mex/sources/estimation/EstimationSubsample.hh
+++ b/mex/sources/estimation/EstimationSubsample.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -59,7 +59,8 @@ class EstimationSubsample
 {
 public:
   EstimationSubsample(size_t startPeriod, size_t endPeriod);
-  virtual ~EstimationSubsample();
+  virtual
+  ~EstimationSubsample();
 
   size_t startPeriod;
   size_t endPeriod;
diff --git a/mex/sources/estimation/InitializeKalmanFilter.cc b/mex/sources/estimation/InitializeKalmanFilter.cc
index 53ea5df6c..095032494 100644
--- a/mex/sources/estimation/InitializeKalmanFilter.cc
+++ b/mex/sources/estimation/InitializeKalmanFilter.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -74,4 +74,3 @@ InitializeKalmanFilter::setPstar(Matrix &Pstar, Matrix &Pinf, const Matrix &T, c
 
   Pinf.setAll(0.0);
 }
-
diff --git a/mex/sources/estimation/InitializeKalmanFilter.hh b/mex/sources/estimation/InitializeKalmanFilter.hh
index 83e25a19f..a78b5970e 100644
--- a/mex/sources/estimation/InitializeKalmanFilter.hh
+++ b/mex/sources/estimation/InitializeKalmanFilter.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -49,13 +49,15 @@ public:
                          const std::vector<size_t> &varobs_arg,
                          double qz_criterium_arg, double lyapunov_tol_arg,
                          bool noconstant_arg);
-  virtual ~InitializeKalmanFilter();
+  virtual
+  ~InitializeKalmanFilter();
   // initialise parameter dependent KF matrices only but not Ps
   template <class Vec1, class Vec2, class Mat1, class Mat2>
-  void initialize(Vec1 &steadyState, const Vec2 &deepParams, Mat1 &R,
-				     const Mat2 &Q, Matrix &RQRt, Matrix &T,
-				     const MatrixConstView &dataView,
-				     MatrixView &detrendedDataView)
+  void
+  initialize(Vec1 &steadyState, const Vec2 &deepParams, Mat1 &R,
+             const Mat2 &Q, Matrix &RQRt, Matrix &T,
+             const MatrixConstView &dataView,
+             MatrixView &detrendedDataView)
   {
     modelSolution.compute(steadyState, deepParams, g_x, g_u);
     detrendData.detrend(steadyState, dataView, detrendedDataView);
@@ -66,10 +68,11 @@ public:
 
   // initialise all KF matrices
   template <class Vec1, class Vec2, class Mat1, class Mat2>
-  void initialize(Vec1 &steadyState, const Vec2 &deepParams, Mat1 &R,
-				     const Mat2 &Q, Matrix &RQRt, Matrix &T, Matrix &Pstar, Matrix &Pinf,
-				     const MatrixConstView &dataView,
-				     MatrixView &detrendedDataView)
+  void
+  initialize(Vec1 &steadyState, const Vec2 &deepParams, Mat1 &R,
+             const Mat2 &Q, Matrix &RQRt, Matrix &T, Matrix &Pstar, Matrix &Pinf,
+             const MatrixConstView &dataView,
+             MatrixView &detrendedDataView)
   {
     initialize(steadyState, deepParams, R, Q, RQRt, T, dataView, detrendedDataView);
     setPstar(Pstar, Pinf, T, RQRt);
@@ -90,7 +93,8 @@ private:
   void setT(Matrix &T);
 
   template <class Mat1, class Mat2>
-  void setRQR(Mat1 &R, const Mat2 &Q, Matrix &RQRt)
+  void
+  setRQR(Mat1 &R, const Mat2 &Q, Matrix &RQRt)
   {
     mat::assignByVectors(R, mat::nullVec, mat::nullVec, g_u, zeta_varobs_back_mixed, mat::nullVec);
 
diff --git a/mex/sources/estimation/KalmanFilter.cc b/mex/sources/estimation/KalmanFilter.cc
index 32f121899..db9628b81 100644
--- a/mex/sources/estimation/KalmanFilter.cc
+++ b/mex/sources/estimation/KalmanFilter.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -74,7 +74,6 @@ KalmanFilter::compute_zeta_varobs_back_mixed(const std::vector<size_t> &zeta_bac
   return zeta_varobs_back_mixed;
 }
 
-
 /**
  * Multi-variate standard Kalman Filter
  */
@@ -86,7 +85,7 @@ KalmanFilter::filter(const MatrixView &detrendedDataView,  const Matrix &H, Vect
   bool nonstationary = true;
   a_init.setAll(0.0);
   int info;
-  
+
   for (size_t t = 0; t < detrendedDataView.getCols(); ++t)
     {
       if (nonstationary)
@@ -192,4 +191,3 @@ KalmanFilter::filter(const MatrixView &detrendedDataView,  const Matrix &H, Vect
 
   return loglik;
 }
-
diff --git a/mex/sources/estimation/KalmanFilter.hh b/mex/sources/estimation/KalmanFilter.hh
index 25a4699fa..4de6e156e 100644
--- a/mex/sources/estimation/KalmanFilter.hh
+++ b/mex/sources/estimation/KalmanFilter.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -48,7 +48,8 @@ class KalmanFilter
 {
 
 public:
-  virtual ~KalmanFilter();
+  virtual
+  ~KalmanFilter();
   KalmanFilter(const std::string &basename, size_t n_endo, size_t n_exo, const std::vector<size_t> &zeta_fwrd_arg,
                const std::vector<size_t> &zeta_back_arg, const std::vector<size_t> &zeta_mixed_arg, const std::vector<size_t> &zeta_static_arg,
                double qz_criterium_arg, const std::vector<size_t> &varobs_arg,
@@ -56,18 +57,19 @@ public:
                bool noconstant_arg);
 
   template <class Vec1, class Vec2, class Mat1>
-  double compute(const MatrixConstView &dataView, Vec1 &steadyState,
-                 const Mat1 &Q, const Matrix &H, const Vec2 &deepParams,
-                 VectorView &vll, MatrixView &detrendedDataView, size_t start, size_t period)
+  double
+  compute(const MatrixConstView &dataView, Vec1 &steadyState,
+          const Mat1 &Q, const Matrix &H, const Vec2 &deepParams,
+          VectorView &vll, MatrixView &detrendedDataView, size_t start, size_t period)
   {
-	if (period == 0) // initialise all KF matrices
-	  initKalmanFilter.initialize(steadyState, deepParams, R, Q, RQRt, T, Pstar, Pinf,
-                                dataView, detrendedDataView);
-	else             // initialise parameter dependent KF matrices only but not Ps
-	  initKalmanFilter.initialize(steadyState, deepParams, R, Q, RQRt, T,
-                                dataView, detrendedDataView);
+    if (period == 0) // initialise all KF matrices
+      initKalmanFilter.initialize(steadyState, deepParams, R, Q, RQRt, T, Pstar, Pinf,
+                                  dataView, detrendedDataView);
+    else                           // initialise parameter dependent KF matrices only but not Ps
+      initKalmanFilter.initialize(steadyState, deepParams, R, Q, RQRt, T,
+                                  dataView, detrendedDataView);
 
-  return filter(detrendedDataView, H, vll, start);
+    return filter(detrendedDataView, H, vll, start);
   }
 
 private:
diff --git a/mex/sources/estimation/LogLikelihoodMain.cc b/mex/sources/estimation/LogLikelihoodMain.cc
index 8109ad99a..e775dbc3b 100644
--- a/mex/sources/estimation/LogLikelihoodMain.cc
+++ b/mex/sources/estimation/LogLikelihoodMain.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -31,11 +31,11 @@ LogLikelihoodMain::LogLikelihoodMain(const std::string &basename, EstimatedParam
                                      const std::vector<size_t> &varobs, double riccati_tol, double lyapunov_tol,
                                      bool noconstant_arg)
 
-  : estSubsamples(estiParDesc.estSubsamples),
-    logLikelihoodSubSample(basename, estiParDesc, n_endo, n_exo, zeta_fwrd_arg, zeta_back_arg, zeta_mixed_arg, zeta_static_arg, qz_criterium,
-                           varobs, riccati_tol, lyapunov_tol, noconstant_arg),
-    vll(estiParDesc.getNumberOfPeriods()), // time dimension size of data
-    detrendedData(varobs.size(), estiParDesc.getNumberOfPeriods())
+: estSubsamples(estiParDesc.estSubsamples),
+  logLikelihoodSubSample(basename, estiParDesc, n_endo, n_exo, zeta_fwrd_arg, zeta_back_arg, zeta_mixed_arg, zeta_static_arg, qz_criterium,
+                         varobs, riccati_tol, lyapunov_tol, noconstant_arg),
+  vll(estiParDesc.getNumberOfPeriods()), // time dimension size of data
+  detrendedData(varobs.size(), estiParDesc.getNumberOfPeriods())
 {
 
 }
@@ -44,5 +44,3 @@ LogLikelihoodMain::~LogLikelihoodMain()
 {
 
 }
-
-
diff --git a/mex/sources/estimation/LogLikelihoodMain.hh b/mex/sources/estimation/LogLikelihoodMain.hh
index 731336a25..33863f336 100644
--- a/mex/sources/estimation/LogLikelihoodMain.hh
+++ b/mex/sources/estimation/LogLikelihoodMain.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -36,7 +36,8 @@ private:
   Matrix detrendedData;
 
 public:
-  virtual ~LogLikelihoodMain();
+  virtual
+  ~LogLikelihoodMain();
   LogLikelihoodMain(const std::string &basename, EstimatedParametersDescription &estiParDesc, size_t n_endo, size_t n_exo,
                     const std::vector<size_t> &zeta_fwrd_arg, const std::vector<size_t> &zeta_back_arg, const std::vector<size_t> &zeta_mixed_arg,
                     const std::vector<size_t> &zeta_static_arg, const double qz_criterium_arg, const std::vector<size_t> &varobs_arg,
@@ -53,25 +54,30 @@ public:
    */
 
   template <class VEC1, class VEC2>
-  double compute(VEC1 &steadyState, VEC2 &estParams, VectorView &deepParams, const MatrixConstView &data, 
-		 MatrixView &Q, Matrix &H, size_t start)
+  double
+  compute(VEC1 &steadyState, VEC2 &estParams, VectorView &deepParams, const MatrixConstView &data,
+          MatrixView &Q, Matrix &H, size_t start)
   {
     double logLikelihood = 0;
     for (size_t i = 0; i < estSubsamples.size(); ++i)
       {
-	MatrixConstView dataView(data, 0, estSubsamples[i].startPeriod,
-				 data.getRows(), estSubsamples[i].endPeriod-estSubsamples[i].startPeriod+1);
-	MatrixView detrendedDataView(detrendedData, 0, estSubsamples[i].startPeriod,
-				     data.getRows(), estSubsamples[i].endPeriod-estSubsamples[i].startPeriod+1);
+        MatrixConstView dataView(data, 0, estSubsamples[i].startPeriod,
+                                 data.getRows(), estSubsamples[i].endPeriod-estSubsamples[i].startPeriod+1);
+        MatrixView detrendedDataView(detrendedData, 0, estSubsamples[i].startPeriod,
+                                     data.getRows(), estSubsamples[i].endPeriod-estSubsamples[i].startPeriod+1);
 
-	VectorView vllView(vll, estSubsamples[i].startPeriod, estSubsamples[i].endPeriod-estSubsamples[i].startPeriod+1);
-	logLikelihood += logLikelihoodSubSample.compute(steadyState, dataView, estParams, deepParams,
-							Q, H, vllView, detrendedDataView, start, i);
+        VectorView vllView(vll, estSubsamples[i].startPeriod, estSubsamples[i].endPeriod-estSubsamples[i].startPeriod+1);
+        logLikelihood += logLikelihoodSubSample.compute(steadyState, dataView, estParams, deepParams,
+                                                        Q, H, vllView, detrendedDataView, start, i);
       }
     return logLikelihood;
   };
 
-  Vector &getVll() { return vll; };
+  Vector &
+  getVll()
+  {
+    return vll;
+  };
 };
 
 #endif // !defined(E126AEF5_AC28_400a_821A_3BCFD1BC4C22__INCLUDED_)
diff --git a/mex/sources/estimation/LogLikelihoodSubSample.cc b/mex/sources/estimation/LogLikelihoodSubSample.cc
index 9a3aabf80..6c647c1f8 100644
--- a/mex/sources/estimation/LogLikelihoodSubSample.cc
+++ b/mex/sources/estimation/LogLikelihoodSubSample.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -38,4 +38,3 @@ LogLikelihoodSubSample::LogLikelihoodSubSample(const std::string &basename, Esti
                varobs, riccati_tol, lyapunov_tol, noconstant_arg), eigQ(n_exo), eigH(varobs.size())
 {
 };
-
diff --git a/mex/sources/estimation/LogLikelihoodSubSample.hh b/mex/sources/estimation/LogLikelihoodSubSample.hh
index 4e0fa509f..e9f0dbe9a 100644
--- a/mex/sources/estimation/LogLikelihoodSubSample.hh
+++ b/mex/sources/estimation/LogLikelihoodSubSample.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -42,15 +42,17 @@ public:
                          const std::vector<size_t> &varobs_arg, double riccati_tol_in, double lyapunov_tol, bool noconstant_arg);
 
   template <class VEC1, class VEC2>
-  double compute(VEC1 &steadyState, const MatrixConstView &dataView, VEC2 &estParams, VectorView &deepParams,
-		 MatrixView &Q, Matrix &H, VectorView &vll, MatrixView &detrendedDataView, size_t start, size_t period)
+  double
+  compute(VEC1 &steadyState, const MatrixConstView &dataView, VEC2 &estParams, VectorView &deepParams,
+          MatrixView &Q, Matrix &H, VectorView &vll, MatrixView &detrendedDataView, size_t start, size_t period)
   {
     updateParams(estParams, deepParams, Q, H, period);
 
     return kalmanFilter.compute(dataView, steadyState,  Q, H, deepParams, vll, detrendedDataView, start, period);
   }
 
-  virtual ~LogLikelihoodSubSample();
+  virtual
+  ~LogLikelihoodSubSample();
 
   class UpdateParamsException
   {
@@ -69,8 +71,9 @@ private:
 
   // methods
   template <class VEC>
-  void updateParams(VEC &estParams, VectorView &deepParams,
-                    MatrixView &Q, Matrix &H, size_t period)
+  void
+  updateParams(VEC &estParams, VectorView &deepParams,
+               MatrixView &Q, Matrix &H, size_t period)
   {
     size_t i, k, k1, k2;
     int test;
@@ -79,97 +82,96 @@ private:
 
     for (i = 0; i <  estParams.getSize(); ++i)
       {
-	found = false;
-	it = find(estiParDesc.estParams[i].subSampleIDs.begin(),
-		  estiParDesc.estParams[i].subSampleIDs.end(), period);
-	if (it != estiParDesc.estParams[i].subSampleIDs.end())
-	  found = true;
-	if (found)
-	  {
-	    switch (estiParDesc.estParams[i].ptype)
-	      {
-	      case EstimatedParameter::shock_SD:
-		k = estiParDesc.estParams[i].ID1;
-		Q(k, k) = estParams(i)*estParams(i);
-		break;
+        found = false;
+        it = find(estiParDesc.estParams[i].subSampleIDs.begin(),
+                  estiParDesc.estParams[i].subSampleIDs.end(), period);
+        if (it != estiParDesc.estParams[i].subSampleIDs.end())
+          found = true;
+        if (found)
+          {
+            switch (estiParDesc.estParams[i].ptype)
+              {
+              case EstimatedParameter::shock_SD:
+                k = estiParDesc.estParams[i].ID1;
+                Q(k, k) = estParams(i)*estParams(i);
+                break;
 
-	      case EstimatedParameter::measureErr_SD:
-		k = estiParDesc.estParams[i].ID1;
-		H(k, k) = estParams(i)*estParams(i);
-		break;
+              case EstimatedParameter::measureErr_SD:
+                k = estiParDesc.estParams[i].ID1;
+                H(k, k) = estParams(i)*estParams(i);
+                break;
 
-	      case EstimatedParameter::shock_Corr:
-		k1 = estiParDesc.estParams[i].ID1;
-		k2 = estiParDesc.estParams[i].ID2;
-		Q(k1, k2) = estParams(i)*sqrt(Q(k1, k1)*Q(k2, k2));
-		Q(k2, k1) = Q(k1, k2);
-		//   [CholQ,testQ] = chol(Q);
-		test = lapack::choleskyDecomp(Q, "L");
+              case EstimatedParameter::shock_Corr:
+                k1 = estiParDesc.estParams[i].ID1;
+                k2 = estiParDesc.estParams[i].ID2;
+                Q(k1, k2) = estParams(i)*sqrt(Q(k1, k1)*Q(k2, k2));
+                Q(k2, k1) = Q(k1, k2);
+                //   [CholQ,testQ] = chol(Q);
+                test = lapack::choleskyDecomp(Q, "L");
                 assert(test >= 0);
-                
-		if (test > 0)
-		  {
-		    // The variance-covariance matrix of the structural innovations is not definite positive.
-		    // We have to compute the eigenvalues of this matrix in order to build the penalty.
-		    double delta = 0;
-		    eigQ.calculate(Q);  // get eigenvalues
-		    //k = find(a < 0);
-		    if (eigQ.hasConverged())
-		      {
-			const Vector &evQ = eigQ.getD();
-			for (i = 0; i < evQ.getSize(); ++i)
-			  if (evQ(i) < 0)
-			    delta -= evQ(i);
-		      }
 
-		    throw UpdateParamsException(delta);
-		  } // if
-		break;
+                if (test > 0)
+                  {
+                    // The variance-covariance matrix of the structural innovations is not definite positive.
+                    // We have to compute the eigenvalues of this matrix in order to build the penalty.
+                    double delta = 0;
+                    eigQ.calculate(Q);  // get eigenvalues
+                    //k = find(a < 0);
+                    if (eigQ.hasConverged())
+                      {
+                        const Vector &evQ = eigQ.getD();
+                        for (i = 0; i < evQ.getSize(); ++i)
+                          if (evQ(i) < 0)
+                            delta -= evQ(i);
+                      }
 
-	      case EstimatedParameter::measureErr_Corr:
-		k1 = estiParDesc.estParams[i].ID1;
-		k2 = estiParDesc.estParams[i].ID2;
-		//      H(k1,k2) = xparam1(i)*sqrt(H(k1,k1)*H(k2,k2));
-		//      H(k2,k1) = H(k1,k2);
-		H(k1, k2) = estParams(i)*sqrt(H(k1, k1)*H(k2, k2));
-		H(k2, k1) = H(k1, k2);
+                    throw UpdateParamsException(delta);
+                  } // if
+                break;
 
-		//[CholH,testH] = chol(H);
-		test = lapack::choleskyDecomp(H, "L");
-		assert(test >= 0);
+              case EstimatedParameter::measureErr_Corr:
+                k1 = estiParDesc.estParams[i].ID1;
+                k2 = estiParDesc.estParams[i].ID2;
+                //      H(k1,k2) = xparam1(i)*sqrt(H(k1,k1)*H(k2,k2));
+                //      H(k2,k1) = H(k1,k2);
+                H(k1, k2) = estParams(i)*sqrt(H(k1, k1)*H(k2, k2));
+                H(k2, k1) = H(k1, k2);
 
-		if (test > 0)
-		  {
-		    // The variance-covariance matrix of the measurement errors is not definite positive.
-		    // We have to compute the eigenvalues of this matrix in order to build the penalty.
-		    //a = diag(eig(H));
-		    double delta = 0;
-		    eigH.calculate(H);  // get eigenvalues
-		    //k = find(a < 0);
-		    if (eigH.hasConverged())
-		      {
-			const Vector &evH = eigH.getD();
-			for (i = 0; i < evH.getSize(); ++i)
-			  if (evH(i) < 0)
-			    delta -= evH(i);
-		      }
-		    throw UpdateParamsException(delta);
-		  } //   end if
-		break;
+                //[CholH,testH] = chol(H);
+                test = lapack::choleskyDecomp(H, "L");
+                assert(test >= 0);
 
-		//if estim_params_.np > 0  // i.e. num of deep parameters >0
-	      case EstimatedParameter::deepPar:
-		k = estiParDesc.estParams[i].ID1;
-		deepParams(k) = estParams(i);
-		break;
-	      default:
+                if (test > 0)
+                  {
+                    // The variance-covariance matrix of the measurement errors is not definite positive.
+                    // We have to compute the eigenvalues of this matrix in order to build the penalty.
+                    //a = diag(eig(H));
+                    double delta = 0;
+                    eigH.calculate(H);  // get eigenvalues
+                    //k = find(a < 0);
+                    if (eigH.hasConverged())
+                      {
+                        const Vector &evH = eigH.getD();
+                        for (i = 0; i < evH.getSize(); ++i)
+                          if (evH(i) < 0)
+                            delta -= evH(i);
+                      }
+                    throw UpdateParamsException(delta);
+                  } //   end if
+                break;
+
+                //if estim_params_.np > 0  // i.e. num of deep parameters >0
+              case EstimatedParameter::deepPar:
+                k = estiParDesc.estParams[i].ID1;
+                deepParams(k) = estParams(i);
+                break;
+              default:
                 assert(false);
-	      } // end switch
-	  } // end found
+              } // end switch
+          } // end found
       } //end for
   };
 
-
 };
 
 #endif // !defined(DF8B7AF5_8169_4587_9037_2CD2C82E2DDF__INCLUDED_)
diff --git a/mex/sources/estimation/LogPosteriorDensity.cc b/mex/sources/estimation/LogPosteriorDensity.cc
index a9da75fc1..c87e6dee7 100644
--- a/mex/sources/estimation/LogPosteriorDensity.cc
+++ b/mex/sources/estimation/LogPosteriorDensity.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -41,7 +41,6 @@ LogPosteriorDensity::LogPosteriorDensity(const std::string &modName, EstimatedPa
 
 }
 
-
 /**
  * vector of log likelihoods for each Kalman step
  */
@@ -50,4 +49,3 @@ LogPosteriorDensity::getLikVector()
 {
   return logLikelihoodMain.getVll();
 }
-
diff --git a/mex/sources/estimation/LogPosteriorDensity.hh b/mex/sources/estimation/LogPosteriorDensity.hh
index 820f2a575..425eb625a 100644
--- a/mex/sources/estimation/LogPosteriorDensity.hh
+++ b/mex/sources/estimation/LogPosteriorDensity.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -42,7 +42,8 @@ private:
   LogLikelihoodMain logLikelihoodMain;
 
 public:
-  virtual ~LogPosteriorDensity();
+  virtual
+  ~LogPosteriorDensity();
 
   LogPosteriorDensity(const std::string &modName, EstimatedParametersDescription &estParamsDesc, size_t n_endo, size_t n_exo,
                       const std::vector<size_t> &zeta_fwrd_arg, const std::vector<size_t> &zeta_back_arg, const std::vector<size_t> &zeta_mixed_arg,
diff --git a/mex/sources/estimation/LogPriorDensity.hh b/mex/sources/estimation/LogPriorDensity.hh
index 5a07402be..c7c57a6bd 100644
--- a/mex/sources/estimation/LogPriorDensity.hh
+++ b/mex/sources/estimation/LogPriorDensity.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -35,18 +35,20 @@ class LogPriorDensity
 
 public:
   LogPriorDensity(EstimatedParametersDescription &estParsDesc);
-  virtual ~LogPriorDensity();
+  virtual
+  ~LogPriorDensity();
 
   template<class VEC>
-  double compute(VEC &ep)
+  double
+  compute(VEC &ep)
   {
     assert(estParsDesc.estParams.size() == ep.getSize());
     double logPriorDensity = 0;
     for (size_t i = 0; i <  ep.getSize(); ++i)
       {
-	logPriorDensity += log(((*(estParsDesc.estParams[i]).prior)).pdf(ep(i)));
-	if (std::isinf(fabs(logPriorDensity)))
-	  return logPriorDensity;
+        logPriorDensity += log(((*(estParsDesc.estParams[i]).prior)).pdf(ep(i)));
+        if (std::isinf(fabs(logPriorDensity)))
+          return logPriorDensity;
       }
     return logPriorDensity;
   };
diff --git a/mex/sources/estimation/ModelSolution.cc b/mex/sources/estimation/ModelSolution.cc
index 64543bf09..abeb02124 100644
--- a/mex/sources/estimation/ModelSolution.cc
+++ b/mex/sources/estimation/ModelSolution.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -51,5 +51,3 @@ ModelSolution::ModelSolution(const std::string &basename,  size_t n_endo_arg, si
             zeta_mixed_arg.begin(), zeta_mixed_arg.end(),
             back_inserter(zeta_back_mixed));
 }
-
-
diff --git a/mex/sources/estimation/ModelSolution.hh b/mex/sources/estimation/ModelSolution.hh
index 92e03a544..8bdc4a66a 100644
--- a/mex/sources/estimation/ModelSolution.hh
+++ b/mex/sources/estimation/ModelSolution.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -42,9 +42,12 @@ public:
   ModelSolution(const std::string &basename,  size_t n_endo, size_t n_exo, const std::vector<size_t> &zeta_fwrd_arg,
                 const std::vector<size_t> &zeta_back_arg, const std::vector<size_t> &zeta_mixed_arg,
                 const std::vector<size_t> &zeta_static_arg, double qz_criterium);
-  virtual ~ModelSolution() {};
+  virtual ~ModelSolution()
+  {
+  };
   template <class Vec1, class Vec2, class Mat1, class Mat2>
-  void compute(Vec1 &steadyState, const Vec2 &deepParams, Mat1 &ghx, Mat2 &ghu) throw (DecisionRules::BlanchardKahnException, GeneralizedSchurDecomposition::GSDException, SteadyStateSolver::SteadyStateException)
+  void
+  compute(Vec1 &steadyState, const Vec2 &deepParams, Mat1 &ghx, Mat2 &ghu) throw (DecisionRules::BlanchardKahnException, GeneralizedSchurDecomposition::GSDException, SteadyStateSolver::SteadyStateException)
   {
     // compute Steady State
     steadyStateSolver.compute(steadyState, Mx, deepParams);
@@ -69,8 +72,9 @@ private:
   Vector llXsteadyState;
   //Matrix jacobian;
   template <class Vec1, class Vec2, class Mat1, class Mat2>
-  void ComputeModelSolution(Vec1 &steadyState, const Vec2 &deepParams,
-                            Mat1 &ghx, Mat2 &ghu)
+  void
+  ComputeModelSolution(Vec1 &steadyState, const Vec2 &deepParams,
+                       Mat1 &ghx, Mat2 &ghu)
     throw (DecisionRules::BlanchardKahnException, GeneralizedSchurDecomposition::GSDException)
   {
     // set extended Steady State
diff --git a/mex/sources/estimation/Prior.hh b/mex/sources/estimation/Prior.hh
index de29bf789..f550e2b75 100644
--- a/mex/sources/estimation/Prior.hh
+++ b/mex/sources/estimation/Prior.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -47,17 +47,18 @@ struct Prior
 public:
   //! probablity density functions
   enum pShape
-  {
-    Beta = 1,
-    Gamma = 2,
-    Gaussian = 3, // i.e. Normal density
-    Inv_gamma_1 = 4, // Inverse gamma (type 1) density
-    Uniform = 5,
-    Inv_gamma_2 = 6 //Inverse gamma (type 2) density
-  };
+    {
+      Beta = 1,
+      Gamma = 2,
+      Gaussian = 3, // i.e. Normal density
+      Inv_gamma_1 = 4, // Inverse gamma (type 1) density
+      Uniform = 5,
+      Inv_gamma_2 = 6 //Inverse gamma (type 2) density
+    };
 
   Prior(double mean, double standard, double lower_bound, double upper_bound, double fhp, double shp);
-  virtual ~Prior();
+  virtual
+  ~Prior();
 
   const double mean;
   const double standard;
@@ -100,7 +101,9 @@ public:
     distribution(fhp, shp)
   {
   };
-  virtual ~BetaPrior(){};
+  virtual ~BetaPrior()
+  {
+  };
   virtual pShape
   getShape()
   {
@@ -134,7 +137,9 @@ public:
     distribution(fhp, shp)
   {
   };
-  virtual ~GammaPrior(){};
+  virtual ~GammaPrior()
+  {
+  };
   virtual pShape
   getShape()
   {
@@ -164,7 +169,9 @@ public:
     distribution(shp/2, 2/fhp)
   {
   };
-  virtual ~InvGamma1_Prior(){};
+  virtual ~InvGamma1_Prior()
+  {
+  };
   virtual pShape
   getShape()
   {
@@ -199,7 +206,9 @@ public:
     distribution(shp/2, 2/fhp)
   {
   };
-  virtual ~InvGamma2_Prior(){};
+  virtual ~InvGamma2_Prior()
+  {
+  };
   virtual pShape
   getShape()
   {
@@ -239,7 +248,9 @@ public:
     distribution(fhp, shp) //pdf distribution(mean, standard)
   {
   };
-  virtual ~GaussianPrior(){};
+  virtual ~GaussianPrior()
+  {
+  };
   virtual pShape
   getShape()
   {
@@ -277,7 +288,9 @@ public:
     distribution(fhp, shp) //pdf distribution(lower_bound, upper_bound)
   {
   };
-  virtual ~UniformPrior(){};
+  virtual ~UniformPrior()
+  {
+  };
   virtual pShape
   getShape()
   {
diff --git a/mex/sources/estimation/Proposal.cc b/mex/sources/estimation/Proposal.cc
index 7e7b633d8..8bf5933d4 100644
--- a/mex/sources/estimation/Proposal.cc
+++ b/mex/sources/estimation/Proposal.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2010 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -88,4 +88,3 @@ Proposal::selectionTestDraw()
 {
   return uniformVrng();
 }
-
diff --git a/mex/sources/estimation/Proposal.hh b/mex/sources/estimation/Proposal.hh
index 13be358fb..4beb1c9dd 100644
--- a/mex/sources/estimation/Proposal.hh
+++ b/mex/sources/estimation/Proposal.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -63,7 +63,9 @@ public:
 
 public:
   Proposal(const VectorConstView &vJscale, const MatrixConstView &covariance);
-  virtual ~Proposal() {};
+  virtual ~Proposal()
+  {
+  };
   virtual void draw(Vector &mean, Vector &draw);
   virtual Matrix&getVar();
   virtual int seed();
diff --git a/mex/sources/estimation/RandomWalkMetropolisHastings.hh b/mex/sources/estimation/RandomWalkMetropolisHastings.hh
index f281939ba..c09b2c9df 100644
--- a/mex/sources/estimation/RandomWalkMetropolisHastings.hh
+++ b/mex/sources/estimation/RandomWalkMetropolisHastings.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -42,13 +42,16 @@ public:
     parDraw(size), newParDraw(size)
   {
   };
-  virtual ~RandomWalkMetropolisHastings() {};
+  virtual ~RandomWalkMetropolisHastings()
+  {
+  };
 
   template<class VEC1>
-  double compute(VectorView &mhLogPostDens, MatrixView &mhParams, VEC1 &steadyState,
-		 Vector &estParams, VectorView &deepParams, const MatrixConstView &data, MatrixView &Q, Matrix &H,
-		 const size_t presampleStart, const size_t startDraw, size_t nMHruns,
-		 LogPosteriorDensity &lpd, Proposal &pDD, EstimatedParametersDescription &epd)
+  double
+  compute(VectorView &mhLogPostDens, MatrixView &mhParams, VEC1 &steadyState,
+          Vector &estParams, VectorView &deepParams, const MatrixConstView &data, MatrixView &Q, Matrix &H,
+          const size_t presampleStart, const size_t startDraw, size_t nMHruns,
+          LogPosteriorDensity &lpd, Proposal &pDD, EstimatedParametersDescription &epd)
   {
     //streambuf *likbuf, *drawbuf *backup;
     std::ofstream urandfilestr, drawfilestr;
@@ -64,46 +67,46 @@ public:
 
     for (size_t run = startDraw - 1; run < nMHruns; ++run)
       {
-	overbound = false;
-	pDD.draw(parDraw, newParDraw);
-	for (count = 0; count < parDraw.getSize(); ++count)
-	  {
-	    overbound = (newParDraw(count) < epd.estParams[count].lower_bound || newParDraw(count) > epd.estParams[count].upper_bound);
-	    if (overbound)
-	      {
-		newLogpost = -INFINITY;
-		break;
-	      }
-	  }
-	if (!overbound)
-	  {
-	    try
-	      {
-		newLogpost = -lpd.compute(steadyState, newParDraw, deepParams, data, Q, H, presampleStart);
-	      }
-	    catch (const std::exception &e)
-	      {
-		throw; // for now handle the system and other errors higher-up
-	      }
-	    catch (...)
-	      {
-		newLogpost = -INFINITY;
-	      }
-	  }
-	urand = pDD.selectionTestDraw();
-	if ((newLogpost > -INFINITY) && log(urand) < newLogpost-logpost)
-	  {
-	    parDraw = newParDraw;
-	    logpost = newLogpost;
-	    accepted++;
-	  }
-	mat::get_row(mhParams, run) = parDraw;
-	mhLogPostDens(run) = logpost;
+        overbound = false;
+        pDD.draw(parDraw, newParDraw);
+        for (count = 0; count < parDraw.getSize(); ++count)
+          {
+            overbound = (newParDraw(count) < epd.estParams[count].lower_bound || newParDraw(count) > epd.estParams[count].upper_bound);
+            if (overbound)
+              {
+                newLogpost = -INFINITY;
+                break;
+              }
+          }
+        if (!overbound)
+          {
+            try
+              {
+                newLogpost = -lpd.compute(steadyState, newParDraw, deepParams, data, Q, H, presampleStart);
+              }
+            catch (const std::exception &e)
+              {
+                throw; // for now handle the system and other errors higher-up
+              }
+            catch (...)
+              {
+                newLogpost = -INFINITY;
+              }
+          }
+        urand = pDD.selectionTestDraw();
+        if ((newLogpost > -INFINITY) && log(urand) < newLogpost-logpost)
+          {
+            parDraw = newParDraw;
+            logpost = newLogpost;
+            accepted++;
+          }
+        mat::get_row(mhParams, run) = parDraw;
+        mhLogPostDens(run) = logpost;
 
-	urandfilestr << urand << "\n"; //","
-	for (size_t c = 0; c < newParDraw.getSize()-1; ++c)
-	  drawfilestr << newParDraw(c) << ",";
-	drawfilestr <<  newParDraw(newParDraw.getSize()-1) << "\n";
+        urandfilestr << urand << "\n"; //","
+        for (size_t c = 0; c < newParDraw.getSize()-1; ++c)
+          drawfilestr << newParDraw(c) << ",";
+        drawfilestr <<  newParDraw(newParDraw.getSize()-1) << "\n";
       }
 
     urandfilestr.close();
diff --git a/mex/sources/estimation/SteadyStateSolver.cc b/mex/sources/estimation/SteadyStateSolver.cc
index e2e9980ae..a0bb7cbe0 100644
--- a/mex/sources/estimation/SteadyStateSolver.cc
+++ b/mex/sources/estimation/SteadyStateSolver.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Dynare Team
+ * Copyright (C) 2013-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -33,12 +33,12 @@ SteadyStateSolver::static_f(const gsl_vector *yy, void *p, gsl_vector *F)
   params *pp = (params *) p;
   VectorConstView deepParams(pp->deepParams, pp->n_params, 1);
   MatrixConstView x(pp->x, 1, pp->n_exo, 1);
-  
+
   VectorView y(yy->data, yy->size, yy->stride);
   VectorView residual(F->data, F->size, F->stride);
 
   pp->static_dll->eval(y, x, deepParams, residual, NULL, NULL);
-  
+
   return GSL_SUCCESS;
 }
 
@@ -48,11 +48,11 @@ SteadyStateSolver::static_df(const gsl_vector *yy, void *p, gsl_matrix *J)
   params *pp = (params *) p;
   VectorConstView deepParams(pp->deepParams, pp->n_params, 1);
   MatrixConstView x(pp->x, 1, pp->n_exo, 1);
-  
+
   VectorView y(yy->data, yy->size, yy->stride);
 
   pp->static_dll->eval(y, x, deepParams, *pp->residual, pp->g1, NULL);
-  
+
   assert(J->size1 == J->size2 && J->size1 == J->tda);
   MatrixView g1t(J->data, J->size1, J->size2, J->tda);
   mat::transpose(g1t, *pp->g1); // GSL wants row-major order
@@ -66,16 +66,15 @@ SteadyStateSolver::static_fdf(const gsl_vector *yy, void *p, gsl_vector *F, gsl_
   params *pp = (params *) p;
   VectorConstView deepParams(pp->deepParams, pp->n_params, 1);
   MatrixConstView x(pp->x, 1, pp->n_exo, 1);
-  
+
   VectorView y(yy->data, yy->size, yy->stride);
   VectorView residual(F->data, F->size, F->stride);
 
   pp->static_dll->eval(y, x, deepParams, residual, pp->g1, NULL);
-  
+
   assert(J->size1 == J->size2 && J->size1 == J->tda);
   MatrixView g1t(J->data, J->size1, J->size2, J->tda);
   mat::transpose(g1t, *pp->g1); // GSL wants row-major order
 
   return GSL_SUCCESS;
 }
-
diff --git a/mex/sources/estimation/SteadyStateSolver.hh b/mex/sources/estimation/SteadyStateSolver.hh
index e52f5f433..726d8594b 100644
--- a/mex/sources/estimation/SteadyStateSolver.hh
+++ b/mex/sources/estimation/SteadyStateSolver.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Dynare Team
+ * Copyright (C) 2013-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -55,7 +55,7 @@ public:
   {
   public:
     std::string message;
-    SteadyStateException(const std::string &message_arg) : message(message_arg) 
+    SteadyStateException(const std::string &message_arg) : message(message_arg)
     {
     }
   };
@@ -63,7 +63,8 @@ public:
   SteadyStateSolver(const std::string &basename, size_t n_endo_arg);
 
   template <class Vec1, class Mat, class Vec2>
-  void compute(Vec1 &steadyState, const Mat &Mx, const Vec2 &deepParams) throw (SteadyStateException)
+  void
+  compute(Vec1 &steadyState, const Mat &Mx, const Vec2 &deepParams) throw (SteadyStateException)
   {
     assert(steadyState.getStride() == 1);
     assert(deepParams.getStride() == 1);
@@ -97,7 +98,7 @@ public:
 
         status = gsl_multiroot_test_residual(s->f, tolerance);
       }
-    while(status == GSL_CONTINUE && iter < max_iterations);
+    while (status == GSL_CONTINUE && iter < max_iterations);
 
     if (status != GSL_SUCCESS)
       throw SteadyStateException(std::string(gsl_strerror(status)));
@@ -107,5 +108,3 @@ public:
     gsl_multiroot_fdfsolver_free(s);
   }
 };
-
-
diff --git a/mex/sources/estimation/libmat/DiscLyapFast.hh b/mex/sources/estimation/libmat/DiscLyapFast.hh
index cd0b014c0..b85d73728 100644
--- a/mex/sources/estimation/libmat/DiscLyapFast.hh
+++ b/mex/sources/estimation/libmat/DiscLyapFast.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -60,7 +60,9 @@ public:
   {
     mat::set_identity(I);
   };
-  virtual ~DiscLyapFast() {};
+  virtual ~DiscLyapFast()
+  {
+  };
   template <class MatG, class MatV, class MatX >
   void solve_lyap(const MatG &G, const MatV &V, MatX &X, double tol = 1e-16, size_t flag_ch = 0) throw (DLPException);
 
diff --git a/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.cc b/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.cc
index 0b9e5d01b..47fc2816e 100644
--- a/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.cc
+++ b/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -51,7 +51,7 @@ GeneralizedSchurDecomposition::~GeneralizedSchurDecomposition()
 lapack_int
 GeneralizedSchurDecomposition::selctg(const double *alphar, const double *alphai, const double *beta)
 {
-  return ((*alphar * *alphar + *alphai * *alphai) < criterium_static * *beta * *beta);
+  return ((*alphar **alphar + *alphai **alphai) < criterium_static **beta **beta);
 }
 
 std::ostream &
diff --git a/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.hh b/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.hh
index f776ba333..e6d939604 100644
--- a/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.hh
+++ b/mex/sources/estimation/libmat/GeneralizedSchurDecomposition.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -37,11 +37,14 @@ public:
   {
   public:
     const lapack_int info, n;
-    GSDException(lapack_int info_arg, lapack_int n_arg) : info(info_arg), n(n_arg) {};
+    GSDException(lapack_int info_arg, lapack_int n_arg) : info(info_arg), n(n_arg)
+    {
+    };
   };
   //! \todo Replace heuristic choice for workspace size by a query to determine the optimal size
   GeneralizedSchurDecomposition(size_t n_arg, double criterium_arg);
-  virtual ~GeneralizedSchurDecomposition();
+  virtual
+  ~GeneralizedSchurDecomposition();
   //! \todo Add a lock around the modification of criterium_static for making it thread-safe
   template<class Mat1, class Mat2, class Mat3>
   void compute(Mat1 &S, Mat2 &T, Mat3 &Z, size_t &sdim) throw (GSDException);
diff --git a/mex/sources/estimation/libmat/LUSolver.hh b/mex/sources/estimation/libmat/LUSolver.hh
index e78c18c74..16ab45dad 100644
--- a/mex/sources/estimation/libmat/LUSolver.hh
+++ b/mex/sources/estimation/libmat/LUSolver.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -32,10 +32,13 @@ public:
   {
   public:
     const lapack_int info;
-    LUException(lapack_int info_arg) : info(info_arg) {};
+    LUException(lapack_int info_arg) : info(info_arg)
+    {
+    };
   };
   LUSolver(size_t dim_arg);
-  virtual ~LUSolver();
+  virtual
+  ~LUSolver();
   /*!
     Computes A^(-1)*B (possibly transposing A).
     The output is stored in B.
diff --git a/mex/sources/estimation/libmat/Matrix.hh b/mex/sources/estimation/libmat/Matrix.hh
index 860af9507..b17e5b3ce 100644
--- a/mex/sources/estimation/libmat/Matrix.hh
+++ b/mex/sources/estimation/libmat/Matrix.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2012 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -69,19 +69,52 @@ public:
   Matrix(size_t rows_arg, size_t cols_arg);
   Matrix(size_t size_arg);
   Matrix(const Matrix &arg);
-  virtual ~Matrix();
-  inline size_t getRows() const { return rows; }
-  inline size_t getCols() const { return cols; }
-  inline size_t getLd() const { return rows; }
-  inline double *getData() { return data; }
-  inline const double *getData() const { return data; }
-  inline void setAll(double val) { std::fill_n(data, rows*cols, val); }
-  inline double &operator() (size_t i, size_t j) { return data[i+j*rows]; }
-  inline const double &operator() (size_t i, size_t j) const { return data[i+j*rows]; }
+  virtual
+  ~Matrix();
+  inline size_t
+  getRows() const
+  {
+    return rows;
+  }
+  inline size_t
+  getCols() const
+  {
+    return cols;
+  }
+  inline size_t
+  getLd() const
+  {
+    return rows;
+  }
+  inline double *
+  getData()
+  {
+    return data;
+  }
+  inline const double *
+  getData() const
+  {
+    return data;
+  }
+  inline void
+  setAll(double val)
+  {
+    std::fill_n(data, rows*cols, val);
+  }
+  inline double &
+  operator()(size_t i, size_t j)
+  {
+    return data[i+j*rows];
+  }
+  inline const double &
+  operator()(size_t i, size_t j) const
+  {
+    return data[i+j*rows];
+  }
   //! Assignment operator, only works for matrices of same dimension
   template<class Mat>
   Matrix &
-  operator= (const Mat &arg)
+  operator=(const Mat &arg)
   {
     assert(rows == arg.getRows() && cols == arg.getCols());
     for (size_t j = 0; j < cols; j++)
@@ -112,23 +145,54 @@ public:
            && col_offset < arg.getCols()
            && col_offset + cols_arg <= arg.getCols());
   }
-  virtual ~MatrixView(){};
-  inline size_t getRows() const { return rows; }
-  inline size_t getCols() const { return cols; }
-  inline size_t getLd() const { return ld; }
-  inline double *getData() { return data; }
-  inline const double *getData() const { return data; }
-  inline void setAll(double val)
+  virtual ~MatrixView()
+  {
+  };
+  inline size_t
+  getRows() const
+  {
+    return rows;
+  }
+  inline size_t
+  getCols() const
+  {
+    return cols;
+  }
+  inline size_t
+  getLd() const
+  {
+    return ld;
+  }
+  inline double *
+  getData()
+  {
+    return data;
+  }
+  inline const double *
+  getData() const
+  {
+    return data;
+  }
+  inline void
+  setAll(double val)
   {
     for (double *p = data; p < data + cols*ld; p += ld)
       std::fill_n(p, rows, val);
   }
-  inline double &operator() (size_t i, size_t j) { return data[i+j*ld]; }
-  inline const double &operator() (size_t i, size_t j) const { return data[i+j*ld]; }
+  inline double &
+  operator()(size_t i, size_t j)
+  {
+    return data[i+j*ld];
+  }
+  inline const double &
+  operator()(size_t i, size_t j) const
+  {
+    return data[i+j*ld];
+  }
   //! Assignment operator, only works for matrices of same dimension
   template<class Mat>
   MatrixView &
-  operator= (const Mat &arg)
+  operator=(const Mat &arg)
   {
     assert(rows == arg.getRows() && cols == arg.getCols());
     for (size_t j = 0; j < cols; j++)
@@ -158,12 +222,34 @@ public:
            && col_offset < arg.getCols()
            && col_offset + cols_arg <= arg.getCols());
   }
-  virtual ~MatrixConstView(){};
-  inline size_t getRows() const { return rows; }
-  inline size_t getCols() const { return cols; }
-  inline size_t getLd() const { return ld; }
-  inline const double *getData() const { return data; }
-  inline const double &operator() (size_t i, size_t j) const { return data[i+j*ld]; }
+  virtual ~MatrixConstView()
+  {
+  };
+  inline size_t
+  getRows() const
+  {
+    return rows;
+  }
+  inline size_t
+  getCols() const
+  {
+    return cols;
+  }
+  inline size_t
+  getLd() const
+  {
+    return ld;
+  }
+  inline const double *
+  getData() const
+  {
+    return data;
+  }
+  inline const double &
+  operator()(size_t i, size_t j) const
+  {
+    return data[i+j*ld];
+  }
 };
 
 std::ostream &operator<<(std::ostream &out, const Matrix &M);
@@ -561,9 +647,9 @@ namespace mat
 
     if (vToRows.size() == 0 && vToCols.size() == 0 && vrows.size() == 0 && vcols.size() == 0)
       a = b;
-    else if (vToRows.size() == 0 && vrows.size() == 0)                                                                                                                                                                                                                                                                                                                                            // just reorder columns
+    else if (vToRows.size() == 0 && vrows.size() == 0)                                                                                                                                                                                                                                                                                                                                                                                                    // just reorder columns
       reorderColumnsByVectors(a, vToCols, b, vcols);
-    else if (vToCols.size() == 0 && vcols.size() == 0)                                                                                                                                                                                                                                                                                                                                            // just reorder rows
+    else if (vToCols.size() == 0 && vcols.size() == 0)                                                                                                                                                                                                                                                                                                                                                                                                    // just reorder rows
       reorderRowsByVectors(a, vToRows, b, vrows);
     else
       {
diff --git a/mex/sources/estimation/libmat/QRDecomposition.hh b/mex/sources/estimation/libmat/QRDecomposition.hh
index d8022a7e5..d77c2baaf 100644
--- a/mex/sources/estimation/libmat/QRDecomposition.hh
+++ b/mex/sources/estimation/libmat/QRDecomposition.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -41,7 +41,8 @@ public:
     \param[in] cols2_arg Number of columns of the matrix to be multiplied by Q
   */
   QRDecomposition(size_t rows_arg, size_t cols_arg, size_t cols2_arg);
-  virtual ~QRDecomposition();
+  virtual
+  ~QRDecomposition();
   //! Performs the QR decomposition of a matrix, and left-multiplies another matrix by Q
   /*!
     \param[in,out] A On input, the matrix to be decomposed. On output, equals to the output of dgeqrf
diff --git a/mex/sources/estimation/libmat/Vector.hh b/mex/sources/estimation/libmat/Vector.hh
index d020beaf4..f4c71c404 100644
--- a/mex/sources/estimation/libmat/Vector.hh
+++ b/mex/sources/estimation/libmat/Vector.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -63,17 +63,47 @@ private:
 public:
   Vector(size_t size_arg);
   Vector(const Vector &arg);
-  virtual ~Vector();
-  inline size_t getSize() const { return size; }
-  inline size_t getStride() const { return 1; }
-  inline double *getData() { return data; }
-  inline const double *getData() const { return data; }
-  inline void setAll(double val) { std::fill_n(data, size, val); }
-  inline double &operator() (size_t i) { return data[i]; }
-  inline const double &operator() (size_t i) const { return data[i]; }
+  virtual
+  ~Vector();
+  inline size_t
+  getSize() const
+  {
+    return size;
+  }
+  inline size_t
+  getStride() const
+  {
+    return 1;
+  }
+  inline double *
+  getData()
+  {
+    return data;
+  }
+  inline const double *
+  getData() const
+  {
+    return data;
+  }
+  inline void
+  setAll(double val)
+  {
+    std::fill_n(data, size, val);
+  }
+  inline double &
+  operator()(size_t i)
+  {
+    return data[i];
+  }
+  inline const double &
+  operator()(size_t i) const
+  {
+    return data[i];
+  }
   //! Assignment operator, only works for vectors of same size
   template<class Vec>
-  Vector &operator=(const Vec &arg)
+  Vector &
+  operator=(const Vec &arg)
   {
     assert(size == arg.getSize());
     const double *p2 = arg.getData();
@@ -99,25 +129,52 @@ private:
 public:
   VectorView(double *data_arg, size_t size_arg, size_t stride_arg);
   /* Can't use a template for the 2 constructors below: this would override the
-  constructor which uses a pointer, because the argument list is the same */
+     constructor which uses a pointer, because the argument list is the same */
   VectorView(Vector &arg, size_t offset, size_t size_arg);
   VectorView(VectorView &arg, size_t offset, size_t size_arg);
-  virtual ~VectorView(){};
-  inline size_t getSize() const { return size; }
-  inline size_t getStride() const { return stride; }
-  inline double *getData() { return data; }
-  inline const double *getData() const { return data; }
-  inline void setAll(double val)
+  virtual ~VectorView()
+  {
+  };
+  inline size_t
+  getSize() const
+  {
+    return size;
+  }
+  inline size_t
+  getStride() const
+  {
+    return stride;
+  }
+  inline double *
+  getData()
+  {
+    return data;
+  }
+  inline const double *
+  getData() const
+  {
+    return data;
+  }
+  inline void
+  setAll(double val)
   {
     for (double *p = data; p < data + size*stride; p += stride)
       *p = val;
   }
-  inline double &operator() (size_t i) { return data[i*stride]; }
-  inline const double &operator() (size_t i) const { return data[i*stride]; }
+  inline double &
+  operator()(size_t i)
+  {
+    return data[i*stride];
+  }
+  inline const double &
+  operator()(size_t i) const
+  {
+    return data[i*stride];
+  }
   //! Assignment operator, only works for vectors of same size
   template<class Vec>
   VectorView &
-  operator= (const Vec &arg)
+  operator=(const Vec &arg)
   {
     assert(size == arg.getSize());
     double *p1;
@@ -145,11 +202,29 @@ public:
   VectorConstView(const VectorView &arg, size_t offset, size_t size_arg);
   VectorConstView(const VectorConstView &arg, size_t offset, size_t size_arg);
 
-  virtual ~VectorConstView() {};
-  inline size_t getSize() const { return size; }
-  inline size_t getStride() const { return stride; }
-  inline const double *getData() const { return data; }
-  inline const double &operator() (size_t i) const { return data[i*stride]; }
+  virtual ~VectorConstView()
+  {
+  };
+  inline size_t
+  getSize() const
+  {
+    return size;
+  }
+  inline size_t
+  getStride() const
+  {
+    return stride;
+  }
+  inline const double *
+  getData() const
+  {
+    return data;
+  }
+  inline const double &
+  operator()(size_t i) const
+  {
+    return data[i*stride];
+  }
 };
 
 std::ostream &operator<<(std::ostream &out, const Vector &V);
diff --git a/mex/sources/estimation/logMHMCMCposterior.cc b/mex/sources/estimation/logMHMCMCposterior.cc
index 5fd7faaae..6551701d8 100644
--- a/mex/sources/estimation/logMHMCMCposterior.cc
+++ b/mex/sources/estimation/logMHMCMCposterior.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -47,7 +47,11 @@ public:
   LogMHMCMCposteriorMexErrMsgTxtException(const std::string &msg) : errMsg(msg)
   {
   }
-  inline const char *getErrMsg() { return errMsg.c_str(); }
+  inline const char *
+  getErrMsg()
+  {
+    return errMsg.c_str();
+  }
 };
 
 void
@@ -279,7 +283,7 @@ sampleMHMC(LogPosteriorDensity &lpd, RandomWalkMetropolisHastings &rwmh,
               // new or different size result arrays/matrices
               currInitSizeArray = (size_t) InitSizeArray(b-1);
               if (mxMhLogPostDensPtr)
-                mxDestroyArray(mxMhLogPostDensPtr);                                                                                                          // log post density array
+                mxDestroyArray(mxMhLogPostDensPtr);                                                                                                                                                                // log post density array
               mxMhLogPostDensPtr = mxCreateDoubleMatrix(currInitSizeArray, 1, mxREAL);
               if (mxMhLogPostDensPtr == NULL)
                 {
@@ -287,7 +291,7 @@ sampleMHMC(LogPosteriorDensity &lpd, RandomWalkMetropolisHastings &rwmh,
                   return (-1);
                 }
               if (mxMhParamDrawsPtr)
-                mxDestroyArray(mxMhParamDrawsPtr);                                                                                                        // accepted MCMC MH draws
+                mxDestroyArray(mxMhParamDrawsPtr);                                                                                                                                                             // accepted MCMC MH draws
               mxMhParamDrawsPtr =  mxCreateDoubleMatrix(currInitSizeArray, npar,  mxREAL);
               if (mxMhParamDrawsPtr == NULL)
                 {
@@ -375,7 +379,7 @@ sampleMHMC(LogPosteriorDensity &lpd, RandomWalkMetropolisHastings &rwmh,
               // new or different size result arrays/matrices
               currInitSizeArray = (size_t) InitSizeArray(b-1);
               if (mxMhLogPostDensPtr)
-                mxDestroyArray(mxMhLogPostDensPtr);                                                                                                          // log post density array
+                mxDestroyArray(mxMhLogPostDensPtr);                                                                                                                                                                // log post density array
               mxMhLogPostDensPtr = mxCreateDoubleMatrix(currInitSizeArray, 1, mxREAL);
               if (mxMhLogPostDensPtr == NULL)
                 {
@@ -383,7 +387,7 @@ sampleMHMC(LogPosteriorDensity &lpd, RandomWalkMetropolisHastings &rwmh,
                   return (-1);
                 }
               if (mxMhParamDrawsPtr)
-                mxDestroyArray(mxMhParamDrawsPtr);                                                                                                        // accepted MCMC MH draws
+                mxDestroyArray(mxMhParamDrawsPtr);                                                                                                                                                             // accepted MCMC MH draws
               mxMhParamDrawsPtr =  mxCreateDoubleMatrix(currInitSizeArray, npar,  mxREAL);
               if (mxMhParamDrawsPtr == NULL)
                 {
@@ -603,9 +607,9 @@ sampleMHMC(LogPosteriorDensity &lpd, RandomWalkMetropolisHastings &rwmh,
 
  cleanup:
   if (mxMhLogPostDensPtr)
-    mxDestroyArray(mxMhLogPostDensPtr);                                            // delete log post density array
+    mxDestroyArray(mxMhLogPostDensPtr);                                                                                      // delete log post density array
   if (mxMhParamDrawsPtr)
-    mxDestroyArray(mxMhParamDrawsPtr);                                            // delete accepted MCMC MH draws
+    mxDestroyArray(mxMhParamDrawsPtr);                                                                                     // delete accepted MCMC MH draws
 
 #ifdef MATLAB_MEX_FILE
   // Waitbar
@@ -631,7 +635,7 @@ sampleMHMC(LogPosteriorDensity &lpd, RandomWalkMetropolisHastings &rwmh,
 int
 logMCMCposterior(VectorConstView &estParams, const MatrixConstView &data,
                  const size_t fblock, const size_t nBlocks, const VectorConstView &nMHruns, const MatrixConstView &D,
-		 VectorView &steadyState, VectorView &deepParams, MatrixView &Q, Matrix &H)
+                 VectorView &steadyState, VectorView &deepParams, MatrixView &Q, Matrix &H)
 {
   // Retrieve pointers to global variables
   const mxArray *M_ = mexGetVariablePtr("global", "M_");
@@ -712,7 +716,6 @@ logMCMCposterior(VectorConstView &estParams, const MatrixConstView &data,
                     estParamsInfo);
   EstimatedParametersDescription epd(estSubsamples, estParamsInfo);
 
-
   bool noconstant = (bool) *mxGetPr(mxGetField(options_, 0, "noconstant"));
 
   // Allocate LogPosteriorDensity object
@@ -771,20 +774,20 @@ mexFunction(int nlhs, mxArray *plhs[],
 
   assert(nMHruns.getSize() == nBlocks);
 
-  mxArray *dataset_data = mxGetField(dataset,0,"data");
+  mxArray *dataset_data = mxGetField(dataset, 0, "data");
   MatrixConstView data(mxGetPr(dataset_data), mxGetM(dataset_data), mxGetN(dataset_data), mxGetM(dataset_data));
 
-  int endo_nbr = *(int*)mxGetPr(mxGetField(M_, 0, "endo_nbr"));
-  int exo_nbr = *(int*)mxGetPr(mxGetField(M_, 0, "exo_nbr"));
-  int param_nbr = *(int*)mxGetPr(mxGetField(M_, 0, "param_nbr"));
+  int endo_nbr = *(int *) mxGetPr(mxGetField(M_, 0, "endo_nbr"));
+  int exo_nbr = *(int *) mxGetPr(mxGetField(M_, 0, "exo_nbr"));
+  int param_nbr = *(int *) mxGetPr(mxGetField(M_, 0, "param_nbr"));
   int varobs_nbr = mxGetN(mxGetField(options_, 0, "varobs"));
 
-  VectorView steadyState(mxGetPr(mxGetField(oo_,0,"steady_state")),endo_nbr, 1);
-  VectorView deepParams(mxGetPr(mxGetField(M_, 0, "params")),param_nbr,1);
+  VectorView steadyState(mxGetPr(mxGetField(oo_, 0, "steady_state")), endo_nbr, 1);
+  VectorView deepParams(mxGetPr(mxGetField(M_, 0, "params")), param_nbr, 1);
 
   MatrixView Q(mxGetPr(mxGetField(M_, 0, "Sigma_e")), exo_nbr, exo_nbr, exo_nbr);
 
-  Matrix H(varobs_nbr,varobs_nbr);
+  Matrix H(varobs_nbr, varobs_nbr);
   const mxArray *H_mx = mxGetField(M_, 0, "H");
   if (mxGetM(H_mx) == 1 && mxGetN(H_mx) == 1 && *mxGetPr(H_mx) == 0)
     H.setAll(0.0);
diff --git a/mex/sources/estimation/logposterior.cc b/mex/sources/estimation/logposterior.cc
index 641244ce4..95e4e3cbe 100644
--- a/mex/sources/estimation/logposterior.cc
+++ b/mex/sources/estimation/logposterior.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -36,7 +36,11 @@ public:
   LogposteriorMexErrMsgTxtException(const std::string &msg) : errMsg(msg)
   {
   }
-  inline const char *getErrMsg() { return errMsg.c_str(); }
+  inline const char *
+  getErrMsg()
+  {
+    return errMsg.c_str();
+  }
 };
 
 void
@@ -103,8 +107,8 @@ template <class VEC1, class VEC2>
 double
 logposterior(VEC1 &estParams, const MatrixConstView &data,
              const mxArray *options_, const mxArray *M_, const mxArray *estim_params_,
-	     const mxArray *bayestopt_, const mxArray *oo_, VEC2 &steadyState, double *trend_coeff,
-	     VectorView &deepParams, Matrix &H, MatrixView &Q)
+             const mxArray *bayestopt_, const mxArray *oo_, VEC2 &steadyState, double *trend_coeff,
+             VectorView &deepParams, Matrix &H, MatrixView &Q)
 {
   double loglinear = *mxGetPr(mxGetField(options_, 0, "loglinear"));
   if (loglinear == 1)
@@ -203,10 +207,10 @@ void
 mexFunction(int nlhs, mxArray *plhs[],
             int nrhs, const mxArray *prhs[])
 {
-  if (nrhs != 7 )
+  if (nrhs != 7)
     DYN_MEX_FUNC_ERR_MSG_TXT("logposterior: exactly 7 input arguments are required.");
 
-  if (nlhs > 9 )
+  if (nlhs > 9)
     DYN_MEX_FUNC_ERR_MSG_TXT("logposterior returns 8 output arguments at the most.");
 
   // Check and retrieve the RHS arguments
@@ -219,9 +223,9 @@ mexFunction(int nlhs, mxArray *plhs[],
   for (int i = 1; i < 7; ++i)
     if (!mxIsStruct(prhs[i]))
       {
-	std::stringstream msg;
-	msg << "logposterior: argument " << i+1 << " must be a Matlab structure";
-	DYN_MEX_FUNC_ERR_MSG_TXT(msg.str().c_str());
+        std::stringstream msg;
+        msg << "logposterior: argument " << i+1 << " must be a Matlab structure";
+        DYN_MEX_FUNC_ERR_MSG_TXT(msg.str().c_str());
       }
 
   const mxArray *dataset = prhs[1];
@@ -231,7 +235,7 @@ mexFunction(int nlhs, mxArray *plhs[],
   const mxArray *bayestopt_ = prhs[5];
   const mxArray *oo_ = prhs[6];
 
-  const mxArray *dataset_data = mxGetField(dataset,0,"data");
+  const mxArray *dataset_data = mxGetField(dataset, 0, "data");
   MatrixConstView data(mxGetPr(dataset_data), mxGetM(dataset_data), mxGetN(dataset_data), mxGetM(dataset_data));
 
   // Creaete LHS arguments
@@ -251,12 +255,12 @@ mexFunction(int nlhs, mxArray *plhs[],
   double *lik = mxGetPr(plhs[0]);
   double *exit_flag = mxGetPr(plhs[1]);
 
-  VectorView steadyState(mxGetPr(mxGetField(oo_,0,"steady_state")),endo_nbr, 1);
-  VectorView deepParams(mxGetPr(mxGetField(M_, 0, "params")),param_nbr,1);
+  VectorView steadyState(mxGetPr(mxGetField(oo_, 0, "steady_state")), endo_nbr, 1);
+  VectorView deepParams(mxGetPr(mxGetField(M_, 0, "params")), param_nbr, 1);
 
   MatrixView Q(mxGetPr(mxGetField(M_, 0, "Sigma_e")), exo_nbr, exo_nbr, exo_nbr);
 
-  Matrix H(varobs_nbr,varobs_nbr);
+  Matrix H(varobs_nbr, varobs_nbr);
   const mxArray *H_mx = mxGetField(M_, 0, "H");
   if (mxGetM(H_mx) == 1 && mxGetN(H_mx) == 1 && *mxGetPr(H_mx) == 0)
     H.setAll(0.0);
@@ -270,7 +274,7 @@ mexFunction(int nlhs, mxArray *plhs[],
   try
     {
       *lik = logposterior(estParams, data, options_, M_, estim_params_, bayestopt_, oo_,
-				steadyState, trend_coeff, deepParams, H, Q);
+                          steadyState, trend_coeff, deepParams, H, Q);
       *info_mx = 0;
       *exit_flag = 0;
     }
diff --git a/mex/sources/estimation/tests/testInitKalman.cc b/mex/sources/estimation/tests/testInitKalman.cc
index 37884a6cc..28139ccdb 100644
--- a/mex/sources/estimation/tests/testInitKalman.cc
+++ b/mex/sources/estimation/tests/testInitKalman.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -147,4 +147,3 @@ main(int argc, char **argv)
   std::cout << "Matrix Pinf: " << std::endl << Pinf << std::endl;
 
 }
-
diff --git a/mex/sources/estimation/tests/testKalman.cc b/mex/sources/estimation/tests/testKalman.cc
index cd1401c69..f75f3459e 100644
--- a/mex/sources/estimation/tests/testKalman.cc
+++ b/mex/sources/estimation/tests/testKalman.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -130,4 +130,3 @@ main(int argc, char **argv)
 
   std::cout << "ll: " << std::endl << ll << std::endl;
 }
-
diff --git a/mex/sources/estimation/utils/dynamic_dll.cc b/mex/sources/estimation/utils/dynamic_dll.cc
index b50d67c41..e9d126d9e 100644
--- a/mex/sources/estimation/utils/dynamic_dll.cc
+++ b/mex/sources/estimation/utils/dynamic_dll.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -88,4 +88,3 @@ DynamicModelDLL::~DynamicModelDLL()
   dlclose(dynamicHinstance);
 #endif
 }
-
diff --git a/mex/sources/estimation/utils/dynamic_dll.hh b/mex/sources/estimation/utils/dynamic_dll.hh
index 36f5b9ec3..5e19472ee 100644
--- a/mex/sources/estimation/utils/dynamic_dll.hh
+++ b/mex/sources/estimation/utils/dynamic_dll.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -32,9 +32,8 @@
 #include "ts_exception.h"
 
 // <model>_Dynamic DLL pointer
-typedef void (*DynamicFn)
-(const double *y, const double *x, int nb_row_x, const double *params, const double *steady_state,
- int it_, double *residual, double *g1, double *g2, double *g3);
+typedef void (*DynamicFn)(const double *y, const double *x, int nb_row_x, const double *params, const double *steady_state,
+                          int it_, double *residual, double *g1, double *g2, double *g3);
 
 /**
  * creates pointer to Dynamic function inside <model>_dynamic.dll
@@ -53,12 +52,14 @@ private:
 public:
   // construct and load Dynamic model DLL
   DynamicModelDLL(const std::string &basename) throw (TSException);
-  virtual ~DynamicModelDLL();
+  virtual
+  ~DynamicModelDLL();
 
   //! evaluate Dynamic model DLL
   template<class Vec1, class Vec2, class Vec3, class Vec4, class Mat1>
-  void eval(const Vec1 &y, const Mat1 &x, const Vec2 &modParams, const Vec3 &ySteady,
-            Vec4 &residual, Matrix *g1, Matrix *g2, Matrix *g3) throw (TSException)
+  void
+  eval(const Vec1 &y, const Mat1 &x, const Vec2 &modParams, const Vec3 &ySteady,
+       Vec4 &residual, Matrix *g1, Matrix *g2, Matrix *g3) throw (TSException)
   {
     assert(y.getStride() == 1);
     assert(x.getLd() == x.getRows());
@@ -70,6 +71,6 @@ public:
     assert(g3->getLd() == g3->getRows());
 
     Dynamic(y.getData(), x.getData(), 1, modParams.getData(), ySteady.getData(), 0, residual.getData(),
-	    g1 == NULL ? NULL : g1->getData(), g2 == NULL ? NULL : g2->getData(), g3 == NULL ? NULL : g3->getData());
+            g1 == NULL ? NULL : g1->getData(), g2 == NULL ? NULL : g2->getData(), g3 == NULL ? NULL : g3->getData());
   };
 };
diff --git a/mex/sources/estimation/utils/static_dll.hh b/mex/sources/estimation/utils/static_dll.hh
index 77f183890..36b28a9f2 100644
--- a/mex/sources/estimation/utils/static_dll.hh
+++ b/mex/sources/estimation/utils/static_dll.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -32,8 +32,7 @@
 #include "ts_exception.h"
 
 // Pointer to the Static function in the MEX
-typedef void (*StaticFn)
-(const double *y, const double *x, int nb_row_x, const double *params, double *residual, double *g1, double *v2);
+typedef void (*StaticFn)(const double *y, const double *x, int nb_row_x, const double *params, double *residual, double *g1, double *v2);
 
 /**
  * creates pointer to Dynamic function inside <model>_static.dll
@@ -52,12 +51,14 @@ private:
 public:
   // construct and load Static model DLL
   StaticModelDLL(const std::string &basename) throw (TSException);
-  virtual ~StaticModelDLL();
+  virtual
+  ~StaticModelDLL();
 
   //! evaluate Static model DLL
   template<class Vec1, class Vec2, class Vec3, class Mat1>
-  void eval(const Vec1 &y, const Mat1 &x, const Vec2 &modParams,
-            Vec3 &residual, Matrix *g1, Matrix *v2) throw (TSException)
+  void
+  eval(const Vec1 &y, const Mat1 &x, const Vec2 &modParams,
+       Vec3 &residual, Matrix *g1, Matrix *v2) throw (TSException)
   {
     assert(y.getStride() == 1);
     assert(x.getLd() == x.getRows());
@@ -67,6 +68,6 @@ public:
     assert(v2->getLd() == v2->getRows());
 
     Static(y.getData(), x.getData(), 1, modParams.getData(), residual.getData(),
-	    g1 == NULL ? NULL : g1->getData(), v2 == NULL ? NULL : v2->getData());
+           g1 == NULL ? NULL : g1->getData(), v2 == NULL ? NULL : v2->getData());
   };
 };
diff --git a/mex/sources/estimation/utils/ts_exception.h b/mex/sources/estimation/utils/ts_exception.h
index b0f8ca71a..c3d3ea3c7 100644
--- a/mex/sources/estimation/utils/ts_exception.h
+++ b/mex/sources/estimation/utils/ts_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -70,4 +70,3 @@ public:
 
 ;
 #endif
-
diff --git a/mex/sources/k_order_perturbation/dynamic_dll.hh b/mex/sources/k_order_perturbation/dynamic_dll.hh
index cf3755058..15b4acfe9 100644
--- a/mex/sources/k_order_perturbation/dynamic_dll.hh
+++ b/mex/sources/k_order_perturbation/dynamic_dll.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2012 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -35,9 +35,8 @@
 #include "dynare_exception.h"
 
 // <model>_Dynamic DLL pointer
-typedef void (*DynamicDLLFn)
-(const double *y, const double *x, int nb_row_x, const double *params, const double *steady_state,
- int it_, double *residual, double *g1, double *g2, double *g3);
+typedef void (*DynamicDLLFn)(const double *y, const double *x, int nb_row_x, const double *params, const double *steady_state,
+                             int it_, double *residual, double *g1, double *g2, double *g3);
 
 /**
  * creates pointer to Dynamic function inside <model>_dynamic.dll
@@ -56,7 +55,8 @@ private:
 public:
   // construct and load Dynamic model DLL
   DynamicModelDLL(const string &fname) throw (DynareException);
-  virtual ~DynamicModelDLL();
+  virtual
+  ~DynamicModelDLL();
 
   void eval(const Vector &y, const Vector &x, const Vector &params, const Vector &ySteady,
             Vector &residual, TwoDMatrix *g1, TwoDMatrix *g2, TwoDMatrix *g3) throw (DynareException);
diff --git a/mex/sources/k_order_perturbation/dynamic_m.hh b/mex/sources/k_order_perturbation/dynamic_m.hh
index 632dcdd7a..260d07ef8 100644
--- a/mex/sources/k_order_perturbation/dynamic_m.hh
+++ b/mex/sources/k_order_perturbation/dynamic_m.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -37,7 +37,8 @@ private:
   const static int nrhs_dynamic = 5;
 public:
   DynamicModelMFile(const string &modName) throw (DynareException);
-  virtual ~DynamicModelMFile();
+  virtual
+  ~DynamicModelMFile();
   void eval(const Vector &y, const Vector &x, const Vector &params, const Vector &ySteady,
             Vector &residual, TwoDMatrix *g1, TwoDMatrix *g2, TwoDMatrix *g3) throw (DynareException);
 };
diff --git a/mex/sources/k_order_perturbation/k_ord_dynare.cc b/mex/sources/k_order_perturbation/k_ord_dynare.cc
index 5f7572a94..7602b550d 100644
--- a/mex/sources/k_order_perturbation/k_ord_dynare.cc
+++ b/mex/sources/k_order_perturbation/k_ord_dynare.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2014 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -63,7 +63,7 @@ KordpDynare::KordpDynare(const vector<string> &endo, int num_endo,
                          const int nsteps, int norder,
                          Journal &jr, DynamicModelAC *dynamicModelFile_arg, double sstol,
                          const vector<int> &var_order, const TwoDMatrix &llincidence, double criterium,
-			 TwoDMatrix *g1_arg, TwoDMatrix *g2_arg, TwoDMatrix *g3_arg) throw (TLException) :
+                         TwoDMatrix *g1_arg, TwoDMatrix *g2_arg, TwoDMatrix *g3_arg) throw (TLException) :
   nStat(nstat), nBoth(nboth), nPred(npred), nForw(nforw), nExog(nexog), nPar(npar),
   nYs(npred + nboth), nYss(nboth + nforw), nY(num_endo), nJcols(jcols), NNZD(nnzd), nSteps(nsteps),
   nOrder(norder), journal(jr), ySteady(ysteady), params(inParams), vCov(vcov),
@@ -116,30 +116,30 @@ KordpDynare::calcDerivativesAtSteady()
     {
       g1p = new TwoDMatrix(nY, nJcols);
       g1p->zeros();
-      
+
       if (nOrder > 1)
-	{
-	  // allocate space for sparse Hessian
-	  g2p = new TwoDMatrix((int) NNZD[1], 3);
-	  g2p->zeros();
-	}
-      
+        {
+          // allocate space for sparse Hessian
+          g2p = new TwoDMatrix((int) NNZD[1], 3);
+          g2p->zeros();
+        }
+
       if (nOrder > 2)
-	{
-	  g3p = new TwoDMatrix((int) NNZD[2], 3);
-	  g3p->zeros();
-	}
+        {
+          g3p = new TwoDMatrix((int) NNZD[2], 3);
+          g3p->zeros();
+        }
 
       Vector xx(nexog());
       xx.zeros();
-      
+
       Vector out(nY);
       out.zeros();
       Vector llxSteady(nJcols-nExog);
       LLxSteady(ySteady, llxSteady);
-      
+
       dynamicModelFile->eval(llxSteady, xx, params, ySteady, out, g1p, g2p, g3p);
-                
+
     }
 
   populateDerivativesContainer(*g1p, 1, JacobianIndices);
diff --git a/mex/sources/k_order_perturbation/k_ord_dynare.hh b/mex/sources/k_order_perturbation/k_ord_dynare.hh
index 62fcc7c0f..b5d942f6b 100644
--- a/mex/sources/k_order_perturbation/k_ord_dynare.hh
+++ b/mex/sources/k_order_perturbation/k_ord_dynare.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2012 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -135,7 +135,8 @@ public:
               const vector<int> &varOrder, const TwoDMatrix &ll_Incidence,
               double qz_criterium, TwoDMatrix *g1_arg, TwoDMatrix *g2_arg, TwoDMatrix *g3_arg) throw (TLException);
 
-  virtual ~KordpDynare();
+  virtual
+  ~KordpDynare();
   int
   nstat() const
   {
diff --git a/mex/sources/k_order_perturbation/k_order_perturbation.cc b/mex/sources/k_order_perturbation/k_order_perturbation.cc
index f2eb3f80d..1159b810b 100644
--- a/mex/sources/k_order_perturbation/k_order_perturbation.cc
+++ b/mex/sources/k_order_perturbation/k_order_perturbation.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2014 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -62,14 +62,15 @@ DynareMxArrayToString(const mxArray *mxFldp, const int len, const int width, vec
         out[j] += cNamesCharStr[j+i*len];
 }
 
-void copy_derivatives(mxArray *destin,const Symmetry &sym,const FGSContainer *derivs,const std::string &fieldname)
+void
+copy_derivatives(mxArray *destin, const Symmetry &sym, const FGSContainer *derivs, const std::string &fieldname)
 {
-  const TwoDMatrix* x = derivs->get(sym);
+  const TwoDMatrix *x = derivs->get(sym);
   int n = x->numRows();
   int m = x->numCols();
   mxArray *tmp = mxCreateDoubleMatrix(n, m, mxREAL);
-  memcpy(mxGetPr(tmp),x->getData().base(),n*m*sizeof(double));
-  mxSetField(destin,0,fieldname.c_str(),tmp);
+  memcpy(mxGetPr(tmp), x->getData().base(), n*m*sizeof(double));
+  mxSetField(destin, 0, fieldname.c_str(), tmp);
 }
 
 extern "C" {
@@ -176,7 +177,7 @@ extern "C" {
     //get NNZH =NNZD(2) = the total number of non-zero Hessian elements
     mxFldp = mxGetField(M_, 0, "NNZDerivatives");
     dparams = mxGetPr(mxFldp);
-    Vector NNZD(dparams, (int) mxGetM(mxFldp));
+    Vector NNZD(dparams, (int)mxGetM(mxFldp));
     if (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");
 
@@ -197,32 +198,31 @@ extern "C" {
     if ((nEndo != nendo) || (nExog != nexo))
       DYN_MEX_FUNC_ERR_MSG_TXT("Incorrect number of input parameters.");
 
-    TwoDMatrix *g1m=NULL;
-    TwoDMatrix *g2m=NULL;
-    TwoDMatrix *g3m=NULL;
+    TwoDMatrix *g1m = NULL;
+    TwoDMatrix *g2m = NULL;
+    TwoDMatrix *g3m = NULL;
     // derivatives passed as arguments */
-    if (nrhs > 3) 
+    if (nrhs > 3)
       {
-	const mxArray *g1 = prhs[3];
-	int m = (int) mxGetM(g1);
-	int n = (int) mxGetN(g1);
-	g1m = new TwoDMatrix(m, n, mxGetPr(g1));
-	if (nrhs > 4)
-	  {
-	    const mxArray *g2 = prhs[4];
-	    int m = (int) mxGetM(g2);
-	    int n = (int) mxGetN(g2);
-	    g2m = new TwoDMatrix(m, n, mxGetPr(g2));
-	    if (nrhs > 5)
-	      {
-		const mxArray *g3 = prhs[5];
-		int m = (int) mxGetM(g3);
-		int n = (int) mxGetN(g3);
-		g3m = new TwoDMatrix(m, n, mxGetPr(g3));
-	      }
-	  }
+        const mxArray *g1 = prhs[3];
+        int m = (int) mxGetM(g1);
+        int n = (int) mxGetN(g1);
+        g1m = new TwoDMatrix(m, n, mxGetPr(g1));
+        if (nrhs > 4)
+          {
+            const mxArray *g2 = prhs[4];
+            int m = (int) mxGetM(g2);
+            int n = (int) mxGetN(g2);
+            g2m = new TwoDMatrix(m, n, mxGetPr(g2));
+            if (nrhs > 5)
+              {
+                const mxArray *g3 = prhs[5];
+                int m = (int) mxGetM(g3);
+                int n = (int) mxGetN(g3);
+                g3m = new TwoDMatrix(m, n, mxGetPr(g3));
+              }
+          }
       }
-	    
 
     const int nSteps = 0; // Dynare++ solving steps, for time being default to 0 = deterministic steady state
     const double sstol = 1.e-13; //NL solver tolerance from
@@ -250,7 +250,7 @@ extern "C" {
                            ySteady, vCov, modParams, nStat, nPred, nForw, nBoth,
                            jcols, NNZD, nSteps, kOrder, journal, dynamicModelFile,
                            sstol, var_order_vp, llincidence, qz_criterium,
-			   g1m, g2m, g3m);
+                           g1m, g2m, g3m);
 
         // construct main K-order approximation class
 
@@ -283,40 +283,40 @@ extern "C" {
             for (map<string, ConstTwoDMatrix>::const_iterator cit = mm.begin();
                  ((cit != mm.end()) && (ii < nlhs)); ++cit)
               {
-		plhs[ii] = mxCreateDoubleMatrix((*cit).second.numRows(), (*cit).second.numCols(), mxREAL);
-		
-		// Copy Dynare++ matrix into MATLAB matrix
-		const ConstVector &vec = (*cit).second.getData();
-		assert(vec.skip() == 1);
-		memcpy(mxGetPr(plhs[ii]), vec.base(), vec.length() * sizeof(double));
-		
-		++ii;
-		
+                plhs[ii] = mxCreateDoubleMatrix((*cit).second.numRows(), (*cit).second.numCols(), mxREAL);
+
+                // Copy Dynare++ matrix into MATLAB matrix
+                const ConstVector &vec = (*cit).second.getData();
+                assert(vec.skip() == 1);
+                memcpy(mxGetPr(plhs[ii]), vec.base(), vec.length() * sizeof(double));
+
+                ++ii;
+
               }
-	    if (kOrder == 3 && nlhs > 4)
-	      {
-		const FGSContainer *derivs = app.get_rule_ders();
-		const std::string fieldnames[] = {"gy", "gu", "gyy", "gyu", "guu", "gss", 
-				      "gyyy", "gyyu", "gyuu", "guuu", "gyss", "guss"};
-		// creates the char** expected by mxCreateStructMatrix()
-		const char* c_fieldnames[12];
-		for (int i=0; i < 12;++i)
-		  c_fieldnames[i] = fieldnames[i].c_str();
-		plhs[ii] = mxCreateStructMatrix(1,1,12,c_fieldnames);
-		copy_derivatives(plhs[ii],Symmetry(1,0,0,0),derivs,"gy");
-		copy_derivatives(plhs[ii],Symmetry(0,1,0,0),derivs,"gu");
-		copy_derivatives(plhs[ii],Symmetry(2,0,0,0),derivs,"gyy");
-		copy_derivatives(plhs[ii],Symmetry(0,2,0,0),derivs,"guu");
-		copy_derivatives(plhs[ii],Symmetry(1,1,0,0),derivs,"gyu");
-		copy_derivatives(plhs[ii],Symmetry(0,0,0,2),derivs,"gss");
-		copy_derivatives(plhs[ii],Symmetry(3,0,0,0),derivs,"gyyy");
-		copy_derivatives(plhs[ii],Symmetry(0,3,0,0),derivs,"guuu");
-		copy_derivatives(plhs[ii],Symmetry(2,1,0,0),derivs,"gyyu");
-		copy_derivatives(plhs[ii],Symmetry(1,2,0,0),derivs,"gyuu");
-		copy_derivatives(plhs[ii],Symmetry(1,0,0,2),derivs,"gyss");
-		copy_derivatives(plhs[ii],Symmetry(0,1,0,2),derivs,"guss");
-	      }
-	  }
+            if (kOrder == 3 && nlhs > 4)
+              {
+                const FGSContainer *derivs = app.get_rule_ders();
+                const std::string fieldnames[] = {"gy", "gu", "gyy", "gyu", "guu", "gss",
+                                                  "gyyy", "gyyu", "gyuu", "guuu", "gyss", "guss"};
+                // creates the char** expected by mxCreateStructMatrix()
+                const char *c_fieldnames[12];
+                for (int i = 0; i < 12; ++i)
+                  c_fieldnames[i] = fieldnames[i].c_str();
+                plhs[ii] = mxCreateStructMatrix(1, 1, 12, c_fieldnames);
+                copy_derivatives(plhs[ii], Symmetry(1, 0, 0, 0), derivs, "gy");
+                copy_derivatives(plhs[ii], Symmetry(0, 1, 0, 0), derivs, "gu");
+                copy_derivatives(plhs[ii], Symmetry(2, 0, 0, 0), derivs, "gyy");
+                copy_derivatives(plhs[ii], Symmetry(0, 2, 0, 0), derivs, "guu");
+                copy_derivatives(plhs[ii], Symmetry(1, 1, 0, 0), derivs, "gyu");
+                copy_derivatives(plhs[ii], Symmetry(0, 0, 0, 2), derivs, "gss");
+                copy_derivatives(plhs[ii], Symmetry(3, 0, 0, 0), derivs, "gyyy");
+                copy_derivatives(plhs[ii], Symmetry(0, 3, 0, 0), derivs, "guuu");
+                copy_derivatives(plhs[ii], Symmetry(2, 1, 0, 0), derivs, "gyyu");
+                copy_derivatives(plhs[ii], Symmetry(1, 2, 0, 0), derivs, "gyuu");
+                copy_derivatives(plhs[ii], Symmetry(1, 0, 0, 2), derivs, "gyss");
+                copy_derivatives(plhs[ii], Symmetry(0, 1, 0, 2), derivs, "guss");
+              }
+          }
       }
     catch (const KordException &e)
       {
diff --git a/mex/sources/kronecker/sparse_hessian_times_B_kronecker_C.cc b/mex/sources/kronecker/sparse_hessian_times_B_kronecker_C.cc
index d4f50cc57..492a18ff6 100644
--- a/mex/sources/kronecker/sparse_hessian_times_B_kronecker_C.cc
+++ b/mex/sources/kronecker/sparse_hessian_times_B_kronecker_C.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2011 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -143,7 +143,7 @@ void
 mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
 {
   // Check input and output:
-  if ((nrhs > 4) || (nrhs < 3) )
+  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 (!mxIsSparse(prhs[0]))
diff --git a/mex/sources/linsolve/linsolve.cc b/mex/sources/linsolve/linsolve.cc
index b33cf2f45..c8e55eecb 100644
--- a/mex/sources/linsolve/linsolve.cc
+++ b/mex/sources/linsolve/linsolve.cc
@@ -10,7 +10,7 @@
  */
 
 /*
- * Copyright (C) 2012-2013 Dynare Team
+ * Copyright (C) 2012-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -28,7 +28,6 @@
  * along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <octave/oct.h>
 #include <octave/ov-struct.h>
 
@@ -81,10 +80,9 @@ If requested, @var{r} will contain the reciprocal condition number.\n\
       return retval;
     }
 
-  
   MatrixType typA;
   typA.mark_as_full();
-  
+
   bool transa = false;
   if (nargin == 3)
     {
diff --git a/mex/sources/local_state_space_iterations/local_state_space_iteration_2.cc b/mex/sources/local_state_space_iterations/local_state_space_iteration_2.cc
index de78ff2e4..3b45d193a 100644
--- a/mex/sources/local_state_space_iterations/local_state_space_iteration_2.cc
+++ b/mex/sources/local_state_space_iterations/local_state_space_iteration_2.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2013 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -29,23 +29,24 @@
 #include <dynblas.h>
 
 #ifdef USE_OMP
-#include <omp.h>
+# include <omp.h>
 #endif
 
 using namespace std;
 
 #define FIRST_ORDER_LOOP 1// Comment out this line to use mkl-blas instead of loops when computing ghx*yhat and ghu*epsilon
 
-void set_vector_of_indices(const int n, const int r, vector<int> &v1, vector<int> &v2, vector<int> &v3)
+void
+set_vector_of_indices(const int n, const int r, vector<int> &v1, vector<int> &v2, vector<int> &v3)
 {
   const int m = n*(n+1)/2;
-  v1.resize(m,0);
-  v2.resize(m,0);
-  v3.resize(m,0);
-  for(int i=0, index=0, jndex=0;i<n; i++)
+  v1.resize(m, 0);
+  v2.resize(m, 0);
+  v3.resize(m, 0);
+  for (int i = 0, index = 0, jndex = 0; i < n; i++)
     {
-      jndex+=i;
-      for(int j=i; j<n; j++, index++, jndex++)
+      jndex += i;
+      for (int j = i; j < n; j++, index++, jndex++)
         {
           v1[index] = i;
           v2[index] = j;
@@ -54,191 +55,191 @@ void set_vector_of_indices(const int n, const int r, vector<int> &v1, vector<int
     }
 }
 
-void ss2Iteration_pruning(double* y2, double* y1, const double* yhat2, const double* yhat1, const double *epsilon,
-                  double* ghx, double* ghu,
-                  const double* constant, const double* ghxx, const double* ghuu, const double* ghxu, const double* ss,
-			  const blas_int m, const blas_int n, const blas_int q, const blas_int s, const int number_of_threads)
+void
+ss2Iteration_pruning(double *y2, double *y1, const double *yhat2, const double *yhat1, const double *epsilon,
+                     double *ghx, double *ghu,
+                     const double *constant, const double *ghxx, const double *ghuu, const double *ghxu, const double *ss,
+                     const blas_int m, const blas_int n, const blas_int q, const blas_int s, const int number_of_threads)
 {
-  #ifndef FIRST_ORDER_LOOP
-      const char transpose[2] = "N";
-      const double one = 1.0;
-      const blas_int ONE = 1;
-  #endif
+#ifndef FIRST_ORDER_LOOP
+  const char transpose[2] = "N";
+  const double one = 1.0;
+  const blas_int ONE = 1;
+#endif
   vector<int> ii1, ii2, ii3;// vector indices for ghxx
   vector<int> jj1, jj2, jj3;// vector indices for ghuu
   set_vector_of_indices(n, m, ii1, ii2, ii3);
   set_vector_of_indices(q, m, jj1, jj2, jj3);
-  #ifdef USE_OMP
-  #pragma omp parallel for num_threads(number_of_threads)
-  #endif
-  for (int particle = 0; particle<s; particle++)
-  {
-    int particle_ = particle*m;
-    int particle__ = particle*n;
-    int particle___ = particle*q;
-    memcpy(&y2[particle_],&constant[0],m*sizeof(double));
-    memcpy(&y1[particle_],&ss[0],m*sizeof(double));
-    #ifndef FIRST_ORDER_LOOP
-        dgemv(transpose,&m,&n,&one,&ghx[0],&m,&yhat2[particle__],&ONE,&one,&y2[particle_],&ONE);
-	dgemv(transpose,&m,&q,&one,&ghu[0],&m,&epsilon[particle___],&ONE,&one,&y2[particle_],&ONE);
-    #endif
-    for (int variable = 0; variable<m; variable++)
-      {
-        int variable_ = variable + particle_;
-        // +ghx*yhat2+ghu*u
-        #ifdef FIRST_ORDER_LOOP
-            for (int column = 0, column_=0; column<q; column++, column_ += m)
-	      {
-		int i1 = variable+column_;
-		int i2 = column+particle__;
-		int i3 = column+particle___;
-		y2[variable_] += ghx[i1]*yhat2[i2];
-		y2[variable_] += ghu[i1]*epsilon[i3];
-	      }
-	    for (int column = q, column_=q*m; column<n; column++, column_ += m)
-	      {
-		y2[variable_] += ghx[variable+column_]*yhat2[column+particle__];
-	      }
-        #endif
-        // +ghxx*kron(yhat1,yhat1)
-        for(int i=0; i<n*(n+1)/2; i++)
-          {
-            int i1 = particle__+ii1[i];
-            int i2 = particle__+ii2[i];
-            if(i1==i2)
-              {
-                y2[variable_] += .5*ghxx[variable+ii3[i]]*yhat1[i1]*yhat1[i1];
-              }
-            else
-              {
-                y2[variable_] += ghxx[variable+ii3[i]]*yhat1[i1]*yhat1[i2];
-              }
-          }
-        // +ghuu*kron(u,u)
-        for(int j=0; j<q*(q+1)/2; j++)
-          {
-            int j1 = particle___+jj1[j];
-            int j2 = particle___+jj2[j];
-            if(j1==j2)
-              {
-                y2[variable_] += .5*ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j1];
-              }
-            else
-              {
-                y2[variable_] += ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j2];
-              }
-          }
-        // +ghxu*kron(yhat1,u)
-        for (int v = particle__, i = 0; v<particle__+n; v++)
-          for (int s = particle___; s<particle___+q; s++, i += m)
-            y2[variable_] += ghxu[variable+i]*epsilon[s]*yhat2[v];
-            #ifdef FIRST_ORDER_LOOP
-                for (int column = 0, column_=0; column<q; column++, column_ += m)
-		  {
-		    int i1 = variable+column_;
-		    int i2 = column+particle__;
-		    int i3 = column+particle___;
-		    y1[variable_] += ghx[i1]*yhat1[i2];
-		    y1[variable_] += ghu[i1]*epsilon[i3];
-		  }
-		for (int column = q, column_=q*m; column<n; column++, column_ += m)
-		  {
-		    y1[variable_] += ghx[variable+column_]*yhat1[column+particle__];
-		  }
-            #endif
-      }
-      #ifndef FIRST_ORDER_LOOP
-          dgemv(transpose,&m,&n,&one,&ghx[0],&m,&yhat1[particle__],&ONE,&one,&y1[particle_],&ONE);
-	  dgemv(transpose,&m,&q,&one,&ghu[0],&m,&epsilon[particle___],&ONE,&one,&y1[particle_],&ONE);
-      #endif
-  }
+#ifdef USE_OMP
+# pragma omp parallel for num_threads(number_of_threads)
+#endif
+  for (int particle = 0; particle < s; particle++)
+    {
+      int particle_ = particle*m;
+      int particle__ = particle*n;
+      int particle___ = particle*q;
+      memcpy(&y2[particle_], &constant[0], m*sizeof(double));
+      memcpy(&y1[particle_], &ss[0], m*sizeof(double));
+#ifndef FIRST_ORDER_LOOP
+      dgemv(transpose, &m, &n, &one, &ghx[0], &m, &yhat2[particle__], &ONE, &one, &y2[particle_], &ONE);
+      dgemv(transpose, &m, &q, &one, &ghu[0], &m, &epsilon[particle___], &ONE, &one, &y2[particle_], &ONE);
+#endif
+      for (int variable = 0; variable < m; variable++)
+        {
+          int variable_ = variable + particle_;
+          // +ghx*yhat2+ghu*u
+#ifdef FIRST_ORDER_LOOP
+          for (int column = 0, column_ = 0; column < q; column++, column_ += m)
+            {
+              int i1 = variable+column_;
+              int i2 = column+particle__;
+              int i3 = column+particle___;
+              y2[variable_] += ghx[i1]*yhat2[i2];
+              y2[variable_] += ghu[i1]*epsilon[i3];
+            }
+          for (int column = q, column_ = q*m; column < n; column++, column_ += m)
+            {
+              y2[variable_] += ghx[variable+column_]*yhat2[column+particle__];
+            }
+#endif
+          // +ghxx*kron(yhat1,yhat1)
+          for (int i = 0; i < n*(n+1)/2; i++)
+            {
+              int i1 = particle__+ii1[i];
+              int i2 = particle__+ii2[i];
+              if (i1 == i2)
+                {
+                  y2[variable_] += .5*ghxx[variable+ii3[i]]*yhat1[i1]*yhat1[i1];
+                }
+              else
+                {
+                  y2[variable_] += ghxx[variable+ii3[i]]*yhat1[i1]*yhat1[i2];
+                }
+            }
+          // +ghuu*kron(u,u)
+          for (int j = 0; j < q*(q+1)/2; j++)
+            {
+              int j1 = particle___+jj1[j];
+              int j2 = particle___+jj2[j];
+              if (j1 == j2)
+                {
+                  y2[variable_] += .5*ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j1];
+                }
+              else
+                {
+                  y2[variable_] += ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j2];
+                }
+            }
+          // +ghxu*kron(yhat1,u)
+          for (int v = particle__, i = 0; v < particle__+n; v++)
+            for (int s = particle___; s < particle___+q; s++, i += m)
+              y2[variable_] += ghxu[variable+i]*epsilon[s]*yhat2[v];
+#ifdef FIRST_ORDER_LOOP
+          for (int column = 0, column_ = 0; column < q; column++, column_ += m)
+            {
+              int i1 = variable+column_;
+              int i2 = column+particle__;
+              int i3 = column+particle___;
+              y1[variable_] += ghx[i1]*yhat1[i2];
+              y1[variable_] += ghu[i1]*epsilon[i3];
+            }
+          for (int column = q, column_ = q*m; column < n; column++, column_ += m)
+            {
+              y1[variable_] += ghx[variable+column_]*yhat1[column+particle__];
+            }
+#endif
+        }
+#ifndef FIRST_ORDER_LOOP
+      dgemv(transpose, &m, &n, &one, &ghx[0], &m, &yhat1[particle__], &ONE, &one, &y1[particle_], &ONE);
+      dgemv(transpose, &m, &q, &one, &ghu[0], &m, &epsilon[particle___], &ONE, &one, &y1[particle_], &ONE);
+#endif
+    }
 }
 
-void ss2Iteration(double* y, const double* yhat, const double *epsilon,
-                  double* ghx, double* ghu,
-                  const double* constant, const double* ghxx, const double* ghuu, const double* ghxu,
-                  const blas_int m, const blas_int n, const blas_int q, const blas_int s, const int number_of_threads)
+void
+ss2Iteration(double *y, const double *yhat, const double *epsilon,
+             double *ghx, double *ghu,
+             const double *constant, const double *ghxx, const double *ghuu, const double *ghxu,
+             const blas_int m, const blas_int n, const blas_int q, const blas_int s, const int number_of_threads)
 {
-  #ifndef FIRST_ORDER_LOOP
-      const char transpose[2] = "N";
-      const double one = 1.0;
-      const blas_int ONE = 1;
-  #endif
+#ifndef FIRST_ORDER_LOOP
+  const char transpose[2] = "N";
+  const double one = 1.0;
+  const blas_int ONE = 1;
+#endif
   vector<int> ii1, ii2, ii3;// vector indices for ghxx
   vector<int> jj1, jj2, jj3;// vector indices for ghuu
   set_vector_of_indices(n, m, ii1, ii2, ii3);
   set_vector_of_indices(q, m, jj1, jj2, jj3);
-  #ifdef USE_OMP
-  #pragma omp parallel for num_threads(number_of_threads)
-  #endif
-  for (int particle = 0; particle<s; particle++)
-  {
-    int particle_ = particle*m;
-    int particle__ = particle*n;
-    int particle___ = particle*q;
-    memcpy(&y[particle_],&constant[0],m*sizeof(double));
-    #ifndef FIRST_ORDER_LOOP
-        dgemv(transpose,&m,&n,&one,&ghx[0],&m,&yhat[particle__],&ONE,&one,&y[particle_],&ONE);
-        dgemv(transpose,&m,&q,&one,&ghu[0],&m,&epsilon[particle___],&ONE,&one,&y[particle_],&ONE);
-    #endif
-    for (int variable = 0; variable<m; variable++)
-      {
-        int variable_ = variable + particle_;
-        // +ghx*yhat+ghu*u
-        #ifdef FIRST_ORDER_LOOP
-            for (int column = 0, column_=0; column<q; column++, column_ += m)
-	      {
-		int i1 = variable+column_;
-		int i2 = column+particle__;
-		int i3 = column+particle___;
-		y[variable_] += ghx[i1]*yhat[i2];
-		y[variable_] += ghu[i1]*epsilon[i3];
-	      }
-	    for (int column = q, column_=q*m; column<n; column++, column_ += m)
-	      {
-		y[variable_] += ghx[variable+column_]*yhat[column+particle__];
-	      }
-        #endif
-        // +ghxx*kron(yhat,yhat)
-	for(int i=0; i<n*(n+1)/2; i++)
-          {
-            int i1 = particle__+ii1[i];
-            int i2 = particle__+ii2[i];
-            if(i1==i2)
-              {
-                y[variable_] += .5*ghxx[variable+ii3[i]]*yhat[i1]*yhat[i1];
-              }
-            else
-              {
-                y[variable_] += ghxx[variable+ii3[i]]*yhat[i1]*yhat[i2];
-              }
-          }
-        // +ghuu*kron(u,u)
-        for(int j=0; j<q*(q+1)/2; j++)
-          {
-            int j1 = particle___+jj1[j];
-            int j2 = particle___+jj2[j];
-            if(j1==j2)
-              {
-                y[variable_] += .5*ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j1];
-              }
-            else
-              {
-                y[variable_] += ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j2];
-              }
-          }
-        // +ghxu*kron(yhat,u)
-        for (int v = particle__, i = 0; v<particle__+n; v++)
-          for (int s = particle___; s<particle___+q; s++, i += m)
-            y[variable_] += ghxu[variable+i]*epsilon[s]*yhat[v];
-      }
-  }
+#ifdef USE_OMP
+# pragma omp parallel for num_threads(number_of_threads)
+#endif
+  for (int particle = 0; particle < s; particle++)
+    {
+      int particle_ = particle*m;
+      int particle__ = particle*n;
+      int particle___ = particle*q;
+      memcpy(&y[particle_], &constant[0], m*sizeof(double));
+#ifndef FIRST_ORDER_LOOP
+      dgemv(transpose, &m, &n, &one, &ghx[0], &m, &yhat[particle__], &ONE, &one, &y[particle_], &ONE);
+      dgemv(transpose, &m, &q, &one, &ghu[0], &m, &epsilon[particle___], &ONE, &one, &y[particle_], &ONE);
+#endif
+      for (int variable = 0; variable < m; variable++)
+        {
+          int variable_ = variable + particle_;
+          // +ghx*yhat+ghu*u
+#ifdef FIRST_ORDER_LOOP
+          for (int column = 0, column_ = 0; column < q; column++, column_ += m)
+            {
+              int i1 = variable+column_;
+              int i2 = column+particle__;
+              int i3 = column+particle___;
+              y[variable_] += ghx[i1]*yhat[i2];
+              y[variable_] += ghu[i1]*epsilon[i3];
+            }
+          for (int column = q, column_ = q*m; column < n; column++, column_ += m)
+            {
+              y[variable_] += ghx[variable+column_]*yhat[column+particle__];
+            }
+#endif
+          // +ghxx*kron(yhat,yhat)
+          for (int i = 0; i < n*(n+1)/2; i++)
+            {
+              int i1 = particle__+ii1[i];
+              int i2 = particle__+ii2[i];
+              if (i1 == i2)
+                {
+                  y[variable_] += .5*ghxx[variable+ii3[i]]*yhat[i1]*yhat[i1];
+                }
+              else
+                {
+                  y[variable_] += ghxx[variable+ii3[i]]*yhat[i1]*yhat[i2];
+                }
+            }
+          // +ghuu*kron(u,u)
+          for (int j = 0; j < q*(q+1)/2; j++)
+            {
+              int j1 = particle___+jj1[j];
+              int j2 = particle___+jj2[j];
+              if (j1 == j2)
+                {
+                  y[variable_] += .5*ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j1];
+                }
+              else
+                {
+                  y[variable_] += ghuu[variable+jj3[j]]*epsilon[j1]*epsilon[j2];
+                }
+            }
+          // +ghxu*kron(yhat,u)
+          for (int v = particle__, i = 0; v < particle__+n; v++)
+            for (int s = particle___; s < particle___+q; s++, i += m)
+              y[variable_] += ghxu[variable+i]*epsilon[s]*yhat[v];
+        }
+    }
 }
 
-
-
-
-void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+void
+mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
 {
   /*
   ** prhs[0] yhat          [double]  n*s array, time t particles.
@@ -275,27 +276,27 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
   //mexPrintf("\n The number of column of epsilon is %d.", mxGetN(prhs[1]));
   // Check the dimensions.
   if (
-      (s != mxGetN(prhs[1]))   || // Number of columns for epsilon
-      (n != mxGetN(prhs[2]))   || // Number of columns for ghx
-      (m != mxGetM(prhs[3]))   || // Number of rows for ghu
-      (q != mxGetN(prhs[3]))   || // Number of columns for ghu
-      (m != mxGetM(prhs[4]))   || // Number of rows for 2nd order constant correction + deterministic steady state
-      (m != mxGetM(prhs[5]))   || // Number of rows for ghxx
-      (n*n != mxGetN(prhs[5])) || // Number of columns for ghxx
-      (m != mxGetM(prhs[6]))   || // Number of rows for ghuu
-      (q*q != mxGetN(prhs[6])) || // Number of columns for ghuu
-      (m != mxGetM(prhs[7]))   || // Number of rows for ghxu
-      (n*q != mxGetN(prhs[7]))    // Number of rows for ghxu
+      (s != mxGetN(prhs[1]))      // Number of columns for epsilon
+      || (n != mxGetN(prhs[2])) // Number of columns for ghx
+      || (m != mxGetM(prhs[3])) // Number of rows for ghu
+      || (q != mxGetN(prhs[3])) // Number of columns for ghu
+      || (m != mxGetM(prhs[4])) // Number of rows for 2nd order constant correction + deterministic steady state
+      || (m != mxGetM(prhs[5])) // Number of rows for ghxx
+      || (n*n != mxGetN(prhs[5])) // Number of columns for ghxx
+      || (m != mxGetM(prhs[6])) // Number of rows for ghuu
+      || (q*q != mxGetN(prhs[6])) // Number of columns for ghuu
+      || (m != mxGetM(prhs[7])) // Number of rows for ghxu
+      || (n*q != mxGetN(prhs[7]))    // Number of rows for ghxu
       )
     {
       mexErrMsgTxt("Input dimension mismatch!.");
     }
-  if (nrhs>9)
+  if (nrhs > 9)
     {
       if (
-          (n != mxGetM(prhs[8]))   || // Number of rows for yhat_
-          (s != mxGetN(prhs[8]))   || // Number of columns for yhat_
-          (m != mxGetM(prhs[9]))      // Number of rows for ss
+          (n != mxGetM(prhs[8]))      // Number of rows for yhat_
+          || (s != mxGetN(prhs[8])) // Number of columns for yhat_
+          || (m != mxGetM(prhs[9]))      // Number of rows for ss
           )
         {
           mexErrMsgTxt("Input dimension mismatch!.");
@@ -311,12 +312,12 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
   double *ghuu = mxGetPr(prhs[6]);
   double *ghxu = mxGetPr(prhs[7]);
   double *yhat_ = NULL, *ss = NULL;
-  if (nrhs>9)
+  if (nrhs > 9)
     {
       yhat_ = mxGetPr(prhs[8]);
       ss = mxGetPr(prhs[9]);
     }
-  if (nrhs==9)
+  if (nrhs == 9)
     {
       int numthreads = (int) mxGetScalar(prhs[8]);
       double *y;
diff --git a/mex/sources/mjdgges/mjdgges.c b/mex/sources/mjdgges/mjdgges.c
index 700f769b8..5086dc8d4 100644
--- a/mex/sources/mjdgges/mjdgges.c
+++ b/mex/sources/mjdgges/mjdgges.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006-2016 Dynare Team
+ * Copyright (C) 2006-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -28,7 +28,7 @@ double criterium;
 lapack_int
 my_criteria(const double *alphar, const double *alphai, const double *beta)
 {
-  return ((*alphar * *alphar + *alphai * *alphai) < criterium * *beta * *beta);
+  return ((*alphar **alphar + *alphai **alphai) < criterium **beta **beta);
 }
 
 void
@@ -60,15 +60,15 @@ mjdgges(double *a, double *b, double *z, double *n, double *sdim, double *eval_r
   pei = eval_i;
   for (per = eval_r; per <= &eval_r[i_n-1]; ++per)
     {
-      if ((fabs(*par) > zhreshold) || (fabs(*pb) > zhreshold)) 
-	*per = *par / *pb;
+      if ((fabs(*par) > zhreshold) || (fabs(*pb) > zhreshold))
+        *per = *par / *pb;
       else
-	{
-	  /* the ratio is too close to 0/0;
-	     returns specific error number only if no other error */
-	  if (i_info == 0)
-	    *info = -30;
-	}
+        {
+          /* the ratio is too close to 0/0;
+             returns specific error number only if no other error */
+          if (i_info == 0)
+            *info = -30;
+        }
       if (*pai == 0.0 && *pb == 0.0)
         *pei = 0.0;
       else
@@ -147,7 +147,6 @@ mexFunction(int nlhs, mxArray *plhs[],
       zhreshold = 1e-6;
     }
 
-
   /* keep a and b intact */
   memcpy(s, a, sizeof(double)*n1*n1);
   memcpy(t, b, sizeof(double)*n1*n1);
diff --git a/mex/sources/ms-sbvar/mex_top_level.cc b/mex/sources/ms-sbvar/mex_top_level.cc
index f4aff3181..9d982f327 100644
--- a/mex/sources/ms-sbvar/mex_top_level.cc
+++ b/mex/sources/ms-sbvar/mex_top_level.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -48,16 +48,16 @@ mexFunction(int nlhs, mxArray *plhs[],
   /*
    * Allocate memory
    */
-  maxnargs = (int)(mxGetN(prhs[0])/2+1);
-  argument = (char *)mxCalloc(mxGetN(prhs[0])+1, sizeof(char));
-  args = (char **)mxCalloc(maxnargs, sizeof(char *));
-  if (argument==NULL || args==NULL)
+  maxnargs = (int) (mxGetN(prhs[0])/2+1);
+  argument = (char *) mxCalloc(mxGetN(prhs[0])+1, sizeof(char));
+  args = (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)");
 
   /*
    * Create argument string from prhs and parse to create args / nargs
    */
-  if (!(args[nargs] = (char *)mxCalloc(strlen(mainarg)+1, sizeof(char))))
+  if (!(args[nargs] = (char *) mxCalloc(strlen(mainarg)+1, sizeof(char))))
     DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: could not allocate memory. (2)");
 
   strncpy(args[nargs++], mainarg, strlen(mainarg));
@@ -66,9 +66,9 @@ mexFunction(int nlhs, mxArray *plhs[],
     DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: error using mxGetString.\n");
 
   beginarg = &argument[0];
-  while((n=strcspn(beginarg, " ")))
+  while ((n = strcspn(beginarg, " ")))
     {
-      if (!(args[nargs] = (char *)mxCalloc(n+1, sizeof(char))))
+      if (!(args[nargs] = (char *) mxCalloc(n+1, sizeof(char))))
         DYN_MEX_FUNC_ERR_MSG_TXT("Error in MS-SBVAR MEX file: could not allocate memory. (3)");
 
       strncpy(args[nargs++], beginarg, n);
@@ -91,7 +91,7 @@ mexFunction(int nlhs, mxArray *plhs[],
   /*
    * free memory
    */
-  for (n=0; n<nargs; n++)
+  for (n = 0; n < nargs; n++)
     mxFree(args[n]);
   mxFree(args);
 
diff --git a/mex/sources/ms-sbvar/mex_write_to_matlab.c b/mex/sources/ms-sbvar/mex_write_to_matlab.c
index 7f188786d..1d14ffe3e 100644
--- a/mex/sources/ms-sbvar/mex_write_to_matlab.c
+++ b/mex/sources/ms-sbvar/mex_write_to_matlab.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Dynare Team
+ * Copyright (C) 2011-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -31,9 +31,9 @@ mex_write_to_matlab_matfile(double *data, int rows, int cols, const char *varnam
   if (matfile == NULL)
     mexErrMsgTxt("Error encountered in mex when opening a .mat file");
 
-  if (matPutVariable(matfile, varname, toWrite) != 0 ||
-      ferror(matGetFp(matfile)) > 0 ||
-      feof(matGetFp(matfile)) > 0)
+  if (matPutVariable(matfile, varname, toWrite) != 0
+      || ferror(matGetFp(matfile)) > 0
+      || feof(matGetFp(matfile)) > 0)
     mexErrMsgTxt("Error encountered in mex when writing a .mat file");
 
   if (matClose(matfile) != 0)
diff --git a/mex/sources/ms-sbvar/modify_for_mex.h b/mex/sources/ms-sbvar/modify_for_mex.h
index cb477633f..0689df90f 100644
--- a/mex/sources/ms-sbvar/modify_for_mex.h
+++ b/mex/sources/ms-sbvar/modify_for_mex.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -22,29 +22,29 @@
 
 #if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
 
-#include <dynmex.h>
-#include <dynblas.h>
-#include <dynlapack.h>
+# include <dynmex.h>
+# include <dynblas.h>
+# include <dynlapack.h>
 
-#define dw_malloc mxMalloc
-#define dw_calloc mxCalloc
-#define dw_realloc mxRealloc
-#define dw_free mxFree
-#define dw_exit msExit
+# define dw_malloc mxMalloc
+# define dw_calloc mxCalloc
+# define dw_realloc mxRealloc
+# define dw_free mxFree
+# define dw_exit msExit
 
 /* Handle Ctrl-C in Matlab/Octave */
-#ifdef MATLAB_MEX_FILE
+# ifdef MATLAB_MEX_FILE
 extern bool utIsInterruptPending();
-#else
-#include <octave/config.h>
-#include <octave/quit.h>
-#endif
+# else
+#  include <octave/config.h>
+#  include <octave/quit.h>
+# endif
 
 void msExit(int status);
 extern int constant_seed;
 
-/* Write Matlab Output 
-mxArray *globalMatlabStruct;*/
+/* Write Matlab Output
+   mxArray *globalMatlabStruct;*/
 void mex_write_to_matlab_matfile(double *, int, int, const char *, const char *);
 void mex_write_to_matlab_global_struct(double *, int, int, const char *);
 mxArray *getMxArray(double *, int, int);
diff --git a/mex/sources/qzcomplex/qzcomplex.cc b/mex/sources/qzcomplex/qzcomplex.cc
index 7b95ce76f..74773fcdc 100644
--- a/mex/sources/qzcomplex/qzcomplex.cc
+++ b/mex/sources/qzcomplex/qzcomplex.cc
@@ -6,7 +6,7 @@
  */
 
 /*
- * Copyright (C) 2010-2016 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -25,15 +25,15 @@
  */
 
 #ifdef __MINGW32__
-#define __CROSS_COMPILATION__
+# define __CROSS_COMPILATION__
 #endif
 
 #ifdef __MINGW64__
-#define __CROSS_COMPILATION__
+# define __CROSS_COMPILATION__
 #endif
 
 #ifdef __CROSS_COMPILATION__
-#define M_PI 3.14159265358979323846
+# define M_PI 3.14159265358979323846
 #endif
 
 #include <octave/oct.h>
diff --git a/mex/sources/sobol/gaussian.hh b/mex/sources/sobol/gaussian.hh
index 450611773..6dd00ca22 100644
--- a/mex/sources/sobol/gaussian.hh
+++ b/mex/sources/sobol/gaussian.hh
@@ -1,8 +1,8 @@
 /* Generates gaussian random deviates from uniform random deviates.
-** 
-** Pseudo code of the algorithm is given at http://home.online.no/~pjacklam/notes/invnorm  
 **
-** Copyright (C) 2010-2016 Dynare Team
+** Pseudo code of the algorithm is given at http://home.online.no/~pjacklam/notes/invnorm
+**
+** Copyright (C) 2010-2017 Dynare Team
 **
 ** This file is part of Dynare.
 **
@@ -18,8 +18,8 @@
 **
 ** You should have received a copy of the GNU General Public License
 ** along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-** 
-** AUTHOR(S): stephane DOT adjemian AT univ DASH lemans DOT fr  
+**
+** AUTHOR(S): stephane DOT adjemian AT univ DASH lemans DOT fr
 */
 
 #include <cstdlib>
@@ -41,58 +41,60 @@ using namespace std;
 #define DEBUG_OMP 0
 
 #ifdef __MINGW32__
-#define __CROSS_COMPILATION__
+# define __CROSS_COMPILATION__
 #endif
 
 #ifdef __MINGW64__
-#define __CROSS_COMPILATION__
+# define __CROSS_COMPILATION__
 #endif
 
 #ifdef __CROSS_COMPILATION__
-#define M_PI 3.14159265358979323846
+# define M_PI 3.14159265358979323846
 #endif
 
-template<typename T> T icdf( const T uniform )
+template<typename T>
+T
+icdf(const T uniform)
 /*
 **  This function invert the gaussian cumulative distribution function.
 **
 */
-{ 
-  static T A[6] = 
+{
+  static T A[6] =
     {
       -3.969683028665376e+01,
-       2.209460984245205e+02,
+      2.209460984245205e+02,
       -2.759285104469687e+02,
-       1.383577518672690e+02,
+      1.383577518672690e+02,
       -3.066479806614716e+01,
-       2.506628277459239e+00
+      2.506628277459239e+00
     };
-  static T B[5] = 
+  static T B[5] =
     {
       -5.447609879822406e+01,
-       1.615858368580409e+02,
+      1.615858368580409e+02,
       -1.556989798598866e+02,
-       6.680131188771972e+01,
+      6.680131188771972e+01,
       -1.328068155288572e+01
     };
-  static T C[6] = 
+  static T C[6] =
     {
       -7.784894002430293e-03,
       -3.223964580411365e-01,
       -2.400758277161838e+00,
       -2.549732539343734e+00,
-       4.374664141464968e+00,
-       2.938163982698783e+00
+      4.374664141464968e+00,
+      2.938163982698783e+00
     };
-  static T D[4] = 
+  static T D[4] =
     {
       7.784695709041462e-03,
       3.224671290700398e-01,
       2.445134137142996e+00,
       3.754408661907416e+00
     };
-  T gaussian = (T)0.0;
-  if ( (0<uniform)  && (uniform<lb) )
+  T gaussian = (T) 0.0;
+  if ((0 < uniform)  && (uniform < lb))
     {
       T tmp;
       tmp = sqrt(-2*log(uniform));
@@ -117,65 +119,71 @@ template<typename T> T icdf( const T uniform )
             }
         }
     }
-  if ( (0<uniform) && (uniform<1) )
+  if ((0 < uniform) && (uniform < 1))
     {
       T tmp, tmp_;
       tmp = .5*erfc(-gaussian/sqrt(2.0))-uniform;
       tmp_ = tmp*sqrt(2*M_PI)*exp(.5*gaussian*gaussian);
       gaussian = gaussian - tmp_/(1+.5*gaussian*tmp_);
     }
-  if ( uniform==0)
+  if (uniform == 0)
     {
       gaussian = -INFINITY;
     }
-  if ( uniform==1)
+  if (uniform == 1)
     {
       gaussian = INFINITY;
     }
- return(gaussian);
+  return (gaussian);
 }
 
-template<typename T> void icdfm( const int n, T *U)
-{ 
-  #if USE_OMP
-  #pragma omp parallel for num_threads(omp_get_num_threads())
-  #endif
-  for(int i=0; i<n; i++)
+template<typename T>
+void
+icdfm(const int n, T *U)
+{
+#if USE_OMP
+# pragma omp parallel for num_threads(omp_get_num_threads())
+#endif
+  for (int i = 0; i < n; i++)
     {
       U[i] = icdf(U[i]);
     }
   return;
 }
 
-template<typename T> void icdfmSigma( const int d, const int n, T *U, const double *LowerCholSigma)
-{ 
+template<typename T>
+void
+icdfmSigma(const int d, const int n, T *U, const double *LowerCholSigma)
+{
   double one = 1.0;
   double zero = 0.0;
   blas_int dd(d);
   blas_int nn(n);
   icdfm(n*d, U);
   double tmp[n*d];
-  dgemm("N","N",&dd,&nn,&dd,&one,LowerCholSigma,&dd,U,&dd,&zero,tmp,&dd);
-  memcpy(U,tmp,d*n*sizeof(double));
+  dgemm("N", "N", &dd, &nn, &dd, &one, LowerCholSigma, &dd, U, &dd, &zero, tmp, &dd);
+  memcpy(U, tmp, d*n*sizeof(double));
   return;
 }
 
-template<typename T> void usphere( const int d, const int n, T *U)
-{ 
+template<typename T>
+void
+usphere(const int d, const int n, T *U)
+{
   icdfm(n*d, U);
-  #if USE_OMP
-  #pragma omp parallel for num_threads(omp_get_num_threads())
-  #endif
-  for (int j=0; j<n; j++)// sequence index.
+#if USE_OMP
+# pragma omp parallel for num_threads(omp_get_num_threads())
+#endif
+  for (int j = 0; j < n; j++)// sequence index.
     {
       int k = j*d;
       double norm = 0.0;
-      for(int i=0; i<d; i++)// dimension index.
+      for (int i = 0; i < d; i++)// dimension index.
         {
           norm = norm + U[k+i]*U[k+i];
         }
       norm = sqrt(norm);
-      for(int i=0; i<d; i++)// dimension index.
+      for (int i = 0; i < d; i++)// dimension index.
         {
           U[k+i] = U[k+i]/norm;
         }
@@ -183,22 +191,24 @@ template<typename T> void usphere( const int d, const int n, T *U)
   return;
 }
 
-template<typename T> void usphereRadius( const int d, const int n, double radius, T *U)
-{ 
+template<typename T>
+void
+usphereRadius(const int d, const int n, double radius, T *U)
+{
   icdfm(n*d, U);
-  #if USE_OMP
-  #pragma omp parallel for num_threads(omp_get_num_threads())
-  #endif
-  for (int j=0; j<n; j++)// sequence index.
+#if USE_OMP
+# pragma omp parallel for num_threads(omp_get_num_threads())
+#endif
+  for (int j = 0; j < n; j++)// sequence index.
     {
       int k = j*d;
       double norm = 0.0;
-      for(int i=0; i<d; i++)// dimension index.
+      for (int i = 0; i < d; i++)// dimension index.
         {
           norm = norm + U[k+i]*U[k+i];
         }
       norm = sqrt(norm);
-      for(int i=0; i<d; i++)// dimension index.
+      for (int i = 0; i < d; i++)// dimension index.
         {
           U[k+i] = radius*U[k+i]/norm;
         }
diff --git a/mex/sources/sobol/initialize_v_array.hh b/mex/sources/sobol/initialize_v_array.hh
index ac6a09b6b..ad172d7a5 100644
--- a/mex/sources/sobol/initialize_v_array.hh
+++ b/mex/sources/sobol/initialize_v_array.hh
@@ -1,11 +1,13 @@
-template<typename T> int initialize_v_array (int dim_max, int log_max, T **v)
+template<typename T>
+int
+initialize_v_array(int dim_max, int log_max, T **v)
 /*
-** This function initializes the v array used in the sobol routine. 
+** This function initializes the v array used in the sobol routine.
 **
 ** Original files downloaded from http://people.sc.fsu.edu/~burkardt/cpp_src/sobol/ (version 17-Feb-2009 09:46)
 **
 ** Copyright (C) 2009 John Burkardt
-** Copyright (C) 2010-2011 Dynare Team
+** Copyright (C) 2010-2017 Dynare Team
 **
 ** This program is free software: you can redistribute it and/or modify
 ** it under the terms of the GNU Lesser General Public License as published by
@@ -19,10 +21,8 @@ template<typename T> int initialize_v_array (int dim_max, int log_max, T **v)
 **
 ** You should have received a copy of the GNU Lesser General Public License
 ** along with this program.  If not, see <http://www.gnu.org/licenses/>.
-**
-** AUTHOR(S): stephane DOT adjemian AT univ DASH lemans DOT fr
 */
 {
-  #include "initialize_v_array.inc"
+#include "initialize_v_array.inc"
   return 1;
 }
diff --git a/mex/sources/sobol/qmc_sequence.cc b/mex/sources/sobol/qmc_sequence.cc
index bd6ed4ddc..e99d80594 100644
--- a/mex/sources/sobol/qmc_sequence.cc
+++ b/mex/sources/sobol/qmc_sequence.cc
@@ -1,7 +1,7 @@
 /*
 ** Computes Quasi Monte-Carlo sequence.
 **
-** Copyright (C) 2010-2012 Dynare Team
+** Copyright (C) 2010-2017 Dynare Team
 **
 ** This file is part of Dynare (can be used outside Dynare).
 **
@@ -17,8 +17,6 @@
 **
 ** You should have received a copy of the GNU General Public License
 ** along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
-**
-** AUTHOR(S): stephane DOT adjemian AT univ DASH lemans DOT fr
 **/
 
 #include <sstream>
@@ -32,9 +30,10 @@
 // the maximum dimension defined in sobol.ff (but undef at the end)
 #define DIM_MAX 1111
 
-void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+void
+mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
 {
-  /* 
+  /*
   ** INPUTS:
   ** prhs[0]    [integer]    scalar, dimension.
   ** prhs[1]    [integer]    scalar, seed.
@@ -51,12 +50,12 @@ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
   ** plhs[0]    [double]     sequence_size*dimension array, the Sobol sequence.
   ** plhs[1]    [integer]    scalar, seed.
   ** plhs[2]    [integer]    zero in case of success, one in case of error
-  ** 
+  **
   */
   /*
   ** Check the number of input and output arguments.
   */
-  if ( !( (nrhs==5) | (nrhs==4) | (nrhs==3) )  )
+  if (!((nrhs == 5) | (nrhs == 4) | (nrhs == 3)))
     {
       DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: Five, four or three input arguments are required!");
     }
@@ -67,40 +66,40 @@ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
   /*
   ** Test the first input argument and assign it to dimension.
   */
-  if (  !( mxIsNumeric(prhs[0]) ) )
+  if (!(mxIsNumeric(prhs[0])))
     {
       DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: First input (dimension) has to be a positive integer!");
     }
-  int dimension = ( int ) mxGetScalar(prhs[0]);
+  int dimension = (int) mxGetScalar(prhs[0]);
   /*
   ** Test the second input argument and assign it to seed.
   */
-  if ( !( mxIsNumeric(prhs[1]) && mxIsClass(prhs[1],"int64") ) )
+  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]!");
     }
-  int64_T seed = ( int64_T ) mxGetScalar( prhs[1] );
+  int64_T seed = (int64_T) mxGetScalar(prhs[1]);
   /*
   ** Test the third input argument and assign it to type (kind of QMC sequence).
   */
   int error_flag_3 = 0;
-  if (  !(mxIsNumeric(prhs[2])) )
+  if (!(mxIsNumeric(prhs[2])))
     {
       error_flag_3 = 1;
     }
-  int type = ( int ) mxGetScalar(prhs[2]);
-  if ( !(type==0 || type==1 || type==2) )
+  int type = (int) mxGetScalar(prhs[2]);
+  if (!(type == 0 || type == 1 || type == 2))
     {
       error_flag_3 = 1;
     }
-  if (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!");
     }
   /*
   ** Test dimension>=2 when type==2
   */
-  if ( (type==2) && (dimension<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!");
     }
@@ -114,14 +113,14 @@ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
   /*
   ** Test the optional fourth input argument and assign it to sequence_size.
   */
-  if  ( ( nrhs>3 )  &&  !mxIsNumeric(prhs[3])  ) 
+  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!");
     }
   int sequence_size;
-  if ( nrhs>3)
+  if (nrhs > 3)
     {
-      sequence_size = ( int ) mxGetScalar( prhs[3] );
+      sequence_size = (int) mxGetScalar(prhs[3]);
     }
   else
     {
@@ -130,53 +129,53 @@ void 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.
+  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!");
     }
-  if  ( (nrhs>4)   &&  (type==0) &&  ( !( (int)mxGetM(prhs[4])==dimension) ) )
+  if  ((nrhs > 4)   &&  (type == 0) &&  (!((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)!");
     }
-  if  ( ( nrhs>4 )  &&  (type==1) && ( !( ((int)mxGetN(prhs[4])==dimension) && ((int)mxGetM(prhs[4])==dimension) ) ) )// Sequence of normally distributed numbers.
+  if  ((nrhs > 4)  &&  (type == 1) && (!(((int) mxGetN(prhs[4]) == dimension) && ((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)!");
     }
-  if  ( ( nrhs>4 )  &&  (type==2) && ( !( (mxGetN(prhs[4])==1) && (mxGetM(prhs[4])==1) ) ) )// Sequence of uniformly distributed numbers on an hypershere.
+  if  ((nrhs > 4)  &&  (type == 2) && (!((mxGetN(prhs[4]) == 1) && (mxGetM(prhs[4]) == 1))))// Sequence of uniformly distributed numbers on an hypershere.
     {
       DYN_MEX_FUNC_ERR_MSG_TXT("qmc_sequence:: The fifth input argument must be a positive scalar!");
     }
   double *lower_bounds = NULL, *upper_bounds = NULL;
   int unit_hypercube_flag = 1;
-  if ( (type==0) && (nrhs>4) )
+  if ((type == 0) && (nrhs > 4))
     {
-      lower_bounds = (double *) mxCalloc(dimension,sizeof(double));
-      upper_bounds = (double *) mxCalloc(dimension,sizeof(double));
+      lower_bounds = (double *) mxCalloc(dimension, sizeof(double));
+      upper_bounds = (double *) mxCalloc(dimension, sizeof(double));
       double *tmp;
-      tmp = (double *) mxCalloc(dimension*2,sizeof(double));
-      memcpy(tmp,mxGetPr(prhs[4]),dimension*2*sizeof(double));
+      tmp = (double *) mxCalloc(dimension*2, sizeof(double));
+      memcpy(tmp, mxGetPr(prhs[4]), dimension*2*sizeof(double));
       lower_bounds = &tmp[0];
       upper_bounds = &tmp[dimension];
       unit_hypercube_flag = 0;
     }
   double *cholcov;
   int identity_covariance_matrix = 1;
-  if ( (type==1) && (nrhs>4) )
+  if ((type == 1) && (nrhs > 4))
     {
-      cholcov = (double *) mxCalloc(dimension*dimension,sizeof(double));
+      cholcov = (double *) mxCalloc(dimension*dimension, sizeof(double));
       double *tmp;
-      tmp = (double *) mxCalloc(dimension*dimension,sizeof(double));
-      memcpy(tmp,mxGetPr(prhs[4]),dimension*dimension*sizeof(double));
+      tmp = (double *) mxCalloc(dimension*dimension, sizeof(double));
+      memcpy(tmp, mxGetPr(prhs[4]), dimension*dimension*sizeof(double));
       cholcov = &tmp[0];
       identity_covariance_matrix = 0;
     }
   double radius = 1.0;
   int unit_radius = 1;
-  if ( (type==2) && (nrhs>4) )
+  if ((type == 2) && (nrhs > 4))
     {
       double *tmp;
-      tmp = (double *) mxCalloc(1,sizeof(double));
-      memcpy(tmp,mxGetPr(prhs[4]),sizeof(double));
+      tmp = (double *) mxCalloc(1, sizeof(double));
+      memcpy(tmp, mxGetPr(prhs[4]), sizeof(double));
       radius = tmp[0];
       unit_radius = 0;
     }
@@ -184,35 +183,35 @@ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
   ** Initialize outputs of the mex file.
   */
   double *qmc_draws;
-  plhs[0] = mxCreateDoubleMatrix(dimension,sequence_size,mxREAL);
+  plhs[0] = mxCreateDoubleMatrix(dimension, sequence_size, mxREAL);
   qmc_draws = mxGetPr(plhs[0]);
   int64_T seed_out;
 
-  if (sequence_size==1)
+  if (sequence_size == 1)
     {
-      next_sobol ( dimension, &seed, qmc_draws );
+      next_sobol(dimension, &seed, qmc_draws);
       seed_out = seed;
     }
   else
-    seed_out = sobol_block( dimension, sequence_size, seed, qmc_draws);
+    seed_out = sobol_block(dimension, sequence_size, seed, qmc_draws);
 
-  if (type==0 && unit_hypercube_flag==0)// Uniform QMC sequence in an hypercube.
-    expand_unit_hypercube( dimension, sequence_size, qmc_draws, lower_bounds, upper_bounds);
-  else if (type==1)// Normal QMC sequance in R^n.
+  if (type == 0 && unit_hypercube_flag == 0) // Uniform QMC sequence in an hypercube.
+    expand_unit_hypercube(dimension, sequence_size, qmc_draws, lower_bounds, upper_bounds);
+  else if (type == 1)// Normal QMC sequance in R^n.
     {
-      if (identity_covariance_matrix==1)
+      if (identity_covariance_matrix == 1)
         icdfm(dimension*sequence_size, qmc_draws);
       else
-        icdfmSigma(dimension,sequence_size, qmc_draws, cholcov);
+        icdfmSigma(dimension, sequence_size, qmc_draws, cholcov);
     }
-  else if (type==2)// Uniform QMC sequence on an hypershere.
+  else if (type == 2)// Uniform QMC sequence on an hypershere.
     {
-      if (unit_radius==1)
+      if (unit_radius == 1)
         usphere(dimension, sequence_size, qmc_draws);
       else
         usphereRadius(dimension, sequence_size, radius, qmc_draws);
     }
-  
+
   if (nlhs >= 2)
     {
       plhs[1] = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
diff --git a/mex/sources/sobol/sobol.hh b/mex/sources/sobol/sobol.hh
index 8dbb98785..8926daca9 100644
--- a/mex/sources/sobol/sobol.hh
+++ b/mex/sources/sobol/sobol.hh
@@ -1,9 +1,9 @@
 /* Quasi Monte Carlo sequences (à la Sobol).
-** 
+**
 ** Original files downloaded from http://people.sc.fsu.edu/~burkardt/cpp_src/sobol/ (version 17-Feb-2009 09:46)
 **
 ** Copyright (C) 2009 John Burkardt
-** Copyright (C) 2010-2011 Dynare Team
+** Copyright (C) 2010-2017 Dynare Team
 **
 ** This program is free software: you can redistribute it and/or modify
 ** it under the terms of the GNU Lesser General Public License as published by
@@ -17,8 +17,6 @@
 **
 ** You should have received a copy of the GNU Lesser General Public License
 ** along with this program.  If not, see <http://www.gnu.org/licenses/>.
-**
-** AUTHOR(S): stephane DOT adjemian AT univ DASH lemans DOT fr
 */
 
 #include <cstdlib>
@@ -33,8 +31,10 @@ using namespace std;
 
 #define DIM_MAX 1111
 
-template<typename T> int bit_hi1(T n)
-/*  
+template<typename T>
+int
+bit_hi1(T n)
+/*
 ** This function returns the position of the high 1 bit base 2 in an integer.
 **
 ** Example:
@@ -44,7 +44,7 @@ template<typename T> int bit_hi1(T n)
 **       0           0     0
 **       1           1     1
 **       2          10     2
-**       3          11     2 
+**       3          11     2
 **       4         100     3
 **       5         101     3
 **       6         110     3
@@ -63,7 +63,7 @@ template<typename T> int bit_hi1(T n)
 **    1024 10000000000    11
 **    1025 10000000001    11
 **
-**  
+**
 **  Original files downloaded from http://people.sc.fsu.edu/~burkardt/cpp_src/sobol/ (version 17-Feb-2009 09:46)
 **
 **    Input, int or long long, the integer to be measured.
@@ -72,16 +72,18 @@ template<typename T> int bit_hi1(T n)
 **    Output: the location of the high order bit.
 */
 {
-  int bit = 0 ;
-  while ( n > 0 )
-  {
-    bit++ ;
-    n = n/2 ;
-  }
-  return bit ;
+  int bit = 0;
+  while (n > 0)
+    {
+      bit++;
+      n = n/2;
+    }
+  return bit;
 }
 
-template<typename T> int bit_lo0 ( T n )
+template<typename T>
+int
+bit_lo0(T n)
 /*
 **  This function returns the position of the low 0 bit base 2 in an integer.
 **
@@ -92,7 +94,7 @@ template<typename T> int bit_lo0 ( T n )
 **       0           0     1
 **       1           1     2
 **       2          10     1
-**       3          11     3 
+**       3          11     3
 **       4         100     1
 **       5         101     2
 **       6         110     1
@@ -123,22 +125,23 @@ template<typename T> int bit_lo0 ( T n )
 */
 {
   int bit = 0;
-  while ( true )
-  {
-    bit++;
-    T n2 = n/2;
-    if ( n == 2*n2 )
+  while (true)
     {
-      break;
+      bit++;
+      T n2 = n/2;
+      if (n == 2*n2)
+        {
+          break;
+        }
+      n = n2;
     }
-    n = n2;
-  }
   return bit;
 }
 
- 
-template<typename T>  T ixor ( T i, T j )
-/*  
+template<typename T>
+T
+ixor(T i, T j)
+/*
 **  This function  calculates the exclusive OR of two integers.
 **
 **  Original files downloaded from http://people.sc.fsu.edu/~burkardt/cpp_src/sobol/ (version 17-Feb-2009 09:46)
@@ -150,25 +153,26 @@ template<typename T>  T ixor ( T i, T j )
 {
   T k = 0;
   T l = 1;
-  while ( i != 0 || j != 0 )
-  {
-    T i2 = i / 2;
-    T j2 = j / 2;
-    if ( 
-        ( ( i == 2 * i2 ) && ( j != 2 * j2 ) ) ||
-        ( ( i != 2 * i2 ) && ( j == 2 * j2 ) )  )
-      {
-        k = k + l;
-      }
-    i = i2;
-    j = j2;
-    l = 2 * l;
-  }
+  while (i != 0 || j != 0)
+    {
+      T i2 = i / 2;
+      T j2 = j / 2;
+      if (
+          ((i == 2 * i2) && (j != 2 * j2))
+          || ((i != 2 * i2) && (j == 2 * j2)))
+        {
+          k = k + l;
+        }
+      i = i2;
+      j = j2;
+      l = 2 * l;
+    }
   return k;
 }
 
-
-template<typename T1, typename T2> void next_sobol ( int dim_num, T1 *seed, T2 *quasi )
+template<typename T1, typename T2>
+void
+next_sobol(int dim_num, T1 *seed, T2 *quasi)
 /*
 **  This function generates a new quasirandom Sobol vector with each call.
 **
@@ -203,7 +207,7 @@ template<typename T1, typename T2> void next_sobol ( int dim_num, T1 *seed, T2 *
 **
 **    Bennett Fox,
 **    Algorithm 647:
-**    Implementation and Relative Efficiency of Quasirandom 
+**    Implementation and Relative Efficiency of Quasirandom
 **    Sequence Generators,
 **    ACM Transactions on Mathematical Software,
 **    Volume 12, Number 4, pages 362-376, 1986.
@@ -218,10 +222,10 @@ template<typename T1, typename T2> void next_sobol ( int dim_num, T1 *seed, T2 *
 **    USSR Computational Mathematics and Mathematical Physics,
 **    Volume 16, pages 236-242, 1977.
 **
-**    Ilya Sobol, YL Levitan, 
-**    The Production of Points Uniformly Distributed in a Multidimensional 
+**    Ilya Sobol, YL Levitan,
+**    The Production of Points Uniformly Distributed in a Multidimensional
 **    Cube (in Russian),
-**    Preprint IPM Akad. Nauk SSSR, 
+**    Preprint IPM Akad. Nauk SSSR,
 **    Number 40, Moscow 1976.
 **
 **  Parameters:
@@ -238,287 +242,288 @@ template<typename T1, typename T2> void next_sobol ( int dim_num, T1 *seed, T2 *
 **
 **    Output, double QUASI[DIM_NUM], the next quasirandom vector.
 */
-{ 
-  static T1 atmost ;
-  static int dim_num_save = 0 ;
-  int LOG_MAX = sizeof(T1)*8-2 ;
+{
+  static T1 atmost;
+  static int dim_num_save = 0;
+  int LOG_MAX = sizeof(T1)*8-2;
   bool includ[LOG_MAX];
   static bool initialized = false;
   static T1 lastq[DIM_MAX];
   static T1 maxcol;
   T1 l = 0;
   static T1 poly[DIM_MAX] =
-  {
-        1,    3,    7,   11,   13,   19,   25,   37,   59,   47,
-       61,   55,   41,   67,   97,   91,  109,  103,  115,  131,
+    {
+      1,    3,    7,   11,   13,   19,   25,   37,   59,   47,
+      61,   55,   41,   67,   97,   91,  109,  103,  115,  131,
       193,  137,  145,  143,  241,  157,  185,  167,  229,  171,
       213,  191,  253,  203,  211,  239,  247,  285,  369,  299,
       301,  333,  351,  355,  357,  361,  391,  397,  425,  451,
       463,  487,  501,  529,  539,  545,  557,  563,  601,  607,
-      617,  623,  631,  637,  647,  661,  675,  677,  687,  695, 
+      617,  623,  631,  637,  647,  661,  675,  677,  687,  695,
       701,  719,  721,  731,  757,  761,  787,  789,  799,  803,
       817,  827,  847,  859,  865,  875,  877,  883,  895,  901,
       911,  949,  953,  967,  971,  973,  981,  985,  995, 1001,
-     1019, 1033, 1051, 1063, 1069, 1125, 1135, 1153, 1163, 1221,
-     1239, 1255, 1267, 1279, 1293, 1305, 1315, 1329, 1341, 1347,
-     1367, 1387, 1413, 1423, 1431, 1441, 1479, 1509, 1527, 1531,
-     1555, 1557, 1573, 1591, 1603, 1615, 1627, 1657, 1663, 1673, 
-     1717, 1729, 1747, 1759, 1789, 1815, 1821, 1825, 1849, 1863,
-     1869, 1877, 1881, 1891, 1917, 1933, 1939, 1969, 2011, 2035,
-     2041, 2053, 2071, 2091, 2093, 2119, 2147, 2149, 2161, 2171,
-     2189, 2197, 2207, 2217, 2225, 2255, 2257, 2273, 2279, 2283,
-     2293, 2317, 2323, 2341, 2345, 2363, 2365, 2373, 2377, 2385,
-     2395, 2419, 2421, 2431, 2435, 2447, 2475, 2477, 2489, 2503, 
-     2521, 2533, 2551, 2561, 2567, 2579, 2581, 2601, 2633, 2657,
-     2669, 2681, 2687, 2693, 2705, 2717, 2727, 2731, 2739, 2741,
-     2773, 2783, 2793, 2799, 2801, 2811, 2819, 2825, 2833, 2867,
-     2879, 2881, 2891, 2905, 2911, 2917, 2927, 2941, 2951, 2955,
-     2963, 2965, 2991, 2999, 3005, 3017, 3035, 3037, 3047, 3053,
-     3083, 3085, 3097, 3103, 3159, 3169, 3179, 3187, 3205, 3209,
-     3223, 3227, 3229, 3251, 3263, 3271, 3277, 3283, 3285, 3299,
-     3305, 3319, 3331, 3343, 3357, 3367, 3373, 3393, 3399, 3413,
-     3417, 3427, 3439, 3441, 3475, 3487, 3497, 3515, 3517, 3529,
-     3543, 3547, 3553, 3559, 3573, 3589, 3613, 3617, 3623, 3627,
-     3635, 3641, 3655, 3659, 3669, 3679, 3697, 3707, 3709, 3713,
-     3731, 3743, 3747, 3771, 3791, 3805, 3827, 3833, 3851, 3865,
-     3889, 3895, 3933, 3947, 3949, 3957, 3971, 3985, 3991, 3995,
-     4007, 4013, 4021, 4045, 4051, 4069, 4073, 4179, 4201, 4219,
-     4221, 4249, 4305, 4331, 4359, 4383, 4387, 4411, 4431, 4439,
-     4449, 4459, 4485, 4531, 4569, 4575, 4621, 4663, 4669, 4711,
-     4723, 4735, 4793, 4801, 4811, 4879, 4893, 4897, 4921, 4927,
-     4941, 4977, 5017, 5027, 5033, 5127, 5169, 5175, 5199, 5213,
-     5223, 5237, 5287, 5293, 5331, 5391, 5405, 5453, 5523, 5573,
-     5591, 5597, 5611, 5641, 5703, 5717, 5721, 5797, 5821, 5909,
-     5913, 5955, 5957, 6005, 6025, 6061, 6067, 6079, 6081, 6231,
-     6237, 6289, 6295, 6329, 6383, 6427, 6453, 6465, 6501, 6523,
-     6539, 6577, 6589, 6601, 6607, 6631, 6683, 6699, 6707, 6761,
-     6795, 6865, 6881, 6901, 6923, 6931, 6943, 6999, 7057, 7079,
-     7103, 7105, 7123, 7173, 7185, 7191, 7207, 7245, 7303, 7327, 
-     7333, 7355, 7365, 7369, 7375, 7411, 7431, 7459, 7491, 7505, 
-     7515, 7541, 7557, 7561, 7701, 7705, 7727, 7749, 7761, 7783,
-     7795, 7823, 7907, 7953, 7963, 7975, 8049, 8089, 8123, 8125,
-     8137, 8219, 8231, 8245, 8275, 8293, 8303, 8331, 8333, 8351,
-     8357, 8367, 8379, 8381, 8387, 8393, 8417, 8435, 8461, 8469,
-     8489, 8495, 8507, 8515, 8551, 8555, 8569, 8585, 8599, 8605,
-     8639, 8641, 8647, 8653, 8671, 8675, 8689, 8699, 8729, 8741,
-     8759, 8765, 8771, 8795, 8797, 8825, 8831, 8841, 8855, 8859,
-     8883, 8895, 8909, 8943, 8951, 8955, 8965, 8999, 9003, 9031,
-     9045, 9049, 9071, 9073, 9085, 9095, 9101, 9109, 9123, 9129,
-     9137, 9143, 9147, 9185, 9197, 9209, 9227, 9235, 9247, 9253,
-     9257, 9277, 9297, 9303, 9313, 9325, 9343, 9347, 9371, 9373,
-     9397, 9407, 9409, 9415, 9419, 9443, 9481, 9495, 9501, 9505,
-     9517, 9529, 9555, 9557, 9571, 9585, 9591, 9607, 9611, 9621,
-     9625, 9631, 9647, 9661, 9669, 9679, 9687, 9707, 9731, 9733,
-     9745, 9773, 9791, 9803, 9811, 9817, 9833, 9847, 9851, 9863,
-     9875, 9881, 9905, 9911, 9917, 9923, 9963, 9973,10003,10025,
-    10043,10063,10071,10077,10091,10099,10105,10115,10129,10145,
-    10169,10183,10187,10207,10223,10225,10247,10265,10271,10275,
-    10289,10299,10301,10309,10343,10357,10373,10411,10413,10431,
-    10445,10453,10463,10467,10473,10491,10505,10511,10513,10523,
-    10539,10549,10559,10561,10571,10581,10615,10621,10625,10643,
-    10655,10671,10679,10685,10691,10711,10739,10741,10755,10767,
-    10781,10785,10803,10805,10829,10857,10863,10865,10875,10877,
-    10917,10921,10929,10949,10967,10971,10987,10995,11009,11029,
-    11043,11045,11055,11063,11075,11081,11117,11135,11141,11159,
-    11163,11181,11187,11225,11237,11261,11279,11297,11307,11309,
-    11327,11329,11341,11377,11403,11405,11413,11427,11439,11453,
-    11461,11473,11479,11489,11495,11499,11533,11545,11561,11567,
-    11575,11579,11589,11611,11623,11637,11657,11663,11687,11691,
-    11701,11747,11761,11773,11783,11795,11797,11817,11849,11855,
-    11867,11869,11873,11883,11919,11921,11927,11933,11947,11955,
-    11961,11999,12027,12029,12037,12041,12049,12055,12095,12097,
-    12107,12109,12121,12127,12133,12137,12181,12197,12207,12209,
-    12239,12253,12263,12269,12277,12287,12295,12309,12313,12335,
-    12361,12367,12391,12409,12415,12433,12449,12469,12479,12481,
-    12499,12505,12517,12527,12549,12559,12597,12615,12621,12639,
-    12643,12657,12667,12707,12713,12727,12741,12745,12763,12769,
-    12779,12781,12787,12799,12809,12815,12829,12839,12857,12875,
-    12883,12889,12901,12929,12947,12953,12959,12969,12983,12987,
-    12995,13015,13019,13031,13063,13077,13103,13137,13149,13173,
-    13207,13211,13227,13241,13249,13255,13269,13283,13285,13303,
-    13307,13321,13339,13351,13377,13389,13407,13417,13431,13435,
-    13447,13459,13465,13477,13501,13513,13531,13543,13561,13581,
-    13599,13605,13617,13623,13637,13647,13661,13677,13683,13695,
-    13725,13729,13753,13773,13781,13785,13795,13801,13807,13825,
-    13835,13855,13861,13871,13883,13897,13905,13915,13939,13941,
-    13969,13979,13981,13997,14027,14035,14037,14051,14063,14085,
-    14095,14107,14113,14125,14137,14145,14151,14163,14193,14199,
-    14219,14229,14233,14243,14277,14287,14289,14295,14301,14305,
-    14323,14339,14341,14359,14365,14375,14387,14411,14425,14441,
-    14449,14499,14513,14523,14537,14543,14561,14579,14585,14593,
-    14599,14603,14611,14641,14671,14695,14701,14723,14725,14743,
-    14753,14759,14765,14795,14797,14803,14831,14839,14845,14855,
-    14889,14895,14909,14929,14941,14945,14951,14963,14965,14985,
-    15033,15039,15053,15059,15061,15071,15077,15081,15099,15121,
-    15147,15149,15157,15167,15187,15193,15203,15205,15215,15217,
-    15223,15243,15257,15269,15273,15287,15291,15313,15335,15347,
-    15359,15373,15379,15381,15391,15395,15397,15419,15439,15453,
-    15469,15491,15503,15517,15527,15531,15545,15559,15593,15611,
-    15613,15619,15639,15643,15649,15661,15667,15669,15681,15693,
-    15717,15721,15741,15745,15765,15793,15799,15811,15825,15835,
-    15847,15851,15865,15877,15881,15887,15899,15915,15935,15937,
-    15955,15973,15977,16011,16035,16061,16069,16087,16093,16097,
-    16121,16141,16153,16159,16165,16183,16189,16195,16197,16201,
-    16209,16215,16225,16259,16265,16273,16299,16309,16355,16375,
-    16381 };
+      1019, 1033, 1051, 1063, 1069, 1125, 1135, 1153, 1163, 1221,
+      1239, 1255, 1267, 1279, 1293, 1305, 1315, 1329, 1341, 1347,
+      1367, 1387, 1413, 1423, 1431, 1441, 1479, 1509, 1527, 1531,
+      1555, 1557, 1573, 1591, 1603, 1615, 1627, 1657, 1663, 1673,
+      1717, 1729, 1747, 1759, 1789, 1815, 1821, 1825, 1849, 1863,
+      1869, 1877, 1881, 1891, 1917, 1933, 1939, 1969, 2011, 2035,
+      2041, 2053, 2071, 2091, 2093, 2119, 2147, 2149, 2161, 2171,
+      2189, 2197, 2207, 2217, 2225, 2255, 2257, 2273, 2279, 2283,
+      2293, 2317, 2323, 2341, 2345, 2363, 2365, 2373, 2377, 2385,
+      2395, 2419, 2421, 2431, 2435, 2447, 2475, 2477, 2489, 2503,
+      2521, 2533, 2551, 2561, 2567, 2579, 2581, 2601, 2633, 2657,
+      2669, 2681, 2687, 2693, 2705, 2717, 2727, 2731, 2739, 2741,
+      2773, 2783, 2793, 2799, 2801, 2811, 2819, 2825, 2833, 2867,
+      2879, 2881, 2891, 2905, 2911, 2917, 2927, 2941, 2951, 2955,
+      2963, 2965, 2991, 2999, 3005, 3017, 3035, 3037, 3047, 3053,
+      3083, 3085, 3097, 3103, 3159, 3169, 3179, 3187, 3205, 3209,
+      3223, 3227, 3229, 3251, 3263, 3271, 3277, 3283, 3285, 3299,
+      3305, 3319, 3331, 3343, 3357, 3367, 3373, 3393, 3399, 3413,
+      3417, 3427, 3439, 3441, 3475, 3487, 3497, 3515, 3517, 3529,
+      3543, 3547, 3553, 3559, 3573, 3589, 3613, 3617, 3623, 3627,
+      3635, 3641, 3655, 3659, 3669, 3679, 3697, 3707, 3709, 3713,
+      3731, 3743, 3747, 3771, 3791, 3805, 3827, 3833, 3851, 3865,
+      3889, 3895, 3933, 3947, 3949, 3957, 3971, 3985, 3991, 3995,
+      4007, 4013, 4021, 4045, 4051, 4069, 4073, 4179, 4201, 4219,
+      4221, 4249, 4305, 4331, 4359, 4383, 4387, 4411, 4431, 4439,
+      4449, 4459, 4485, 4531, 4569, 4575, 4621, 4663, 4669, 4711,
+      4723, 4735, 4793, 4801, 4811, 4879, 4893, 4897, 4921, 4927,
+      4941, 4977, 5017, 5027, 5033, 5127, 5169, 5175, 5199, 5213,
+      5223, 5237, 5287, 5293, 5331, 5391, 5405, 5453, 5523, 5573,
+      5591, 5597, 5611, 5641, 5703, 5717, 5721, 5797, 5821, 5909,
+      5913, 5955, 5957, 6005, 6025, 6061, 6067, 6079, 6081, 6231,
+      6237, 6289, 6295, 6329, 6383, 6427, 6453, 6465, 6501, 6523,
+      6539, 6577, 6589, 6601, 6607, 6631, 6683, 6699, 6707, 6761,
+      6795, 6865, 6881, 6901, 6923, 6931, 6943, 6999, 7057, 7079,
+      7103, 7105, 7123, 7173, 7185, 7191, 7207, 7245, 7303, 7327,
+      7333, 7355, 7365, 7369, 7375, 7411, 7431, 7459, 7491, 7505,
+      7515, 7541, 7557, 7561, 7701, 7705, 7727, 7749, 7761, 7783,
+      7795, 7823, 7907, 7953, 7963, 7975, 8049, 8089, 8123, 8125,
+      8137, 8219, 8231, 8245, 8275, 8293, 8303, 8331, 8333, 8351,
+      8357, 8367, 8379, 8381, 8387, 8393, 8417, 8435, 8461, 8469,
+      8489, 8495, 8507, 8515, 8551, 8555, 8569, 8585, 8599, 8605,
+      8639, 8641, 8647, 8653, 8671, 8675, 8689, 8699, 8729, 8741,
+      8759, 8765, 8771, 8795, 8797, 8825, 8831, 8841, 8855, 8859,
+      8883, 8895, 8909, 8943, 8951, 8955, 8965, 8999, 9003, 9031,
+      9045, 9049, 9071, 9073, 9085, 9095, 9101, 9109, 9123, 9129,
+      9137, 9143, 9147, 9185, 9197, 9209, 9227, 9235, 9247, 9253,
+      9257, 9277, 9297, 9303, 9313, 9325, 9343, 9347, 9371, 9373,
+      9397, 9407, 9409, 9415, 9419, 9443, 9481, 9495, 9501, 9505,
+      9517, 9529, 9555, 9557, 9571, 9585, 9591, 9607, 9611, 9621,
+      9625, 9631, 9647, 9661, 9669, 9679, 9687, 9707, 9731, 9733,
+      9745, 9773, 9791, 9803, 9811, 9817, 9833, 9847, 9851, 9863,
+      9875, 9881, 9905, 9911, 9917, 9923, 9963, 9973, 10003, 10025,
+      10043, 10063, 10071, 10077, 10091, 10099, 10105, 10115, 10129, 10145,
+      10169, 10183, 10187, 10207, 10223, 10225, 10247, 10265, 10271, 10275,
+      10289, 10299, 10301, 10309, 10343, 10357, 10373, 10411, 10413, 10431,
+      10445, 10453, 10463, 10467, 10473, 10491, 10505, 10511, 10513, 10523,
+      10539, 10549, 10559, 10561, 10571, 10581, 10615, 10621, 10625, 10643,
+      10655, 10671, 10679, 10685, 10691, 10711, 10739, 10741, 10755, 10767,
+      10781, 10785, 10803, 10805, 10829, 10857, 10863, 10865, 10875, 10877,
+      10917, 10921, 10929, 10949, 10967, 10971, 10987, 10995, 11009, 11029,
+      11043, 11045, 11055, 11063, 11075, 11081, 11117, 11135, 11141, 11159,
+      11163, 11181, 11187, 11225, 11237, 11261, 11279, 11297, 11307, 11309,
+      11327, 11329, 11341, 11377, 11403, 11405, 11413, 11427, 11439, 11453,
+      11461, 11473, 11479, 11489, 11495, 11499, 11533, 11545, 11561, 11567,
+      11575, 11579, 11589, 11611, 11623, 11637, 11657, 11663, 11687, 11691,
+      11701, 11747, 11761, 11773, 11783, 11795, 11797, 11817, 11849, 11855,
+      11867, 11869, 11873, 11883, 11919, 11921, 11927, 11933, 11947, 11955,
+      11961, 11999, 12027, 12029, 12037, 12041, 12049, 12055, 12095, 12097,
+      12107, 12109, 12121, 12127, 12133, 12137, 12181, 12197, 12207, 12209,
+      12239, 12253, 12263, 12269, 12277, 12287, 12295, 12309, 12313, 12335,
+      12361, 12367, 12391, 12409, 12415, 12433, 12449, 12469, 12479, 12481,
+      12499, 12505, 12517, 12527, 12549, 12559, 12597, 12615, 12621, 12639,
+      12643, 12657, 12667, 12707, 12713, 12727, 12741, 12745, 12763, 12769,
+      12779, 12781, 12787, 12799, 12809, 12815, 12829, 12839, 12857, 12875,
+      12883, 12889, 12901, 12929, 12947, 12953, 12959, 12969, 12983, 12987,
+      12995, 13015, 13019, 13031, 13063, 13077, 13103, 13137, 13149, 13173,
+      13207, 13211, 13227, 13241, 13249, 13255, 13269, 13283, 13285, 13303,
+      13307, 13321, 13339, 13351, 13377, 13389, 13407, 13417, 13431, 13435,
+      13447, 13459, 13465, 13477, 13501, 13513, 13531, 13543, 13561, 13581,
+      13599, 13605, 13617, 13623, 13637, 13647, 13661, 13677, 13683, 13695,
+      13725, 13729, 13753, 13773, 13781, 13785, 13795, 13801, 13807, 13825,
+      13835, 13855, 13861, 13871, 13883, 13897, 13905, 13915, 13939, 13941,
+      13969, 13979, 13981, 13997, 14027, 14035, 14037, 14051, 14063, 14085,
+      14095, 14107, 14113, 14125, 14137, 14145, 14151, 14163, 14193, 14199,
+      14219, 14229, 14233, 14243, 14277, 14287, 14289, 14295, 14301, 14305,
+      14323, 14339, 14341, 14359, 14365, 14375, 14387, 14411, 14425, 14441,
+      14449, 14499, 14513, 14523, 14537, 14543, 14561, 14579, 14585, 14593,
+      14599, 14603, 14611, 14641, 14671, 14695, 14701, 14723, 14725, 14743,
+      14753, 14759, 14765, 14795, 14797, 14803, 14831, 14839, 14845, 14855,
+      14889, 14895, 14909, 14929, 14941, 14945, 14951, 14963, 14965, 14985,
+      15033, 15039, 15053, 15059, 15061, 15071, 15077, 15081, 15099, 15121,
+      15147, 15149, 15157, 15167, 15187, 15193, 15203, 15205, 15215, 15217,
+      15223, 15243, 15257, 15269, 15273, 15287, 15291, 15313, 15335, 15347,
+      15359, 15373, 15379, 15381, 15391, 15395, 15397, 15419, 15439, 15453,
+      15469, 15491, 15503, 15517, 15527, 15531, 15545, 15559, 15593, 15611,
+      15613, 15619, 15639, 15643, 15649, 15661, 15667, 15669, 15681, 15693,
+      15717, 15721, 15741, 15745, 15765, 15793, 15799, 15811, 15825, 15835,
+      15847, 15851, 15865, 15877, 15881, 15887, 15899, 15915, 15935, 15937,
+      15955, 15973, 15977, 16011, 16035, 16061, 16069, 16087, 16093, 16097,
+      16121, 16141, 16153, 16159, 16165, 16183, 16189, 16195, 16197, 16201,
+      16209, 16215, 16225, 16259, 16265, 16273, 16299, 16309, 16355, 16375,
+      16381
+    };
   static T2 recipd;
-  static T1 seed_save = - 1;
-  static T1** v ;
-  if ( !initialized || dim_num != dim_num_save )
-  {
-    v = new T1 *[DIM_MAX] ;
-    for( int i = 0 ; i < DIM_MAX ; i++ )
-      v[i] = new T1[LOG_MAX];
-    initialized = true;
-    initialize_v_array(DIM_MAX, LOG_MAX, v);
-    /*
-    **  Check parameters.
-    */
-    if ( dim_num < 1 || DIM_MAX < dim_num )
+  static T1 seed_save = -1;
+  static T1 **v;
+  if (!initialized || dim_num != dim_num_save)
     {
-      cout << "\n";
-      cout << "NEXT_SOBOL - Fatal error!\n";
-      cout << "  The spatial dimension DIM_NUM should satisfy:\n";
-      cout << "    1 <= DIM_NUM <= " << DIM_MAX << "\n";
-      cout << "  But this input value is DIM_NUM = " << dim_num << "\n";
-      exit ( 1 );
+      v = new T1 *[DIM_MAX];
+      for (int i = 0; i < DIM_MAX; i++)
+        v[i] = new T1[LOG_MAX];
+      initialized = true;
+      initialize_v_array(DIM_MAX, LOG_MAX, v);
+      /*
+      **  Check parameters.
+      */
+      if (dim_num < 1 || DIM_MAX < dim_num)
+        {
+          cout << "\n";
+          cout << "NEXT_SOBOL - Fatal error!\n";
+          cout << "  The spatial dimension DIM_NUM should satisfy:\n";
+          cout << "    1 <= DIM_NUM <= " << DIM_MAX << "\n";
+          cout << "  But this input value is DIM_NUM = " << dim_num << "\n";
+          exit(1);
+        }
+      dim_num_save = dim_num;
+      /*
+      **  Set ATMOST = 2^LOG_MAX - 1.
+      */
+      atmost = (T1) 0;
+      for (int i = 1; i <= LOG_MAX; i++)
+        atmost = 2 * atmost + 1;
+      /*
+      **  Find the highest 1 bit in ATMOST (should be LOG_MAX).
+      */
+      maxcol = bit_hi1(atmost);
+      /*
+      **  Initialize row 1 of V.
+      */
+      for (T1 j = 0; j < maxcol; j++)
+        {
+          v[0][j] = (T1) 1;
+        }
+      /*
+      **  Initialize the remaining rows of V.
+      */
+      for (int i = 1; i < dim_num; i++)
+        {
+          /*
+          **  The bit pattern of the integer POLY(I) gives the form
+          **  of polynomial I.
+          **
+          **  Find the degree of polynomial I from binary encoding.
+          */
+          T1 j = poly[i];
+          T1 m = 0;
+          while (true)
+            {
+              j = j / 2;
+              if (j <= 0)
+                {
+                  break;
+                }
+              m = m + 1;
+            }
+          /*
+          **  We expand this bit pattern to separate components
+          **  of the logical array INCLUD.
+          */
+          j = poly[i];
+          for (T1 k = m-1; 0 <= k; k--)
+            {
+              T1 j2 = j / 2;
+              includ[k] = (j != (2 * j2));
+              j = j2;
+            }
+          /*
+          **  Calculate the remaining elements of row I as explained
+          **  in Bratley and Fox, section 2.
+          **
+          **  Some tricky indexing here.  Did I change it correctly?
+          */
+          for (j = m; j < maxcol; j++)
+            {
+              T1 newv = v[i][j-m];
+              l = 1;
+              for (T1 k = 0; k < m; k++)
+                {
+                  l = 2 * l;
+                  if (includ[k])
+                    {
+                      newv = (newv ^ (l * v[i][j-k-1]));
+                    }
+                }
+              v[i][j] = newv;
+            }
+        }
+      /*
+      **  Multiply columns of V by appropriate power of 2.
+      */
+      l = 1;
+      for (T1 j = maxcol - 2; 0 <= j; j--)
+        {
+          l = 2 * l;
+          for (int i = 0; i < dim_num; i++)
+            {
+              v[i][j] = v[i][j] * l;
+            }
+        }
+      /*
+      **  RECIPD is 1/(common denominator of the elements in V).
+      */
+      recipd = 1.0E+00 / ((T2) (2 * l));
     }
-    dim_num_save = dim_num;
-    /*
-    **  Set ATMOST = 2^LOG_MAX - 1.
-    */
-    atmost = (T1) 0;
-    for ( int i = 1; i <= LOG_MAX; i++ )
-      atmost = 2 * atmost + 1;
-    /*
-    **  Find the highest 1 bit in ATMOST (should be LOG_MAX).
-    */
-    maxcol = bit_hi1 ( atmost );
-    /*
-    **  Initialize row 1 of V.
-    */
-    for ( T1 j = 0; j < maxcol; j++ )
-      {
-        v[0][j] = (T1) 1;
-      }
-    /*
-    **  Initialize the remaining rows of V.
-    */
-    for ( int i = 1; i < dim_num; i++ )
-      {
-        /*
-        **  The bit pattern of the integer POLY(I) gives the form
-        **  of polynomial I.
-        **
-        **  Find the degree of polynomial I from binary encoding.
-        */
-        T1 j = poly[i];
-        T1 m = 0;
-        while ( true )
-          {
-            j = j / 2;
-            if ( j <= 0 )
-              {
-                break;
-              }
-            m = m + 1;
-          }
-        /*
-        **  We expand this bit pattern to separate components
-        **  of the logical array INCLUD.
-        */
-        j = poly[i];
-        for ( T1 k = m-1; 0 <= k; k-- )
-          {
-            T1 j2 = j / 2;
-            includ[k] = ( j != ( 2 * j2 ) );
-            j = j2;
-          }
-        /*
-        **  Calculate the remaining elements of row I as explained
-        **  in Bratley and Fox, section 2.
-        **
-        **  Some tricky indexing here.  Did I change it correctly?
-        */
-        for ( j = m; j < maxcol; j++ )
-          {
-            T1 newv = v[i][j-m];
-            l = 1;
-            for ( T1 k = 0; k < m; k++ )
-              {
-                l = 2 * l;
-                if ( includ[k] )
-                  {
-                    newv = ( newv ^ ( l * v[i][j-k-1] ) );
-                  }
-              }
-            v[i][j] = newv;
-          }
-      }
-    /*
-    **  Multiply columns of V by appropriate power of 2.
-    */
-    l = 1;
-    for ( T1 j = maxcol - 2; 0 <= j; j-- )
-      {
-        l = 2 * l;
-        for ( int i = 0; i < dim_num; i++ )
-          {
-            v[i][j] = v[i][j] * l;
-          }
-      }
-    /*
-    **  RECIPD is 1/(common denominator of the elements in V).
-    */
-    recipd = 1.0E+00 / ( ( T2 ) ( 2 * l ) );
-  }
-  if ( *seed < 0 )
-    *seed = 0 ;
-  
-  if ( *seed == 0 )
+  if (*seed < 0)
+    *seed = 0;
+
+  if (*seed == 0)
     {
       l = 1;
-      for ( int i = 0; i < dim_num; i++ )
+      for (int i = 0; i < dim_num; i++)
         {
           lastq[i] = 0;
         }
     }
-  else if ( *seed == seed_save + 1 )
+  else if (*seed == seed_save + 1)
     {
-      l = bit_lo0 ( *seed );
+      l = bit_lo0(*seed);
     }
-  else if ( *seed <= seed_save )
+  else if (*seed <= seed_save)
     {
       seed_save = 0;
       l = 1;
-      for ( int i = 0; i < dim_num; i++ )
+      for (int i = 0; i < dim_num; i++)
         lastq[i] = 0;
-      for ( T1 seed_temp = seed_save; seed_temp <= (*seed)-1; seed_temp++ )
+      for (T1 seed_temp = seed_save; seed_temp <= (*seed)-1; seed_temp++)
         {
-          l = bit_lo0 ( seed_temp );
-          for ( int i = 0; i < dim_num; i++ )
+          l = bit_lo0(seed_temp);
+          for (int i = 0; i < dim_num; i++)
             {
-              lastq[i] = ( lastq[i] ^ v[i][l-1] );
+              lastq[i] = (lastq[i] ^ v[i][l-1]);
             }
         }
-      l = bit_lo0 ( *seed );
+      l = bit_lo0(*seed);
     }
-  else if ( seed_save+1 < *seed )
+  else if (seed_save+1 < *seed)
     {
-      for ( T1 seed_temp = seed_save+1; seed_temp <= (*seed)-1; seed_temp++ )
+      for (T1 seed_temp = seed_save+1; seed_temp <= (*seed)-1; seed_temp++)
         {
-          l = bit_lo0 ( seed_temp );
-          for ( int i = 0; i < dim_num; i++ )
+          l = bit_lo0(seed_temp);
+          for (int i = 0; i < dim_num; i++)
             {
-              lastq[i] = ( lastq[i] ^ v[i][l-1] );
+              lastq[i] = (lastq[i] ^ v[i][l-1]);
             }
         }
-      l = bit_lo0 ( *seed );
+      l = bit_lo0(*seed);
     }
   /*
   **  Check that the user is not calling too many times!
   */
-  if ( maxcol < l )
+  if (maxcol < l)
     {
       cout << "\n";
       cout << "NEXT_SOBOL - Fatal error!\n";
@@ -526,49 +531,52 @@ template<typename T1, typename T2> void next_sobol ( int dim_num, T1 *seed, T2 *
       cout << "  SEED =   " << *seed  << "\n";
       cout << "  MAXCOL = " << maxcol << "\n";
       cout << "  L =      " << l << "\n";
-      exit ( 2 );
+      exit(2);
     }
   /*
   **  Calculate the new components of QUASI.
   **  The caret indicates the bitwise exclusive OR.
   */
-  for ( int i = 0; i < dim_num; i++ )
+  for (int i = 0; i < dim_num; i++)
     {
-      quasi[i] = ( ( T2 ) lastq[i] ) * recipd;
-      lastq[i] = ( lastq[i]^v[i][l-1] );
+      quasi[i] = ((T2) lastq[i]) * recipd;
+      lastq[i] = (lastq[i]^v[i][l-1]);
     }
   seed_save = *seed;
   *seed = *seed + 1;
   return;
 }
 
-template<typename T1, typename T2> T1 sobol_block( int dimension, int block_size, T1 seed, T2 *block )
+template<typename T1, typename T2>
+T1
+sobol_block(int dimension, int block_size, T1 seed, T2 *block)
 {
-  for ( int iter = 0 ; iter < block_size ; iter++ )
+  for (int iter = 0; iter < block_size; iter++)
     {
-      next_sobol ( dimension, &seed, &block[iter*dimension] );
+      next_sobol(dimension, &seed, &block[iter*dimension]);
     }
   return seed;
 }
 
-template<typename T> void expand_unit_hypercube( int dimension, int block_size, T *block, T *lower_bound, T* upper_bound )
+template<typename T>
+void
+expand_unit_hypercube(int dimension, int block_size, T *block, T *lower_bound, T *upper_bound)
 {
   T *hypercube_length = new T[dimension];
-  for(int dim = 0 ; dim < dimension ; dim++ )
+  for (int dim = 0; dim < dimension; dim++)
     {
-      hypercube_length[dim] = upper_bound[dim]-lower_bound[dim] ; 
+      hypercube_length[dim] = upper_bound[dim]-lower_bound[dim];
     }
   int base = 0;
-  for ( int sim = 0 ; sim < block_size ; sim++ )
+  for (int sim = 0; sim < block_size; sim++)
     {
-      for (int dim = 0 ; dim < dimension ; dim++ )
+      for (int dim = 0; dim < dimension; dim++)
         {
           block[base+dim] = lower_bound[dim] + hypercube_length[dim]*block[base+dim];
         }
-      base+= dimension;
+      base += dimension;
     }
   delete[] hypercube_length;
 }
 
-
 #undef DIM_MAX
diff --git a/others/C/dynare_driver.h b/others/C/dynare_driver.h
index 56091c7d7..14588c2cd 100644
--- a/others/C/dynare_driver.h
+++ b/others/C/dynare_driver.h
@@ -17,8 +17,9 @@
 #ifndef _DYNARE_C_DRIVER_H
 #define _DYNARE_C_DRIVER_H
 
-struct aux_vars_t {
+struct aux_vars_t
+{
   int endo_index, type, orig_index, orig_lead_lag;
-} ;
+};
 
 #endif // ! _DYNARE_C_DRIVER_H
diff --git a/others/cpp/dynare_cpp_driver.cc b/others/cpp/dynare_cpp_driver.cc
index f6701dd4b..2beec5260 100644
--- a/others/cpp/dynare_cpp_driver.cc
+++ b/others/cpp/dynare_cpp_driver.cc
@@ -39,7 +39,7 @@ DynareInfo::DynareInfo(map<string, int > exo_names_arg,
   exo_nbr = exo_names.size();
   exo_det_nbr = exo_det_names.size();
   param_nbr = param_names.size();
-  
+
   exo_names = exo_names_arg;
   exo_det_names = exo_det_names_arg;
   endo_names = endo_names_arg;
@@ -54,27 +54,27 @@ DynareInfo::DynareInfo(map<string, int > exo_names_arg,
 DynareInfo::~DynareInfo()
 {
   for (vector<MarkovSwitching *>::iterator it = markov_switching_vector.begin();
-       it < markov_switching_vector.end(); it++ )
+       it < markov_switching_vector.end(); it++)
     delete *it;
 
   for (vector<ModFilePrior *>::iterator it = prior_vector.begin();
-       it < prior_vector.end(); it++ )
+       it < prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileStructuralInnovationPrior *>::iterator it = structural_innovation_prior_vector.begin();
-       it < structural_innovation_prior_vector.end(); it++ )
+       it < structural_innovation_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileMeasurementErrorPrior *>::iterator it = measurement_error_prior_vector.begin();
-       it < measurement_error_prior_vector.end(); it++ )
+       it < measurement_error_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileStructuralInnovationCorrPrior *>::iterator it = structural_innovation_corr_prior_vector.begin();
-       it < structural_innovation_corr_prior_vector.end(); it++ )
+       it < structural_innovation_corr_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileMeasurementErrorCorrPrior *>::iterator it = measurement_error_corr_prior_vector.begin();
-       it < measurement_error_corr_prior_vector.end(); it++ )
+       it < measurement_error_corr_prior_vector.end(); it++)
     delete *it;
 
   markov_switching_vector.clear();
diff --git a/others/cpp/dynare_cpp_driver.hh b/others/cpp/dynare_cpp_driver.hh
index 9e39ee96e..afdbc21a2 100644
--- a/others/cpp/dynare_cpp_driver.hh
+++ b/others/cpp/dynare_cpp_driver.hh
@@ -25,11 +25,12 @@
 
 using namespace std;
 
-struct aux_vars_t {
+struct aux_vars_t
+{
   int endo_index, type, orig_index, orig_lead_lag;
-} ;
+};
 
-typedef map<pair<int, int >, double> restriction_map_t ;
+typedef map<pair<int, int >, double> restriction_map_t;
 
 class ValueNotSetException
 {
@@ -57,21 +58,49 @@ public:
                   const vector<double> duration_arg,
                   const restriction_map_t restriction_map_arg);
 
-  inline bool number_of_lags_has_val() const { return number_of_lags_was_passed; };
-  inline bool restriction_map_has_val() const { return !restriction_map.empty(); };
+  inline bool
+  number_of_lags_has_val() const
+  {
+    return number_of_lags_was_passed;
+  };
+  inline bool
+  restriction_map_has_val() const
+  {
+    return !restriction_map.empty();
+  };
 
-  inline int get_chain() const { return chain; };
-  inline int get_number_of_regimes() const { return number_of_regimes; };
+  inline int
+  get_chain() const
+  {
+    return chain;
+  };
+  inline int
+  get_number_of_regimes() const
+  {
+    return number_of_regimes;
+  };
   int get_number_of_lags() throw (ValueNotSetException);
-  inline vector<int> get_parameters() { return parameters; };
-  inline vector<double> get_duration() { return duration; };
+  inline vector<int>
+  get_parameters()
+  {
+    return parameters;
+  };
+  inline vector<double>
+  get_duration()
+  {
+    return duration;
+  };
   restriction_map_t get_restriction_map() throw (ValueNotSetException);
 };
 
 class BasicModFilePrior
 {
 private:
-  inline bool isnan(double x) const { return (x!=x); };
+  inline bool
+  isnan(double x) const
+  {
+    return (x != x);
+  };
 protected:
   const int index;
   const string shape;
@@ -86,14 +115,42 @@ protected:
                     const double variance_arg,
                     const vector <double> domain_arg);
 public:
-  inline bool mean_has_val() const { return !isnan(mean); };
-  inline bool mode_has_val() const { return !isnan(mode); };
-  inline bool stdev_has_val() const { return !isnan(stdev); };
-  inline bool variance_has_val() const { return !isnan(variance); };
-  inline bool domain_has_val() const { return (domain.size() == 2); };
+  inline bool
+  mean_has_val() const
+  {
+    return !isnan(mean);
+  };
+  inline bool
+  mode_has_val() const
+  {
+    return !isnan(mode);
+  };
+  inline bool
+  stdev_has_val() const
+  {
+    return !isnan(stdev);
+  };
+  inline bool
+  variance_has_val() const
+  {
+    return !isnan(variance);
+  };
+  inline bool
+  domain_has_val() const
+  {
+    return (domain.size() == 2);
+  };
 
-  inline int get_index() const { return index; };
-  inline string get_shape() const { return shape; };
+  inline int
+  get_index() const
+  {
+    return index;
+  };
+  inline string
+  get_shape() const
+  {
+    return shape;
+  };
   double get_mean() throw (ValueNotSetException);
   double get_mode() throw (ValueNotSetException);
   double get_stdev() throw (ValueNotSetException);
@@ -113,7 +170,7 @@ public:
                const vector <double> domain_arg);
 };
 
-class ModFileStructuralInnovationPrior: public BasicModFilePrior
+class ModFileStructuralInnovationPrior : public BasicModFilePrior
 {
 public:
   ModFileStructuralInnovationPrior(const int index_arg,
@@ -170,7 +227,11 @@ public:
 class BasicModFileOption
 {
 private:
-  inline bool isnan(double x) const { return (x!=x); };
+  inline bool
+  isnan(double x) const
+  {
+    return (x != x);
+  };
 protected:
   const int index;
   const double init;
@@ -178,8 +239,16 @@ protected:
   BasicModFileOption(const int index_arg,
                      const double init_arg);
 public:
-  inline int get_index() const { return index; };
-  inline double get_init() const { return init; };
+  inline int
+  get_index() const
+  {
+    return index;
+  };
+  inline double
+  get_init() const
+  {
+    return init;
+  };
 };
 
 class ModFileOption : public BasicModFileOption
@@ -189,7 +258,7 @@ public:
                 const double init_arg);
 };
 
-class ModFileStructuralInnovationOption: public BasicModFileOption
+class ModFileStructuralInnovationOption : public BasicModFileOption
 {
 public:
   ModFileStructuralInnovationOption(const int index_arg,
@@ -257,65 +326,269 @@ public:
              vector<int> varobs_arg,
              vector<int> NNZDerivatives_arg);
 
-  inline void addMarkovSwitching(MarkovSwitching *ms) { markov_switching_vector.push_back(ms); };
+  inline void
+  addMarkovSwitching(MarkovSwitching *ms)
+  {
+    markov_switching_vector.push_back(ms);
+  };
 
-  inline void addPrior(ModFilePrior *p) { prior_vector.push_back(p); };
-  inline void addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip) { structural_innovation_prior_vector.push_back(sip); };
-  inline void addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep) { measurement_error_prior_vector.push_back(mep); };
-  inline void addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp) { structural_innovation_corr_prior_vector.push_back(sicp); };
-  inline void addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp) { measurement_error_corr_prior_vector.push_back(mecp); };
+  inline void
+  addPrior(ModFilePrior *p)
+  {
+    prior_vector.push_back(p);
+  };
+  inline void
+  addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip)
+  {
+    structural_innovation_prior_vector.push_back(sip);
+  };
+  inline void
+  addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep)
+  {
+    measurement_error_prior_vector.push_back(mep);
+  };
+  inline void
+  addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp)
+  {
+    structural_innovation_corr_prior_vector.push_back(sicp);
+  };
+  inline void
+  addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp)
+  {
+    measurement_error_corr_prior_vector.push_back(mecp);
+  };
 
-  inline void addOption(ModFileOption *o) { option_vector.push_back(o); };
-  inline void addStructuralInnovationOption(ModFileStructuralInnovationOption *sio) { structural_innovation_option_vector.push_back(sio); };
-  inline void addMeasurementErrorOption(ModFileMeasurementErrorOption *meo) { measurement_error_option_vector.push_back(meo); };
-  inline void addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico) { structural_innovation_corr_option_vector.push_back(sico); };
-  inline void addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco) { measurement_error_corr_option_vector.push_back(meco); };
+  inline void
+  addOption(ModFileOption *o)
+  {
+    option_vector.push_back(o);
+  };
+  inline void
+  addStructuralInnovationOption(ModFileStructuralInnovationOption *sio)
+  {
+    structural_innovation_option_vector.push_back(sio);
+  };
+  inline void
+  addMeasurementErrorOption(ModFileMeasurementErrorOption *meo)
+  {
+    measurement_error_option_vector.push_back(meo);
+  };
+  inline void
+  addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico)
+  {
+    structural_innovation_corr_option_vector.push_back(sico);
+  };
+  inline void
+  addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco)
+  {
+    measurement_error_corr_option_vector.push_back(meco);
+  };
 
-  inline bool markov_switching_has_val() { return !markov_switching_vector.empty(); };
-  inline bool prior_has_val() { return !prior_vector.empty(); };
-  inline bool structural_innovation_prior_has_val() { return !structural_innovation_prior_vector.empty(); };
-  inline bool measurement_error_prior_has_val() { return !measurement_error_prior_vector.empty(); };
-  inline bool structural_innovation_corr_prior_has_val() { return !structural_innovation_corr_prior_vector.empty(); };
-  inline bool measurement_error_corr_prior_has_val() { return !measurement_error_corr_prior_vector.empty(); };
+  inline bool
+  markov_switching_has_val()
+  {
+    return !markov_switching_vector.empty();
+  };
+  inline bool
+  prior_has_val()
+  {
+    return !prior_vector.empty();
+  };
+  inline bool
+  structural_innovation_prior_has_val()
+  {
+    return !structural_innovation_prior_vector.empty();
+  };
+  inline bool
+  measurement_error_prior_has_val()
+  {
+    return !measurement_error_prior_vector.empty();
+  };
+  inline bool
+  structural_innovation_corr_prior_has_val()
+  {
+    return !structural_innovation_corr_prior_vector.empty();
+  };
+  inline bool
+  measurement_error_corr_prior_has_val()
+  {
+    return !measurement_error_corr_prior_vector.empty();
+  };
 
-  inline bool option_has_val() { return !option_vector.empty(); };
-  inline bool structural_innovation_option_has_val() { return !structural_innovation_option_vector.empty(); };
-  inline bool measurement_error_option_has_val() { return !measurement_error_option_vector.empty(); };
-  inline bool structural_innovation_corr_option_has_val() { return !structural_innovation_corr_option_vector.empty(); };
-  inline bool measurement_error_corr_option_has_val() { return !measurement_error_corr_option_vector.empty(); };
+  inline bool
+  option_has_val()
+  {
+    return !option_vector.empty();
+  };
+  inline bool
+  structural_innovation_option_has_val()
+  {
+    return !structural_innovation_option_vector.empty();
+  };
+  inline bool
+  measurement_error_option_has_val()
+  {
+    return !measurement_error_option_vector.empty();
+  };
+  inline bool
+  structural_innovation_corr_option_has_val()
+  {
+    return !structural_innovation_corr_option_vector.empty();
+  };
+  inline bool
+  measurement_error_corr_option_has_val()
+  {
+    return !measurement_error_corr_option_vector.empty();
+  };
 
-  inline vector<MarkovSwitching *>get_markov_switching() { return markov_switching_vector; };
-  inline vector<ModFilePrior *> get_prior() { return prior_vector; };
-  inline vector<ModFileStructuralInnovationPrior *> get_structural_innovation_prior() { return structural_innovation_prior_vector; };
-  inline vector<ModFileMeasurementErrorPrior *> get_measurement_error_prior() { return measurement_error_prior_vector; };
-  inline vector<ModFileStructuralInnovationCorrPrior *> get_structural_innovation_corr_prior() { return structural_innovation_corr_prior_vector; };
-  inline vector<ModFileMeasurementErrorCorrPrior *> get_measurement_error_corr_prior() { return measurement_error_corr_prior_vector; };
+  inline vector<MarkovSwitching *>
+  get_markov_switching()
+  {
+    return markov_switching_vector;
+  };
+  inline vector<ModFilePrior *>
+  get_prior()
+  {
+    return prior_vector;
+  };
+  inline vector<ModFileStructuralInnovationPrior *>
+  get_structural_innovation_prior()
+  {
+    return structural_innovation_prior_vector;
+  };
+  inline vector<ModFileMeasurementErrorPrior *>
+  get_measurement_error_prior()
+  {
+    return measurement_error_prior_vector;
+  };
+  inline vector<ModFileStructuralInnovationCorrPrior *>
+  get_structural_innovation_corr_prior()
+  {
+    return structural_innovation_corr_prior_vector;
+  };
+  inline vector<ModFileMeasurementErrorCorrPrior *>
+  get_measurement_error_corr_prior()
+  {
+    return measurement_error_corr_prior_vector;
+  };
 
-  inline vector<ModFileOption *> get_option() { return option_vector; };
-  inline vector<ModFileStructuralInnovationOption *> get_structural_innovation_option() { return structural_innovation_option_vector; };
-  inline vector<ModFileMeasurementErrorOption *> get_measurement_error_option() { return measurement_error_option_vector; };
-  inline vector<ModFileStructuralInnovationCorrOption *> get_structural_innovation_corr_option() { return structural_innovation_corr_option_vector; };
-  inline vector<ModFileMeasurementErrorCorrOption *> get_measurement_error_corr_option() { return measurement_error_corr_option_vector; };
+  inline vector<ModFileOption *>
+  get_option()
+  {
+    return option_vector;
+  };
+  inline vector<ModFileStructuralInnovationOption *>
+  get_structural_innovation_option()
+  {
+    return structural_innovation_option_vector;
+  };
+  inline vector<ModFileMeasurementErrorOption *>
+  get_measurement_error_option()
+  {
+    return measurement_error_option_vector;
+  };
+  inline vector<ModFileStructuralInnovationCorrOption *>
+  get_structural_innovation_corr_option()
+  {
+    return structural_innovation_corr_option_vector;
+  };
+  inline vector<ModFileMeasurementErrorCorrOption *>
+  get_measurement_error_corr_option()
+  {
+    return measurement_error_corr_option_vector;
+  };
 
-  inline map<string, int > get_exo_names() { return exo_names; };
-  inline map<string, int > get_exo_det_names() { return exo_det_names; };
-  inline map<string, int > get_endo_names() { return endo_names; };
-  inline map<string, int > get_param_names() { return param_names; };
-  inline vector<double> get_params() { return params; };
-  inline double *get_params_data(void) { return params.data(); };
-  inline vector <aux_vars_t> get_aux_vars() { return aux_vars; };
-  inline vector <int> get_predetermined_variables() { return predetermined_variables; };
-  inline vector <int> get_varobs() { return varobs; };
-  inline vector<int> get_NNZDerivatives() { return NNZDerivatives; };
+  inline map<string, int >
+  get_exo_names()
+  {
+    return exo_names;
+  };
+  inline map<string, int >
+  get_exo_det_names()
+  {
+    return exo_det_names;
+  };
+  inline map<string, int >
+  get_endo_names()
+  {
+    return endo_names;
+  };
+  inline map<string, int >
+  get_param_names()
+  {
+    return param_names;
+  };
+  inline vector<double>
+  get_params()
+  {
+    return params;
+  };
+  inline double *
+  get_params_data(void)
+  {
+    return params.data();
+  };
+  inline vector <aux_vars_t>
+  get_aux_vars()
+  {
+    return aux_vars;
+  };
+  inline vector <int>
+  get_predetermined_variables()
+  {
+    return predetermined_variables;
+  };
+  inline vector <int>
+  get_varobs()
+  {
+    return varobs;
+  };
+  inline vector<int>
+  get_NNZDerivatives()
+  {
+    return NNZDerivatives;
+  };
 
-  inline int get_endo_nbr(void) { return endo_nbr; };
-  inline int get_exo_nbr(void) { return exo_nbr; };
-  inline int get_exo_det_nbr(void) { return exo_det_nbr; };
-  inline int get_param_nbr(void) { return param_nbr; };
-  inline vector<size_t>  get_zeta_back(void) { return zeta_back; };
-  inline vector<size_t>  get_zeta_fwrd(void) { return zeta_fwrd; };
-  inline vector<size_t>  get_zeta_mixed(void) { return zeta_mixed; };
-  inline vector<size_t>  get_zeta_static(void) { return zeta_static; };
+  inline int
+  get_endo_nbr(void)
+  {
+    return endo_nbr;
+  };
+  inline int
+  get_exo_nbr(void)
+  {
+    return exo_nbr;
+  };
+  inline int
+  get_exo_det_nbr(void)
+  {
+    return exo_det_nbr;
+  };
+  inline int
+  get_param_nbr(void)
+  {
+    return param_nbr;
+  };
+  inline vector<size_t>
+  get_zeta_back(void)
+  {
+    return zeta_back;
+  };
+  inline vector<size_t>
+  get_zeta_fwrd(void)
+  {
+    return zeta_fwrd;
+  };
+  inline vector<size_t>
+  get_zeta_mixed(void)
+  {
+    return zeta_mixed;
+  };
+  inline vector<size_t>
+  get_zeta_static(void)
+  {
+    return zeta_static;
+  };
 
   string get_exo_name_by_index(int index) throw (ValueNotSetException);
   int get_exo_index_by_name(string name) throw (ValueNotSetException);
diff --git a/others/cpp/dynare_driver.c b/others/cpp/dynare_driver.c
index f6701dd4b..2beec5260 100644
--- a/others/cpp/dynare_driver.c
+++ b/others/cpp/dynare_driver.c
@@ -39,7 +39,7 @@ DynareInfo::DynareInfo(map<string, int > exo_names_arg,
   exo_nbr = exo_names.size();
   exo_det_nbr = exo_det_names.size();
   param_nbr = param_names.size();
-  
+
   exo_names = exo_names_arg;
   exo_det_names = exo_det_names_arg;
   endo_names = endo_names_arg;
@@ -54,27 +54,27 @@ DynareInfo::DynareInfo(map<string, int > exo_names_arg,
 DynareInfo::~DynareInfo()
 {
   for (vector<MarkovSwitching *>::iterator it = markov_switching_vector.begin();
-       it < markov_switching_vector.end(); it++ )
+       it < markov_switching_vector.end(); it++)
     delete *it;
 
   for (vector<ModFilePrior *>::iterator it = prior_vector.begin();
-       it < prior_vector.end(); it++ )
+       it < prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileStructuralInnovationPrior *>::iterator it = structural_innovation_prior_vector.begin();
-       it < structural_innovation_prior_vector.end(); it++ )
+       it < structural_innovation_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileMeasurementErrorPrior *>::iterator it = measurement_error_prior_vector.begin();
-       it < measurement_error_prior_vector.end(); it++ )
+       it < measurement_error_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileStructuralInnovationCorrPrior *>::iterator it = structural_innovation_corr_prior_vector.begin();
-       it < structural_innovation_corr_prior_vector.end(); it++ )
+       it < structural_innovation_corr_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileMeasurementErrorCorrPrior *>::iterator it = measurement_error_corr_prior_vector.begin();
-       it < measurement_error_corr_prior_vector.end(); it++ )
+       it < measurement_error_corr_prior_vector.end(); it++)
     delete *it;
 
   markov_switching_vector.clear();
diff --git a/others/cpp/dynare_driver.h b/others/cpp/dynare_driver.h
index 581cdd6ea..3dcb7acd9 100644
--- a/others/cpp/dynare_driver.h
+++ b/others/cpp/dynare_driver.h
@@ -25,11 +25,12 @@
 
 using namespace std;
 
-struct aux_vars_t {
+struct aux_vars_t
+{
   int endo_index, type, orig_index, orig_lead_lag;
-} ;
+};
 
-typedef map<pair<int, int >, double> restriction_map_t ;
+typedef map<pair<int, int >, double> restriction_map_t;
 
 class ValueNotSetException
 {
@@ -57,21 +58,49 @@ public:
                   const vector<double> duration_arg,
                   const restriction_map_t restriction_map_arg);
 
-  inline bool number_of_lags_has_val() const { return number_of_lags_was_passed; };
-  inline bool restriction_map_has_val() const { return !restriction_map.empty(); };
+  inline bool
+  number_of_lags_has_val() const
+  {
+    return number_of_lags_was_passed;
+  };
+  inline bool
+  restriction_map_has_val() const
+  {
+    return !restriction_map.empty();
+  };
 
-  inline int get_chain() const { return chain; };
-  inline int get_number_of_regimes() const { return number_of_regimes; };
+  inline int
+  get_chain() const
+  {
+    return chain;
+  };
+  inline int
+  get_number_of_regimes() const
+  {
+    return number_of_regimes;
+  };
   int get_number_of_lags() throw (ValueNotSetException);
-  inline vector<int> get_parameters() { return parameters; };
-  inline vector<double> get_duration() { return duration; };
+  inline vector<int>
+  get_parameters()
+  {
+    return parameters;
+  };
+  inline vector<double>
+  get_duration()
+  {
+    return duration;
+  };
   restriction_map_t get_restriction_map() throw (ValueNotSetException);
 };
 
 class BasicModFilePrior
 {
 private:
-  inline bool isnan(double x) const { return (x!=x); };
+  inline bool
+  isnan(double x) const
+  {
+    return (x != x);
+  };
 protected:
   const int index;
   const string shape;
@@ -86,14 +115,42 @@ protected:
                     const double variance_arg,
                     const vector <double> domain_arg);
 public:
-  inline bool mean_has_val() const { return !isnan(mean); };
-  inline bool mode_has_val() const { return !isnan(mode); };
-  inline bool stdev_has_val() const { return !isnan(stdev); };
-  inline bool variance_has_val() const { return !isnan(variance); };
-  inline bool domain_has_val() const { return (domain.size() == 2); };
+  inline bool
+  mean_has_val() const
+  {
+    return !isnan(mean);
+  };
+  inline bool
+  mode_has_val() const
+  {
+    return !isnan(mode);
+  };
+  inline bool
+  stdev_has_val() const
+  {
+    return !isnan(stdev);
+  };
+  inline bool
+  variance_has_val() const
+  {
+    return !isnan(variance);
+  };
+  inline bool
+  domain_has_val() const
+  {
+    return (domain.size() == 2);
+  };
 
-  inline int get_index() const { return index; };
-  inline string get_shape() const { return shape; };
+  inline int
+  get_index() const
+  {
+    return index;
+  };
+  inline string
+  get_shape() const
+  {
+    return shape;
+  };
   double get_mean() throw (ValueNotSetException);
   double get_mode() throw (ValueNotSetException);
   double get_stdev() throw (ValueNotSetException);
@@ -113,7 +170,7 @@ public:
                const vector <double> domain_arg);
 };
 
-class ModFileStructuralInnovationPrior: public BasicModFilePrior
+class ModFileStructuralInnovationPrior : public BasicModFilePrior
 {
 public:
   ModFileStructuralInnovationPrior(const int index_arg,
@@ -170,7 +227,11 @@ public:
 class BasicModFileOption
 {
 private:
-  inline bool isnan(double x) const { return (x!=x); };
+  inline bool
+  isnan(double x) const
+  {
+    return (x != x);
+  };
 protected:
   const int index;
   const double init;
@@ -178,8 +239,16 @@ protected:
   BasicModFileOption(const int index_arg,
                      const double init_arg);
 public:
-  inline int get_index() const { return index; };
-  inline double get_init() const { return init; };
+  inline int
+  get_index() const
+  {
+    return index;
+  };
+  inline double
+  get_init() const
+  {
+    return init;
+  };
 };
 
 class ModFileOption : public BasicModFileOption
@@ -189,7 +258,7 @@ public:
                 const double init_arg);
 };
 
-class ModFileStructuralInnovationOption: public BasicModFileOption
+class ModFileStructuralInnovationOption : public BasicModFileOption
 {
 public:
   ModFileStructuralInnovationOption(const int index_arg,
@@ -258,65 +327,269 @@ public:
              vector<int> NNZDerivatives_arg);
   ~DynareInfo();
 
-  inline void addMarkovSwitching(MarkovSwitching *ms) { markov_switching_vector.push_back(ms); };
+  inline void
+  addMarkovSwitching(MarkovSwitching *ms)
+  {
+    markov_switching_vector.push_back(ms);
+  };
 
-  inline void addPrior(ModFilePrior *p) { prior_vector.push_back(p); };
-  inline void addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip) { structural_innovation_prior_vector.push_back(sip); };
-  inline void addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep) { measurement_error_prior_vector.push_back(mep); };
-  inline void addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp) { structural_innovation_corr_prior_vector.push_back(sicp); };
-  inline void addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp) { measurement_error_corr_prior_vector.push_back(mecp); };
+  inline void
+  addPrior(ModFilePrior *p)
+  {
+    prior_vector.push_back(p);
+  };
+  inline void
+  addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip)
+  {
+    structural_innovation_prior_vector.push_back(sip);
+  };
+  inline void
+  addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep)
+  {
+    measurement_error_prior_vector.push_back(mep);
+  };
+  inline void
+  addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp)
+  {
+    structural_innovation_corr_prior_vector.push_back(sicp);
+  };
+  inline void
+  addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp)
+  {
+    measurement_error_corr_prior_vector.push_back(mecp);
+  };
 
-  inline void addOption(ModFileOption *o) { option_vector.push_back(o); };
-  inline void addStructuralInnovationOption(ModFileStructuralInnovationOption *sio) { structural_innovation_option_vector.push_back(sio); };
-  inline void addMeasurementErrorOption(ModFileMeasurementErrorOption *meo) { measurement_error_option_vector.push_back(meo); };
-  inline void addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico) { structural_innovation_corr_option_vector.push_back(sico); };
-  inline void addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco) { measurement_error_corr_option_vector.push_back(meco); };
+  inline void
+  addOption(ModFileOption *o)
+  {
+    option_vector.push_back(o);
+  };
+  inline void
+  addStructuralInnovationOption(ModFileStructuralInnovationOption *sio)
+  {
+    structural_innovation_option_vector.push_back(sio);
+  };
+  inline void
+  addMeasurementErrorOption(ModFileMeasurementErrorOption *meo)
+  {
+    measurement_error_option_vector.push_back(meo);
+  };
+  inline void
+  addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico)
+  {
+    structural_innovation_corr_option_vector.push_back(sico);
+  };
+  inline void
+  addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco)
+  {
+    measurement_error_corr_option_vector.push_back(meco);
+  };
 
-  inline bool markov_switching_has_val() { return !markov_switching_vector.empty(); };
-  inline bool prior_has_val() { return !prior_vector.empty(); };
-  inline bool structural_innovation_prior_has_val() { return !structural_innovation_prior_vector.empty(); };
-  inline bool measurement_error_prior_has_val() { return !measurement_error_prior_vector.empty(); };
-  inline bool structural_innovation_corr_prior_has_val() { return !structural_innovation_corr_prior_vector.empty(); };
-  inline bool measurement_error_corr_prior_has_val() { return !measurement_error_corr_prior_vector.empty(); };
+  inline bool
+  markov_switching_has_val()
+  {
+    return !markov_switching_vector.empty();
+  };
+  inline bool
+  prior_has_val()
+  {
+    return !prior_vector.empty();
+  };
+  inline bool
+  structural_innovation_prior_has_val()
+  {
+    return !structural_innovation_prior_vector.empty();
+  };
+  inline bool
+  measurement_error_prior_has_val()
+  {
+    return !measurement_error_prior_vector.empty();
+  };
+  inline bool
+  structural_innovation_corr_prior_has_val()
+  {
+    return !structural_innovation_corr_prior_vector.empty();
+  };
+  inline bool
+  measurement_error_corr_prior_has_val()
+  {
+    return !measurement_error_corr_prior_vector.empty();
+  };
 
-  inline bool option_has_val() { return !option_vector.empty(); };
-  inline bool structural_innovation_option_has_val() { return !structural_innovation_option_vector.empty(); };
-  inline bool measurement_error_option_has_val() { return !measurement_error_option_vector.empty(); };
-  inline bool structural_innovation_corr_option_has_val() { return !structural_innovation_corr_option_vector.empty(); };
-  inline bool measurement_error_corr_option_has_val() { return !measurement_error_corr_option_vector.empty(); };
+  inline bool
+  option_has_val()
+  {
+    return !option_vector.empty();
+  };
+  inline bool
+  structural_innovation_option_has_val()
+  {
+    return !structural_innovation_option_vector.empty();
+  };
+  inline bool
+  measurement_error_option_has_val()
+  {
+    return !measurement_error_option_vector.empty();
+  };
+  inline bool
+  structural_innovation_corr_option_has_val()
+  {
+    return !structural_innovation_corr_option_vector.empty();
+  };
+  inline bool
+  measurement_error_corr_option_has_val()
+  {
+    return !measurement_error_corr_option_vector.empty();
+  };
 
-  inline vector<MarkovSwitching *>get_markov_switching() { return markov_switching_vector; };
-  inline vector<ModFilePrior *> get_prior() { return prior_vector; };
-  inline vector<ModFileStructuralInnovationPrior *> get_structural_innovation_prior() { return structural_innovation_prior_vector; };
-  inline vector<ModFileMeasurementErrorPrior *> get_measurement_error_prior() { return measurement_error_prior_vector; };
-  inline vector<ModFileStructuralInnovationCorrPrior *> get_structural_innovation_corr_prior() { return structural_innovation_corr_prior_vector; };
-  inline vector<ModFileMeasurementErrorCorrPrior *> get_measurement_error_corr_prior() { return measurement_error_corr_prior_vector; };
+  inline vector<MarkovSwitching *>
+  get_markov_switching()
+  {
+    return markov_switching_vector;
+  };
+  inline vector<ModFilePrior *>
+  get_prior()
+  {
+    return prior_vector;
+  };
+  inline vector<ModFileStructuralInnovationPrior *>
+  get_structural_innovation_prior()
+  {
+    return structural_innovation_prior_vector;
+  };
+  inline vector<ModFileMeasurementErrorPrior *>
+  get_measurement_error_prior()
+  {
+    return measurement_error_prior_vector;
+  };
+  inline vector<ModFileStructuralInnovationCorrPrior *>
+  get_structural_innovation_corr_prior()
+  {
+    return structural_innovation_corr_prior_vector;
+  };
+  inline vector<ModFileMeasurementErrorCorrPrior *>
+  get_measurement_error_corr_prior()
+  {
+    return measurement_error_corr_prior_vector;
+  };
 
-  inline vector<ModFileOption *> get_option() { return option_vector; };
-  inline vector<ModFileStructuralInnovationOption *> get_structural_innovation_option() { return structural_innovation_option_vector; };
-  inline vector<ModFileMeasurementErrorOption *> get_measurement_error_option() { return measurement_error_option_vector; };
-  inline vector<ModFileStructuralInnovationCorrOption *> get_structural_innovation_corr_option() { return structural_innovation_corr_option_vector; };
-  inline vector<ModFileMeasurementErrorCorrOption *> get_measurement_error_corr_option() { return measurement_error_corr_option_vector; };
+  inline vector<ModFileOption *>
+  get_option()
+  {
+    return option_vector;
+  };
+  inline vector<ModFileStructuralInnovationOption *>
+  get_structural_innovation_option()
+  {
+    return structural_innovation_option_vector;
+  };
+  inline vector<ModFileMeasurementErrorOption *>
+  get_measurement_error_option()
+  {
+    return measurement_error_option_vector;
+  };
+  inline vector<ModFileStructuralInnovationCorrOption *>
+  get_structural_innovation_corr_option()
+  {
+    return structural_innovation_corr_option_vector;
+  };
+  inline vector<ModFileMeasurementErrorCorrOption *>
+  get_measurement_error_corr_option()
+  {
+    return measurement_error_corr_option_vector;
+  };
 
-  inline map<string, int > get_exo_names() { return exo_names; };
-  inline map<string, int > get_exo_det_names() { return exo_det_names; };
-  inline map<string, int > get_endo_names() { return endo_names; };
-  inline map<string, int > get_param_names() { return param_names; };
-  inline vector<double> get_params() { return params; };
-  inline double *get_params_data(void) { return params.data(); };
-  inline vector <aux_vars_t> get_aux_vars() { return aux_vars; };
-  inline vector <int> get_predetermined_variables() { return predetermined_variables; };
-  inline vector <int> get_varobs() { return varobs; };
-  inline vector<int> get_NNZDerivatives() { return NNZDerivatives; };
+  inline map<string, int >
+  get_exo_names()
+  {
+    return exo_names;
+  };
+  inline map<string, int >
+  get_exo_det_names()
+  {
+    return exo_det_names;
+  };
+  inline map<string, int >
+  get_endo_names()
+  {
+    return endo_names;
+  };
+  inline map<string, int >
+  get_param_names()
+  {
+    return param_names;
+  };
+  inline vector<double>
+  get_params()
+  {
+    return params;
+  };
+  inline double *
+  get_params_data(void)
+  {
+    return params.data();
+  };
+  inline vector <aux_vars_t>
+  get_aux_vars()
+  {
+    return aux_vars;
+  };
+  inline vector <int>
+  get_predetermined_variables()
+  {
+    return predetermined_variables;
+  };
+  inline vector <int>
+  get_varobs()
+  {
+    return varobs;
+  };
+  inline vector<int>
+  get_NNZDerivatives()
+  {
+    return NNZDerivatives;
+  };
 
-  inline int get_endo_nbr(void) { return endo_nbr; };
-  inline int get_exo_nbr(void) { return exo_nbr; };
-  inline int get_exo_det_nbr(void) { return exo_det_nbr; };
-  inline int get_param_nbr(void) { return param_nbr; };
-  inline vector<size_t>  get_zeta_back(void) { return zeta_back; };
-  inline vector<size_t>  get_zeta_fwrd(void) { return zeta_fwrd; };
-  inline vector<size_t>  get_zeta_mixed(void) { return zeta_mixed; };
-  inline vector<size_t>  get_zeta_static(void) { return zeta_static; };
+  inline int
+  get_endo_nbr(void)
+  {
+    return endo_nbr;
+  };
+  inline int
+  get_exo_nbr(void)
+  {
+    return exo_nbr;
+  };
+  inline int
+  get_exo_det_nbr(void)
+  {
+    return exo_det_nbr;
+  };
+  inline int
+  get_param_nbr(void)
+  {
+    return param_nbr;
+  };
+  inline vector<size_t>
+  get_zeta_back(void)
+  {
+    return zeta_back;
+  };
+  inline vector<size_t>
+  get_zeta_fwrd(void)
+  {
+    return zeta_fwrd;
+  };
+  inline vector<size_t>
+  get_zeta_mixed(void)
+  {
+    return zeta_mixed;
+  };
+  inline vector<size_t>
+  get_zeta_static(void)
+  {
+    return zeta_static;
+  };
 
   string get_exo_name_by_index(int index) throw (ValueNotSetException);
   int get_exo_index_by_name(string name) throw (ValueNotSetException);
diff --git a/others/cpp/ms_dsge_c_driver.cc b/others/cpp/ms_dsge_c_driver.cc
index 681520531..b1183a845 100644
--- a/others/cpp/ms_dsge_c_driver.cc
+++ b/others/cpp/ms_dsge_c_driver.cc
@@ -50,27 +50,27 @@ MsDsgeInfo::MsDsgeInfo(map<string, int > exo_names_arg,
 MsDsgeInfo::~MsDsgeInfo()
 {
   for (vector<MarkovSwitching *>::iterator it = markov_switching_vector.begin();
-       it < markov_switching_vector.end(); it++ )
+       it < markov_switching_vector.end(); it++)
     delete *it;
 
   for (vector<ModFilePrior *>::iterator it = prior_vector.begin();
-       it < prior_vector.end(); it++ )
+       it < prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileStructuralInnovationPrior *>::iterator it = structural_innovation_prior_vector.begin();
-       it < structural_innovation_prior_vector.end(); it++ )
+       it < structural_innovation_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileMeasurementErrorPrior *>::iterator it = measurement_error_prior_vector.begin();
-       it < measurement_error_prior_vector.end(); it++ )
+       it < measurement_error_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileStructuralInnovationCorrPrior *>::iterator it = structural_innovation_corr_prior_vector.begin();
-       it < structural_innovation_corr_prior_vector.end(); it++ )
+       it < structural_innovation_corr_prior_vector.end(); it++)
     delete *it;
 
   for (vector<ModFileMeasurementErrorCorrPrior *>::iterator it = measurement_error_corr_prior_vector.begin();
-       it < measurement_error_corr_prior_vector.end(); it++ )
+       it < measurement_error_corr_prior_vector.end(); it++)
     delete *it;
 
   markov_switching_vector.clear();
diff --git a/others/cpp/ms_dsge_c_driver.hh b/others/cpp/ms_dsge_c_driver.hh
index 9e968b4b6..194cfa94d 100644
--- a/others/cpp/ms_dsge_c_driver.hh
+++ b/others/cpp/ms_dsge_c_driver.hh
@@ -25,11 +25,12 @@
 
 using namespace std;
 
-struct aux_vars_t {
+struct aux_vars_t
+{
   int endo_index, type, orig_index, orig_lead_lag;
-} ;
+};
 
-typedef map<pair<int, int >, double> restriction_map_t ;
+typedef map<pair<int, int >, double> restriction_map_t;
 
 class ValueNotSetException
 {
@@ -57,21 +58,49 @@ public:
                   const vector<double> duration_arg,
                   const restriction_map_t restriction_map_arg);
 
-  inline bool number_of_lags_has_val() const { return number_of_lags_was_passed; };
-  inline bool restriction_map_has_val() const { return !restriction_map.empty(); };
+  inline bool
+  number_of_lags_has_val() const
+  {
+    return number_of_lags_was_passed;
+  };
+  inline bool
+  restriction_map_has_val() const
+  {
+    return !restriction_map.empty();
+  };
 
-  inline int get_chain() const { return chain; };
-  inline int get_number_of_regimes() const { return number_of_regimes; };
+  inline int
+  get_chain() const
+  {
+    return chain;
+  };
+  inline int
+  get_number_of_regimes() const
+  {
+    return number_of_regimes;
+  };
   int get_number_of_lags() throw (ValueNotSetException);
-  inline vector<int> get_parameters() { return parameters; };
-  inline vector<double> get_duration() { return duration; };
+  inline vector<int>
+  get_parameters()
+  {
+    return parameters;
+  };
+  inline vector<double>
+  get_duration()
+  {
+    return duration;
+  };
   restriction_map_t get_restriction_map() throw (ValueNotSetException);
 };
 
 class BasicModFilePrior
 {
 private:
-  inline bool isnan(double x) const { return (x!=x); };
+  inline bool
+  isnan(double x) const
+  {
+    return (x != x);
+  };
 protected:
   const int index;
   const string shape;
@@ -86,14 +115,42 @@ protected:
                     const double variance_arg,
                     const vector <double> domain_arg);
 public:
-  inline bool mean_has_val() const { return !isnan(mean); };
-  inline bool mode_has_val() const { return !isnan(mode); };
-  inline bool stdev_has_val() const { return !isnan(stdev); };
-  inline bool variance_has_val() const { return !isnan(variance); };
-  inline bool domain_has_val() const { return (domain.size() == 2); };
+  inline bool
+  mean_has_val() const
+  {
+    return !isnan(mean);
+  };
+  inline bool
+  mode_has_val() const
+  {
+    return !isnan(mode);
+  };
+  inline bool
+  stdev_has_val() const
+  {
+    return !isnan(stdev);
+  };
+  inline bool
+  variance_has_val() const
+  {
+    return !isnan(variance);
+  };
+  inline bool
+  domain_has_val() const
+  {
+    return (domain.size() == 2);
+  };
 
-  inline int get_index() const { return index; };
-  inline string get_shape() const { return shape; };
+  inline int
+  get_index() const
+  {
+    return index;
+  };
+  inline string
+  get_shape() const
+  {
+    return shape;
+  };
   double get_mean() throw (ValueNotSetException);
   double get_mode() throw (ValueNotSetException);
   double get_stdev() throw (ValueNotSetException);
@@ -113,7 +170,7 @@ public:
                const vector <double> domain_arg);
 };
 
-class ModFileStructuralInnovationPrior: public BasicModFilePrior
+class ModFileStructuralInnovationPrior : public BasicModFilePrior
 {
 public:
   ModFileStructuralInnovationPrior(const int index_arg,
@@ -170,7 +227,11 @@ public:
 class BasicModFileOption
 {
 private:
-  inline bool isnan(double x) const { return (x!=x); };
+  inline bool
+  isnan(double x) const
+  {
+    return (x != x);
+  };
 protected:
   const int index;
   const double init;
@@ -178,8 +239,16 @@ protected:
   BasicModFileOption(const int index_arg,
                      const double init_arg);
 public:
-  inline int get_index() const { return index; };
-  inline double get_init() const { return init; };
+  inline int
+  get_index() const
+  {
+    return index;
+  };
+  inline double
+  get_init() const
+  {
+    return init;
+  };
 };
 
 class ModFileOption : public BasicModFileOption
@@ -189,7 +258,7 @@ public:
                 const double init_arg);
 };
 
-class ModFileStructuralInnovationOption: public BasicModFileOption
+class ModFileStructuralInnovationOption : public BasicModFileOption
 {
 public:
   ModFileStructuralInnovationOption(const int index_arg,
@@ -242,7 +311,7 @@ private:
   vector<aux_vars_t> aux_vars;
   vector<int> predetermined_variables;
   vector<int> varobs;
-  vector<vector<int > >lead_lag_incidence;
+  vector<vector<int > > lead_lag_incidence;
   vector<double> NNZDerivatives;
 public:
   DynareInfo(map<string, int > exo_names_arg,
@@ -257,56 +326,228 @@ public:
              vector<double> NNZDerivatives_arg);
   ~DynareInfo();
 
-  inline void addMarkovSwitching(MarkovSwitching *ms) { markov_switching_vector.push_back(ms); };
+  inline void
+  addMarkovSwitching(MarkovSwitching *ms)
+  {
+    markov_switching_vector.push_back(ms);
+  };
 
-  inline void addPrior(ModFilePrior *p) { prior_vector.push_back(p); };
-  inline void addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip) { structural_innovation_prior_vector.push_back(sip); };
-  inline void addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep) { measurement_error_prior_vector.push_back(mep); };
-  inline void addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp) { structural_innovation_corr_prior_vector.push_back(sicp); };
-  inline void addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp) { measurement_error_corr_prior_vector.push_back(mecp); };
+  inline void
+  addPrior(ModFilePrior *p)
+  {
+    prior_vector.push_back(p);
+  };
+  inline void
+  addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip)
+  {
+    structural_innovation_prior_vector.push_back(sip);
+  };
+  inline void
+  addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep)
+  {
+    measurement_error_prior_vector.push_back(mep);
+  };
+  inline void
+  addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp)
+  {
+    structural_innovation_corr_prior_vector.push_back(sicp);
+  };
+  inline void
+  addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp)
+  {
+    measurement_error_corr_prior_vector.push_back(mecp);
+  };
 
-  inline void addOption(ModFileOption *o) { option_vector.push_back(o); };
-  inline void addStructuralInnovationOption(ModFileStructuralInnovationOption *sio) { structural_innovation_option_vector.push_back(sio); };
-  inline void addMeasurementErrorOption(ModFileMeasurementErrorOption *meo) { measurement_error_option_vector.push_back(meo); };
-  inline void addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico) { structural_innovation_corr_option_vector.push_back(sico); };
-  inline void addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco) { measurement_error_corr_option_vector.push_back(meco); };
+  inline void
+  addOption(ModFileOption *o)
+  {
+    option_vector.push_back(o);
+  };
+  inline void
+  addStructuralInnovationOption(ModFileStructuralInnovationOption *sio)
+  {
+    structural_innovation_option_vector.push_back(sio);
+  };
+  inline void
+  addMeasurementErrorOption(ModFileMeasurementErrorOption *meo)
+  {
+    measurement_error_option_vector.push_back(meo);
+  };
+  inline void
+  addStructuralInnovationCorrOption(ModFileStructuralInnovationCorrOption *sico)
+  {
+    structural_innovation_corr_option_vector.push_back(sico);
+  };
+  inline void
+  addMeasurementErrorCorrOption(ModFileMeasurementErrorCorrOption *meco)
+  {
+    measurement_error_corr_option_vector.push_back(meco);
+  };
 
-  inline bool markov_switching_has_val() { return !markov_switching_vector.empty(); };
-  inline bool prior_has_val() { return !prior_vector.empty(); };
-  inline bool structural_innovation_prior_has_val() { return !structural_innovation_prior_vector.empty(); };
-  inline bool measurement_error_prior_has_val() { return !measurement_error_prior_vector.empty(); };
-  inline bool structural_innovation_corr_prior_has_val() { return !structural_innovation_corr_prior_vector.empty(); };
-  inline bool measurement_error_corr_prior_has_val() { return !measurement_error_corr_prior_vector.empty(); };
+  inline bool
+  markov_switching_has_val()
+  {
+    return !markov_switching_vector.empty();
+  };
+  inline bool
+  prior_has_val()
+  {
+    return !prior_vector.empty();
+  };
+  inline bool
+  structural_innovation_prior_has_val()
+  {
+    return !structural_innovation_prior_vector.empty();
+  };
+  inline bool
+  measurement_error_prior_has_val()
+  {
+    return !measurement_error_prior_vector.empty();
+  };
+  inline bool
+  structural_innovation_corr_prior_has_val()
+  {
+    return !structural_innovation_corr_prior_vector.empty();
+  };
+  inline bool
+  measurement_error_corr_prior_has_val()
+  {
+    return !measurement_error_corr_prior_vector.empty();
+  };
 
-  inline bool option_has_val() { return !option_vector.empty(); };
-  inline bool structural_innovation_option_has_val() { return !structural_innovation_option_vector.empty(); };
-  inline bool measurement_error_option_has_val() { return !measurement_error_option_vector.empty(); };
-  inline bool structural_innovation_corr_option_has_val() { return !structural_innovation_corr_option_vector.empty(); };
-  inline bool measurement_error_corr_option_has_val() { return !measurement_error_corr_option_vector.empty(); };
+  inline bool
+  option_has_val()
+  {
+    return !option_vector.empty();
+  };
+  inline bool
+  structural_innovation_option_has_val()
+  {
+    return !structural_innovation_option_vector.empty();
+  };
+  inline bool
+  measurement_error_option_has_val()
+  {
+    return !measurement_error_option_vector.empty();
+  };
+  inline bool
+  structural_innovation_corr_option_has_val()
+  {
+    return !structural_innovation_corr_option_vector.empty();
+  };
+  inline bool
+  measurement_error_corr_option_has_val()
+  {
+    return !measurement_error_corr_option_vector.empty();
+  };
 
-  inline vector<MarkovSwitching *>get_markov_switching() { return markov_switching_vector; };
-  inline vector<ModFilePrior *> get_prior() { return prior_vector; };
-  inline vector<ModFileStructuralInnovationPrior *> get_structural_innovation_prior() { return structural_innovation_prior_vector; };
-  inline vector<ModFileMeasurementErrorPrior *> get_measurement_error_prior() { return measurement_error_prior_vector; };
-  inline vector<ModFileStructuralInnovationCorrPrior *> get_structural_innovation_corr_prior() { return structural_innovation_corr_prior_vector; };
-  inline vector<ModFileMeasurementErrorCorrPrior *> get_measurement_error_corr_prior() { return measurement_error_corr_prior_vector; };
+  inline vector<MarkovSwitching *>
+  get_markov_switching()
+  {
+    return markov_switching_vector;
+  };
+  inline vector<ModFilePrior *>
+  get_prior()
+  {
+    return prior_vector;
+  };
+  inline vector<ModFileStructuralInnovationPrior *>
+  get_structural_innovation_prior()
+  {
+    return structural_innovation_prior_vector;
+  };
+  inline vector<ModFileMeasurementErrorPrior *>
+  get_measurement_error_prior()
+  {
+    return measurement_error_prior_vector;
+  };
+  inline vector<ModFileStructuralInnovationCorrPrior *>
+  get_structural_innovation_corr_prior()
+  {
+    return structural_innovation_corr_prior_vector;
+  };
+  inline vector<ModFileMeasurementErrorCorrPrior *>
+  get_measurement_error_corr_prior()
+  {
+    return measurement_error_corr_prior_vector;
+  };
 
-  inline vector<ModFileOption *> get_option() { return option_vector; };
-  inline vector<ModFileStructuralInnovationOption *> get_structural_innovation_option() { return structural_innovation_option_vector; };
-  inline vector<ModFileMeasurementErrorOption *> get_measurement_error_option() { return measurement_error_option_vector; };
-  inline vector<ModFileStructuralInnovationCorrOption *> get_structural_innovation_corr_option() { return structural_innovation_corr_option_vector; };
-  inline vector<ModFileMeasurementErrorCorrOption *> get_measurement_error_corr_option() { return measurement_error_corr_option_vector; };
+  inline vector<ModFileOption *>
+  get_option()
+  {
+    return option_vector;
+  };
+  inline vector<ModFileStructuralInnovationOption *>
+  get_structural_innovation_option()
+  {
+    return structural_innovation_option_vector;
+  };
+  inline vector<ModFileMeasurementErrorOption *>
+  get_measurement_error_option()
+  {
+    return measurement_error_option_vector;
+  };
+  inline vector<ModFileStructuralInnovationCorrOption *>
+  get_structural_innovation_corr_option()
+  {
+    return structural_innovation_corr_option_vector;
+  };
+  inline vector<ModFileMeasurementErrorCorrOption *>
+  get_measurement_error_corr_option()
+  {
+    return measurement_error_corr_option_vector;
+  };
 
-  inline map<string, int > get_exo_names() { return exo_names; };
-  inline map<string, int > get_exo_det_names() { return exo_det_names; };
-  inline map<string, int > get_endo_names() { return endo_names; };
-  inline map<string, int > get_param_names() { return param_names; };
-  inline map<int, double > get_params() { return params; };
-  inline vector <aux_vars_t> get_aux_vars() { return aux_vars; };
-  inline vector <int> get_predetermined_variables() { return predetermined_variables; };
-  inline vector <int> get_varobs() { return varobs; };
-  inline vector<vector<int > > get_lead_lag_incidence() { return lead_lag_incidence; };
-  inline vector<double> get_NNZDerivatives() { return NNZDerivatives; };
+  inline map<string, int >
+  get_exo_names()
+  {
+    return exo_names;
+  };
+  inline map<string, int >
+  get_exo_det_names()
+  {
+    return exo_det_names;
+  };
+  inline map<string, int >
+  get_endo_names()
+  {
+    return endo_names;
+  };
+  inline map<string, int >
+  get_param_names()
+  {
+    return param_names;
+  };
+  inline map<int, double >
+  get_params()
+  {
+    return params;
+  };
+  inline vector <aux_vars_t>
+  get_aux_vars()
+  {
+    return aux_vars;
+  };
+  inline vector <int>
+  get_predetermined_variables()
+  {
+    return predetermined_variables;
+  };
+  inline vector <int>
+  get_varobs()
+  {
+    return varobs;
+  };
+  inline vector<vector<int > >
+  get_lead_lag_incidence()
+  {
+    return lead_lag_incidence;
+  };
+  inline vector<double>
+  get_NNZDerivatives()
+  {
+    return NNZDerivatives;
+  };
 
   string get_exo_name_by_index(int index) throw (ValueNotSetException);
   int get_exo_index_by_name(string name) throw (ValueNotSetException);
@@ -317,7 +558,7 @@ public:
   string get_param_name_by_index(int index) throw (ValueNotSetException);
   int get_param_index_by_name(string name) throw (ValueNotSetException);
   double get_param_value_by_index(int index) throw (ValueNotSetException);
-  vector<int >get_lead_lag_incidence_for_endo_var_by_index(int index) throw (ValueNotSetException);
+  vector<int > get_lead_lag_incidence_for_endo_var_by_index(int index) throw (ValueNotSetException);
 };
 
 #endif // ! _DYNARE_CPP_DRIVER_HH
diff --git a/others/cpp/tests/snes_1.cc b/others/cpp/tests/snes_1.cc
index a5ddda6b2..1f03026e0 100644
--- a/others/cpp/tests/snes_1.cc
+++ b/others/cpp/tests/snes_1.cc
@@ -6,40 +6,44 @@
 #include "main_tao.h"
 
 DynareInfo *preprocessorOutput(void);
-PetscErrorCode FormFunction(SNES snes,Vec y,Vec f,void *ctx);
-PetscErrorCode FormJacobian(SNES snes,Vec y,Mat J, Mat B,void *ctx);
-PetscErrorCode Monitor(SNES,PetscInt,PetscReal,void*);
-PetscErrorCode PreCheck(SNESLineSearch,Vec,Vec,PetscBool*,void*);
-PetscErrorCode PostCheck(SNESLineSearch,Vec,Vec,Vec,PetscBool*,PetscBool*,void*);
-PetscErrorCode PostSetSubKSP(SNESLineSearch,Vec,Vec,Vec,PetscBool*,PetscBool*,void*);
-PetscErrorCode MatrixFreePreconditioner(PC,Vec,Vec);
+PetscErrorCode FormFunction(SNES snes, Vec y, Vec f, void *ctx);
+PetscErrorCode FormJacobian(SNES snes, Vec y, Mat J, Mat B, void *ctx);
+PetscErrorCode Monitor(SNES, PetscInt, PetscReal, void *);
+PetscErrorCode PreCheck(SNESLineSearch, Vec, Vec, PetscBool *, void *);
+PetscErrorCode PostCheck(SNESLineSearch, Vec, Vec, Vec, PetscBool *, PetscBool *, void *);
+PetscErrorCode PostSetSubKSP(SNESLineSearch, Vec, Vec, Vec, PetscBool *, PetscBool *, void *);
+PetscErrorCode MatrixFreePreconditioner(PC, Vec, Vec);
 
 static char  help[] = "Testing";
 
 /*
-   User-defined context for monitoring
+  User-defined context for monitoring
 */
-typedef struct {
+typedef struct
+{
   PetscViewer viewer;
 } MonitorCtx;
 
 /*
-   User-defined context for checking candidate iterates that are
-   determined by line search methods
+  User-defined context for checking candidate iterates that are
+  determined by line search methods
 */
-typedef struct {
+typedef struct
+{
   Vec            last_step;  /* previous iterate */
   PetscReal      tolerance;  /* tolerance for changes between successive iterates */
   AppCtx *user;
 } StepCheckCtx;
 
-typedef struct {
+typedef struct
+{
   PetscInt its0; /* num of prevous outer KSP iterations */
 } SetSubKSPCtx;
 
 #undef __FUNCT__
 #define __FUNCT__ "main"
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
   DynareInfo model_info;
 
@@ -49,7 +53,7 @@ int main(int argc, char **argv)
   // Steady state
   double *steady_state = new double[endo_nbr];
   int info;
-  steadystate(NULL,params, steady_state, &info);
+  steadystate(NULL, params, steady_state, &info);
   vector<int> NNZDerivatives = model_info.get_NNZDerivatives();
   AppCtx         user;            /* user-defined work context */
   user.exogenous = new double[exo_nbr];
@@ -65,237 +69,245 @@ int main(int argc, char **argv)
   user.val_ptr = new double[NNZDerivatives[0]];
   user.initial_values = new double[user.endo_nbr];
   user.terminal_values = new double[user.endo_nbr];
-  for (int i=0; i < user.endo_nbr; ++i)
+  for (int i = 0; i < user.endo_nbr; ++i)
     {
       user.initial_values[i] = user.steady_state[i];
       user.terminal_values[i] = user.steady_state[i];
     }
   /* Initialize PETSc */
-  PetscInitialize(&argc, &argv, (char *)0, help);
+  PetscInitialize(&argc, &argv, (char *) 0, help);
   PetscErrorCode ierr;
   /* Get number of processors */
   PetscInt size;
-  ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
+  ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size); CHKERRQ(ierr);
   /* Set periods a multiple of processor nbr */
-  user.periods = size*ceil((double)user.periods/size);
+  user.periods = size*ceil((double) user.periods/size);
   user.nb_row_x = user.periods + 1;
   user.X = new double[user.nb_row_x*user.exo_nbr];
-  for(double* px=user.X; px < user.X+user.nb_row_x*user.exo_nbr; px++) *px = 0.0;
+  for (double *px = user.X; px < user.X+user.nb_row_x*user.exo_nbr; px++)
+    *px = 0.0;
   user.X[1] = 0.01;
   user.X[1+user.nb_row_x] = 0.01;
   std::cout << size << " " << user.periods << " " << std::endl;
   PetscInt N = user.periods*user.endo_nbr;
   /* Create DMA */
-  DMDACreate1d(PETSC_COMM_WORLD,DM_BOUNDARY_GHOSTED,N,1,user.endo_nbr,NULL,&user.da);
+  DMDACreate1d(PETSC_COMM_WORLD, DM_BOUNDARY_GHOSTED, N, 1, user.endo_nbr, NULL, &user.da);
 
-  /*     Allocate vector and Jacobian matrix  */\
+  /*     Allocate vector and Jacobian matrix  */ \
   Vec Y, R;
-  DMCreateGlobalVector(user.da,&Y);
-  VecDuplicate(Y,&R);
+  DMCreateGlobalVector(user.da, &Y);
+  VecDuplicate(Y, &R);
 
-  Mat J ;
-  ierr = MatCreate(PETSC_COMM_WORLD,&J);CHKERRQ(ierr);
-  ierr = MatSetSizes(J,PETSC_DECIDE,PETSC_DECIDE,N,N);CHKERRQ(ierr);
-  ierr = MatSetFromOptions(J);CHKERRQ(ierr);
-  ierr = MatSetUp(J);CHKERRQ(ierr);
+  Mat J;
+  ierr = MatCreate(PETSC_COMM_WORLD, &J); CHKERRQ(ierr);
+  ierr = MatSetSizes(J, PETSC_DECIDE, PETSC_DECIDE, N, N); CHKERRQ(ierr);
+  ierr = MatSetFromOptions(J); CHKERRQ(ierr);
+  ierr = MatSetUp(J); CHKERRQ(ierr);
 
   /*
-   Get local grid boundaries (for 1-dimensional DMDA):
-     xs, xm - starting grid index, width of local grid (no ghost points)
+    Get local grid boundaries (for 1-dimensional DMDA):
+    xs, xm - starting grid index, width of local grid (no ghost points)
   */
   PetscInt xs, xm, xsg, xmg;
-  DMDAGetCorners(user.da,&xs,NULL,NULL,&xm,NULL,NULL);
+  DMDAGetCorners(user.da, &xs, NULL, NULL, &xm, NULL, NULL);
   std::cout << xs << " " << xm << std::endl;
-  DMDAGetGhostCorners(user.da,&xsg,NULL,NULL,&xmg,NULL,NULL);
+  DMDAGetGhostCorners(user.da, &xsg, NULL, NULL, &xmg, NULL, NULL);
   std::cout << "ghost " << xsg << " " << xmg << std::endl;
   /*
     Get pointers to vector data
   */
   PetscScalar *YY;
-  DMDAVecGetArray(user.da,Y,&YY);
-  
+  DMDAVecGetArray(user.da, Y, &YY);
+
   /*
     Compute local vector entries
   */
-  for (int i=xs; i<xs+xm; i += user.endo_nbr)
-    for (int j=0; j < user.endo_nbr; j++)
+  for (int i = xs; i < xs+xm; i += user.endo_nbr)
+    for (int j = 0; j < user.endo_nbr; j++)
       YY[i+j] = steady_state[j];
   /*
     Restore vectors
   */
-  DMDAVecRestoreArray(user.da,Y,&YY);
+  DMDAVecRestoreArray(user.da, Y, &YY);
 
   SNES snes;
-  ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
-  
+  ierr = SNESCreate(PETSC_COMM_WORLD, &snes); CHKERRQ(ierr);
+
   //  SNES snes;
   SNESLineSearch linesearch;          /* SNESLineSearch context */
   MonitorCtx     monP;                 /* monitoring context */
   StepCheckCtx   checkP;               /* step-checking context */
   SetSubKSPCtx   checkP1;
-  PetscBool      pre_check,post_check,post_setsubksp; /* flag indicating whether we're checking candidate iterates */
-  PetscReal      abstol,rtol,stol,norm;
-  PetscInt       its,maxit,maxf;
+  PetscBool      pre_check, post_check, post_setsubksp; /* flag indicating whether we're checking candidate iterates */
+  PetscReal      abstol, rtol, stol, norm;
+  PetscInt       its, maxit, maxf;
   PetscBool      flg;
-  
+
   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      Create nonlinear solver context
      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
-  ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
+  ierr = SNESCreate(PETSC_COMM_WORLD, &snes); CHKERRQ(ierr);
 
   /*
-     Set function evaluation routine and vector.  Whenever the nonlinear
-     solver needs to compute the nonlinear function, it will call this
-     routine.
-      - Note that the final routine argument is the user-defined
-        context that provides application-specific data for the
-        function evaluation routine.
+    Set function evaluation routine and vector.  Whenever the nonlinear
+    solver needs to compute the nonlinear function, it will call this
+    routine.
+    - Note that the final routine argument is the user-defined
+    context that provides application-specific data for the
+    function evaluation routine.
   */
-  ierr = SNESSetFunction(snes,R,FormFunction,&user);CHKERRQ(ierr);
+  ierr = SNESSetFunction(snes, R, FormFunction, &user); CHKERRQ(ierr);
 
   /*
-     Set Jacobian matrix data structure and default Jacobian evaluation
-     routine.  Whenever the nonlinear solver needs to compute the
-     Jacobian matrix, it will call this routine.
-      - Note that the final routine argument is the user-defined
-        context that provides application-specific data for the
-        Jacobian evaluation routine.
+    Set Jacobian matrix data structure and default Jacobian evaluation
+    routine.  Whenever the nonlinear solver needs to compute the
+    Jacobian matrix, it will call this routine.
+    - Note that the final routine argument is the user-defined
+    context that provides application-specific data for the
+    Jacobian evaluation routine.
   */
-  ierr = SNESSetJacobian(snes,J,J,FormJacobian,&user);CHKERRQ(ierr);
+  ierr = SNESSetJacobian(snes, J, J, FormJacobian, &user); CHKERRQ(ierr);
 
   /*
-     Optional allow user provided preconditioner
-   */
-  ierr = PetscOptionsHasName(NULL,NULL,"-user_precond",&flg);CHKERRQ(ierr);
-  if (flg) {
-    KSP ksp;
-    PC  pc;
-    ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
-    ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
-    ierr = PCSetType(pc,PCSHELL);CHKERRQ(ierr);
-    ierr = PCShellSetApply(pc,MatrixFreePreconditioner);CHKERRQ(ierr);
-  }
+    Optional allow user provided preconditioner
+  */
+  ierr = PetscOptionsHasName(NULL, NULL, "-user_precond", &flg); CHKERRQ(ierr);
+  if (flg)
+    {
+      KSP ksp;
+      PC  pc;
+      ierr = SNESGetKSP(snes, &ksp); CHKERRQ(ierr);
+      ierr = KSPGetPC(ksp, &pc); CHKERRQ(ierr);
+      ierr = PCSetType(pc, PCSHELL); CHKERRQ(ierr);
+      ierr = PCShellSetApply(pc, MatrixFreePreconditioner); CHKERRQ(ierr);
+    }
 
   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      Customize nonlinear solver; set runtime options
-   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+     - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
   /*
-     Set an optional user-defined monitoring routine
+    Set an optional user-defined monitoring routine
   */
-  ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD,0,0,0,0,400,400,&monP.viewer);CHKERRQ(ierr);
-  ierr = SNESMonitorSet(snes,Monitor,&monP,0);CHKERRQ(ierr);
+  ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD, 0, 0, 0, 0, 400, 400, &monP.viewer); CHKERRQ(ierr);
+  ierr = SNESMonitorSet(snes, Monitor, &monP, 0); CHKERRQ(ierr);
 
   /*
-     Set names for some vectors to facilitate monitoring (optional)
+    Set names for some vectors to facilitate monitoring (optional)
   */
-  ierr = PetscObjectSetName((PetscObject)Y,"Approximate Solution");CHKERRQ(ierr);
+  ierr = PetscObjectSetName((PetscObject) Y, "Approximate Solution"); CHKERRQ(ierr);
   //  ierr = PetscObjectSetName((PetscObject)U,"Exact Solution");CHKERRQ(ierr);
 
   /*
-     Set SNES/KSP/KSP/PC runtime options, e.g.,
-         -snes_view -snes_monitor -ksp_type <ksp> -pc_type <pc>
+    Set SNES/KSP/KSP/PC runtime options, e.g.,
+    -snes_view -snes_monitor -ksp_type <ksp> -pc_type <pc>
   */
   KSP ksp;
   PC pc;
-  ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
-  ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
-  ierr = PCSetType(pc,PCLU);CHKERRQ(ierr);
+  ierr = SNESGetKSP(snes, &ksp); CHKERRQ(ierr);
+  ierr = KSPGetPC(ksp, &pc); CHKERRQ(ierr);
+  ierr = PCSetType(pc, PCLU); CHKERRQ(ierr);
   //  PetscOptionsSetValue(NULL,"-pc_type","lu");
-  ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
+  ierr = SNESSetFromOptions(snes); CHKERRQ(ierr);
 
   /*
-     Set an optional user-defined routine to check the validity of candidate
-     iterates that are determined by line search methods
+    Set an optional user-defined routine to check the validity of candidate
+    iterates that are determined by line search methods
   */
-  ierr = SNESGetLineSearch(snes, &linesearch);CHKERRQ(ierr);
-  ierr = PetscOptionsHasName(NULL,NULL,"-post_check_iterates",&post_check);CHKERRQ(ierr);
+  ierr = SNESGetLineSearch(snes, &linesearch); CHKERRQ(ierr);
+  ierr = PetscOptionsHasName(NULL, NULL, "-post_check_iterates", &post_check); CHKERRQ(ierr);
 
-  if (post_check) {
-    ierr = PetscPrintf(PETSC_COMM_WORLD,"Activating post step checking routine\n");CHKERRQ(ierr);
-    ierr = SNESLineSearchSetPostCheck(linesearch,PostCheck,&checkP);CHKERRQ(ierr);
-    ierr = VecDuplicate(Y,&(checkP.last_step));CHKERRQ(ierr);
+  if (post_check)
+    {
+      ierr = PetscPrintf(PETSC_COMM_WORLD, "Activating post step checking routine\n"); CHKERRQ(ierr);
+      ierr = SNESLineSearchSetPostCheck(linesearch, PostCheck, &checkP); CHKERRQ(ierr);
+      ierr = VecDuplicate(Y, &(checkP.last_step)); CHKERRQ(ierr);
 
-    checkP.tolerance = 1.0;
-    checkP.user      = &user;
+      checkP.tolerance = 1.0;
+      checkP.user      = &user;
 
-    ierr = PetscOptionsGetReal(NULL,NULL,"-check_tol",&checkP.tolerance,NULL);CHKERRQ(ierr);
-  }
+      ierr = PetscOptionsGetReal(NULL, NULL, "-check_tol", &checkP.tolerance, NULL); CHKERRQ(ierr);
+    }
 
-  ierr = PetscOptionsHasName(NULL,NULL,"-post_setsubksp",&post_setsubksp);CHKERRQ(ierr);
-  if (post_setsubksp) {
-    ierr = PetscPrintf(PETSC_COMM_WORLD,"Activating post setsubksp\n");CHKERRQ(ierr);
-    ierr = SNESLineSearchSetPostCheck(linesearch,PostSetSubKSP,&checkP1);CHKERRQ(ierr);
-  }
+  ierr = PetscOptionsHasName(NULL, NULL, "-post_setsubksp", &post_setsubksp); CHKERRQ(ierr);
+  if (post_setsubksp)
+    {
+      ierr = PetscPrintf(PETSC_COMM_WORLD, "Activating post setsubksp\n"); CHKERRQ(ierr);
+      ierr = SNESLineSearchSetPostCheck(linesearch, PostSetSubKSP, &checkP1); CHKERRQ(ierr);
+    }
 
-  ierr = PetscOptionsHasName(NULL,NULL,"-pre_check_iterates",&pre_check);CHKERRQ(ierr);
-  if (pre_check) {
-    ierr = PetscPrintf(PETSC_COMM_WORLD,"Activating pre step checking routine\n");CHKERRQ(ierr);
-    ierr = SNESLineSearchSetPreCheck(linesearch,PreCheck,&checkP);CHKERRQ(ierr);
-  }
+  ierr = PetscOptionsHasName(NULL, NULL, "-pre_check_iterates", &pre_check); CHKERRQ(ierr);
+  if (pre_check)
+    {
+      ierr = PetscPrintf(PETSC_COMM_WORLD, "Activating pre step checking routine\n"); CHKERRQ(ierr);
+      ierr = SNESLineSearchSetPreCheck(linesearch, PreCheck, &checkP); CHKERRQ(ierr);
+    }
 
   /*
-     Print parameters used for convergence testing (optional) ... just
-     to demonstrate this routine; this information is also printed with
-     the option -snes_view
+    Print parameters used for convergence testing (optional) ... just
+    to demonstrate this routine; this information is also printed with
+    the option -snes_view
   */
-  ierr = SNESGetTolerances(snes,&abstol,&rtol,&stol,&maxit,&maxf);CHKERRQ(ierr);
-  ierr = PetscPrintf(PETSC_COMM_WORLD,"atol=%g, rtol=%g, stol=%g, maxit=%D, maxf=%D\n",(double)abstol,(double)rtol,(double)stol,maxit,maxf);CHKERRQ(ierr);
+  ierr = SNESGetTolerances(snes, &abstol, &rtol, &stol, &maxit, &maxf); CHKERRQ(ierr);
+  ierr = PetscPrintf(PETSC_COMM_WORLD, "atol=%g, rtol=%g, stol=%g, maxit=%D, maxf=%D\n", (double) abstol, (double) rtol, (double) stol, maxit, maxf); CHKERRQ(ierr);
 
   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      Evaluate initial guess; then solve nonlinear system
-   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+     - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
   /*
-     Note: The user should initialize the vector, x, with the initial guess
-     for the nonlinear solver prior to calling SNESSolve().  In particular,
-     to employ an initial guess of zero, the user should explicitly set
-     this vector to zero by calling VecSet().
+    Note: The user should initialize the vector, x, with the initial guess
+    for the nonlinear solver prior to calling SNESSolve().  In particular,
+    to employ an initial guess of zero, the user should explicitly set
+    this vector to zero by calling VecSet().
   */
-  ierr = SNESSolve(snes,NULL,Y);CHKERRQ(ierr);
-  ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
-  ierr = PetscPrintf(PETSC_COMM_WORLD,"Number of SNES iterations = %D\n",its);CHKERRQ(ierr);
+  ierr = SNESSolve(snes, NULL, Y); CHKERRQ(ierr);
+  ierr = SNESGetIterationNumber(snes, &its); CHKERRQ(ierr);
+  ierr = PetscPrintf(PETSC_COMM_WORLD, "Number of SNES iterations = %D\n", its); CHKERRQ(ierr);
 
   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      Check solution and clean up
-   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+     - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
   /*
-     Free work space.  All PETSc objects should be destroyed when they
-     are no longer needed.
+    Free work space.  All PETSc objects should be destroyed when they
+    are no longer needed.
   */
-  ierr = PetscViewerDestroy(&monP.viewer);CHKERRQ(ierr);
-  if (post_check) {ierr = VecDestroy(&checkP.last_step);CHKERRQ(ierr);}
-  ierr = SNESDestroy(&snes);CHKERRQ(ierr);
-  ierr = DMDestroy(&user.da);CHKERRQ(ierr);
+  ierr = PetscViewerDestroy(&monP.viewer); CHKERRQ(ierr);
+  if (post_check)
+    {
+      ierr = VecDestroy(&checkP.last_step); CHKERRQ(ierr);
+    }
+  ierr = SNESDestroy(&snes); CHKERRQ(ierr);
+  ierr = DMDestroy(&user.da); CHKERRQ(ierr);
 
-  
-  ierr = MatDestroy(&J);CHKERRQ(ierr);
-  ierr = VecDestroy(&Y);CHKERRQ(ierr);
-  ierr = VecDestroy(&R);CHKERRQ(ierr);
-  ierr = PetscFinalize();CHKERRQ(ierr);
+  ierr = MatDestroy(&J); CHKERRQ(ierr);
+  ierr = VecDestroy(&Y); CHKERRQ(ierr);
+  ierr = VecDestroy(&R); CHKERRQ(ierr);
+  ierr = PetscFinalize(); CHKERRQ(ierr);
 
   PetscFunctionReturn(0);
 }
 
-PetscErrorCode FormFunction(SNES snes,Vec y,Vec f,void *ctx)
+PetscErrorCode
+FormFunction(SNES snes, Vec y, Vec f, void *ctx)
 {
-  AppCtx *user = (AppCtx*) ctx;
+  AppCtx *user = (AppCtx *) ctx;
   DM             da    = user->da;
-  PetscScalar    *yy,*ff;
-  PetscInt       M,ys,ym;
+  PetscScalar    *yy, *ff;
+  PetscInt       M, ys, ym;
   Vec            ylocal;
 
-  DMGetLocalVector(da,&ylocal);
+  DMGetLocalVector(da, &ylocal);
   /*
     Scatter ghost points to local vector, using the 2-step process
     DMGlobalToLocalBegin(), DMGlobalToLocalEnd().
     By placing code between these two statements, computations can
     be done while messages are in transition.
   */
-  DMGlobalToLocalBegin(da,y,INSERT_VALUES,ylocal);
-  DMGlobalToLocalEnd(da,y,INSERT_VALUES,ylocal);
+  DMGlobalToLocalBegin(da, y, INSERT_VALUES, ylocal);
+  DMGlobalToLocalEnd(da, y, INSERT_VALUES, ylocal);
 
   /*
     Get pointers to vector data.
@@ -303,15 +315,15 @@ PetscErrorCode FormFunction(SNES snes,Vec y,Vec f,void *ctx)
     NOT include ghost points.
     - Using DMDAVecGetArray() allows accessing the values using global ordering
   */
-  DMDAVecGetArray(da,ylocal,&yy);
-  DMDAVecGetArray(da,f,&ff);
+  DMDAVecGetArray(da, ylocal, &yy);
+  DMDAVecGetArray(da, f, &ff);
 
   /*
     Get local grid boundaries (for 1-dimensional DMDA):
     ys, ym  - starting grid index, width of local grid (no ghost points)
   */
-  DMDAGetCorners(da,&ys,NULL,NULL,&ym,NULL,NULL);
-  DMDAGetInfo(da,NULL,&M,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
+  DMDAGetCorners(da, &ys, NULL, NULL, &ym, NULL, NULL);
+  DMDAGetInfo(da, NULL, &M, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 
   /*
     Set function values for boundary points; define local interior grid point range:
@@ -321,8 +333,10 @@ PetscErrorCode FormFunction(SNES snes,Vec y,Vec f,void *ctx)
   if (ys == 0) /* left boundary */
     {
       PetscReal *y1 = new PetscReal[3*user->endo_nbr];
-      for (int i=0; i < user->endo_nbr; ++i) y1[i] = user->initial_values[i];
-      for (int i=0; i < 2*user->endo_nbr; ++i) y1[i+user->endo_nbr] = yy[i];
+      for (int i = 0; i < user->endo_nbr; ++i)
+        y1[i] = user->initial_values[i];
+      for (int i = 0; i < 2*user->endo_nbr; ++i)
+        y1[i+user->endo_nbr] = yy[i];
       Residuals(y1, user->X, user->nb_row_x, user->params, user->steady_state, 1, ff);
       ys += user->endo_nbr;
       ym -= user->endo_nbr;
@@ -331,7 +345,7 @@ PetscErrorCode FormFunction(SNES snes,Vec y,Vec f,void *ctx)
   /*
     Compute function over locally owned part of the grid (interior points only)
   */
-  while ( (ym  >= user->endo_nbr) && (ys + 2*user->endo_nbr <= M) )
+  while ((ym  >= user->endo_nbr) && (ys + 2*user->endo_nbr <= M))
     {
       int it = ys/user->endo_nbr + 2;
       Residuals(yy+ys-user->endo_nbr, user->X, user->nb_row_x, user->params, user->steady_state, it, ff+ys);
@@ -339,42 +353,44 @@ PetscErrorCode FormFunction(SNES snes,Vec y,Vec f,void *ctx)
       ym -= user->endo_nbr;
     }
 
-  
-  if ( (ym >= user->endo_nbr) && (ys + 2*user->endo_nbr >= M) ) 
+  if ((ym >= user->endo_nbr) && (ys + 2*user->endo_nbr >= M))
     {
       int it = ys/user->endo_nbr + 1;
       PetscReal *y1 = new PetscReal[3*user->endo_nbr];
-      for (int i=0; i < 2*user->endo_nbr; ++i) y1[i] = yy[ys+i-user->endo_nbr];
-      for (int i=0; i < user->endo_nbr; ++i) y1[i+2*user->endo_nbr] = user->terminal_values[i];
+      for (int i = 0; i < 2*user->endo_nbr; ++i)
+        y1[i] = yy[ys+i-user->endo_nbr];
+      for (int i = 0; i < user->endo_nbr; ++i)
+        y1[i+2*user->endo_nbr] = user->terminal_values[i];
       Residuals(y1, user->X, user->nb_row_x, user->params, user->steady_state, it, ff+ys);
     }
 
   /*
     Restore vectors
   */
-  DMDAVecRestoreArray(da,ylocal,&yy);
-  DMDAVecRestoreArray(da,f,&ff);
-  DMRestoreLocalVector(da,&ylocal);
-  return(0);
+  DMDAVecRestoreArray(da, ylocal, &yy);
+  DMDAVecRestoreArray(da, f, &ff);
+  DMRestoreLocalVector(da, &ylocal);
+  return (0);
 }
 
-PetscErrorCode FormJacobian(SNES snes,Vec y,Mat J, Mat B,void *ctx)
+PetscErrorCode
+FormJacobian(SNES snes, Vec y, Mat J, Mat B, void *ctx)
 {
-  AppCtx *user = (AppCtx*) ctx;
+  AppCtx *user = (AppCtx *) ctx;
   DM             da    = user->da;
   PetscScalar    *yy;
-  PetscInt       M,ys,ym,ierr;
+  PetscInt       M, ys, ym, ierr;
   Vec            ylocal;
 
-  DMGetLocalVector(da,&ylocal);
+  DMGetLocalVector(da, &ylocal);
   /*
     Scatter ghost points to local vector, using the 2-step process
     DMGlobalToLocalBegin(), DMGlobalToLocalEnd().
     By placing code between these two statements, computations can
     be done while messages are in transition.
   */
-  DMGlobalToLocalBegin(da,y,INSERT_VALUES,ylocal);
-  DMGlobalToLocalEnd(da,y,INSERT_VALUES,ylocal);
+  DMGlobalToLocalBegin(da, y, INSERT_VALUES, ylocal);
+  DMGlobalToLocalEnd(da, y, INSERT_VALUES, ylocal);
 
   /*
     Get pointers to vector data.
@@ -382,14 +398,14 @@ PetscErrorCode FormJacobian(SNES snes,Vec y,Mat J, Mat B,void *ctx)
     NOT include ghost points.
     - Using DMDAVecGetArray() allows accessing the values using global ordering
   */
-  DMDAVecGetArray(da,ylocal,&yy);
+  DMDAVecGetArray(da, ylocal, &yy);
 
   /*
     Get local grid boundaries (for 1-dimensional DMDA):
     ys, ym  - starting grid index, width of local grid (no ghost points)
   */
-  DMDAGetCorners(da,&ys,NULL,NULL,&ym,NULL,NULL);
-  DMDAGetInfo(da,NULL,&M,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
+  DMDAGetCorners(da, &ys, NULL, NULL, &ym, NULL, NULL);
+  DMDAGetInfo(da, NULL, &M, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 
   /*
     Set function values for boundary points; define local interior grid point range:
@@ -400,32 +416,34 @@ PetscErrorCode FormJacobian(SNES snes,Vec y,Mat J, Mat B,void *ctx)
   if (ys == 0) /* left boundary */
     {
       PetscReal *y1 = new PetscReal[3*user->endo_nbr];
-      for (int i=0; i < user->endo_nbr; ++i) y1[i] = user->initial_values[i];
-      for (int i=0; i < 2*user->endo_nbr; ++i) y1[i+user->endo_nbr] = yy[i];
+      for (int i = 0; i < user->endo_nbr; ++i)
+        y1[i] = user->initial_values[i];
+      for (int i = 0; i < 2*user->endo_nbr; ++i)
+        y1[i+user->endo_nbr] = yy[i];
       FirstDerivatives(y1, user->X, user->nb_row_x, user->params, user->steady_state, 1, NULL, user->row_ptr, user->col_ptr, user->val_ptr);
-      for (int* r=user->row_ptr; r < user->row_ptr+user->endo_nbr; r++)
-	{
-	  int first_col = 0;
-	  int ncol = 0;
-	  int *pc = user->col_ptr + *r;
-	  while(*(pc) < user->endo_nbr)
-	    {
-	      ++first_col;
-	      ++pc;
-	    }
-	  while(pc < ((user->col_ptr)+*(r+1)))
-	    {
-	      if (*pc < 3*(user->endo_nbr))
-		{
-		  ++ncol;
-		  *pc -= user->endo_nbr;
-		}
-	      ++pc;
-	    }
-	  ierr = MatSetValues(J,1,&row,ncol,user->col_ptr + *r + first_col,user->val_ptr + *r  + first_col,INSERT_VALUES);
-	  CHKERRQ(ierr);
-	  ++row;
-	}
+      for (int *r = user->row_ptr; r < user->row_ptr+user->endo_nbr; r++)
+        {
+          int first_col = 0;
+          int ncol = 0;
+          int *pc = user->col_ptr + *r;
+          while (*(pc) < user->endo_nbr)
+            {
+              ++first_col;
+              ++pc;
+            }
+          while (pc < ((user->col_ptr)+*(r+1)))
+            {
+              if (*pc < 3*(user->endo_nbr))
+                {
+                  ++ncol;
+                  *pc -= user->endo_nbr;
+                }
+              ++pc;
+            }
+          ierr = MatSetValues(J, 1, &row, ncol, user->col_ptr + *r + first_col, user->val_ptr + *r  + first_col, INSERT_VALUES);
+          CHKERRQ(ierr);
+          ++row;
+        }
       ys += user->endo_nbr;
       ym -= user->endo_nbr;
     }
@@ -433,88 +451,90 @@ PetscErrorCode FormJacobian(SNES snes,Vec y,Mat J, Mat B,void *ctx)
   /*
     Compute function over locally owned part of the grid (interior points only)
   */
-  while ( (ym  >= user->endo_nbr) && (ys + 2*user->endo_nbr <= M) )
+  while ((ym  >= user->endo_nbr) && (ys + 2*user->endo_nbr <= M))
     {
       int it = ys/user->endo_nbr + 2;
       FirstDerivatives(yy+ys-user->endo_nbr, user->X, user->nb_row_x, user->params, user->steady_state, it, NULL, user->row_ptr, user->col_ptr, user->val_ptr);
-      for (int* r=user->row_ptr; r < user->row_ptr+user->endo_nbr; r++)
-	{
-	  int ncol = 0;
-	  for(int *pc = user->col_ptr + *r; pc < user->col_ptr + *(r+1); ++pc)
-	    if(*pc < 3*user->endo_nbr)
-	      {
-		*pc += ys - user->endo_nbr;
-		++ncol;
-	      }
-	  ierr = MatSetValues(J,1,&row,ncol,user->col_ptr + *r,user->val_ptr + *r,INSERT_VALUES);
-	  CHKERRQ(ierr);
-	  ++row;
-	}
+      for (int *r = user->row_ptr; r < user->row_ptr+user->endo_nbr; r++)
+        {
+          int ncol = 0;
+          for (int *pc = user->col_ptr + *r; pc < user->col_ptr + *(r+1); ++pc)
+            if (*pc < 3*user->endo_nbr)
+              {
+                *pc += ys - user->endo_nbr;
+                ++ncol;
+              }
+          ierr = MatSetValues(J, 1, &row, ncol, user->col_ptr + *r, user->val_ptr + *r, INSERT_VALUES);
+          CHKERRQ(ierr);
+          ++row;
+        }
       ys += user->endo_nbr;
       ym -= user->endo_nbr;
     }
 
-  
-  if ( (ym >= user->endo_nbr) && (ys + 2*user->endo_nbr >= M) ) 
+  if ((ym >= user->endo_nbr) && (ys + 2*user->endo_nbr >= M))
     {
       int it = ys/user->endo_nbr + 1;
       PetscReal *y1 = new PetscReal[3*user->endo_nbr];
-      for (int i=0; i < 2*user->endo_nbr; ++i) y1[i] = yy[ys+i-user->endo_nbr];
-      for (int i=0; i < user->endo_nbr; ++i) y1[i+2*user->endo_nbr] = user->terminal_values[i];
+      for (int i = 0; i < 2*user->endo_nbr; ++i)
+        y1[i] = yy[ys+i-user->endo_nbr];
+      for (int i = 0; i < user->endo_nbr; ++i)
+        y1[i+2*user->endo_nbr] = user->terminal_values[i];
       FirstDerivatives(y1, user->X, user->nb_row_x, user->params, user->steady_state, it, NULL, user->row_ptr, user->col_ptr, user->val_ptr);
-      for (int* r=user->row_ptr; r < user->row_ptr+user->endo_nbr; r++)
-	{
-	  int *pc = user->col_ptr + *r;
-	  int ncol = 0;
-	  while((*pc < 2*user->endo_nbr) && (pc < user->col_ptr + *(r+1)))
-	    {
-	      ++ncol;
-	      *pc += ys - user->endo_nbr;
-	      ++pc;
-	    }
-	  ierr = MatSetValues(J,1,&row,ncol,user->col_ptr + *r,user->val_ptr + *r,INSERT_VALUES);
-	  CHKERRQ(ierr);
-	  ++row;
-	}
+      for (int *r = user->row_ptr; r < user->row_ptr+user->endo_nbr; r++)
+        {
+          int *pc = user->col_ptr + *r;
+          int ncol = 0;
+          while ((*pc < 2*user->endo_nbr) && (pc < user->col_ptr + *(r+1)))
+            {
+              ++ncol;
+              *pc += ys - user->endo_nbr;
+              ++pc;
+            }
+          ierr = MatSetValues(J, 1, &row, ncol, user->col_ptr + *r, user->val_ptr + *r, INSERT_VALUES);
+          CHKERRQ(ierr);
+          ++row;
+        }
     }
 
   /*
     Restore vectors
   */
-  ierr = MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
-  DMDAVecRestoreArray(da,ylocal,&yy);
-  DMRestoreLocalVector(da,&ylocal);
-  ierr = MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
-  return(0);
+  ierr = MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);
+  DMDAVecRestoreArray(da, ylocal, &yy);
+  DMRestoreLocalVector(da, &ylocal);
+  ierr = MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);
+  return (0);
 }
 
 #undef __FUNCT__
 #define __FUNCT__ "Monitor"
 /*
-   Monitor - Optional user-defined monitoring routine that views the
-   current iterate with an x-window plot. Set by SNESMonitorSet().
+  Monitor - Optional user-defined monitoring routine that views the
+  current iterate with an x-window plot. Set by SNESMonitorSet().
 
-   Input Parameters:
-   snes - the SNES context
-   its - iteration number
-   norm - 2-norm function value (may be estimated)
-   ctx - optional user-defined context for private data for the
-         monitor routine, as set by SNESMonitorSet()
+  Input Parameters:
+  snes - the SNES context
+  its - iteration number
+  norm - 2-norm function value (may be estimated)
+  ctx - optional user-defined context for private data for the
+  monitor routine, as set by SNESMonitorSet()
 
-   Note:
-   See the manpage for PetscViewerDrawOpen() for useful runtime options,
-   such as -nox to deactivate all x-window output.
- */
-PetscErrorCode Monitor(SNES snes,PetscInt its,PetscReal fnorm,void *ctx)
+  Note:
+  See the manpage for PetscViewerDrawOpen() for useful runtime options,
+  such as -nox to deactivate all x-window output.
+*/
+PetscErrorCode
+Monitor(SNES snes, PetscInt its, PetscReal fnorm, void *ctx)
 {
   PetscErrorCode ierr;
-  MonitorCtx     *monP = (MonitorCtx*) ctx;
+  MonitorCtx     *monP = (MonitorCtx *) ctx;
   Vec            x;
 
   PetscFunctionBeginUser;
-  ierr = PetscPrintf(PETSC_COMM_WORLD,"iter = %D,SNES Function norm %g\n",its,(double)fnorm);CHKERRQ(ierr);
-  ierr = SNESGetSolution(snes,&x);CHKERRQ(ierr);
-  ierr = VecView(x,monP->viewer);CHKERRQ(ierr);
+  ierr = PetscPrintf(PETSC_COMM_WORLD, "iter = %D,SNES Function norm %g\n", its, (double) fnorm); CHKERRQ(ierr);
+  ierr = SNESGetSolution(snes, &x); CHKERRQ(ierr);
+  ierr = VecView(x, monP->viewer); CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
@@ -522,19 +542,20 @@ PetscErrorCode Monitor(SNES snes,PetscInt its,PetscReal fnorm,void *ctx)
 #undef __FUNCT__
 #define __FUNCT__ "PreCheck"
 /*
-   PreCheck - Optional user-defined routine that checks the validity of
-   candidate steps of a line search method.  Set by SNESLineSearchSetPreCheck().
+  PreCheck - Optional user-defined routine that checks the validity of
+  candidate steps of a line search method.  Set by SNESLineSearchSetPreCheck().
 
-   Input Parameters:
-   snes - the SNES context
-   xcurrent - current solution
-   y - search direction and length
+  Input Parameters:
+  snes - the SNES context
+  xcurrent - current solution
+  y - search direction and length
 
-   Output Parameters:
-   y         - proposed step (search direction and length) (possibly changed)
-   changed_y - tells if the step has changed or not
- */
-PetscErrorCode PreCheck(SNESLineSearch linesearch,Vec xcurrent,Vec y, PetscBool *changed_y, void * ctx)
+  Output Parameters:
+  y         - proposed step (search direction and length) (possibly changed)
+  changed_y - tells if the step has changed or not
+*/
+PetscErrorCode
+PreCheck(SNESLineSearch linesearch, Vec xcurrent, Vec y, PetscBool *changed_y, void *ctx)
 {
   PetscFunctionBeginUser;
   *changed_y = PETSC_FALSE;
@@ -545,29 +566,30 @@ PetscErrorCode PreCheck(SNESLineSearch linesearch,Vec xcurrent,Vec y, PetscBool
 #undef __FUNCT__
 #define __FUNCT__ "PostCheck"
 /*
-   PostCheck - Optional user-defined routine that checks the validity of
-   candidate steps of a line search method.  Set by SNESLineSearchSetPostCheck().
+  PostCheck - Optional user-defined routine that checks the validity of
+  candidate steps of a line search method.  Set by SNESLineSearchSetPostCheck().
 
-   Input Parameters:
-   snes - the SNES context
-   ctx  - optional user-defined context for private data for the
-          monitor routine, as set by SNESLineSearchSetPostCheck()
-   xcurrent - current solution
-   y - search direction and length
-   x    - the new candidate iterate
+  Input Parameters:
+  snes - the SNES context
+  ctx  - optional user-defined context for private data for the
+  monitor routine, as set by SNESLineSearchSetPostCheck()
+  xcurrent - current solution
+  y - search direction and length
+  x    - the new candidate iterate
 
-   Output Parameters:
-   y    - proposed step (search direction and length) (possibly changed)
-   x    - current iterate (possibly modified)
+  Output Parameters:
+  y    - proposed step (search direction and length) (possibly changed)
+  x    - current iterate (possibly modified)
 
- */
-PetscErrorCode PostCheck(SNESLineSearch linesearch,Vec xcurrent,Vec y,Vec x,PetscBool  *changed_y,PetscBool  *changed_x, void * ctx)
+*/
+PetscErrorCode
+PostCheck(SNESLineSearch linesearch, Vec xcurrent, Vec y, Vec x, PetscBool  *changed_y, PetscBool  *changed_x, void *ctx)
 {
   PetscErrorCode ierr;
-  PetscInt       i,iter,xs,xm;
+  PetscInt       i, iter, xs, xm;
   StepCheckCtx   *check;
   AppCtx *user;
-  PetscScalar    *xa,*xa_last,tmp;
+  PetscScalar    *xa, *xa_last, tmp;
   PetscReal      rdiff;
   DM             da;
   SNES           snes;
@@ -576,116 +598,124 @@ PetscErrorCode PostCheck(SNESLineSearch linesearch,Vec xcurrent,Vec y,Vec x,Pets
   *changed_x = PETSC_FALSE;
   *changed_y = PETSC_FALSE;
 
-  ierr  = SNESLineSearchGetSNES(linesearch, &snes);CHKERRQ(ierr);
-  check = (StepCheckCtx*)ctx;
+  ierr  = SNESLineSearchGetSNES(linesearch, &snes); CHKERRQ(ierr);
+  check = (StepCheckCtx *) ctx;
   user  = check->user;
-  ierr  = SNESGetIterationNumber(snes,&iter);CHKERRQ(ierr);
-  ierr  = SNESLineSearchGetPreCheck(linesearch, NULL, (void**)&check);CHKERRQ(ierr);
+  ierr  = SNESGetIterationNumber(snes, &iter); CHKERRQ(ierr);
+  ierr  = SNESLineSearchGetPreCheck(linesearch, NULL, (void **) &check); CHKERRQ(ierr);
 
   /* iteration 1 indicates we are working on the second iteration */
-  if (iter > 0) {
-    da   = user->da;
-    ierr = PetscPrintf(PETSC_COMM_WORLD,"Checking candidate step at iteration %D with tolerance %g\n",iter,(double)check->tolerance);CHKERRQ(ierr);
+  if (iter > 0)
+    {
+      da   = user->da;
+      ierr = PetscPrintf(PETSC_COMM_WORLD, "Checking candidate step at iteration %D with tolerance %g\n", iter, (double) check->tolerance); CHKERRQ(ierr);
 
-    /* Access local array data */
-    ierr = DMDAVecGetArray(da,check->last_step,&xa_last);CHKERRQ(ierr);
-    ierr = DMDAVecGetArray(da,x,&xa);CHKERRQ(ierr);
-    ierr = DMDAGetCorners(da,&xs,NULL,NULL,&xm,NULL,NULL);CHKERRQ(ierr);
+      /* Access local array data */
+      ierr = DMDAVecGetArray(da, check->last_step, &xa_last); CHKERRQ(ierr);
+      ierr = DMDAVecGetArray(da, x, &xa); CHKERRQ(ierr);
+      ierr = DMDAGetCorners(da, &xs, NULL, NULL, &xm, NULL, NULL); CHKERRQ(ierr);
 
-    /*
-       If we fail the user-defined check for validity of the candidate iterate,
-       then modify the iterate as we like.  (Note that the particular modification
-       below is intended simply to demonstrate how to manipulate this data, not
-       as a meaningful or appropriate choice.)
-    */
-    for (i=xs; i<xs+xm; i++) {
-      if (!PetscAbsScalar(xa[i])) rdiff = 2*check->tolerance;
-      else rdiff = PetscAbsScalar((xa[i] - xa_last[i])/xa[i]);
-      if (rdiff > check->tolerance) {
-        tmp        = xa[i];
-        xa[i]      = .5*(xa[i] + xa_last[i]);
-        *changed_x = PETSC_TRUE;
-        ierr       = PetscPrintf(PETSC_COMM_WORLD,"  Altering entry %D: x=%g, x_last=%g, diff=%g, x_new=%g\n",
-                                 i,(double)PetscAbsScalar(tmp),(double)PetscAbsScalar(xa_last[i]),(double)rdiff,(double)PetscAbsScalar(xa[i]));CHKERRQ(ierr);
-      }
+      /*
+        If we fail the user-defined check for validity of the candidate iterate,
+        then modify the iterate as we like.  (Note that the particular modification
+        below is intended simply to demonstrate how to manipulate this data, not
+        as a meaningful or appropriate choice.)
+      */
+      for (i = xs; i < xs+xm; i++)
+        {
+          if (!PetscAbsScalar(xa[i]))
+            rdiff = 2*check->tolerance;
+          else
+            rdiff = PetscAbsScalar((xa[i] - xa_last[i])/xa[i]);
+          if (rdiff > check->tolerance)
+            {
+              tmp        = xa[i];
+              xa[i]      = .5*(xa[i] + xa_last[i]);
+              *changed_x = PETSC_TRUE;
+              ierr       = PetscPrintf(PETSC_COMM_WORLD, "  Altering entry %D: x=%g, x_last=%g, diff=%g, x_new=%g\n",
+                                       i, (double) PetscAbsScalar(tmp), (double) PetscAbsScalar(xa_last[i]), (double) rdiff, (double) PetscAbsScalar(xa[i])); CHKERRQ(ierr);
+            }
+        }
+      ierr = DMDAVecRestoreArray(da, check->last_step, &xa_last); CHKERRQ(ierr);
+      ierr = DMDAVecRestoreArray(da, x, &xa); CHKERRQ(ierr);
     }
-    ierr = DMDAVecRestoreArray(da,check->last_step,&xa_last);CHKERRQ(ierr);
-    ierr = DMDAVecRestoreArray(da,x,&xa);CHKERRQ(ierr);
-  }
-  ierr = VecCopy(x,check->last_step);CHKERRQ(ierr);
+  ierr = VecCopy(x, check->last_step); CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
-
 /* ------------------------------------------------------------------- */
 #undef __FUNCT__
 #define __FUNCT__ "PostSetSubKSP"
 /*
-   PostSetSubKSP - Optional user-defined routine that reset SubKSP options when hierarchical bjacobi PC is used
-   e.g,
-     mpiexec -n 8 ./ex3 -nox -n 10000 -ksp_type fgmres -pc_type bjacobi -pc_bjacobi_blocks 4 -sub_ksp_type gmres -sub_ksp_max_it 3 -post_setsubksp -sub_ksp_rtol 1.e-16
-   Set by SNESLineSearchSetPostCheck().
+  PostSetSubKSP - Optional user-defined routine that reset SubKSP options when hierarchical bjacobi PC is used
+  e.g,
+  mpiexec -n 8 ./ex3 -nox -n 10000 -ksp_type fgmres -pc_type bjacobi -pc_bjacobi_blocks 4 -sub_ksp_type gmres -sub_ksp_max_it 3 -post_setsubksp -sub_ksp_rtol 1.e-16
+  Set by SNESLineSearchSetPostCheck().
 
-   Input Parameters:
-   linesearch - the LineSearch context
-   xcurrent - current solution
-   y - search direction and length
-   x    - the new candidate iterate
+  Input Parameters:
+  linesearch - the LineSearch context
+  xcurrent - current solution
+  y - search direction and length
+  x    - the new candidate iterate
 
-   Output Parameters:
-   y    - proposed step (search direction and length) (possibly changed)
-   x    - current iterate (possibly modified)
+  Output Parameters:
+  y    - proposed step (search direction and length) (possibly changed)
+  x    - current iterate (possibly modified)
 
- */
-PetscErrorCode PostSetSubKSP(SNESLineSearch linesearch,Vec xcurrent,Vec y,Vec x,PetscBool  *changed_y,PetscBool  *changed_x, void * ctx)
+*/
+PetscErrorCode
+PostSetSubKSP(SNESLineSearch linesearch, Vec xcurrent, Vec y, Vec x, PetscBool  *changed_y, PetscBool  *changed_x, void *ctx)
 {
   PetscErrorCode ierr;
   SetSubKSPCtx   *check;
-  PetscInt       iter,its,sub_its,maxit;
-  KSP            ksp,sub_ksp,*sub_ksps;
+  PetscInt       iter, its, sub_its, maxit;
+  KSP            ksp, sub_ksp, *sub_ksps;
   PC             pc;
   PetscReal      ksp_ratio;
   SNES           snes;
 
   PetscFunctionBeginUser;
-  ierr    = SNESLineSearchGetSNES(linesearch, &snes);CHKERRQ(ierr);
-  check   = (SetSubKSPCtx*)ctx;
-  ierr    = SNESGetIterationNumber(snes,&iter);CHKERRQ(ierr);
-  ierr    = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
-  ierr    = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
-  ierr    = PCBJacobiGetSubKSP(pc,NULL,NULL,&sub_ksps);CHKERRQ(ierr);
+  ierr    = SNESLineSearchGetSNES(linesearch, &snes); CHKERRQ(ierr);
+  check   = (SetSubKSPCtx *) ctx;
+  ierr    = SNESGetIterationNumber(snes, &iter); CHKERRQ(ierr);
+  ierr    = SNESGetKSP(snes, &ksp); CHKERRQ(ierr);
+  ierr    = KSPGetPC(ksp, &pc); CHKERRQ(ierr);
+  ierr    = PCBJacobiGetSubKSP(pc, NULL, NULL, &sub_ksps); CHKERRQ(ierr);
   sub_ksp = sub_ksps[0];
-  ierr    = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr);      /* outer KSP iteration number */
-  ierr    = KSPGetIterationNumber(sub_ksp,&sub_its);CHKERRQ(ierr); /* inner KSP iteration number */
+  ierr    = KSPGetIterationNumber(ksp, &its); CHKERRQ(ierr);      /* outer KSP iteration number */
+  ierr    = KSPGetIterationNumber(sub_ksp, &sub_its); CHKERRQ(ierr); /* inner KSP iteration number */
 
-  if (iter) {
-    ierr      = PetscPrintf(PETSC_COMM_WORLD,"    ...PostCheck snes iteration %D, ksp_it %d %d, subksp_it %d\n",iter,check->its0,its,sub_its);CHKERRQ(ierr);
-    ksp_ratio = ((PetscReal)(its))/check->its0;
-    maxit     = (PetscInt)(ksp_ratio*sub_its + 0.5);
-    if (maxit < 2) maxit = 2;
-    ierr = KSPSetTolerances(sub_ksp,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,maxit);CHKERRQ(ierr);
-    ierr = PetscPrintf(PETSC_COMM_WORLD,"    ...ksp_ratio %g, new maxit %d\n\n",ksp_ratio,maxit);CHKERRQ(ierr);
-  }
+  if (iter)
+    {
+      ierr      = PetscPrintf(PETSC_COMM_WORLD, "    ...PostCheck snes iteration %D, ksp_it %d %d, subksp_it %d\n", iter, check->its0, its, sub_its); CHKERRQ(ierr);
+      ksp_ratio = ((PetscReal) (its))/check->its0;
+      maxit     = (PetscInt) (ksp_ratio*sub_its + 0.5);
+      if (maxit < 2)
+        maxit = 2;
+      ierr = KSPSetTolerances(sub_ksp, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, maxit); CHKERRQ(ierr);
+      ierr = PetscPrintf(PETSC_COMM_WORLD, "    ...ksp_ratio %g, new maxit %d\n\n", ksp_ratio, maxit); CHKERRQ(ierr);
+    }
   check->its0 = its; /* save current outer KSP iteration number */
   PetscFunctionReturn(0);
 }
 
 /* ------------------------------------------------------------------- */
 /*
-   MatrixFreePreconditioner - This routine demonstrates the use of a
-   user-provided preconditioner.  This code implements just the null
-   preconditioner, which of course is not recommended for general use.
+  MatrixFreePreconditioner - This routine demonstrates the use of a
+  user-provided preconditioner.  This code implements just the null
+  preconditioner, which of course is not recommended for general use.
 
-   Input Parameters:
-+  pc - preconditioner
--  x - input vector
+  Input Parameters:
+  +  pc - preconditioner
+  -  x - input vector
 
-   Output Parameter:
-.  y - preconditioned vector
+  Output Parameter:
+  .  y - preconditioned vector
 */
-PetscErrorCode MatrixFreePreconditioner(PC pc,Vec x,Vec y)
+PetscErrorCode
+MatrixFreePreconditioner(PC pc, Vec x, Vec y)
 {
   PetscErrorCode ierr;
-  ierr = VecCopy(x,y);CHKERRQ(ierr);
+  ierr = VecCopy(x, y); CHKERRQ(ierr);
   return 0;
 }
diff --git a/others/cpp/tests/test1.cc b/others/cpp/tests/test1.cc
index 9e2c1304d..b5d773ac2 100644
--- a/others/cpp/tests/test1.cc
+++ b/others/cpp/tests/test1.cc
@@ -3,9 +3,9 @@
 #include "DecisionRules.hh"
 
 DynareInfo *preprocessorOutput(void);
-extern "C"{
-void steadystate(double const*, double const*, double *, int *);
-void FirstDerivatives(const double *y, double *x, int nb_row_x, double *params, double *steady_state, int it_, double *residual, double *g1, double *v2, double *v3);
+extern "C" {
+  void steadystate(double const *, double const *, double *, int *);
+  void FirstDerivatives(const double *y, double *x, int nb_row_x, double *params, double *steady_state, int it_, double *residual, double *g1, double *v2, double *v3);
 }
 main(int argc, char **argv)
 {
@@ -17,8 +17,8 @@ main(int argc, char **argv)
   // Steady state
   double *steady_state = new double[endo_nbr];
   int info;
-  steadystate(NULL,params, steady_state, &info);
-  for (int i=0; i < endo_nbr; ++i)
+  steadystate(NULL, params, steady_state, &info);
+  for (int i = 0; i < endo_nbr; ++i)
     std::cout << model_info.get_endo_name_by_index(i) << " " << steady_state[i] << "\n";
 
   // 1st order approximation
@@ -54,7 +54,7 @@ main(int argc, char **argv)
   std::cout << "g1[44] = " << jacob_data[44] << endl;
   MatrixView jacob_tmp(jacob_data, endo_nbr, jacobian_col_nbr, endo_nbr);
   std::cout << "g1[44] = " << jacob_data[44] << endl;
-  std::cout << "jacob_tmp(2,7) = "<< jacob_tmp(2,7) << endl;
+  std::cout << "jacob_tmp(2,7) = "<< jacob_tmp(2, 7) << endl;
 
   Matrix jacobian(endo_nbr, jacobian_col_nbr), g_y(endo_nbr, nback+nmixed), g_u(endo_nbr, exo_nbr);
   jacobian = jacob_tmp;
diff --git a/preprocessor/CodeInterpreter.hh b/preprocessor/CodeInterpreter.hh
index 6d4707202..8939950fc 100644
--- a/preprocessor/CodeInterpreter.hh
+++ b/preprocessor/CodeInterpreter.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2015 Dynare Team
+ * Copyright (C) 2007-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/ComputingTasks.cc b/preprocessor/ComputingTasks.cc
index d3f2d1c15..5488b0905 100644
--- a/preprocessor/ComputingTasks.cc
+++ b/preprocessor/ComputingTasks.cc
@@ -2325,15 +2325,16 @@ IdentificationStatement::writeJsonOutput(ostream &output) const
   output << "}";
 }
 
-WriteLatexDynamicModelStatement::WriteLatexDynamicModelStatement(const DynamicModel &dynamic_model_arg) :
-  dynamic_model(dynamic_model_arg)
+WriteLatexDynamicModelStatement::WriteLatexDynamicModelStatement(const DynamicModel &dynamic_model_arg, bool write_equation_tags_arg) :
+  dynamic_model(dynamic_model_arg),
+  write_equation_tags(write_equation_tags_arg)
 {
 }
 
 void
 WriteLatexDynamicModelStatement::writeOutput(ostream &output, const string &basename, bool minimal_workspace) const
 {
-  dynamic_model.writeLatexFile(basename);
+  dynamic_model.writeLatexFile(basename, write_equation_tags);
 }
 
 void
@@ -2408,6 +2409,53 @@ ShockDecompositionStatement::writeJsonOutput(ostream &output) const
   output << "}";
 }
 
+RealtimeShockDecompositionStatement::RealtimeShockDecompositionStatement(const SymbolList &symbol_list_arg,
+                                                                         const OptionsList &options_list_arg) :
+  symbol_list(symbol_list_arg),
+  options_list(options_list_arg)
+{
+}
+
+void
+RealtimeShockDecompositionStatement::writeOutput(ostream &output, const string &basename, bool minimal_workspace) const
+{
+  options_list.writeOutput(output);
+  symbol_list.writeOutput("var_list_", output);
+  output << "oo_ = realtime_shock_decomposition(M_,oo_,options_,var_list_,bayestopt_,estim_params_);" << endl;
+}
+
+PlotShockDecompositionStatement::PlotShockDecompositionStatement(const SymbolList &symbol_list_arg,
+                                                                 const OptionsList &options_list_arg) :
+  symbol_list(symbol_list_arg),
+  options_list(options_list_arg)
+{
+}
+
+void
+PlotShockDecompositionStatement::writeOutput(ostream &output, const string &basename, bool minimal_workspace) const
+{
+  output << "options_ = set_default_plot_shock_decomposition_options(options_);" << endl;
+  options_list.writeOutput(output);
+  symbol_list.writeOutput("var_list_", output);
+  output << "plot_shock_decomposition(M_, oo_, options_, var_list_);" << endl;
+}
+
+InitialConditionDecompositionStatement::InitialConditionDecompositionStatement(const SymbolList &symbol_list_arg,
+                                                                               const OptionsList &options_list_arg) :
+  symbol_list(symbol_list_arg),
+  options_list(options_list_arg)
+{
+}
+
+void
+InitialConditionDecompositionStatement::writeOutput(ostream &output, const string &basename, bool minimal_workspace) const
+{
+  output << "options_ = set_default_initial_condition_decomposition_options(options_);" << endl;
+  options_list.writeOutput(output);
+  symbol_list.writeOutput("var_list_", output);
+  output << "initial_condition_decomposition(M_, oo_, options_, var_list_, bayestopt_, estim_params_);" << endl;
+}
+
 ConditionalForecastStatement::ConditionalForecastStatement(const OptionsList &options_list_arg) :
   options_list(options_list_arg)
 {
@@ -4300,7 +4348,7 @@ CalibSmootherStatement::writeOutput(ostream &output, const string &basename, boo
   symbol_list.writeOutput("var_list_", output);
   output << "options_.smoother = 1;" << endl;
   output << "options_.order = 1;" << endl;
-  output << "[oo_,options_,bayestopt_]=evaluate_smoother('calibration',var_list_,M_,oo_,options_,bayestopt_,estim_params_);" << endl;
+  output << "[oo_,M_,options_,bayestopt_]=evaluate_smoother('calibration',var_list_,M_,oo_,options_,bayestopt_,estim_params_);" << endl;
 }
 
 void
diff --git a/preprocessor/ComputingTasks.hh b/preprocessor/ComputingTasks.hh
index 43b374c26..a222950af 100644
--- a/preprocessor/ComputingTasks.hh
+++ b/preprocessor/ComputingTasks.hh
@@ -598,8 +598,9 @@ class WriteLatexDynamicModelStatement : public Statement
 {
 private:
   const DynamicModel &dynamic_model;
+  const bool write_equation_tags;
 public:
-  WriteLatexDynamicModelStatement(const DynamicModel &dynamic_model_arg);
+  WriteLatexDynamicModelStatement(const DynamicModel &dynamic_model_arg, bool write_equation_tags_arg);
   virtual void writeOutput(ostream &output, const string &basename, bool minimal_workspace) const;
   virtual void writeJsonOutput(ostream &output) const;
 };
@@ -636,6 +637,39 @@ public:
   virtual void writeJsonOutput(ostream &output) const;
 };
 
+class RealtimeShockDecompositionStatement : public Statement
+{
+private:
+  const SymbolList symbol_list;
+  const OptionsList options_list;
+public:
+  RealtimeShockDecompositionStatement(const SymbolList &symbol_list_arg,
+                                      const OptionsList &options_list_arg);
+  virtual void writeOutput(ostream &output, const string &basename, bool minimal_workspace) const;
+};
+
+class PlotShockDecompositionStatement : public Statement
+{
+private:
+  const SymbolList symbol_list;
+  const OptionsList options_list;
+public:
+  PlotShockDecompositionStatement(const SymbolList &symbol_list_arg,
+                                  const OptionsList &options_list_arg);
+  virtual void writeOutput(ostream &output, const string &basename, bool minimal_workspace) const;
+};
+
+class InitialConditionDecompositionStatement : public Statement
+{
+private:
+  const SymbolList symbol_list;
+  const OptionsList options_list;
+public:
+  InitialConditionDecompositionStatement(const SymbolList &symbol_list_arg,
+                                         const OptionsList &options_list_arg);
+  virtual void writeOutput(ostream &output, const string &basename, bool minimal_workspace) const;
+};
+
 class ConditionalForecastStatement : public Statement
 {
 private:
diff --git a/preprocessor/ConfigFile.cc b/preprocessor/ConfigFile.cc
index 36a1faa7d..64d899e13 100644
--- a/preprocessor/ConfigFile.cc
+++ b/preprocessor/ConfigFile.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2016 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/ConfigFile.hh b/preprocessor/ConfigFile.hh
index e054922f7..e3d9143eb 100644
--- a/preprocessor/ConfigFile.hh
+++ b/preprocessor/ConfigFile.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2016 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/DataTree.hh b/preprocessor/DataTree.hh
index d7a1de5d8..5efb57bdb 100644
--- a/preprocessor/DataTree.hh
+++ b/preprocessor/DataTree.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2016 Dynare Team
+ * Copyright (C) 2003-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/DynamicModel.cc b/preprocessor/DynamicModel.cc
index 00820fa15..663453429 100644
--- a/preprocessor/DynamicModel.cc
+++ b/preprocessor/DynamicModel.cc
@@ -2002,6 +2002,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
           mDynamicModelFile << "  tmp = y(:,M_.block_structure.block(" << block + 1 << ").variable);\n";
           mDynamicModelFile << "  if any(isnan(tmp) | isinf(tmp))\n";
           mDynamicModelFile << "    disp(['Inf or Nan value during the evaluation of block " << block <<"']);\n";
+          mDynamicModelFile << "    oo_.deterministic_simulation.status = 0;\n";
           mDynamicModelFile << "    oo_.deterministic_simulation.error = 100;\n";
           mDynamicModelFile << "    varargout{1} = oo_;\n";
           mDynamicModelFile << "    return;\n";
@@ -2029,6 +2030,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
           mDynamicModelFile << "  tmp = y(:,M_.block_structure.block(" << block + 1 << ").variable);\n";
           mDynamicModelFile << "  if any(isnan(tmp) | isinf(tmp))\n";
           mDynamicModelFile << "    disp(['Inf or Nan value during the evaluation of block " << block <<"']);\n";
+          mDynamicModelFile << "    oo_.deterministic_simulation.status = 0;\n";
           mDynamicModelFile << "    oo_.deterministic_simulation.error = 100;\n";
           mDynamicModelFile << "    varargout{1} = oo_;\n";
           mDynamicModelFile << "    return;\n";
@@ -2060,6 +2062,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
           mDynamicModelFile << "  tmp = y(:,M_.block_structure.block(" << block + 1 << ").variable);\n";
           mDynamicModelFile << "  if any(isnan(tmp) | isinf(tmp))\n";
           mDynamicModelFile << "    disp(['Inf or Nan value during the resolution of block " << block <<"']);\n";
+          mDynamicModelFile << "    oo_.deterministic_simulation.status = 0;\n";
           mDynamicModelFile << "    oo_.deterministic_simulation.error = 100;\n";
           mDynamicModelFile << "    varargout{1} = oo_;\n";
           mDynamicModelFile << "    return;\n";
@@ -2092,6 +2095,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
           mDynamicModelFile << "  tmp = y(:,M_.block_structure.block(" << block + 1 << ").variable);\n";
           mDynamicModelFile << "  if any(isnan(tmp) | isinf(tmp))\n";
           mDynamicModelFile << "    disp(['Inf or Nan value during the resolution of block " << block <<"']);\n";
+          mDynamicModelFile << "    oo_.deterministic_simulation.status = 0;\n";
           mDynamicModelFile << "    oo_.deterministic_simulation.error = 100;\n";
           mDynamicModelFile << "    varargout{1} = oo_;\n";
           mDynamicModelFile << "    return;\n";
@@ -2124,6 +2128,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
           mDynamicModelFile << "  tmp = y(:,M_.block_structure.block(" << block + 1 << ").variable);\n";
           mDynamicModelFile << "  if any(isnan(tmp) | isinf(tmp))\n";
           mDynamicModelFile << "    disp(['Inf or Nan value during the resolution of block " << block <<"']);\n";
+          mDynamicModelFile << "    oo_.deterministic_simulation.status = 0;\n";
           mDynamicModelFile << "    oo_.deterministic_simulation.error = 100;\n";
           mDynamicModelFile << "    varargout{1} = oo_;\n";
           mDynamicModelFile << "    return;\n";
@@ -4097,11 +4102,11 @@ DynamicModel::testTrendDerivativesEqualToZero(const eval_context_t &eval_context
                     double nearZero = testeq->getDerivative(endogit->second)->eval(eval_context); // eval d F / d Trend d Endog
                     if (fabs(nearZero) > ZERO_BAND)
                       {
-                        cerr << "ERROR: trends not compatible with balanced growth path; the second-order cross partial of equation " << eq + 1 << " (line "
+                        cerr << "WARNING: trends not compatible with balanced growth path; the second-order cross partial of equation " << eq + 1 << " (line "
                              << equations_lineno[eq] << ") w.r.t. trend variable "
                              << symbol_table.getName(it->first.first) << " and endogenous variable "
                              << symbol_table.getName(endogit->first.first) << " is not null. " << endl;
-                        exit(EXIT_FAILURE);
+                        // Changed to warning. See discussion in #1389
                       }
                   }
             }
@@ -4371,9 +4376,9 @@ DynamicModel::writeChainRuleDerivative(ostream &output, int eqr, int varr, int l
 }
 
 void
-DynamicModel::writeLatexFile(const string &basename) const
+DynamicModel::writeLatexFile(const string &basename, const bool write_equation_tags) const
 {
-  writeLatexModelFile(basename + "_dynamic", oLatexDynamicModel);
+  writeLatexModelFile(basename + "_dynamic", oLatexDynamicModel, write_equation_tags);
 }
 
 void
diff --git a/preprocessor/DynamicModel.hh b/preprocessor/DynamicModel.hh
index 4e4b64538..270359430 100644
--- a/preprocessor/DynamicModel.hh
+++ b/preprocessor/DynamicModel.hh
@@ -290,7 +290,7 @@ public:
   size_t dynamicOnlyEquationsNbr() const;
 
   //! Writes LaTeX file with the equations of the dynamic model
-  void writeLatexFile(const string &basename) const;
+  void writeLatexFile(const string &basename, const bool write_equation_tags) const;
 
   //! Writes LaTeX file with the equations of the dynamic model (for the original model)
   void writeLatexOriginalFile(const string &basename) const;
diff --git a/preprocessor/DynareBison.yy b/preprocessor/DynareBison.yy
index 7f6d28834..c82b7025b 100644
--- a/preprocessor/DynareBison.yy
+++ b/preprocessor/DynareBison.yy
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2016 Dynare Team
+ * Copyright (C) 2003-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -86,12 +86,12 @@ class ParsingDriver;
 
 %token AIM_SOLVER ANALYTIC_DERIVATION ANALYTIC_DERIVATION_MODE AR AUTOCORR POSTERIOR_SAMPLING_METHOD
 %token BAYESIAN_IRF BETA_PDF BLOCK USE_CALIBRATION SILENT_OPTIMIZER
-%token BVAR_DENSITY BVAR_FORECAST NODECOMPOSITION DR_DISPLAY_TOL HUGE_NUMBER
-%token BVAR_PRIOR_DECAY BVAR_PRIOR_FLAT BVAR_PRIOR_LAMBDA
-%token BVAR_PRIOR_MU BVAR_PRIOR_OMEGA BVAR_PRIOR_TAU BVAR_PRIOR_TRAIN
-%token BVAR_REPLIC BYTECODE ALL_VALUES_REQUIRED PROPOSAL_DISTRIBUTION
+%token BVAR_DENSITY BVAR_FORECAST NODECOMPOSITION DR_DISPLAY_TOL HUGE_NUMBER FIG_NAME WRITE_XLS
+%token BVAR_PRIOR_DECAY BVAR_PRIOR_FLAT BVAR_PRIOR_LAMBDA INTERACTIVE SCREEN_SHOCKS STEADYSTATE
+%token BVAR_PRIOR_MU BVAR_PRIOR_OMEGA BVAR_PRIOR_TAU BVAR_PRIOR_TRAIN DETAIL_PLOT TYPE
+%token BVAR_REPLIC BYTECODE ALL_VALUES_REQUIRED PROPOSAL_DISTRIBUTION REALTIME VINTAGE
 %token CALIB_SMOOTHER CHANGE_TYPE CHECK CONDITIONAL_FORECAST CONDITIONAL_FORECAST_PATHS CONF_SIG CONSTANT CONTROLLED_VAREXO CORR COVAR CUTOFF CYCLE_REDUCTION LOGARITHMIC_REDUCTION
-%token CONSIDER_ALL_ENDOGENOUS CONSIDER_ONLY_OBSERVED
+%token CONSIDER_ALL_ENDOGENOUS CONSIDER_ONLY_OBSERVED INITIAL_CONDITION_DECOMPOSITION
 %token DATAFILE FILE SERIES DOUBLING DR_CYCLE_REDUCTION_TOL DR_LOGARITHMIC_REDUCTION_TOL DR_LOGARITHMIC_REDUCTION_MAXITER DR_ALGO DROP DSAMPLE DYNASAVE DYNATYPE CALIBRATION DIFFERENTIATE_FORWARD_VARS
 %token END ENDVAL EQUAL ESTIMATION ESTIMATED_PARAMS ESTIMATED_PARAMS_BOUNDS ESTIMATED_PARAMS_INIT EXTENDED_PATH ENDOGENOUS_PRIOR
 %token FILENAME DIRNAME FILTER_STEP_AHEAD FILTERED_VARS FIRST_OBS LAST_OBS SET_TIME OSR_PARAMS_BOUNDS KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED
@@ -103,17 +103,17 @@ class ParsingDriver;
 %token IDENTIFICATION INF_CONSTANT INITVAL INITVAL_FILE BOUNDS JSCALE INIT INFILE INVARS
 %token <string_val> INT_NUMBER
 %token INV_GAMMA_PDF INV_GAMMA1_PDF INV_GAMMA2_PDF IRF IRF_SHOCKS IRF_PLOT_THRESHOLD IRF_CALIBRATION
-%token FAST_KALMAN_FILTER KALMAN_ALGO KALMAN_TOL DIFFUSE_KALMAN_TOL SUBSAMPLES OPTIONS TOLF TOLX
+%token FAST_KALMAN_FILTER KALMAN_ALGO KALMAN_TOL DIFFUSE_KALMAN_TOL SUBSAMPLES OPTIONS TOLF TOLX PLOT_INIT_DATE PLOT_END_DATE
 %token LAPLACE LIK_ALGO LIK_INIT LINEAR LOAD_IDENT_FILES LOAD_MH_FILE LOAD_RESULTS_AFTER_LOAD_MH LOAD_PARAMS_AND_STEADY_STATE LOGLINEAR LOGDATA LYAPUNOV LINEAR_APPROXIMATION
 %token LYAPUNOV_FIXED_POINT_TOL LYAPUNOV_DOUBLING_TOL LYAPUNOV_SQUARE_ROOT_SOLVER_TOL LOG_DEFLATOR LOG_TREND_VAR LOG_GROWTH_FACTOR MARKOWITZ MARGINAL_DENSITY MAX MAXIT
 %token MFS MH_CONF_SIG MH_DROP MH_INIT_SCALE MH_JSCALE MH_MODE MH_NBLOCKS MH_REPLIC MH_RECOVER POSTERIOR_MAX_SUBSAMPLE_DRAWS MIN MINIMAL_SOLVING_PERIODS
 %token MODE_CHECK MODE_CHECK_NEIGHBOURHOOD_SIZE MODE_CHECK_SYMMETRIC_PLOTS MODE_CHECK_NUMBER_OF_POINTS MODE_COMPUTE MODE_FILE MODEL MODEL_COMPARISON MODEL_INFO MSHOCKS ABS SIGN
 %token MODEL_DIAGNOSTICS MODIFIEDHARMONICMEAN MOMENTS_VARENDO CONTEMPORANEOUS_CORRELATION DIFFUSE_FILTER SUB_DRAWS TAPER_STEPS GEWEKE_INTERVAL RAFTERY_LEWIS_QRS RAFTERY_LEWIS_DIAGNOSTICS MCMC_JUMPING_COVARIANCE MOMENT_CALIBRATION
 %token NUMBER_OF_PARTICLES RESAMPLING SYSTEMATIC GENERIC RESAMPLING_THRESHOLD RESAMPLING_METHOD KITAGAWA STRATIFIED SMOOTH
-%token CPF_WEIGHTS AMISANOTRISTANI MURRAYJONESPARSLOW
-%token FILTER_ALGORITHM PROPOSAL_APPROXIMATION CUBATURE UNSCENTED MONTECARLO DISTRIBUTION_APPROXIMATION
+%token CPF_WEIGHTS AMISANOTRISTANI MURRAYJONESPARSLOW WRITE_EQUATION_TAGS
+%token NONLINEAR_FILTER_INITIALIZATION FILTER_ALGORITHM PROPOSAL_APPROXIMATION CUBATURE UNSCENTED MONTECARLO DISTRIBUTION_APPROXIMATION
 %token <string_val> NAME
-%token USE_PENALIZED_OBJECTIVE_FOR_HESSIAN
+%token USE_PENALIZED_OBJECTIVE_FOR_HESSIAN INIT_STATE RESCALE_PREDICTION_ERROR_COVARIANCE
 %token NAN_CONSTANT NO_STATIC NOBS NOCONSTANT NODISPLAY NOCORR NODIAGNOSTIC NOFUNCTIONS NO_HOMOTOPY
 %token NOGRAPH POSTERIOR_NOGRAPH POSTERIOR_GRAPH NOMOMENTS NOPRINT NORMAL_PDF SAVE_DRAWS
 %token OBSERVATION_TRENDS OPTIM OPTIM_WEIGHTS ORDER OSR OSR_PARAMS MAX_DIM_COVA_GROUP ADVANCED OUTFILE OUTVARS OVERWRITE
@@ -125,13 +125,13 @@ class ParsingDriver;
 %token RELATIVE_IRF REPLIC SIMUL_REPLIC RPLOT SAVE_PARAMS_AND_STEADY_STATE PARAMETER_UNCERTAINTY
 %token SHOCKS SHOCK_DECOMPOSITION SHOCK_GROUPS USE_SHOCK_GROUPS SIGMA_E SIMUL SIMUL_ALGO SIMUL_SEED ENDOGENOUS_TERMINAL_PERIOD
 %token SMOOTHER SMOOTHER2HISTVAL SQUARE_ROOT_SOLVER STACK_SOLVE_ALGO STEADY_STATE_MODEL SOLVE_ALGO SOLVER_PERIODS ROBUST_LIN_SOLVE
-%token STDERR STEADY STOCH_SIMUL SURPRISE SYLVESTER SYLVESTER_FIXED_POINT_TOL REGIMES REGIME
+%token STDERR STEADY STOCH_SIMUL SURPRISE SYLVESTER SYLVESTER_FIXED_POINT_TOL REGIMES REGIME REALTIME_SHOCK_DECOMPOSITION
 %token TEX RAMSEY_MODEL RAMSEY_POLICY RAMSEY_CONSTRAINTS PLANNER_DISCOUNT DISCRETIONARY_POLICY DISCRETIONARY_TOL
 %token <string_val> TEX_NAME
 %token UNIFORM_PDF UNIT_ROOT_VARS USE_DLL USEAUTOCORR GSA_SAMPLE_FILE USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED
-%token VALUES VAR VAREXO VAREXO_DET VAROBS PREDETERMINED_VARIABLES
+%token VALUES VAR VAREXO VAREXO_DET VAROBS PREDETERMINED_VARIABLES PLOT_SHOCK_DECOMPOSITION
 %token WRITE_LATEX_DYNAMIC_MODEL WRITE_LATEX_STATIC_MODEL WRITE_LATEX_ORIGINAL_MODEL
-%token XLS_SHEET XLS_RANGE LMMCP OCCBIN BANDPASS_FILTER COLORMAP
+%token XLS_SHEET XLS_RANGE LMMCP OCCBIN BANDPASS_FILTER COLORMAP QOQ YOY AOA
 %left COMMA
 %left EQUAL_EQUAL EXCLAMATION_EQUAL
 %left LESS GREATER LESS_EQUAL GREATER_EQUAL
@@ -143,7 +143,7 @@ class ParsingDriver;
 %token ASINH ACOSH ATANH SQRT NORMCDF NORMPDF STEADY_STATE EXPECTATION
 /* GSA analysis */
 %token DYNARE_SENSITIVITY MORRIS STAB REDFORM PPRIOR PRIOR_RANGE PPOST ILPTAU MORRIS_NLIV
-%token MORRIS_NTRA NSAM LOAD_REDFORM LOAD_RMSE LOAD_STAB ALPHA2_STAB KSSTAT LOGTRANS_REDFORM THRESHOLD_REDFORM
+%token MORRIS_NTRA NSAM LOAD_REDFORM LOAD_RMSE LOAD_STAB ALPHA2_STAB LOGTRANS_REDFORM THRESHOLD_REDFORM
 %token KSSTAT_REDFORM ALPHA2_REDFORM NAMENDO NAMLAGENDO NAMEXO RMSE LIK_ONLY VAR_RMSE PFILT_RMSE ISTART_RMSE
 %token ALPHA_RMSE ALPHA2_RMSE
 /* end of GSA analysis*/
@@ -171,7 +171,7 @@ class ParsingDriver;
 %token ADAPTIVE_MH_DRAWS THINNING_FACTOR COEFFICIENTS_PRIOR_HYPERPARAMETERS
 %token CONVERGENCE_STARTING_VALUE CONVERGENCE_ENDING_VALUE CONVERGENCE_INCREMENT_VALUE
 %token MAX_ITERATIONS_STARTING_VALUE MAX_ITERATIONS_INCREMENT_VALUE MAX_BLOCK_ITERATIONS
-%token MAX_REPEATED_OPTIMIZATION_RUNS FUNCTION_CONVERGENCE_CRITERION
+%token MAX_REPEATED_OPTIMIZATION_RUNS FUNCTION_CONVERGENCE_CRITERION SAVE_REALTIME
 %token PARAMETER_CONVERGENCE_CRITERION NUMBER_OF_LARGE_PERTURBATIONS NUMBER_OF_SMALL_PERTURBATIONS
 %token NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION MAX_NUMBER_OF_STAGES
 %token RANDOM_FUNCTION_CONVERGENCE_CRITERION RANDOM_PARAMETER_CONVERGENCE_CRITERION
@@ -261,6 +261,9 @@ statement : parameters
           | write_latex_static_model
           | write_latex_original_model
           | shock_decomposition
+          | realtime_shock_decomposition
+          | plot_shock_decomposition
+          | initial_condition_decomposition
           | conditional_forecast
           | conditional_forecast_paths
           | plot_conditional_forecast
@@ -1815,6 +1818,7 @@ estimation_options : o_datafile
 		   | o_resampling_threshold
 		   | o_resampling_method
 		   | o_filter_algorithm
+                   | o_nonlinear_filter_initialization
                    | o_cpf_weights
 		   | o_proposal_approximation
 		   | o_distribution_approximation
@@ -1827,6 +1831,7 @@ estimation_options : o_datafile
                    | o_posterior_sampler_options
                    | o_keep_kalman_algo_if_singularity_is_detected
                    | o_use_penalized_objective_for_hessian
+                   | o_rescale_prediction_error_covariance
                    ;
 
 list_optim_option : QUOTED_STRING COMMA QUOTED_STRING
@@ -2107,7 +2112,9 @@ ramsey_policy_options : stoch_simul_primary_options
                       ;
 
 write_latex_dynamic_model : WRITE_LATEX_DYNAMIC_MODEL ';'
-                            { driver.write_latex_dynamic_model(); }
+                            { driver.write_latex_dynamic_model(false); }
+                          | WRITE_LATEX_DYNAMIC_MODEL '(' WRITE_EQUATION_TAGS ')' ';'
+                            { driver.write_latex_dynamic_model(true); }
                           ;
 
 write_latex_static_model : WRITE_LATEX_STATIC_MODEL ';'
@@ -2128,6 +2135,36 @@ shock_decomposition : SHOCK_DECOMPOSITION ';'
                       { driver.shock_decomposition(); }
                     ;
 
+realtime_shock_decomposition : REALTIME_SHOCK_DECOMPOSITION ';'
+                               {driver.realtime_shock_decomposition(); }
+                             | REALTIME_SHOCK_DECOMPOSITION '(' realtime_shock_decomposition_options_list ')' ';'
+                               { driver.realtime_shock_decomposition(); }
+                             | REALTIME_SHOCK_DECOMPOSITION symbol_list ';'
+                               { driver.realtime_shock_decomposition(); }
+                             | REALTIME_SHOCK_DECOMPOSITION '(' realtime_shock_decomposition_options_list ')' symbol_list ';'
+                               { driver.realtime_shock_decomposition(); }
+                             ;
+
+plot_shock_decomposition : PLOT_SHOCK_DECOMPOSITION ';'
+                           {driver.plot_shock_decomposition(); }
+                         | PLOT_SHOCK_DECOMPOSITION '(' plot_shock_decomposition_options_list ')' ';'
+                           { driver.plot_shock_decomposition(); }
+                         | PLOT_SHOCK_DECOMPOSITION symbol_list ';'
+                           { driver.plot_shock_decomposition(); }
+                         | PLOT_SHOCK_DECOMPOSITION '(' plot_shock_decomposition_options_list ')' symbol_list ';'
+                           { driver.plot_shock_decomposition(); }
+                         ;
+
+initial_condition_decomposition : INITIAL_CONDITION_DECOMPOSITION ';'
+                                  {driver.initial_condition_decomposition(); }
+                                | INITIAL_CONDITION_DECOMPOSITION '(' initial_condition_decomposition_options_list ')' ';'
+                                  { driver.initial_condition_decomposition(); }
+                                | INITIAL_CONDITION_DECOMPOSITION symbol_list ';'
+                                  { driver.initial_condition_decomposition(); }
+                                | INITIAL_CONDITION_DECOMPOSITION '(' initial_condition_decomposition_options_list ')' symbol_list ';'
+                                  { driver.initial_condition_decomposition(); }
+                                ;
+
 bvar_prior_option : o_bvar_prior_tau
                   | o_bvar_prior_decay
                   | o_bvar_prior_lambda
@@ -2444,7 +2481,6 @@ dynare_sensitivity_option : o_gsa_identification
                           | o_gsa_load_rmse
                           | o_gsa_load_stab
                           | o_gsa_alpha2_stab
-                          | o_gsa_ksstat
                           | o_gsa_logtrans_redform
                           | o_gsa_ksstat_redform
                           | o_gsa_alpha2_redform
@@ -2494,8 +2530,58 @@ shock_decomposition_option : o_parameter_set
                            | o_shock_decomposition_nograph
                            | o_first_obs
                            | o_nobs
+                           | o_init_state
                            ;
 
+realtime_shock_decomposition_options_list : realtime_shock_decomposition_option COMMA realtime_shock_decomposition_options_list
+                                         | realtime_shock_decomposition_option
+                                         ;
+
+realtime_shock_decomposition_option : o_parameter_set
+                                    | o_datafile
+                                    | o_first_obs
+                                    | o_nobs
+                                    | o_use_shock_groups
+                                    | o_colormap
+                                    | o_shock_decomposition_nograph
+                                    | o_shock_decomposition_presample
+                                    | o_shock_decomposition_forecast
+                                    | o_save_realtime
+                                    ;
+
+plot_shock_decomposition_options_list : plot_shock_decomposition_option COMMA plot_shock_decomposition_options_list
+                                      | plot_shock_decomposition_option
+                                      ;
+
+plot_shock_decomposition_option : o_psd_use_shock_groups
+                                | o_psd_colormap
+                                | o_psd_nodisplay
+                                | o_psd_graph_format
+                                | o_psd_detail_plot
+                                | o_psd_interactive
+                                | o_psd_screen_shocks
+                                | o_psd_steadystate
+                                | o_psd_type
+                                | o_psd_fig_name
+                                | o_psd_write_xls
+                                | o_psd_realtime
+                                | o_psd_vintage
+                                | o_psd_plot_init_date
+                                | o_psd_plot_end_date
+                                ;
+
+initial_condition_decomposition_options_list : initial_condition_decomposition_option COMMA initial_condition_decomposition_options_list
+                                             | initial_condition_decomposition_option
+                                             ;
+
+initial_condition_decomposition_option : o_icd_type
+                                       | o_icd_detail_plot
+                                       | o_icd_steadystate
+                                       | o_icd_write_xls
+                                       | o_icd_plot_init_date
+                                       | o_icd_plot_end_date
+                                       ;
+
 homotopy_setup: HOMOTOPY_SETUP ';' homotopy_list END ';'
                { driver.end_homotopy();};
 
@@ -2832,12 +2918,22 @@ o_posterior_nograph : POSTERIOR_NOGRAPH
             { driver.option_num("no_graph.posterior", "0"); }
           ;
 o_shock_decomposition_nograph : NOGRAPH { driver.option_num("no_graph.shock_decomposition", "1"); }
+o_init_state : INIT_STATE EQUAL INT_NUMBER { driver.option_num("shock_decomp.init_state", $3); };
+o_shock_decomposition_presample : PRESAMPLE EQUAL INT_NUMBER { driver.option_num("shock_decomp.presample", $3); };
+o_shock_decomposition_forecast : FORECAST EQUAL INT_NUMBER { driver.option_num("shock_decomp.forecast", $3); };
+o_save_realtime : SAVE_REALTIME EQUAL vec_int { driver.option_vec_int("shock_decomp.save_realtime", $3); };
 o_nodisplay : NODISPLAY { driver.option_num("nodisplay","1"); };
+o_psd_nodisplay : NODISPLAY { driver.option_num("plot_shock_decomp.nodisplay","1"); };
 o_graph_format : GRAPH_FORMAT EQUAL allowed_graph_formats
                  { driver.process_graph_format_option(); }
                | GRAPH_FORMAT EQUAL '(' list_allowed_graph_formats ')'
                  { driver.process_graph_format_option(); }
                ;
+o_psd_graph_format : GRAPH_FORMAT EQUAL allowed_graph_formats
+                     { driver.plot_shock_decomp_process_graph_format_option(); }
+                   | GRAPH_FORMAT EQUAL '(' list_allowed_graph_formats ')'
+                     { driver.plot_shock_decomp_process_graph_format_option(); }
+                   ;
 allowed_graph_formats : EPS
                         { driver.add_graph_format("eps"); }
                       | FIG
@@ -2943,7 +3039,35 @@ o_dr : DR EQUAL CYCLE_REDUCTION {driver.option_num("dr_cycle_reduction", "1"); }
 o_dr_cycle_reduction_tol : DR_CYCLE_REDUCTION_TOL EQUAL non_negative_number {driver.option_num("dr_cycle_reduction_tol",$3);};
 o_dr_logarithmic_reduction_tol : DR_LOGARITHMIC_REDUCTION_TOL EQUAL non_negative_number {driver.option_num("dr_logarithmic_reduction_tol",$3);};
 o_dr_logarithmic_reduction_maxiter : DR_LOGARITHMIC_REDUCTION_MAXITER EQUAL INT_NUMBER {driver.option_num("dr_logarithmic_reduction_maxiter",$3);};
-
+o_psd_detail_plot : DETAIL_PLOT { driver.option_num("plot_shock_decomp.detail_plot", "1"); };
+o_icd_detail_plot : DETAIL_PLOT { driver.option_num("initial_condition_decomp.detail_plot", "1"); };
+o_psd_interactive : INTERACTIVE { driver.option_num("plot_shock_decomp.interactive", "1"); };
+o_psd_screen_shocks : SCREEN_SHOCKS { driver.option_num("plot_shock_decomp.screen_shocks", "1"); };
+o_psd_steadystate : STEADYSTATE { driver.option_num("plot_shock_decomp.steadystate", "1"); };
+o_icd_steadystate : STEADYSTATE { driver.option_num("initial_condition_decomp.steadystate", "1"); };
+o_psd_fig_name : FIG_NAME EQUAL filename { driver.option_str("plot_shock_decomp.fig_name", $3); };
+o_psd_type : TYPE EQUAL QOQ
+             { driver.option_str("plot_shock_decomp.type", "qoq"); }
+           | TYPE EQUAL YOY
+             { driver.option_str("plot_shock_decomp.type", "qoq"); }
+           | TYPE EQUAL AOA
+             { driver.option_str("plot_shock_decomp.type", "qoq"); }
+           ;
+o_icd_type : TYPE EQUAL QOQ
+             { driver.option_str("initial_condition_decomp.type", "qoq"); }
+           | TYPE EQUAL YOY
+             { driver.option_str("initial_condition_decomp.type", "qoq"); }
+           | TYPE EQUAL AOA
+             { driver.option_str("initial_condition_decomp.type", "qoq"); }
+           ;
+o_icd_plot_init_date : PLOT_INIT_DATE EQUAL date_expr { driver.option_date("initial_condition_decomp.plot_init_date", $3); } ;
+o_icd_plot_end_date : PLOT_END_DATE EQUAL date_expr { driver.option_date("initial_condition_decomp.plot_end_date", $3); } ;
+o_psd_plot_init_date : PLOT_INIT_DATE EQUAL date_expr { driver.option_date("plot_shock_decomp.plot_init_date", $3); } ;
+o_psd_plot_end_date : PLOT_END_DATE EQUAL date_expr { driver.option_date("plot_shock_decomp.plot_end_date", $3); } ;
+o_icd_write_xls : WRITE_XLS { driver.option_num("initial_condition_decomp.write_xls", "1"); };
+o_psd_write_xls : WRITE_XLS { driver.option_num("plot_shock_decomp.write_xls", "1"); };
+o_psd_realtime : REALTIME EQUAL INT_NUMBER { driver.option_num("plot_shock_decomp.realtime", $3); };
+o_psd_vintage : VINTAGE EQUAL INT_NUMBER { driver.option_num("plot_shock_decomp.vintage", $3); };
 o_bvar_prior_tau : BVAR_PRIOR_TAU EQUAL signed_number { driver.option_num("bvar_prior_tau", $3); };
 o_bvar_prior_decay : BVAR_PRIOR_DECAY EQUAL non_negative_number { driver.option_num("bvar_prior_decay", $3); };
 o_bvar_prior_lambda : BVAR_PRIOR_LAMBDA EQUAL signed_number { driver.option_num("bvar_prior_lambda", $3); };
@@ -2964,6 +3088,7 @@ o_resampling_method : RESAMPLING_METHOD EQUAL KITAGAWA {driver.option_num("parti
 o_cpf_weights : CPF_WEIGHTS EQUAL AMISANOTRISTANI {driver.option_num("particle.cpf_weights_method.amisanotristani", "1"); driver.option_num("particle.cpf_weights_method.murrayjonesparslow", "0"); }
               | CPF_WEIGHTS EQUAL MURRAYJONESPARSLOW {driver.option_num("particle.cpf_weights_method.amisanotristani", "0"); driver.option_num("particle.cpf_weights_method.murrayjonesparslow", "1"); };
 o_filter_algorithm : FILTER_ALGORITHM EQUAL symbol { driver.option_str("particle.filter_algorithm", $3); };
+o_nonlinear_filter_initialization : NONLINEAR_FILTER_INITIALIZATION EQUAL INT_NUMBER { driver.option_num("particle.initialization", $3); };
 o_proposal_approximation : PROPOSAL_APPROXIMATION EQUAL CUBATURE {driver.option_num("particle.proposal_approximation.cubature", "1"); driver.option_num("particle.proposal_approximation.unscented", "0"); driver.option_num("particle.proposal_approximation.montecarlo", "0");}
 		| PROPOSAL_APPROXIMATION EQUAL UNSCENTED {driver.option_num("particle.proposal_approximation.cubature", "0"); driver.option_num("particle.proposal_approximation.unscented", "1"); driver.option_num("particle.proposal_approximation.montecarlo", "0");}
 		| PROPOSAL_APPROXIMATION EQUAL MONTECARLO {driver.option_num("particle.proposal_approximation.cubature", "0"); driver.option_num("particle.proposal_approximation.unscented", "0"); driver.option_num("particle.proposal_approximation.montecarlo", "1");} ;
@@ -2987,7 +3112,6 @@ o_gsa_load_redform : LOAD_REDFORM EQUAL INT_NUMBER { driver.option_num("load_red
 o_gsa_load_rmse : LOAD_RMSE EQUAL INT_NUMBER { driver.option_num("load_rmse", $3); };
 o_gsa_load_stab : LOAD_STAB EQUAL INT_NUMBER { driver.option_num("load_stab", $3); };
 o_gsa_alpha2_stab : ALPHA2_STAB EQUAL non_negative_number { driver.option_num("alpha2_stab", $3); };
-o_gsa_ksstat : KSSTAT EQUAL non_negative_number { driver.option_num("ksstat", $3); };
 o_gsa_logtrans_redform : LOGTRANS_REDFORM EQUAL INT_NUMBER { driver.option_num("logtrans_redform", $3); };
 o_gsa_threshold_redform : THRESHOLD_REDFORM EQUAL vec_value_w_inf { driver.option_num("threshold_redform",$3); };
 o_gsa_ksstat_redform : KSSTAT_REDFORM EQUAL non_negative_number { driver.option_num("ksstat_redform", $3); };
@@ -3234,6 +3358,7 @@ o_mcmc_jumping_covariance : MCMC_JUMPING_COVARIANCE EQUAL HESSIAN
                           | MCMC_JUMPING_COVARIANCE EQUAL filename
                             { driver.option_str("MCMC_jumping_covariance", $3); }
                           ;
+o_rescale_prediction_error_covariance : RESCALE_PREDICTION_ERROR_COVARIANCE { driver.option_num("rescale_prediction_error_covariance", "true"); };
 o_use_penalized_objective_for_hessian : USE_PENALIZED_OBJECTIVE_FOR_HESSIAN { driver.option_num("hessian.use_penalized_objective","true"); };
 o_irf_plot_threshold : IRF_PLOT_THRESHOLD EQUAL non_negative_number { driver.option_num("impulse_responses.plot_threshold", $3); };
 o_dr_display_tol : DR_DISPLAY_TOL EQUAL non_negative_number { driver.option_num("dr_display_tol", $3); };
@@ -3253,7 +3378,11 @@ o_sampling_draws : SAMPLING_DRAWS EQUAL INT_NUMBER { driver.option_num("sampling
 o_use_shock_groups : USE_SHOCK_GROUPS { driver.option_str("use_shock_groups","default"); }
                    | USE_SHOCK_GROUPS EQUAL symbol { driver.option_str("use_shock_groups", $3); }
                    ;
-o_colormap : COLORMAP EQUAL symbol { driver.option_num("colormap",$3); };
+o_psd_use_shock_groups : USE_SHOCK_GROUPS { driver.option_str("plot_shock_decomp.use_shock_groups","default"); }
+                       | USE_SHOCK_GROUPS EQUAL symbol { driver.option_str("plot_shock_decomp.use_shock_groups", $3); }
+                       ;
+o_colormap : COLORMAP EQUAL symbol { driver.option_num("plot_shock_decomp.colormap",$3); };
+o_psd_colormap : COLORMAP EQUAL symbol { driver.option_num("plot_shock_decomp.colormap",$3); };
 
 range : symbol ':' symbol
         {
diff --git a/preprocessor/DynareFlex.ll b/preprocessor/DynareFlex.ll
index e1e0aa4c5..9553fab45 100644
--- a/preprocessor/DynareFlex.ll
+++ b/preprocessor/DynareFlex.ll
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2016 Dynare Team
+ * Copyright (C) 2003-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -150,6 +150,9 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 <INITIAL>histval_file {BEGIN DYNARE_STATEMENT; return token::HISTVAL_FILE;}
 <INITIAL>forecast {BEGIN DYNARE_STATEMENT; return token::FORECAST;}
 <INITIAL>shock_decomposition {BEGIN DYNARE_STATEMENT; return token::SHOCK_DECOMPOSITION;}
+<INITIAL>realtime_shock_decomposition {BEGIN DYNARE_STATEMENT; return token::REALTIME_SHOCK_DECOMPOSITION;}
+<INITIAL>plot_shock_decomposition {BEGIN DYNARE_STATEMENT; return token::PLOT_SHOCK_DECOMPOSITION;}
+<INITIAL>initial_condition_decomposition {BEGIN DYNARE_STATEMENT; return token::INITIAL_CONDITION_DECOMPOSITION;}
 <INITIAL>sbvar {BEGIN DYNARE_STATEMENT; return token::SBVAR;}
 <INITIAL>ms_estimation {BEGIN DYNARE_STATEMENT; return token::MS_ESTIMATION;}
 <INITIAL>ms_simulation {BEGIN DYNARE_STATEMENT; return token::MS_SIMULATION;}
@@ -373,6 +376,8 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 <DYNARE_STATEMENT>indxscalesstates {return token::INDXSCALESSTATES;}
 <DYNARE_STATEMENT>fixed_point {return token::FIXED_POINT;}
 <DYNARE_STATEMENT>doubling {return token::DOUBLING;}
+<DYNARE_STATEMENT>plot_init_date {return token::PLOT_INIT_DATE;}
+<DYNARE_STATEMENT>plot_end_date {return token::PLOT_END_DATE;}
 <DYNARE_STATEMENT>square_root_solver {return token::SQUARE_ROOT_SOLVER;}
 <DYNARE_STATEMENT>cycle_reduction {return token::CYCLE_REDUCTION;}
 <DYNARE_STATEMENT>logarithmic_reduction {return token::LOGARITHMIC_REDUCTION;}
@@ -393,6 +398,7 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 <DYNARE_STATEMENT>amisanotristani {return token::AMISANOTRISTANI;}
 <DYNARE_STATEMENT>murrayjonesparslow {return token::MURRAYJONESPARSLOW;}
 <DYNARE_STATEMENT>filter_algorithm {return token::FILTER_ALGORITHM;}
+<DYNARE_STATEMENT>nonlinear_filter_initialization {return token::NONLINEAR_FILTER_INITIALIZATION;}
 <DYNARE_STATEMENT>proposal_approximation {return token::PROPOSAL_APPROXIMATION;}
 <DYNARE_STATEMENT>cubature {return token::CUBATURE;}
 <DYNARE_STATEMENT>unscented {return token::UNSCENTED;}
@@ -400,6 +406,7 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 <DYNARE_STATEMENT>distribution_approximation {return token::DISTRIBUTION_APPROXIMATION;}
 <DYNARE_STATEMENT>proposal_distribution {return token::PROPOSAL_DISTRIBUTION;}
 <DYNARE_STATEMENT>no_posterior_kernel_density {return token::NO_POSTERIOR_KERNEL_DENSITY;}
+<DYNARE_STATEMENT>rescale_prediction_error_covariance {return token::RESCALE_PREDICTION_ERROR_COVARIANCE;}
 <DYNARE_STATEMENT>use_penalized_objective_for_hessian {return token::USE_PENALIZED_OBJECTIVE_FOR_HESSIAN;}
 
 <DYNARE_STATEMENT>alpha {
@@ -459,6 +466,7 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
   yylval->string_val = new string(yytext);
   return token::ABAND;
 }
+<DYNARE_STATEMENT>write_equation_tags {return token::WRITE_EQUATION_TAGS;}
 <DYNARE_STATEMENT>indxap {return token::INDXAP;}
 <DYNARE_STATEMENT>apband {return token::APBAND;}
 <DYNARE_STATEMENT>indximf {return token::INDXIMF;}
@@ -570,6 +578,20 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 
 <DYNARE_STATEMENT>controlled_varexo {return token::CONTROLLED_VAREXO; }
 <DYNARE_STATEMENT>parameter_set {return token::PARAMETER_SET; }
+<DYNARE_STATEMENT>init_state {return token::INIT_STATE; }
+<DYNARE_STATEMENT>save_realtime {return token::SAVE_REALTIME;}
+<DYNARE_STATEMENT>detail_plot {return token::DETAIL_PLOT;}
+<DYNARE_STATEMENT>interactive {return token::INTERACTIVE;}
+<DYNARE_STATEMENT>screen_shocks {return token::SCREEN_SHOCKS;}
+<DYNARE_STATEMENT>steadystate {return token::STEADYSTATE;}
+<DYNARE_STATEMENT>type {return token::TYPE;}
+<DYNARE_STATEMENT>qoq {return token::QOQ; }
+<DYNARE_STATEMENT>yoy {return token::YOY; }
+<DYNARE_STATEMENT>aoa {return token::AOA; }
+<DYNARE_STATEMENT>fig_name {return token::FIG_NAME;}
+<DYNARE_STATEMENT>write_xls {return token::WRITE_XLS;}
+<DYNARE_STATEMENT>realtime {return token::REALTIME;}
+<DYNARE_STATEMENT>vintage {return token::VINTAGE;}
 <DYNARE_STATEMENT>prior_mode {return token::PRIOR_MODE; }
 <DYNARE_STATEMENT>prior_mean {return token::PRIOR_MEAN; }
 <DYNARE_STATEMENT>posterior_mode {return token::POSTERIOR_MODE; }
@@ -779,7 +801,6 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
 <DYNARE_STATEMENT>load_rmse {return token::LOAD_RMSE;}
 <DYNARE_STATEMENT>load_stab {return token::LOAD_STAB;}
 <DYNARE_STATEMENT>alpha2_stab {return token::ALPHA2_STAB;}
-<DYNARE_STATEMENT>ksstat {return token::KSSTAT;}
 <DYNARE_STATEMENT>logtrans_redform {return token::LOGTRANS_REDFORM;}
 <DYNARE_STATEMENT>threshold_redform {return token::THRESHOLD_REDFORM;}
 <DYNARE_STATEMENT>ksstat_redform {return token::KSSTAT_REDFORM;}
diff --git a/preprocessor/ExternalFunctionsTable.cc b/preprocessor/ExternalFunctionsTable.cc
index 8554d8304..eb4ab00cb 100644
--- a/preprocessor/ExternalFunctionsTable.cc
+++ b/preprocessor/ExternalFunctionsTable.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2015 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/ExternalFunctionsTable.hh b/preprocessor/ExternalFunctionsTable.hh
index aa4b02cdf..42d18391e 100644
--- a/preprocessor/ExternalFunctionsTable.hh
+++ b/preprocessor/ExternalFunctionsTable.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2011 Dynare Team
+ * Copyright (C) 2010-2015 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/MinimumFeedbackSet.cc b/preprocessor/MinimumFeedbackSet.cc
index a84a994ab..d91391c58 100644
--- a/preprocessor/MinimumFeedbackSet.cc
+++ b/preprocessor/MinimumFeedbackSet.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 Dynare Team
+ * Copyright (C) 2009-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/ModFile.cc b/preprocessor/ModFile.cc
index e0462b6b0..a7c5c0b26 100644
--- a/preprocessor/ModFile.cc
+++ b/preprocessor/ModFile.cc
@@ -144,7 +144,7 @@ ModFile::checkPass(bool nostrict)
   if ((mod_file_struct.ramsey_model_present || mod_file_struct.ramsey_policy_present)
       && mod_file_struct.discretionary_policy_present)
     {
-      cerr << "ERROR: You cannot use the discretionary_policy command when you use either rasmey_model or ramsey_policy and vice versa" << endl;
+      cerr << "ERROR: You cannot use the discretionary_policy command when you use either ramsey_model or ramsey_policy and vice versa" << endl;
       exit(EXIT_FAILURE);
     }
 
@@ -277,6 +277,19 @@ ModFile::checkPass(bool nostrict)
           || dynamic_model.isBinaryOpUsed(oDifferent)))
     warnings << "WARNING: you are using a function (max, min, abs, sign) or an operator (<, >, <=, >=, ==, !=) which is unsuitable for a stochastic context; see the reference manual, section about \"Expressions\", for more details." << endl;
 
+  if (linear
+      && (dynamic_model.isUnaryOpUsed(oSign)
+          || dynamic_model.isUnaryOpUsed(oAbs)
+          || dynamic_model.isBinaryOpUsed(oMax)
+          || dynamic_model.isBinaryOpUsed(oMin)
+          || dynamic_model.isBinaryOpUsed(oGreater)
+          || dynamic_model.isBinaryOpUsed(oLess)
+          || dynamic_model.isBinaryOpUsed(oGreaterEqual)
+          || dynamic_model.isBinaryOpUsed(oLessEqual)
+          || dynamic_model.isBinaryOpUsed(oEqualEqual)
+          || dynamic_model.isBinaryOpUsed(oDifferent)))
+    warnings << "WARNING: you have declared your model 'linear' but you are using a function (max, min, abs, sign) or an operator (<, >, <=, >=, ==, !=) which potentially makes it non-linear." << endl;
+
   // Test if some estimated parameters are used within the values of shocks
   // statements (see issue #469)
   set<int> parameters_intersect;
diff --git a/preprocessor/ModelTree.cc b/preprocessor/ModelTree.cc
index ecfb7fee0..2282f292d 100644
--- a/preprocessor/ModelTree.cc
+++ b/preprocessor/ModelTree.cc
@@ -232,7 +232,7 @@ ModelTree::computeNonSingularNormalization(jacob_map_t &contemporaneous_jacobian
 void
 ModelTree::computeNormalizedEquations(multimap<int, int> &endo2eqs) const
 {
-  for (int i = 0; i < equations.size(); i++)
+  for (size_t i = 0; i < equations.size(); i++)
     {
       VariableNode *lhs = dynamic_cast<VariableNode *>(equations[i]->get_arg1());
       if (lhs == NULL)
@@ -247,7 +247,7 @@ ModelTree::computeNormalizedEquations(multimap<int, int> &endo2eqs) const
       if (endo.find(make_pair(symbol_table.getTypeSpecificID(symb_id), 0)) != endo.end())
         continue;
 
-      endo2eqs.insert(make_pair(symbol_table.getTypeSpecificID(symb_id), i));
+      endo2eqs.insert(make_pair(symbol_table.getTypeSpecificID(symb_id), (int) i));
       cout << "Endogenous " << symbol_table.getName(symb_id) << " normalized in equation " << (i+1) << endl;
     }
 }
@@ -1631,7 +1631,7 @@ ModelTree::Write_Inf_To_Bin_File(const string &basename,
 }
 
 void
-ModelTree::writeLatexModelFile(const string &basename, ExprNodeOutputType output_type) const
+ModelTree::writeLatexModelFile(const string &basename, ExprNodeOutputType output_type, const bool write_equation_tags) const
 {
   ofstream output, content_output;
   string filename = basename + ".tex";
@@ -1675,8 +1675,31 @@ ModelTree::writeLatexModelFile(const string &basename, ExprNodeOutputType output
 
   for (int eq = 0; eq < (int) equations.size(); eq++)
     {
-      content_output << "\\begin{dmath}" << endl
-                     << "% Equation " << eq+1 << endl;
+      content_output << "% Equation " << eq + 1 << endl;
+      bool wrote_eq_tag = false;
+      if (write_equation_tags)
+        {
+          for (vector<pair<int, pair<string, string> > >::const_iterator iteqt = equation_tags.begin();
+               iteqt != equation_tags.end(); iteqt++)
+            if (iteqt->first == eq)
+              {
+                if (!wrote_eq_tag)
+                  content_output << "\\noindent[";
+                else
+                  content_output << ", ";
+
+                content_output << iteqt->second.first;
+
+                if (iteqt->second.second.empty())
+                  content_output << "= `" << iteqt->second.second << "'";
+
+                wrote_eq_tag = true;
+              }
+        }
+      if (wrote_eq_tag)
+        content_output << "]";
+
+      content_output << "\\begin{dmath}" << endl;
       // Here it is necessary to cast to superclass ExprNode, otherwise the overloaded writeOutput() method is not found
       dynamic_cast<ExprNode *>(equations[eq])->writeOutput(content_output, output_type);
       content_output << endl << "\\end{dmath}" << endl;
@@ -1746,7 +1769,7 @@ ModelTree::addNonstationaryVariables(vector<int> nonstationary_vars, bool log_de
 void
 ModelTree::initializeVariablesAndEquations()
 {
-  for (int j = 0; j < equations.size(); j++)
+  for (size_t j = 0; j < equations.size(); j++)
     {
       equation_reordered.push_back(j);
       variable_reordered.push_back(j);
diff --git a/preprocessor/ModelTree.hh b/preprocessor/ModelTree.hh
index 8a9a6877d..24db008ab 100644
--- a/preprocessor/ModelTree.hh
+++ b/preprocessor/ModelTree.hh
@@ -200,7 +200,7 @@ protected:
   void compileModelEquations(ostream &code_file, unsigned int &instruction_number, const temporary_terms_t &tt, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
 
   //! Writes LaTeX model file
-  void writeLatexModelFile(const string &basename, ExprNodeOutputType output_type) const;
+  void writeLatexModelFile(const string &basename, ExprNodeOutputType output_type, const bool write_equation_tags = false) const;
 
   //! Sparse matrix of double to store the values of the Jacobian
   /*! First index is equation number, second index is endogenous type specific ID */
diff --git a/preprocessor/NumericalInitialization.cc b/preprocessor/NumericalInitialization.cc
index 59ef96ad7..843026517 100644
--- a/preprocessor/NumericalInitialization.cc
+++ b/preprocessor/NumericalInitialization.cc
@@ -245,12 +245,12 @@ InitValStatement::writeJsonOutput(ostream &output) const
 void
 InitValStatement::writeOutputPostInit(ostream &output) const
 {
-  output << "if M_.exo_nbr > 0;" << endl
-         << "\too_.exo_simul = [ones(M_.maximum_lag,1)*oo_.exo_steady_state'];" << endl
-         <<"end;" << endl
-         << "if M_.exo_det_nbr > 0;" << endl
-         << "\too_.exo_det_simul = [ones(M_.maximum_lag,1)*oo_.exo_det_steady_state'];" << endl
-         <<"end;" << endl;
+  output << "if M_.exo_nbr > 0" << endl
+         << "\too_.exo_simul = ones(M_.maximum_lag,1)*oo_.exo_steady_state';" << endl
+         <<"end" << endl
+         << "if M_.exo_det_nbr > 0" << endl
+         << "\too_.exo_det_simul = ones(M_.maximum_lag,1)*oo_.exo_det_steady_state';" << endl
+         <<"end" << endl;
 }
 
 EndValStatement::EndValStatement(const init_values_t &init_values_arg,
@@ -319,8 +319,6 @@ HistValStatement::HistValStatement(const hist_values_t &hist_values_arg,
 void
 HistValStatement::checkPass(ModFileStructure &mod_file_struct, WarningConsolidation &warnings)
 {
-  mod_file_struct.histval_present = true;
-
   if (all_values_required)
     {
       set<int> unused_endo = symbol_table.getEndogenous();
diff --git a/preprocessor/ParsingDriver.cc b/preprocessor/ParsingDriver.cc
index 2fbab28f5..f8b1e8814 100644
--- a/preprocessor/ParsingDriver.cc
+++ b/preprocessor/ParsingDriver.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2016 Dynare Team
+ * Copyright (C) 2003-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -1962,9 +1962,9 @@ ParsingDriver::discretionary_policy()
 }
 
 void
-ParsingDriver::write_latex_dynamic_model()
+ParsingDriver::write_latex_dynamic_model(bool write_equation_tags)
 {
-  mod_file->addStatement(new WriteLatexDynamicModelStatement(mod_file->dynamic_model));
+  mod_file->addStatement(new WriteLatexDynamicModelStatement(mod_file->dynamic_model, write_equation_tags));
 }
 
 void
@@ -2124,6 +2124,30 @@ ParsingDriver::shock_decomposition()
   options_list.clear();
 }
 
+void
+ParsingDriver::realtime_shock_decomposition()
+{
+  mod_file->addStatement(new RealtimeShockDecompositionStatement(symbol_list, options_list));
+  symbol_list.clear();
+  options_list.clear();
+}
+
+void
+ParsingDriver::plot_shock_decomposition()
+{
+  mod_file->addStatement(new PlotShockDecompositionStatement(symbol_list, options_list));
+  symbol_list.clear();
+  options_list.clear();
+}
+
+void
+ParsingDriver::initial_condition_decomposition()
+{
+  mod_file->addStatement(new InitialConditionDecompositionStatement(symbol_list, options_list));
+  symbol_list.clear();
+  options_list.clear();
+}
+
 void
 ParsingDriver::conditional_forecast()
 {
@@ -2216,7 +2240,7 @@ ParsingDriver::declare_and_init_model_local_variable(string *name, expr_t rhs)
       // It can have already been declared in a steady_state_model block, check that it is indeed a ModelLocalVariable
       symb_id = mod_file->symbol_table.getID(*name);
       if (mod_file->symbol_table.getType(symb_id) != eModelLocalVariable)
-        error(*name + " has wrong type, you cannot use it within as left-hand side of a pound ('#') expression");
+        error(*name + " has wrong type or was already used on the right-hand side. You cannot use it on the left-hand side of a pound ('#') expression");
     }
 
   try
@@ -2806,6 +2830,13 @@ ParsingDriver::process_graph_format_option()
   graph_formats.clear();
 }
 
+void
+ParsingDriver::plot_shock_decomp_process_graph_format_option()
+{
+  options_list.symbol_list_options["plot_shock_decomp.graph_format"] = graph_formats;
+  graph_formats.clear();
+}
+
 void
 ParsingDriver::model_diagnostics()
 {
diff --git a/preprocessor/ParsingDriver.hh b/preprocessor/ParsingDriver.hh
index ad9a75e38..f6f04f8a0 100644
--- a/preprocessor/ParsingDriver.hh
+++ b/preprocessor/ParsingDriver.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2016 Dynare Team
+ * Copyright (C) 2003-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -561,7 +561,7 @@ public:
   //! Discretionary policy statement
   void discretionary_policy();
   //! Adds a write_latex_dynamic_model statement
-  void write_latex_dynamic_model();
+  void write_latex_dynamic_model(bool write_equation_tags);
   //! Adds a write_latex_static_model statement
   void write_latex_static_model();
   //! Adds a write_latex_original_model statement
@@ -592,6 +592,12 @@ public:
   void markov_switching();
   //! Shock decomposition
   void shock_decomposition();
+  //! Realtime Shock decomposition
+  void realtime_shock_decomposition();
+  //! Plot Shock decomposition
+  void plot_shock_decomposition();
+  //! Initial Condition decomposition
+  void initial_condition_decomposition();
   //! Conditional forecast statement
   void conditional_forecast();
   //! Conditional forecast paths block
@@ -722,6 +728,8 @@ public:
   void add_graph_format(const string &name);
   //! Add the graph_format option to the OptionsList structure
   void process_graph_format_option();
+  //! Add the graph_format option to the plot_shock_decomp substructure of the OptionsList structure
+  void plot_shock_decomp_process_graph_format_option();
   //! Model diagnostics
   void model_diagnostics();
   //! Processing the parallel_local_files option
diff --git a/preprocessor/Statement.cc b/preprocessor/Statement.cc
index e3e54b3b3..14bffcc3b 100644
--- a/preprocessor/Statement.cc
+++ b/preprocessor/Statement.cc
@@ -40,7 +40,6 @@ ModFileStructure::ModFileStructure() :
   identification_present(false),
   estimation_analytic_derivation(false),
   partial_information(false),
-  histval_present(false),
   k_order_solver(false),
   calibrated_measurement_errors(false),
   dsge_prior_weight_in_estimated_params(false),
diff --git a/preprocessor/Statement.hh b/preprocessor/Statement.hh
index ceb819574..7c80f5d5b 100644
--- a/preprocessor/Statement.hh
+++ b/preprocessor/Statement.hh
@@ -72,9 +72,6 @@ public:
   bool estimation_analytic_derivation;
   //! Whether the option partial_information is given to stoch_simul/estimation/osr/ramsey_policy
   bool partial_information;
-  //! Whether a histval bloc is present
-  /*! Used for the workaround for trac ticket #157 */
-  bool histval_present;
   //! Whether the "k_order_solver" option is used (explictly, or implicitly if order >= 3)
   bool k_order_solver;
   //! Whether there is a calibrated measurement error
diff --git a/preprocessor/SteadyStateModel.cc b/preprocessor/SteadyStateModel.cc
index 5fc9dc1de..0a6e1536d 100644
--- a/preprocessor/SteadyStateModel.cc
+++ b/preprocessor/SteadyStateModel.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2016 Dynare Team
+ * Copyright (C) 2010-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/WarningConsolidation.cc b/preprocessor/WarningConsolidation.cc
index f026dea8f..f1c24f4ad 100644
--- a/preprocessor/WarningConsolidation.cc
+++ b/preprocessor/WarningConsolidation.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2013 Dynare Team
+ * Copyright (C) 2012-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/WarningConsolidation.hh b/preprocessor/WarningConsolidation.hh
index 582af0f43..ece47995e 100644
--- a/preprocessor/WarningConsolidation.hh
+++ b/preprocessor/WarningConsolidation.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2013 Dynare Team
+ * Copyright (C) 2012-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/macro/MacroDriver.cc b/preprocessor/macro/MacroDriver.cc
index c5193cc6b..71d53b9cb 100644
--- a/preprocessor/macro/MacroDriver.cc
+++ b/preprocessor/macro/MacroDriver.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2015 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/macro/MacroDriver.hh b/preprocessor/macro/MacroDriver.hh
index 7b828b028..773a99dcf 100644
--- a/preprocessor/macro/MacroDriver.hh
+++ b/preprocessor/macro/MacroDriver.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2015 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/macro/MacroValue.cc b/preprocessor/macro/MacroValue.cc
index 3dfab3233..b20beb5db 100644
--- a/preprocessor/macro/MacroValue.cc
+++ b/preprocessor/macro/MacroValue.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2013 Dynare Team
+ * Copyright (C) 2008-2014 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/preprocessor/macro/MacroValue.hh b/preprocessor/macro/MacroValue.hh
index 64f0cdef7..1097841d9 100644
--- a/preprocessor/macro/MacroValue.hh
+++ b/preprocessor/macro/MacroValue.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008-2016 Dynare Team
+ * Copyright (C) 2008-2017 Dynare Team
  *
  * This file is part of Dynare.
  *
diff --git a/scripts/fix-copyright-years b/scripts/fix-copyright-years
index 86eceb7bd..d6f883e27 100755
--- a/scripts/fix-copyright-years
+++ b/scripts/fix-copyright-years
@@ -14,7 +14,7 @@
 # Note that the script does not understand some unusual copyright notices: it
 # will display a message in that case.
 
-LAST_UPDATE_COMMIT=61485ab809d9a33484abf6136f05abd84da2be1b
+LAST_UPDATE_COMMIT=1bf81c9f5a79757c23356f16fe015ae4f10bebde
 
 if [ -z "$1" ]; then
     echo "Give a filename in argument"
diff --git a/scripts/indent-c++.el b/scripts/indent-c++.el
index 17ab26ba5..ffbfaf68d 100644
--- a/scripts/indent-c++.el
+++ b/scripts/indent-c++.el
@@ -1,5 +1,6 @@
 (c++-mode)
 (setq indent-tabs-mode nil)
 (indent-region (point-min) (point-max))
-(set-buffer-file-coding-system 'unix)
+(set-buffer-file-coding-system 'utf-8-unix)
+(delete-trailing-whitespace)
 (save-buffer)
diff --git a/scripts/indent-matlab.el b/scripts/indent-matlab.el
index 76861b258..a0ef3ae76 100644
--- a/scripts/indent-matlab.el
+++ b/scripts/indent-matlab.el
@@ -3,5 +3,6 @@
 (setq matlab-indent-function-body nil)
 (untabify (point-min) (point-max))
 (indent-region (point-min) (point-max))
-(set-buffer-file-coding-system 'unix)
+(set-buffer-file-coding-system 'utf-8-unix)
+(delete-trailing-whitespace)
 (save-buffer)
diff --git a/tests/Makefile.am b/tests/Makefile.am
index b857b28f5..a4e8ab876 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -12,6 +12,8 @@ MODFILES = \
 	observation_trends_and_prefiltering/MCMC/Trend_loglin_prefilt_first_obs_MC.mod \
 	observation_trends_and_prefiltering/MCMC/Trend_prefilter_MC.mod \
 	observation_trends_and_prefiltering/MCMC/Trend_prefilter_first_obs_MC.mod \
+	dates/dseries_interact.mod \
+	dates/fs2000.mod \
 	estimation/slice/fs2000_slice.mod \
 	optimizers/fs2000_9.mod \
 	optimizers/fs2000_10.mod \
@@ -26,6 +28,7 @@ MODFILES = \
 	estimation/fs2000_MCMC_jumping_covariance.mod \
 	ms-sbvar/test_ms_variances_repeated_runs.mod \
 	fs2000/fs2000.mod \
+	ls2003/ls2003_hessian_zero.mod \
 	ep/rbc.mod \
 	estimation/fs2000_with_weibull_prior.mod \
 	estimation/fs2000_initialize_from_calib.mod	\
@@ -247,7 +250,7 @@ MODFILES = \
 	stochastic-backward-models/solow_cd_with_steadystate.mod \
 	stochastic-backward-models/backward_linear.mod \
 	deterministic_simulations/purely_forward/ar1.mod \
-        deterministic_simulations/purely_forward/nk.mod \
+	deterministic_simulations/purely_forward/nk.mod \
 	deterministic_simulations/purely_backward/ar1.mod \
 	deterministic_simulations/rbc_det1.mod \
 	deterministic_simulations/rbc_det2.mod \
@@ -272,9 +275,9 @@ MODFILES = \
 	deterministic_simulations/multiple_lead_lags/AR2.mod \
 	deterministic_simulations/multiple_lead_lags/AR2_forward.mod \
 	deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.mod \
-        deterministic_simulations/rbc_det.mod \
-        deterministic_simulations/rbc_det_stack_solve_algo_7.mod \
-        lmmcp/rbc.mod \
+	deterministic_simulations/rbc_det.mod \
+	deterministic_simulations/rbc_det_stack_solve_algo_7.mod \
+	lmmcp/rbc.mod \
 	lmmcp/sw_lmmcp.mod \
 	lmmcp/sw_newton.mod \
 	trend_var/fs2000_nonstationary.mod \
@@ -286,6 +289,7 @@ MODFILES = \
 	shock_decomposition/fs2000_est.mod \
 	shock_decomposition/fs2000_est_varlist.mod \
 	shock_decomposition/fs2000_cal_groups.mod \
+	shock_decomposition/ls2003_plot.mod \
 	stochastic_purely_forward/stochastic_purely_forward.mod \
 	stochastic_purely_forward/stochastic_purely_forward_with_static.mod \
 	forecast/Hansen_exo_det_forecast.mod \
@@ -297,9 +301,12 @@ MODFILES = \
 	gradient/fs2000_numgrad_5.mod \
 	filter_step_ahead/fs2000_filter_step_ahead_bayesian.mod \
 	filter_step_ahead/fs2000_filter_step_ahead_ML.mod \
+	loglinear/example4_exp.mod \
 	loglinear/example4_loglinear.mod \
 	loglinear/example4_loglinear_lagged_exogenous.mod \
 	loglinear/example4_loglinear_lagged_exogenous_a.mod \
+	loglinear/example4_exp_histval.mod \
+	loglinear/example4_loglinear_histval.mod \
 	smoother2histval/fs2000_simul.mod \
 	smoother2histval/fs2000_smooth.mod \
 	smoother2histval/fs2000_smooth_stoch_simul.mod \
@@ -334,6 +341,10 @@ MODFILES = \
 	observation_trends_and_prefiltering/calib_smoother/Tr_prefil_f_obs_loglin_cal_smoother.mod \
 	observation_trends_and_prefiltering/ML/Trend_no_prefilter_selected_var.mod
 
+PARTICLEFILES = \
+	particle/dsge_base2.mod \
+	particle/dsge_unit_root.mod
+
 
 XFAIL_MODFILES = ramst_xfail.mod \
 	estim_param_in_shock_value_xfail.mod \
@@ -462,9 +473,14 @@ deterministic_simulations/multiple_lead_lags/sim_lead_lag.o.trs: deterministic_s
 deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.m.trs: ramst.m.trs 
 deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.o.trs: ramst.o.trs
 
+loglinear/example4_loglinear.m.trs: loglinear/example4_exp.m.trs
+loglinear/example4_loglinear.o.trs: loglinear/example4_exp.o.trs
 loglinear/example4_loglinear_lagged_exogenous_a.m.trs: loglinear/example4_loglinear_lagged_exogenous.m.trs 
 loglinear/example4_loglinear_lagged_exogenous_a.o.trs: loglinear/example4_loglinear_lagged_exogenous.o.trs 
 
+loglinear/example4_loglinear_histval.m.trs: loglinear/example4_exp_histval.m.trs
+loglinear/example4_loglinear_histval.o.trs: loglinear/example4_exp_histval.o.trs
+
 observation_trends_and_prefiltering/ML/Trend_loglinear_no_prefilter_first_obs.m.trs: observation_trends_and_prefiltering/ML/Trend_loglinear_no_prefilter.m.trs
 observation_trends_and_prefiltering/ML/Trend_loglinear_no_prefilter_first_obs.o.trs: observation_trends_and_prefiltering/ML/Trend_loglinear_no_prefilter.o.trs
 observation_trends_and_prefiltering/ML/Trend_loglinear_no_prefilter.m.trs: observation_trends_and_prefiltering/ML/Trend_no_prefilter.m.trs
@@ -625,6 +641,10 @@ lmmcp: m/lmmcp o/lmmcp
 m/lmmcp: $(patsubst %.mod, %.m.trs, $(filter lmmcp/%.mod, $(MODFILES)))
 o/lmmcp: $(patsubst %.mod, %.o.trs, $(filter lmmcp/%.mod, $(MODFILES)))
 
+loglinear: m/loglinear o/loglinear
+m/loglinear: $(patsubst %.mod, %.m.trs, $(filter loglinear/%.mod, $(MODFILES)))
+o/loglinear: $(patsubst %.mod, %.o.trs, $(filter loglinear/%.mod, $(MODFILES)))
+
 gsa: m/gsa o/gsa
 m/gsa: $(patsubst %.mod, %.m.trs, $(filter gsa/%.mod, $(MODFILES)))
 o/gsa: $(patsubst %.mod, %.o.trs, $(filter gsa/%.mod, $(MODFILES)))
@@ -681,6 +701,10 @@ gradient: m/gradient o/gradient
 m/gradient: $(patsubst %.mod, %.m.trs, $(filter gradient/%.mod, $(MODFILES)))
 o/gradient: $(patsubst %.mod, %.o.trs, $(filter gradient/%.mod, $(MODFILES)))
 
+particle: m/particle o/particle
+m/particle: $(patsubst %.mod, %.m.trs, $(PARTICLEFILES))
+o/particle: $(patsubst %.mod, %.o.trs, $(PARTICLEFILES))
+
 # Matlab TRS Files
 M_TRS_FILES = $(patsubst %.mod, %.m.trs, $(MODFILES))
 M_TRS_FILES += run_block_byte_tests_matlab.m.trs run_reporting_test_matlab.m.trs run_all_unitary_tests.m.trs
@@ -697,12 +721,11 @@ M_TLS_FILES = $(patsubst %.m, %.m.tls, $(MFILES))
 # Octave TLS Files
 O_TLS_FILES = $(patsubst %.m, %.o.tls, $(MFILES))
 
-
-
 EXTRA_DIST = \
 	read_trs_files.sh \
 	run_test_matlab.m \
 	run_test_octave.m \
+	load_octave_packages.m \
 	$(MODFILES) \
 	$(XFAIL_MODFILES) \
 	$(MFILES) \
@@ -731,6 +754,7 @@ EXTRA_DIST = \
 	AIM/fsdat.m \
 	block_bytecode/run_ls2003.m \
 	bvar_a_la_sims/bvar_sample.m \
+	dates/fsdat_simul.m \
 	external_function/extFunDeriv.m \
 	external_function/extFunNoDerivs.m \
 	external_function/extFunWithFirstAndSecondDerivs.m \
@@ -779,7 +803,6 @@ EXTRA_DIST = \
 	decision_rules/third_order/comparison_policy_functions_dynare_mathematica.m \
 	shock_decomposition/example1_calib_shock_decomp_data.mat \
 	shock_decomposition/fsdat_simul.m \
-	loglinear/results_exp.mat \
 	smoother2histval/fsdat_simul.m \
 	optimal_policy/Ramsey/find_c.m \
 	optimal_policy/Ramsey/oo_ramsey_policy_initval.mat \
@@ -833,7 +856,7 @@ check-octave: $(O_XFAIL_TRS_FILES) $(O_TRS_FILES)
 	@echo "`tput bold``tput setaf 8`MATLAB: $(PWD)/$*... `tput sgr0`"
 	@DYNARE_VERSION="$(PACKAGE_VERSION)" TOP_TEST_DIR="$(PWD)" FILESTEM="$*" \
 		$(MATLAB)/bin/matlab -nosplash -nodisplay -r run_test_matlab > $*.m.log  2> /dev/null || \
-	printf ":test-result: FAIL\n:number-tests: 1\n:number-failed-tests: 1\n:list-of-failed-tests: $*.mod\n:cputime: 0.0\n" > $*.m.trs
+	printf ":test-result: FAIL\n:number-tests: 1\n:number-failed-tests: 1\n:list-of-failed-tests: $*.mod\n:elapsed-time: 0.0\n" > $*.m.trs
 	@if grep -q ":test-result: PASS" $*.m.trs; then \
 	echo "`tput bold``tput setaf 2`MATLAB: $(PWD)/$* PASSED!`tput sgr0`" ; \
 	else \
@@ -853,7 +876,7 @@ check-octave: $(O_XFAIL_TRS_FILES) $(O_TRS_FILES)
 	@echo "`tput bold``tput setaf 8`OCTAVE: $(PWD)/$*... `tput sgr0`"
 	@DYNARE_VERSION="$(PACKAGE_VERSION)" TOP_TEST_DIR="$(PWD)" FILESTEM="$*" \
 		$(OCTAVE) --no-init-file --silent --no-history --path "$*.mod" run_test_octave.m > $*.o.log 2>&1 || \
-	printf ":test-result: FAIL\n:number-tests: 1\n:number-failed-tests: 1\n:list-of-failed-tests: $*.mod\n:cputime: 0.0\n" > $*.o.trs
+	printf ":test-result: FAIL\n:number-tests: 1\n:number-failed-tests: 1\n:list-of-failed-tests: $*.mod\n:elapsed-time: 0.0\n" > $*.o.trs
 	@if grep -q ":test-result: PASS" $*.o.trs; then \
 	echo "`tput bold``tput setaf 2`OCTAVE: $(PWD)/$* PASSED!`tput sgr0`" ; \
 	else \
@@ -938,6 +961,8 @@ clean-local:
 
 	rm -rf ramsey_objective
 
+	rm -f ep/*.c
+
 	rm -f fs2000_ssfile_steadystate.m
 
 	rm -f $(shell find -name '*~')
@@ -967,6 +992,8 @@ clean-local:
 
 	rm -f initval_file/ramst_initval_file_data_col_vec_mat.mat initval_file/ramst_initval_file_data_row_vec_mat.mat initval_file/ramst_initval_file_excel.xls
 
+	rm -f loglinear/results_exp_histval.mat loglinear/results_exp.mat
+
 	find . -name "*.tex" -type f -delete
 	find . -name "*.aux" -type f -delete
 	find . -name "*.log" -type f -delete
diff --git a/tests/TeX/fs2000_corr_ME.mod b/tests/TeX/fs2000_corr_ME.mod
index dfb933ee1..c226ef835 100644
--- a/tests/TeX/fs2000_corr_ME.mod
+++ b/tests/TeX/fs2000_corr_ME.mod
@@ -71,7 +71,9 @@ del = 0.02;
 options_.TeX=1;
 
 model;
+[name='technology growth: $\Delta A_{t}$', eq='\#1']
 dA = exp(gam+e_a);
+[name='money supply rule']
 log(m) = (1-rho)*log(mst) + rho*log(m(-1))+e_m;
 -P/(c(+1)*P(+1)*m)+bet*P(+1)*(alp*exp(-alp*(gam+log(e(+1))))*k^(alp-1)*n(+1)^(1-alp)+(1-del)*exp(-(gam+log(e(+1)))))/(c(+2)*P(+2)*m(+1))=0;
 W = l/n;
@@ -82,8 +84,11 @@ c+k = exp(-alp*(gam+e_a))*k(-1)^alp*n^(1-alp)+(1-del)*exp(-(gam+e_a))*k(-1);
 P*c = m;
 m-1+d = l;
 e = exp(e_a);
+[name='Production function']
 y = k(-1)^alp*n^(1-alp)*exp(-alp*(gam+e_a));
+[name='observed output growth']
 gy_obs = dA*y/y(-1);
+[name='observed inflation']
 gp_obs = (P/P(-1))*m(-1)/dA;
 end;
 
@@ -134,7 +139,7 @@ stoch_simul(order=1,irf=20,graph_format=eps,periods=0,contemporaneous_correlatio
 
 write_latex_original_model;
 write_latex_static_model;
-write_latex_dynamic_model;
+write_latex_dynamic_model(write_equation_tags);
 write_latex_parameter_table;
 write_latex_definitions;
 
diff --git a/tests/bvar_a_la_sims/bvar_standalone.mod b/tests/bvar_a_la_sims/bvar_standalone.mod
index f3b2cbf18..ae34ff959 100644
--- a/tests/bvar_a_la_sims/bvar_standalone.mod
+++ b/tests/bvar_a_la_sims/bvar_standalone.mod
@@ -2,9 +2,9 @@ var dx dy;
 varobs dx dy;
 
 bvar_density(datafile = bvar_sample, first_obs = 20, bvar_prior_flat,
-             bvar_prior_train = 10) 8;
+             bvar_prior_train = 10) 2;
 
-bvar_forecast(forecast = 10, bvar_replic = 10000, nobs = 200) 8;
+bvar_forecast(forecast = 2, bvar_replic = 1000, nobs = 200) 2;
 
-bvar_irf(8,'Cholesky');
-bvar_irf(8,'SquareRoot');
\ No newline at end of file
+bvar_irf(2,'Cholesky');
+bvar_irf(2,'SquareRoot');
\ No newline at end of file
diff --git a/tests/dates/dseries_interact.mod b/tests/dates/dseries_interact.mod
new file mode 100644
index 000000000..068d070b2
--- /dev/null
+++ b/tests/dates/dseries_interact.mod
@@ -0,0 +1,57 @@
+%% Mod-file tests interaction between estimation and shock_decomposition when dseries is used or not
+var hh nn log_nn;
+varexo eps_a;
+parameters alfa nbar lambda betta rho_a std_a nn_init;
+
+nn_init = -0.1;
+alfa = 0.05;
+lambda = 0.054;
+betta = 0.99;
+nbar = 1;
+rho_a = 0;
+std_a = 1;
+
+
+model(linear);
+
+hh = - alfa * nn + betta * ( hh(+1) + 0  *  eps_a(+1) ) + eps_a;
+
+log_nn = log_nn(-1) + hh * lambda / (1-lambda);
+
+log_nn = ln(nbar) + nn;
+
+end;
+
+steady_state_model;
+log_nn = log(nbar);
+nn = 0;
+hh = 0;
+end;
+
+shocks;
+var eps_a; stderr 1;
+end;
+
+estimated_params;
+alfa, beta_pdf,   0.1, 0.05; 
+std_a,   inv_gamma_pdf, 0.05, 1;
+end;
+
+varobs log_nn;
+
+if ~isoctave() && ~matlab_ver_less_than('8.4')
+   websave('data_uav.xlsx','http://www.dynare.org/Datasets/data_uav.xlsx', weboptions('Timeout', 30))
+else
+   urlwrite('http://www.dynare.org/Datasets/data_uav.xlsx','data_uav.xlsx')
+end
+
+%reading Excel sheet from column A on creates quarterly dseries starting in
+%1950
+estimation(first_obs=2,datafile=data_uav, xls_sheet=Tabelle1, xls_range=a1:b54, mh_replic=2, mh_nblocks=1, mh_jscale=1.1, mh_drop=0.8, plot_priors=0, smoother) log_nn nn hh ;
+shock_decomposition( parameter_set=posterior_median ) nn hh;
+
+%reading Excel sheet from column B on creates annual dseries starting with 1
+estimation(first_obs=2,datafile=data_uav, xls_sheet=Tabelle1, xls_range=b1:b54, mh_replic=2, mh_nblocks=1, mh_jscale=1.1, mh_drop=0.8, plot_priors=0, smoother) log_nn nn hh ;
+shock_decomposition( parameter_set=posterior_median ) nn hh;
+
+delete('data_uav.xlsx')
diff --git a/tests/dates/fs2000.mod b/tests/dates/fs2000.mod
index 897f78b5f..957b4b745 100644
--- a/tests/dates/fs2000.mod
+++ b/tests/dates/fs2000.mod
@@ -1,12 +1,8 @@
-// See fs2000.mod in the examples/ directory for details on the model
-
 var m P c e W R k d n l gy_obs gp_obs y dA;
 varexo e_a e_m;
 
 parameters alp bet gam mst rho psi del;
 
-set_time(1950Q1);
-
 alp = 0.33;
 bet = 0.99;
 gam = 0.003;
@@ -79,19 +75,18 @@ stderr e_a, inv_gamma_pdf, 0.035449, inf;
 stderr e_m, inv_gamma_pdf, 0.008862, inf;
 end;
 
+// List the observed variables.
 varobs gp_obs gy_obs;
 
-options_.solve_tolf = 1e-12;
-
-//data(file=fsdat_simul, first_obs=1950Q3, last_obs=1998Q1);
-
+// Instantiate a dseries object from an m file. Note that the dseries object has more than two variables. 
 ts = dseries('fsdat_simul.m');
-rr = 1950Q3:(1950Q1+ts.nobs);
-nn = length(rr);
-ds = ts(rr);
-ds.save('fsdat_simul2','m');
 
-estimation(order=1,datafile=fsdat_simul2,loglinear,mh_replic=0);
+// Load directly the dseries object as data for the estimation. The declared observed variables must be in the dseries object ts. 
+data(series=ts, first_obs=1950Q3, last_obs=2000Q3);
+
+// Print the first date of the sample.
+disp('First date is $1950Q3')  // disp('First date is 1950Q3'), without the $ symbol,  would trigger an error because of the substitution of 1950Q3 by dates('1950Q3')
+
+// Run the estimation. Note that we do not have a datafile option, because of the data command used above.
+estimation(order=1, loglinear, mh_replic=0);
 
-disp('First date is $1950Q3')
-// disp('Last date is 2000Q1') // This line would trigger an error because of the substitution of 2000Q1 by dates('2000Q1')
diff --git a/tests/deterministic_simulations/homotopy.mod b/tests/deterministic_simulations/homotopy.mod
index cd17a513e..f6b3081dd 100644
--- a/tests/deterministic_simulations/homotopy.mod
+++ b/tests/deterministic_simulations/homotopy.mod
@@ -46,4 +46,8 @@ steady;
 
 simul(periods=200);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 plot(Simulated_time_series.Capital(1Q1:25Q4));
diff --git a/tests/deterministic_simulations/homotopy_histval.mod b/tests/deterministic_simulations/homotopy_histval.mod
index 6fbc5e96f..394081c56 100644
--- a/tests/deterministic_simulations/homotopy_histval.mod
+++ b/tests/deterministic_simulations/homotopy_histval.mod
@@ -53,6 +53,10 @@ end;
 
 simul(periods=200);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 plot(Simulated_time_series.Capital(1Q1:25Q4));
 
 if max(abs(oo_.endo_simul(:,1)-M_.endo_histval))>1e-6
diff --git a/tests/deterministic_simulations/initialization.mod b/tests/deterministic_simulations/initialization.mod
index 3523cfc22..057618526 100644
--- a/tests/deterministic_simulations/initialization.mod
+++ b/tests/deterministic_simulations/initialization.mod
@@ -18,5 +18,10 @@ check;
 
 %% DETERMINISTIC SIMULATION
 simul(periods = 40, stack_solve_algo=0, maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 dsample 40;
 rplot x;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/lbj/rbc.mod b/tests/deterministic_simulations/lbj/rbc.mod
index 3395c6cc8..8d31197e7 100644
--- a/tests/deterministic_simulations/lbj/rbc.mod
+++ b/tests/deterministic_simulations/lbj/rbc.mod
@@ -73,11 +73,19 @@ end;
 perfect_foresight_setup(periods=400);
 perfect_foresight_solver(stack_solve_algo=0);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 oo0 = oo_;
 
 perfect_foresight_setup(periods=400);
 perfect_foresight_solver(stack_solve_algo=6);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 oo6 = oo_;
 
 maxabsdiff = max(max(abs(oo0.endo_simul-oo6.endo_simul)));
diff --git a/tests/deterministic_simulations/linear_approximation/sw.mod b/tests/deterministic_simulations/linear_approximation/sw.mod
index 218d4f203..0ef745d6a 100644
--- a/tests/deterministic_simulations/linear_approximation/sw.mod
+++ b/tests/deterministic_simulations/linear_approximation/sw.mod
@@ -117,9 +117,15 @@ check;
 
 simul(periods=300);
 endo_simul_0 = oo_.endo_simul;
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
 
 simul(linear_approximation,periods=300);
 endo_simul_1 = oo_.endo_simul;
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
 
 if max(abs(endo_simul_0(:)-endo_simul_1(:)))>.01*options_.dynatol.f
     error('Something is wrong!')
diff --git a/tests/deterministic_simulations/lola_solve_one_boundary.mod b/tests/deterministic_simulations/lola_solve_one_boundary.mod
index bb200110b..707d2f8b1 100644
--- a/tests/deterministic_simulations/lola_solve_one_boundary.mod
+++ b/tests/deterministic_simulations/lola_solve_one_boundary.mod
@@ -980,4 +980,8 @@ end;
 
 simul(periods=125,maxit=100);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 delete('lola_data.mat')
diff --git a/tests/deterministic_simulations/multiple_lead_lags/AR2.mod b/tests/deterministic_simulations/multiple_lead_lags/AR2.mod
index c13db02e2..3a7734881 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/AR2.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/AR2.mod
@@ -30,6 +30,10 @@ check;
 options_.solve_tolf=1e-12;
 simul(periods=100);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 // Display the path of consumption and capital
 rplot y_backward;
 
diff --git a/tests/deterministic_simulations/multiple_lead_lags/AR2_forward.mod b/tests/deterministic_simulations/multiple_lead_lags/AR2_forward.mod
index cdeb8bb8f..8e6b3f083 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/AR2_forward.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/AR2_forward.mod
@@ -32,6 +32,10 @@ check;
 options_.solve_tolf=1e-12;
 simul(periods=100);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 // Display the path of consumption and capital
 rplot y_backward;
 
diff --git a/tests/deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.mod b/tests/deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.mod
index 9b417917a..52aa9de85 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/ramst_augmented_histval.mod
@@ -54,6 +54,10 @@ end;
 // Deterministic simulation of the model for 200 periods
 simul(periods=200);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 junk=zeros(1,options_.periods+M_.maximum_lag);
 junk(1)=2;
 junk(2)=1;
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_base.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_base.mod
index 27c3b41cc..c54c3b472 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_base.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_base.mod
@@ -27,4 +27,8 @@ periods 2;
 values 0.9;
 end;
 
-simul(periods=200,maxit=100);
\ No newline at end of file
+simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
\ No newline at end of file
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag.mod
index b85b0b5c1..490c2882c 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag.mod
@@ -39,6 +39,11 @@ values 0.9;
 end;
 
 simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 base_results=load('sim_base_results.mat');
 if max(abs(base_results.oo_.endo_simul(strmatch('c',base_results.M_.endo_names,'exact'),1+base_results.M_.maximum_endo_lag:end-base_results.M_.maximum_endo_lead) -...
     oo_.endo_simul(strmatch('c',M_.endo_names,'exact'),1+M_.maximum_endo_lag:end-M_.maximum_endo_lead)))>1e-8 || ...
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag_aux_vars.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag_aux_vars.mod
index 6f6b4f560..9c5a26f4d 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag_aux_vars.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_endo_lead_lag_aux_vars.mod
@@ -42,6 +42,11 @@ values 0.9;
 end;
 
 simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 base_results=load('sim_base_results.mat');
 if max(abs(base_results.oo_.endo_simul(strmatch('c',base_results.M_.endo_names,'exact'),1+base_results.M_.maximum_endo_lag:end-base_results.M_.maximum_endo_lead) -...
     oo_.endo_simul(strmatch('c',M_.endo_names,'exact'),1+M_.maximum_endo_lag:end-M_.maximum_endo_lead)))>1e-8 || ...
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag.mod
index 2a73f2074..0df5a01f1 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag.mod
@@ -37,6 +37,11 @@ values 0.9;
 end;
 
 simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 base_results=load('sim_base_results.mat');
 if max(abs(base_results.oo_.endo_simul(strmatch('c',base_results.M_.endo_names,'exact'),1+base_results.M_.maximum_endo_lag:end-base_results.M_.maximum_endo_lead) -...
     oo_.endo_simul(strmatch('c',M_.endo_names,'exact'),1+M_.maximum_lag:end-M_.maximum_lead)))>1e-8 || ...
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag_aux_vars.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag_aux_vars.mod
index c0d60e072..0cf9342ae 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag_aux_vars.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_exo_lead_lag_aux_vars.mod
@@ -42,6 +42,11 @@ values 0.9;
 end;
 
 simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 base_results=load('sim_base_results.mat');
 if max(abs(base_results.oo_.endo_simul(strmatch('c',base_results.M_.endo_names,'exact'),1+base_results.M_.maximum_endo_lag:end-base_results.M_.maximum_endo_lead) -...
     oo_.endo_simul(strmatch('c',M_.endo_names,'exact'),1+M_.maximum_endo_lag:end-M_.maximum_endo_lead)))>1e-8 || ...
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag.mod
index 9fe8de65b..406f66459 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag.mod
@@ -41,6 +41,11 @@ values 0.9;
 end;
 
 simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 base_results=load('sim_base_results.mat');
 if max(abs(base_results.oo_.endo_simul(strmatch('c',base_results.M_.endo_names,'exact'),1+base_results.M_.maximum_endo_lag:end-base_results.M_.maximum_endo_lead) -...
     oo_.endo_simul(strmatch('c',M_.endo_names,'exact'),1+M_.maximum_lag:end-M_.maximum_lead)))>1e-8 || ...
diff --git a/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag_aux_vars.mod b/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag_aux_vars.mod
index e8c11d073..a09c0d0e6 100644
--- a/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag_aux_vars.mod
+++ b/tests/deterministic_simulations/multiple_lead_lags/sim_lead_lag_aux_vars.mod
@@ -52,6 +52,11 @@ values 0.9;
 end;
 
 simul(periods=200,maxit=100);
+
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 base_results=load('sim_base_results.mat');
 if max(abs(base_results.oo_.endo_simul(strmatch('c',base_results.M_.endo_names,'exact'),1+base_results.M_.maximum_endo_lag:end-base_results.M_.maximum_endo_lead) -...
     oo_.endo_simul(strmatch('c',M_.endo_names,'exact'),1+M_.maximum_endo_lag:end-M_.maximum_endo_lead)))>1e-8 || ...
diff --git a/tests/deterministic_simulations/purely_backward/ar1.mod b/tests/deterministic_simulations/purely_backward/ar1.mod
index c4ea3299d..1eb5dc5a4 100644
--- a/tests/deterministic_simulations/purely_backward/ar1.mod
+++ b/tests/deterministic_simulations/purely_backward/ar1.mod
@@ -27,6 +27,10 @@ end;
 
 simul(periods=10);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 if max(abs(y-[1; exp(cumprod([1; rho*ones(9, 1)]))]))>options_.dynatol.x
     error('Wrong solution!')
 end
diff --git a/tests/deterministic_simulations/purely_forward/ar1.mod b/tests/deterministic_simulations/purely_forward/ar1.mod
index 0942e8466..4c7f8ee04 100644
--- a/tests/deterministic_simulations/purely_forward/ar1.mod
+++ b/tests/deterministic_simulations/purely_forward/ar1.mod
@@ -24,6 +24,10 @@ end;
 
 simul(periods=5);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 expected_y = ones(1, 6);
 expected_y(2) = exp(-1);
 expected_y(1) = sqrt(exp(-1))*exp(1);
diff --git a/tests/deterministic_simulations/purely_forward/nk.mod b/tests/deterministic_simulations/purely_forward/nk.mod
index 5d5dcfa8b..15295ff01 100644
--- a/tests/deterministic_simulations/purely_forward/nk.mod
+++ b/tests/deterministic_simulations/purely_forward/nk.mod
@@ -37,6 +37,10 @@ end;
 
 simul(periods=5);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 % Initialize the analytical solution for the endogenous variables.
 expected_y = zeros(1, 6);
 expected_pi = zeros(1, 6);
diff --git a/tests/deterministic_simulations/rbc_det.mod b/tests/deterministic_simulations/rbc_det.mod
index 77388ac6f..71fdbd59f 100644
--- a/tests/deterministic_simulations/rbc_det.mod
+++ b/tests/deterministic_simulations/rbc_det.mod
@@ -74,5 +74,9 @@ perfect_foresight_setup(periods=200);
 
 perfect_foresight_solver;
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det1.mod b/tests/deterministic_simulations/rbc_det1.mod
index a5fe6f5b3..0458074b2 100644
--- a/tests/deterministic_simulations/rbc_det1.mod
+++ b/tests/deterministic_simulations/rbc_det1.mod
@@ -71,5 +71,9 @@ end;
 
 simul(periods=20);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det2.mod b/tests/deterministic_simulations/rbc_det2.mod
index 7c34d592f..55eab92c7 100644
--- a/tests/deterministic_simulations/rbc_det2.mod
+++ b/tests/deterministic_simulations/rbc_det2.mod
@@ -71,5 +71,9 @@ end;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det3.mod b/tests/deterministic_simulations/rbc_det3.mod
index be9f5ff3e..f805b607d 100644
--- a/tests/deterministic_simulations/rbc_det3.mod
+++ b/tests/deterministic_simulations/rbc_det3.mod
@@ -71,5 +71,9 @@ end;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det4.mod b/tests/deterministic_simulations/rbc_det4.mod
index cdee86dd5..82542bb31 100644
--- a/tests/deterministic_simulations/rbc_det4.mod
+++ b/tests/deterministic_simulations/rbc_det4.mod
@@ -74,5 +74,9 @@ steady;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det5.mod b/tests/deterministic_simulations/rbc_det5.mod
index 7fcd4d0b6..ffeadf10a 100644
--- a/tests/deterministic_simulations/rbc_det5.mod
+++ b/tests/deterministic_simulations/rbc_det5.mod
@@ -80,5 +80,9 @@ end;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det6.mod b/tests/deterministic_simulations/rbc_det6.mod
index 0bbb1008c..ad1ff2870 100644
--- a/tests/deterministic_simulations/rbc_det6.mod
+++ b/tests/deterministic_simulations/rbc_det6.mod
@@ -72,12 +72,20 @@ end;
 simul(periods=500);
 fff = oo_.endo_simul;
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 simul(periods=500, endogenous_terminal_period);
 ggg = oo_.endo_simul;
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 t1 = abs(fff-ggg);
 t2 = max(max(t1));
 
 if t2>1e-5
-    error('sim1::endogenous_terminal_period: round off error is greater than 1e-5!')
+    error('Perfect foresight simulation with endogenous terminal period failed! Round off error is greater than 1e-5')
 end
diff --git a/tests/deterministic_simulations/rbc_det_exo_lag_2a.mod b/tests/deterministic_simulations/rbc_det_exo_lag_2a.mod
index b831cfdda..a0505dcd3 100644
--- a/tests/deterministic_simulations/rbc_det_exo_lag_2a.mod
+++ b/tests/deterministic_simulations/rbc_det_exo_lag_2a.mod
@@ -71,5 +71,9 @@ end;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
\ No newline at end of file
diff --git a/tests/deterministic_simulations/rbc_det_exo_lag_2b.mod b/tests/deterministic_simulations/rbc_det_exo_lag_2b.mod
index d59a8e613..fb687f4c6 100644
--- a/tests/deterministic_simulations/rbc_det_exo_lag_2b.mod
+++ b/tests/deterministic_simulations/rbc_det_exo_lag_2b.mod
@@ -72,6 +72,10 @@ end;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
 
diff --git a/tests/deterministic_simulations/rbc_det_exo_lag_2c.mod b/tests/deterministic_simulations/rbc_det_exo_lag_2c.mod
index fd7024109..c6c8cbd88 100644
--- a/tests/deterministic_simulations/rbc_det_exo_lag_2c.mod
+++ b/tests/deterministic_simulations/rbc_det_exo_lag_2c.mod
@@ -72,6 +72,10 @@ end;
 
 simul(periods=300);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
 
diff --git a/tests/deterministic_simulations/rbc_det_stack_solve_algo_7.mod b/tests/deterministic_simulations/rbc_det_stack_solve_algo_7.mod
index c1e015dc3..a4c829ffb 100644
--- a/tests/deterministic_simulations/rbc_det_stack_solve_algo_7.mod
+++ b/tests/deterministic_simulations/rbc_det_stack_solve_algo_7.mod
@@ -74,6 +74,10 @@ perfect_foresight_setup(periods=200);
 
 perfect_foresight_solver(stack_solve_algo=7,solve_algo=1);
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
 
@@ -91,6 +95,10 @@ options_.dynatol.f=1e-10;
 perfect_foresight_setup(periods=200);
 perfect_foresight_solver(stack_solve_algo=7,solve_algo=@{solve_algo_iter});
 
+if ~oo_.deterministic_simulation.status
+   error('Perfect foresight simulation failed')
+end
+
 rplot Consumption;
 rplot Capital;
 
diff --git a/tests/ep/rbc_mc.mod b/tests/ep/rbc_mc.mod
index d16e48352..5f30d6ce5 100644
--- a/tests/ep/rbc_mc.mod
+++ b/tests/ep/rbc_mc.mod
@@ -72,4 +72,4 @@ end;
 
 steady(nocheck);
 
-Simulations = extended_path_mc([], 10, 5, [], options_, M_, oo_);
\ No newline at end of file
+Simulations = extended_path_mc([], 2, 2, [], options_, M_, oo_);
\ No newline at end of file
diff --git a/tests/gsa/ls2003.mod b/tests/gsa/ls2003.mod
index 2905f6de2..c93a7ff22 100644
--- a/tests/gsa/ls2003.mod
+++ b/tests/gsa/ls2003.mod
@@ -216,6 +216,7 @@ disp('Press ENTER to continue'); pause(5);
 
 dynare_sensitivity(nodisplay, stab=0, // no need for stability analysis since the posterior sample is surely OK
 datafile='data_ca1.m',first_obs=8,nobs=79,prefilter=1,
+alpha2_rmse=0, // no correlation analysis
 rmse=1,ppost=1,Nsam=512);
 
 collect_latex_files;
diff --git a/tests/gsa/morris/nk_est.mod b/tests/gsa/morris/nk_est.mod
index eb994ba01..fd502b4f9 100644
--- a/tests/gsa/morris/nk_est.mod
+++ b/tests/gsa/morris/nk_est.mod
@@ -55,7 +55,7 @@ stderr eps_A,0.02,0.000000000001,100,INV_GAMMA2_PDF,0.2,inf;
 stderr eps_P,0.03,0.000000000001,100,INV_GAMMA2_PDF,0.2,inf;
 end;
 estimation(order=1,prior_trunc=0,plot_priors =0, datafile=nk_est_data,conf_sig =.95,smoother,moments_varendo,filtered_vars,mode_check,mode_compute=4,mh_replic=5000,mh_jscale=1.5,mh_nblocks=1,bayesian_irf) y pi l dy pic;
-dynare_sensitivity (pprior=0,ppost=1,datafile=nk_est_data,rmse=1, nsam = 2000, lik_only = 0, morris = 2,var_rmse=(dy pic)) ;
-dynare_sensitivity (pprior=0,ppost=1,datafile=nk_est_data,rmse=1, nsam = 2000, lik_only = 0, morris = 1,var_rmse=(dy pic)) ;
+dynare_sensitivity (datafile=nk_est_data,rmse=0, nsam = 2000, lik_only = 0, morris = 2,var_rmse=(dy pic)) ;
+dynare_sensitivity (datafile=nk_est_data,rmse=0, nsam = 2000, lik_only = 0, morris = 1,var_rmse=(dy pic)) ;
 
 
diff --git a/tests/kalman_filter_smoother/check_variable_dimensions/fs2000_ML.mod b/tests/kalman_filter_smoother/check_variable_dimensions/fs2000_ML.mod
index 6b396682c..b333d7ff0 100644
--- a/tests/kalman_filter_smoother/check_variable_dimensions/fs2000_ML.mod
+++ b/tests/kalman_filter_smoother/check_variable_dimensions/fs2000_ML.mod
@@ -116,7 +116,7 @@ corr e_m, e_a, 0;
 stderr gp_obs, 0.01;
 end;
 options_.prior_trunc=0;
-estimation(order=1,datafile='../fsdat_simul', nobs=192, loglinear, forecast=8,smoother,filtered_vars,filter_step_ahead=[1,2,4],filter_decomposition,selected_variables_only)  m P c e W R k d y gy_obs;
+estimation(order=1,datafile='../fsdat_simul', nobs=192, loglinear, forecast=8,smoother,filter_covariance,filtered_vars,filter_step_ahead=[1,2,4],filter_decomposition,selected_variables_only)  m P c e W R k d y gy_obs;
 
 
 if size(oo_.FilteredVariablesKStepAhead,3)~=(options_.nobs+max(options_.filter_step_ahead)) || ...
@@ -124,8 +124,8 @@ if size(oo_.FilteredVariablesKStepAhead,3)~=(options_.nobs+max(options_.filter_s
     error('FilteredVariablesKStepAhead has the wrong length')    
 end
 
-if size(oo_.FilteredVariablesKStepAheadVariances,4)~=(options_.nobs+max(options_.filter_step_ahead)) || ...
-        size(oo_.FilteredVariablesKStepAheadVariances,1)~=(length(options_.filter_step_ahead))
+if options_.filter_covariance && (size(oo_.FilteredVariablesKStepAheadVariances,4)~=(options_.nobs+max(options_.filter_step_ahead)) || ...
+        size(oo_.FilteredVariablesKStepAheadVariances,1)~=(length(options_.filter_step_ahead)))
     error('FilteredVariablesKStepAhead has the wrong length')    
 end
 
diff --git a/tests/kalman_filter_smoother/test_compute_Pinf_Pstar.mod b/tests/kalman_filter_smoother/test_compute_Pinf_Pstar.mod
index 036b62442..e2551ef2c 100644
--- a/tests/kalman_filter_smoother/test_compute_Pinf_Pstar.mod
+++ b/tests/kalman_filter_smoother/test_compute_Pinf_Pstar.mod
@@ -103,9 +103,9 @@ k = reshape(1:M_.endo_nbr,3,round(M_.endo_nbr/3));
 kc = k(1,:);
 kr = k(2:3,:);
 
-if norm(Pinf(kr(:),kc)) > 1e-15
+if norm(Pinf(kr(:),kc)) > 1e-14
    error('Pinf isn''t correct')
 end
-if norm(Pinf(kr(:),kc)) > 1e-15
+if norm(Pinf(kr(:),kc)) > 1e-14
    error('Pstar isn''t correct')
 end
diff --git a/tests/loglinear/example4_exp.mod b/tests/loglinear/example4_exp.mod
index e53b68db7..4fd4811bf 100644
--- a/tests/loglinear/example4_exp.mod
+++ b/tests/loglinear/example4_exp.mod
@@ -64,5 +64,19 @@ var e, u = phi*0.009*0.009;
 end;
 
 stoch_simul(order=1);
+forecast;
+conditional_forecast_paths;
+var a;
+periods  1  2  ;
+values   0.01 -0.02;
+var b;
+periods 1 2;
+values  0.05 0;
+end;
+
+conditional_forecast(parameter_set=calibration, controlled_varexo=(u,e));
+
 oo_exp=oo_;
-save results_exp.mat oo_exp
+load('conditional_forecasts.mat')
+conditional_forecasts_exp=forecasts;
+save results_exp.mat oo_exp conditional_forecasts_exp
\ No newline at end of file
diff --git a/tests/loglinear/example4_exp_histval.mod b/tests/loglinear/example4_exp_histval.mod
new file mode 100644
index 000000000..e07a0a6fb
--- /dev/null
+++ b/tests/loglinear/example4_exp_histval.mod
@@ -0,0 +1,92 @@
+/*
+ * Example 1 from F. Collard (2001): "Stochastic simulations with DYNARE:
+ * A practical guide" (see "guide.pdf" in the documentation directory).
+ */
+
+/*
+ * Copyright (C) 2001-2016 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/>.
+ */
+
+
+var y, c, k, a, h, b;
+varexo e, u;
+
+parameters beta, rho, alpha, delta, theta, psi, tau;
+
+alpha = 0.36;
+rho   = 0.95;
+tau   = 0.025;
+beta  = 0.99;
+delta = 0.025;
+psi   = 0;
+theta = 2.95;
+
+phi   = 0.1;
+
+model;
+exp(c)*theta*exp(h)^(1+psi)=(1-alpha)*exp(y);
+exp(k) = beta*(((exp(b)*exp(c))/(exp(b(+1))*exp(c(+1))))
+    *(exp(b(+1))*alpha*exp(y(+1))+(1-delta)*exp(k)));
+exp(y) = exp(a)*(exp(k(-1))^alpha)*(exp(h)^(1-alpha));
+exp(k) = exp(b)*(exp(y)-exp(c))+(1-delta)*exp(k(-1));
+a = rho*a(-1)+tau*b(-1) + e;
+b = tau*a(-1)+rho*b(-1) + u;
+end;
+
+initval;
+y = log(1.08068253095672);
+c = log(0.80359242014163);
+h = log(0.29175631001732);
+k = log(11.08360443260358);
+a = 0;
+b = 0;
+end;
+resid(1);
+shocks;
+var e; stderr 0.009;
+var u; stderr 0.009;
+var e, u = phi*0.009*0.009;
+end;
+
+histval;
+k(0) = log(11.08);
+a(0) = log(1.2);
+b(0) = log(1);
+end;
+
+stoch_simul(order=1,periods=1000);
+forecast;
+
+forecast;
+conditional_forecast_paths;
+var a;
+periods  1  2  ;
+values   0.01 -0.02;
+var b;
+periods 1 2;
+values  0.05 0;
+end;
+
+conditional_forecast(parameter_set=calibration, controlled_varexo=(u,e));
+
+oo_exp=oo_;
+load('conditional_forecasts.mat')
+conditional_forecasts_exp=forecasts;
+
+oo_exp=oo_;
+save results_exp_histval.mat oo_exp conditional_forecasts_exp
diff --git a/tests/loglinear/example4_loglinear.mod b/tests/loglinear/example4_loglinear.mod
index 482a39e7e..81f4583a4 100644
--- a/tests/loglinear/example4_loglinear.mod
+++ b/tests/loglinear/example4_loglinear.mod
@@ -64,6 +64,18 @@ var e, u = phi*0.009*0.009;
 end;
 
 stoch_simul(loglinear,order=1);
+forecast;
+
+conditional_forecast_paths;
+var a;
+periods  1  2  ;
+values   0.01 -0.02;
+var b;
+periods 1 2;
+values  0.05 0;
+end;
+
+conditional_forecast(parameter_set=calibration, controlled_varexo=(u,e));
 
 load results_exp;
 if max(max(abs(oo_.dr.ghx-oo_exp.dr.ghx)))>1e-10
@@ -99,6 +111,22 @@ for ii=1:length(oo_.autocorr)
     error('Option loglinear wrong, moments not equal')
     end
 end
+
+if max(max(abs(struct2array(oo_.forecast.Mean)-struct2array(oo_exp.forecast.Mean))))>1e-10 || ...
+    max(max(abs(struct2array(oo_.forecast.HPDinf)-struct2array(oo_exp.forecast.HPDinf))))>1e-10 || ...
+    max(max(abs(struct2array(oo_.forecast.HPDsup)-struct2array(oo_exp.forecast.HPDsup))))>1e-10
+    error('Option loglinear wrong, forecast not equal')
+end
+
+load('conditional_forecasts.mat')
+
+if max(max(abs(struct2array(forecasts.cond.Mean)-struct2array(conditional_forecasts_exp.cond.Mean))))>1e-10 || ...
+    max(max(abs(struct2array(forecasts.cond.ci)-struct2array(conditional_forecasts_exp.cond.ci))))>1e-10 || ...
+    max(max(abs(struct2array(forecasts.uncond.Mean)-struct2array(conditional_forecasts_exp.uncond.Mean))))>1e-10 || ...
+    max(max(abs(struct2array(forecasts.uncond.ci)-struct2array(conditional_forecasts_exp.uncond.ci))))>1e-10 
+    error('Option loglinear wrong, conditional forecast not equal')
+end
+
 stoch_simul(loglinear,order=1,periods=100000);
 if abs(mean(y)-0.0776)>0.02
     error('Simulations are wrong')
diff --git a/tests/loglinear/example4_loglinear_histval.mod b/tests/loglinear/example4_loglinear_histval.mod
new file mode 100644
index 000000000..752baa8bc
--- /dev/null
+++ b/tests/loglinear/example4_loglinear_histval.mod
@@ -0,0 +1,124 @@
+/*
+ * Example 1 from F. Collard (2001): "Stochastic simulations with DYNARE:
+ * A practical guide" (see "guide.pdf" in the documentation directory).
+ */
+
+/*
+ * Copyright (C) 2001-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/>.
+ */
+
+
+var y, c, k, a, h, b;
+varexo e, u;
+
+parameters beta, rho, alpha, delta, theta, psi, tau;
+
+alpha = 0.36;
+rho   = 0.95;
+tau   = 0.025;
+beta  = 0.99;
+delta = 0.025;
+psi   = 0;
+theta = 2.95;
+
+phi   = 0.1;
+
+model;
+c*theta*h^(1+psi)=(1-alpha)*y;
+k = beta*(((b*c)/(b(+1)*c(+1)))
+    *(b(+1)*alpha*y(+1)+(1-delta)*k));
+y = a*(k(-1)^alpha)*(h^(1-alpha));
+k = b*(y-c)+(1-delta)*k(-1);
+log(a) = rho*log(a(-1))+tau*log(b(-1)) + e;
+log(b) = tau*log(a(-1))+rho*log(b(-1)) + u;
+end;
+
+initval;
+y = 1.08068253095672;
+c = 0.80359242014163;
+h = 0.29175631001732;
+k = 11.08360443260358;
+a = 1;
+b = 1;
+end;
+
+resid(1);
+shocks;
+var e; stderr 0.009;
+var u; stderr 0.009;
+var e, u = phi*0.009*0.009;
+end;
+
+histval;
+k(0) = 11.08;
+a(0) = 1.2;
+b(0) = 1;
+end;
+
+stoch_simul(loglinear,order=1,periods=1000);
+forecast;
+
+load results_exp_histval;
+if max(max(abs(oo_.dr.ghx-oo_exp.dr.ghx)))>1e-10
+    error('Option loglinear wrong, ghx not equal')
+end
+if max(max(abs(oo_.dr.ghu-oo_exp.dr.ghu)))>1e-10
+    error('Option loglinear wrong, ghu not equal')
+end
+if max(max(abs(oo_.irfs.y_e-oo_exp.irfs.y_e)))>1e-10
+    error('Option loglinear wrong, IRFs not equal')
+end
+if max(max(abs(oo_.irfs.y_u-oo_exp.irfs.y_u)))>1e-10
+    error('Option loglinear wrong, ghu not equal')
+end
+if max(max(abs(oo_.mean-oo_exp.mean)))>1e-10
+    error('Option loglinear wrong, mean not equal')
+end
+if max(max(abs(oo_.dr.ys-oo_exp.dr.ys)))>1e-10
+    error('Option loglinear wrong, ys not equal')
+end
+if max(max(abs(oo_.steady_state-oo_exp.steady_state)))>1e-10
+    error('Option loglinear wrong, steady_state not equal')
+end
+
+if max(max(abs(struct2array(oo_.forecast.Mean)-struct2array(oo_exp.forecast.Mean))))>1e-10 || ...
+    max(max(abs(struct2array(oo_.forecast.HPDinf)-struct2array(oo_exp.forecast.HPDinf))))>1e-10 || ...
+    max(max(abs(struct2array(oo_.forecast.HPDsup)-struct2array(oo_exp.forecast.HPDsup))))>1e-10
+    error('Option loglinear wrong, forecast not equal')
+end
+
+conditional_forecast_paths;
+var a;
+periods  1  2  ;
+values   0.01 -0.02;
+var b;
+periods 1 2;
+values  0.05 0;
+end;
+
+conditional_forecast(parameter_set=calibration, controlled_varexo=(u,e));
+
+
+load('conditional_forecasts.mat')
+
+if max(max(abs(struct2array(forecasts.cond.Mean)-struct2array(conditional_forecasts_exp.cond.Mean))))>1e-10 || ...
+    max(max(abs(struct2array(forecasts.cond.ci)-struct2array(conditional_forecasts_exp.cond.ci))))>1e-10 || ...
+    max(max(abs(struct2array(forecasts.uncond.Mean)-struct2array(conditional_forecasts_exp.uncond.Mean))))>1e-10 || ...
+    max(max(abs(struct2array(forecasts.uncond.ci)-struct2array(conditional_forecasts_exp.uncond.ci))))>1e-10 
+    error('Option loglinear wrong, conditional forecast not equal')
+end
diff --git a/tests/loglinear/results_exp.mat b/tests/loglinear/results_exp.mat
deleted file mode 100644
index fad6d3f8f..000000000
Binary files a/tests/loglinear/results_exp.mat and /dev/null differ
diff --git a/tests/ls2003/ls2003_hessian_zero.mod b/tests/ls2003/ls2003_hessian_zero.mod
new file mode 100644
index 000000000..7476b5b3d
--- /dev/null
+++ b/tests/ls2003/ls2003_hessian_zero.mod
@@ -0,0 +1,44 @@
+//test whether Dynare correctly reverts to linear approximation if 0 Hessian is detected
+
+var y y_s R pie dq pie_s de A y_obs pie_obs R_obs;
+varexo e_R e_q e_ys e_pies e_A;
+
+parameters psi1 psi2 psi3 rho_R tau alpha rr k rho_q rho_A rho_ys rho_pies;
+
+psi1 = 1.54;
+psi2 = 0.25;
+psi3 = 0.25;
+rho_R = 0.5;
+alpha = 0.3;
+rr = 2.51;
+k = 0.5;
+tau = 0.5;
+rho_q = 0.4;
+rho_A = 0.2;
+rho_ys = 0.9;
+rho_pies = 0.7;
+
+
+model;
+y = y(+1) - (tau +alpha*(2-alpha)*(1-tau))*(R-pie(+1))-alpha*(tau +alpha*(2-alpha)*(1-tau))*dq(+1) + alpha*(2-alpha)*((1-tau)/tau)*(y_s-y_s(+1))-A(+1);
+pie = exp(-rr/400)*pie(+1)+alpha*exp(-rr/400)*dq(+1)-alpha*dq+(k/(tau+alpha*(2-alpha)*(1-tau)))*y+alpha*(2-alpha)*(1-tau)/(tau*(tau+alpha*(2-alpha)*(1-tau)))*y_s;
+pie = de+(1-alpha)*dq+pie_s;
+R = rho_R*R(-1)+(1-rho_R)*(psi1*pie+psi2*(y+alpha*(2-alpha)*((1-tau)/tau)*y_s)+psi3*de)+e_R;
+dq = rho_q*dq(-1)+e_q;
+y_s = rho_ys*y_s(-1)+e_ys;
+pie_s = rho_pies*pie_s(-1)+e_pies;
+A = rho_A*A(-1)+e_A;
+y_obs = y-y(-1)+A;
+pie_obs = 4*pie;
+R_obs = 4*R;
+end;
+
+shocks;
+var e_R = 1.25^2;
+var e_q = 2.5^2;
+var e_A = 1.89;
+var e_ys = 1.89;
+var e_pies = 1.89;
+end;
+
+stoch_simul(order=2);
\ No newline at end of file
diff --git a/tests/observation_trends_and_prefiltering/ML/Trend_no_prefilter_selected_var.mod b/tests/observation_trends_and_prefiltering/ML/Trend_no_prefilter_selected_var.mod
index d785da2ab..b64d27fdd 100644
--- a/tests/observation_trends_and_prefiltering/ML/Trend_no_prefilter_selected_var.mod
+++ b/tests/observation_trends_and_prefiltering/ML/Trend_no_prefilter_selected_var.mod
@@ -68,7 +68,7 @@ generate_trend_stationary_AR1;
 estimation(order=1,datafile='AR1_trend_data_with_constant',mh_replic=0,
         mode_compute=4,first_obs=1,nobs=1000,
         filtered_vars, filter_step_ahead = [1,2,4],        
-        diffuse_filter,smoother,forecast=0,prefilter=0,filter_decomposition) P_obs Y_obs junk2;
+        diffuse_filter,filter_covariance,smoother,forecast=0,prefilter=0,filter_decomposition) P_obs Y_obs junk2;
 
 %Test selected_variables_only option
 oo_all_variables=oo_;
@@ -85,7 +85,7 @@ set_dynare_seed('default');
 estimation(order=1,datafile='AR1_trend_data_with_constant',mh_replic=0,
         mode_compute=4,first_obs=1,nobs=1000,
         filtered_vars, filter_step_ahead = [1,2,4],        
-        diffuse_filter,smoother,forecast=0,prefilter=0,filter_decomposition,selected_variables_only) P_obs Y_obs junk2;
+        diffuse_filter,smoother,forecast=0,filter_covariance,prefilter=0,filter_decomposition,selected_variables_only) P_obs Y_obs junk2;
 
 % do checks
         
@@ -118,7 +118,7 @@ if max(max(max(abs(oo_.FilteredVariablesKStepAhead-oo_all_variables.FilteredVari
     error('FilteredVariablesKStepAhead is wrong')
 end
 
-if max(max(max(max(abs(oo_.FilteredVariablesKStepAheadVariances-oo_all_variables.FilteredVariablesKStepAheadVariances(:,[Y_pos;P_pos;junk2_pos],[Y_pos;P_pos;junk2_pos],:))))))>1e-8
+if options_.filter_covariance && max(max(max(max(abs(oo_.FilteredVariablesKStepAheadVariances-oo_all_variables.FilteredVariablesKStepAheadVariances(:,[Y_pos;P_pos;junk2_pos],[Y_pos;P_pos;junk2_pos],:))))))>1e-8
     error('FilteredVariablesKStepAheadVariances is wrong')
 end
 
diff --git a/tests/optimizers/fs2000_6.mod b/tests/optimizers/fs2000_6.mod
index 3a3fe275c..21738c869 100644
--- a/tests/optimizers/fs2000_6.mod
+++ b/tests/optimizers/fs2000_6.mod
@@ -1,6 +1,6 @@
 @#include "fs2000.common.inc"
 
-estimation(mode_compute=6,order=1, datafile='../fs2000/fsdat_simul', nobs=192, mh_replic=0, optim=('nclimb-mh', 10, 'ncov-mh', 5000, 'nscale-mh', 10000));
+estimation(mode_compute=6,order=1, datafile='../fs2000/fsdat_simul', nobs=192, mh_replic=0, optim=('nclimb-mh', 10, 'ncov-mh', 1000, 'nscale-mh', 5000));
 
 // test the mode file generated with mode_compute=6
 estimation(order=1,datafile='../fs2000/fsdat_simul',nobs=192,loglinear,mode_compute=0,mode_file=fs2000_6_mode,mh_replic=10,
diff --git a/tests/particle/dsge_base2.mod b/tests/particle/dsge_base2.mod
index 2b1f26410..b7d4cb1b5 100644
--- a/tests/particle/dsge_base2.mod
+++ b/tests/particle/dsge_base2.mod
@@ -1,27 +1,51 @@
-// This file deals with the resolution and estimation of a basic DSGE model with
-//employment for comparison with the benchmark in Gauss which solves with
-//the same particular filter but global methodology.
-//
-// Juin 2015
-
 // DGP
+@#ifndef RISKY_CALIBRATION
 @#define RISKY_CALIBRATION = 0
+@#endif
+@#ifndef EXTREME_CALIBRATION
 @#define EXTREME_CALIBRATION = 1
+@#endif
+@#ifndef BENCHMARK_CALIBRATION
 @#define BENCHMARK_CALIBRATION = 0
+@#endif
 
 // ALGORITHM
-@#define LINEAR_KALMAN = 1
+@#ifndef LINEAR_KALMAN
+@#define LINEAR_KALMAN = 0
+@#endif
+@#ifndef ALGO_SIR
 @#define ALGO_SIR = 0
+@#endif
+@#ifndef ALGO_SISmoothR
 @#define ALGO_SISmoothR = 0
+@#endif
+@#ifndef ALGO_APF
 @#define ALGO_APF = 0
+@#endif
+@#ifndef ALGO_GPF
 @#define ALGO_GPF = 0
+@#endif
+@#ifndef ALGO_GCF
 @#define ALGO_GCF = 0
-@#define ALGO_GUF = 0
+@#endif
+@#ifndef ALGO_GUF
+@#define ALGO_GUF = 1
+@#endif
+@#ifndef ALGO_GMPF
 @#define ALGO_GMPF = 0
+@#endif
+@#ifndef ALGO_GMCF
 @#define ALGO_GMCF = 0
+@#endif
+@#ifndef ALGO_ONLINE_1
 @#define ALGO_ONLINE_1 = 0
+@#endif
+@#ifndef ALGO_ONLINE_2
 @#define ALGO_ONLINE_2 = 0
-
+@#endif
+@#ifndef MCMC
+@#define MCMC = 0
+@#endif
 
 var k A c l i y;
 varexo e_a;
@@ -164,7 +188,9 @@ options_.mode_check.number_of_points = 250;
   estimation(order=1,number_of_particles=1000,mode_compute=11);
 @#endif
 
-options_.mh_nblck = 10 ;
-options_.posterior_sampling_method = 'RWGMH';
-options_.rwgmh_scale_shock = (1e-5)*[10 10 1 1 10 10 10 1000 10 10] ;
-estimation(order=1,mh_replic=5000,mode_compute=0,mode_file=dsge_base2_mode);
+@#if MCMC
+  options_.mh_nblck = 10 ;
+  options_.posterior_sampling_method = 'RWGMH';
+  options_.rwgmh_scale_shock = (1e-5)*[10 10 1 1 10 10 10 1000 10 10] ;
+  estimation(order=1,mh_replic=5000,mode_compute=0,mode_file=dsge_base2_mode);
+@#endif
\ No newline at end of file
diff --git a/tests/particle/dsge_unit_root.mod b/tests/particle/dsge_unit_root.mod
new file mode 100644
index 000000000..a0f1a4f85
--- /dev/null
+++ b/tests/particle/dsge_unit_root.mod
@@ -0,0 +1,221 @@
+// DGP
+@#ifndef RISKY_CALIBRATION 
+@#define RISKY_CALIBRATION = 0
+@#endif
+@#ifndef EXTREME_CALIBRATION
+@#define EXTREME_CALIBRATION = 1
+@#endif
+@#ifndef BENCHMARK_CALIBRATION
+@#define BENCHMARK_CALIBRATION = 0
+@#endif
+
+// ALGORITHM
+@#ifndef LINEAR_KALMAN
+@#define LINEAR_KALMAN = 0
+@#endif
+@#ifndef ALGO_SIR
+@#define ALGO_SIR = 0
+@#endif
+@#ifndef ALGO_SISmoothR
+@#define ALGO_SISmoothR = 0
+@#endif
+@#ifndef ALGO_APF
+@#define ALGO_APF = 0
+@#endif
+@#ifndef ALGO_GPF
+@#define ALGO_GPF = 0
+@#endif
+@#ifndef ALGO_GCF
+@#define ALGO_GCF = 0
+@#endif
+@#ifndef ALGO_GUF
+@#define ALGO_GUF = 1
+@#endif
+@#ifndef ALGO_GMPF
+@#define ALGO_GMPF = 0
+@#endif
+@#ifndef ALGO_GMCF
+@#define ALGO_GMCF = 0
+@#endif
+@#ifndef ALGO_ONLINE_1
+@#define ALGO_ONLINE_1 = 0
+@#endif
+@#ifndef ALGO_ONLINE_2
+@#define ALGO_ONLINE_2 = 0
+@#endif
+@#ifndef MCMC
+@#define MCMC = 0
+@#endif
+
+var k A c l i y;
+varexo e_a;
+
+parameters alp bet tet tau delt rho ;
+alp = 0.4;
+bet = 0.99;
+tet = 0.357 ;
+tau =  50 ;
+delt = 0.02;
+rho = 1.0;
+
+model;
+c = ((1 - alp)*tet/(1-tet))*A*(1-l)*((k(-1)/l)^alp) ;
+y = A*(k(-1)^alp)*(l^(1-alp)) ;
+i = y-c ;
+k = (1-delt)*k(-1) + i ;
+log(A) = rho*log(A(-1)) + e_a ;
+(((c^(tet))*((1-l)^(1-tet)))^(1-tau))/c - bet*((((c(+1)^(tet))*((1-l(+1))^(1-tet)))^(1-tau))/c(+1))*(1 -delt+alp*(A(1)*(k^alp)*(l(1)^(1-alp)))/k)=0 ;
+end;
+
+shocks;
+var e_a; stderr 0.035;
+end;
+
+steady(nocheck);
+
+
+stoch_simul(periods=5000, irf=0, noprint);
+
+@#if EXTREME_CALIBRATION
+    verbatim;
+    y = y + randn(size(y))*.0175;
+    l = l + randn(size(l))*.00312;
+    i = i + randn(size(i))*.00465;
+    end;
+    ds = dseries([y, l, i, c, A], 1900Q1, {'y'; 'l'; 'i'; 'c'; 'A'});
+@#endif 
+
+@#if RISKY_CALIBRATION
+    verbatim;
+    y = y + randn(size(y))*.00158;
+    l = l + randn(size(l))*.0011;
+    i = i + randn(size(i))*.000866;
+    end;
+    ds = dseries([y, l, i, c, A], 1900Q1, {'y'; 'l'; 'i'; 'c'; 'A'});
+@#endif
+
+@#if BENCHMARK_CALIBRATION
+    // TODO: This section is to be completed (measurement are missing)
+    ds = dseries([y, l, i, c, A], 1900Q1, {'y'; 'l'; 'i'; 'c'; 'A'});
+@#endif
+
+estimated_params;
+alp, uniform_pdf,,, 0.0001, 0.99;
+bet, uniform_pdf,,, 0.0001, 0.99999;
+tet, uniform_pdf,,, 0.0001, .999;
+tau, uniform_pdf,,, 0.0001, 100;
+delt, uniform_pdf,,, 0.0001, 0.05;
+stderr e_a, uniform_pdf,,, 0.00001, 0.1;
+stderr y, uniform_pdf,,, 0.00001, 0.1;
+stderr l, uniform_pdf,,, 0.00001, 0.1;
+stderr i, uniform_pdf,,, 0.00001, 0.1;
+end;
+
+@#if RISKY_CALIBRATION
+  estimated_params_init;
+  alp, 0.4;
+  bet, 0.99;
+  tet, 0.357;
+  tau, 50;
+  delt, 0.02;
+  stderr e_a, .035;
+  stderr y, .00158;
+  stderr l, .0011;
+  stderr i, .000866;
+  end;
+@#endif
+
+@#if EXTREME_CALIBRATION
+  estimated_params_init;
+  alp, 0.4;
+  bet, 0.99;
+  tet, 0.357;
+  tau, 50;
+  delt, 0.02;
+  stderr e_a, .035;
+  stderr y, .0175;
+  stderr l, .00312;
+  stderr i, .00465;
+  end;
+@#endif
+
+varobs y l i ;
+
+options_.mode_check.neighbourhood_size = .01 ;
+options_.mode_check.number_of_points = 250;
+
+//options_.particle.initialization = 3;
+
+@#if EXTREME_CALIBRATION
+  data(series=ds, nobs=200, first_obs=1973Q1);
+@#endif 
+
+@#if RISKY_CALIBRATION
+    data(series=ds, nobs=200, first_obs=1973Q1);
+@#endif
+
+@#if BENCHMARK_CALIBRATION
+    data(series=ds, nobs = 200, first_obs=1973Q1);
+@#endif
+
+
+@#if LINEAR_KALMAN
+%  estimation(nograph,order=1,mode_compute=8,mh_replic=0,mode_check);
+@#endif
+
+@#if ALGO_SIR
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,number_of_particles=1000,mh_replic=0,mode_compute=8,mode_check);
+@#endif
+
+@#if ALGO_SISmoothR
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,number_of_particles=1000,resampling_method=smooth,mode_compute=8,mh_replic=0);
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,number_of_particles=1000,resampling_method=smooth,mode_compute=8,mode_file=dsge_unit_root_mode,mh_replic=0);
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,number_of_particles=1000,resampling_method=smooth,mode_compute=4,mode_file=dsge_unit_root_mode,mh_replic=0,mode_check);
+@#endif
+
+@#if ALGO_APF
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=apf,number_of_particles=1000,mh_replic=0,mode_compute=8,mode_check);
+@#endif
+
+@#if ALGO_GPF
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=gf,distribution_approximation=montecarlo,number_of_particles=1000,mh_replic=0,mode_compute=8);
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=gf,distribution_approximation=montecarlo,number_of_particles=1000,mode_file=dsge_unit_root_mode,mh_replic=0,mode_compute=4,mode_check);
+@#endif
+
+@#if ALGO_GCF
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=gf,mh_replic=0,mode_compute=8);
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=gf,mh_replic=0,mode_compute=4,mode_file=dsge_unit_root_mode,mode_check);
+@#endif
+
+@#if ALGO_GUF
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=gf,proposal_approximation=unscented,distribution_approximation=unscented,mh_replic=0,mode_compute=4);
+  estimation(order=2,nonlinear_filter_initialization=3,nograph,filter_algorithm=gf,proposal_approximation=unscented,distribution_approximation=unscented,mode_file=dsge_unit_root_mode,mh_replic=0,mode_compute=8,mode_check);
+@#endif
+
+@#if ALGO_GMPF
+  estimation(nograph,order=2,nonlinear_filter_initialization=3,filter_algorithm=gmf,distribution_approximation=montecarlo,number_of_particles=1000,mh_replic=0,mode_compute=8);
+  estimation(nograph,order=2,nonlinear_filter_initialization=3,filter_algorithm=gmf,distribution_approximation=montecarlo,number_of_particles=1000,mh_replic=0,mode_file=dsge_unit_root_mode,mode_compute=8);
+  estimation(nograph,order=2,nonlinear_filter_initialization=3,filter_algorithm=gmf,distribution_approximation=montecarlo,number_of_particles=1000,mh_replic=0,mode_file=dsge_unit_root_mode,mode_compute=4,mode_check);
+@#endif
+
+@#if ALGO_GMCF
+  estimation(nograph,order=2,nonlinear_filter_initialization=3,filter_algorithm=gmf,mh_replic=0,mode_compute=8);
+  estimation(nograph,order=2,nonlinear_filter_initialization=3,filter_algorithm=gmf,mh_replic=0,mode_compute=4,mode_file=dsge_unit_root_mode,mode_check);
+@#endif
+
+@#if ALGO_ONLINE_2
+  options_.particle.liu_west_delta = 0.9 ;
+  estimation(order=2,number_of_particles=1000,mode_compute=11);
+@#endif
+
+@#if ALGO_ONLINE_1
+  options_.particle.liu_west_delta = 0.9 ;
+  estimation(order=1,number_of_particles=1000,mode_compute=11);
+@#endif
+
+@#if MCMC
+  options_.mh_nblck = 10 ;
+  options_.posterior_sampling_method = 'RWGMH';
+  options_.rwgmh_scale_shock = (1e-5)*[10 10 1 1 10 10 10 1000 10 10] ;
+  estimation(order=1,mh_replic=5000,mode_compute=0,mode_file=dsge_base2_mode);
+@#endif
\ No newline at end of file
diff --git a/tests/read_trs_files.sh b/tests/read_trs_files.sh
index e805cb150..cdd866d55 100755
--- a/tests/read_trs_files.sh
+++ b/tests/read_trs_files.sh
@@ -22,7 +22,7 @@ for file in $1 ; do
     done
   fi
 
-  time=`grep cputime $file | cut -d: -f3`
+  time=`grep elapsed-time $file | cut -d: -f3`
   tosort=`echo $tosort\| $file ' - ' $time:`
 done
 ((passed=$total-$failed));
@@ -42,7 +42,7 @@ for file in $2 ; do
     done
   fi
 
-  time=`grep cputime $file | cut -d: -f3`
+  time=`grep elapsed-time $file | cut -d: -f3`
   tosort=`echo $tosort\| $file ' - ' $time:`
 done
 ((xfailed=$total_xfail-$xpassed));
diff --git a/tests/reporting/AnnualTable.m b/tests/reporting/AnnualTable.m
index fb78267f2..304cc3fe9 100644
--- a/tests/reporting/AnnualTable.m
+++ b/tests/reporting/AnnualTable.m
@@ -1,5 +1,5 @@
 function rep = AnnualTable(rep, db_a, dc_a, seriesRootName, arange)
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/tests/reporting/CountryGraphPage.m b/tests/reporting/CountryGraphPage.m
index d67bb28a1..c3b03d188 100644
--- a/tests/reporting/CountryGraphPage.m
+++ b/tests/reporting/CountryGraphPage.m
@@ -1,5 +1,5 @@
 function rep = CountryGraphPage(rep, countryAbbr, db_q, dc_q, prange, srange)
-% Copyright (C) 2013 Dynare Team
+% Copyright (C) 2013-2014 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/tests/reporting/CountryTablePage.m b/tests/reporting/CountryTablePage.m
index 309d69c9c..bf0087587 100644
--- a/tests/reporting/CountryTablePage.m
+++ b/tests/reporting/CountryTablePage.m
@@ -1,5 +1,5 @@
 function rep = CountryTablePage(rep, countryAbbr, countryName, db_q, dc_q, db_a, dc_a, trange, vline_after)
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2016 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/tests/reporting/runDynareReport.m b/tests/reporting/runDynareReport.m
index eab6eb234..3d779c7ec 100644
--- a/tests/reporting/runDynareReport.m
+++ b/tests/reporting/runDynareReport.m
@@ -1,5 +1,5 @@
 function runDynareReport(dc_a, dc_q, db_a, db_q)
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2015 Dynare Team
 %
 % This file is part of Dynare.
 %
diff --git a/tests/run_all_unitary_tests.m b/tests/run_all_unitary_tests.m
index 34ab08a21..49ddb307c 100644
--- a/tests/run_all_unitary_tests.m
+++ b/tests/run_all_unitary_tests.m
@@ -1,4 +1,4 @@
-% Copyright (C) 2013-2016 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -82,7 +82,7 @@ else
   fprintf(fid,':number-tests: %d\n', counter);
   fprintf(fid,':number-failed-tests: 0\n');
 end
-fprintf(fid,':cputime: %f\n',0.0);
+fprintf(fid,':elapsed-time: %f\n',0.0);
 fclose(fid);
 if ~isoctave
     exit
diff --git a/tests/run_block_byte_tests_matlab.m b/tests/run_block_byte_tests_matlab.m
index 530d2f7a8..b3e017c56 100644
--- a/tests/run_block_byte_tests_matlab.m
+++ b/tests/run_block_byte_tests_matlab.m
@@ -1,4 +1,4 @@
-% Copyright (C) 2011-2013 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -38,7 +38,7 @@ failedBlock = {};
 num_block_tests = 0;
 cd([top_test_dir filesep 'block_bytecode']);
 has_optimization_toolbox = user_has_matlab_license('optimization_toolbox');
-cput = cputime;
+tic;
 for blockFlag = 0:1
     for bytecodeFlag = 0:1
         default_solve_algo = 2;
@@ -129,7 +129,7 @@ for blockFlag = 0:1
         end
     end
 end
-ecput = cputime - cput;
+ecput = toc;
 delete('wsMat.mat')
 cd(getenv('TOP_TEST_DIR'));
 fid = fopen('run_block_byte_tests_matlab.m.trs', 'w+');
@@ -143,6 +143,6 @@ else
   fprintf(fid,':number-tests: %d\n', num_block_tests);
   fprintf(fid,':number-failed-tests: 0\n');
 end
-fprintf(fid,':cputime: %f\n', ecput);
+fprintf(fid,':elapsed-time: %f\n', ecput);
 fclose(fid);
 exit;
diff --git a/tests/run_block_byte_tests_octave.m b/tests/run_block_byte_tests_octave.m
index a915e9752..be1acf564 100644
--- a/tests/run_block_byte_tests_octave.m
+++ b/tests/run_block_byte_tests_octave.m
@@ -1,4 +1,4 @@
-## Copyright (C) 2009-2013 Dynare Team
+## Copyright (C) 2009-2017 Dynare Team
 ##
 ## This file is part of Dynare.
 ##
@@ -40,7 +40,7 @@ putenv("GNUTERM", "dumb")
 failedBlock = {};
 num_block_tests = 0;
 cd([top_test_dir filesep 'block_bytecode']);
-cput = cputime;
+tic;
 for blockFlag = 0:1
     for bytecodeFlag = 0:1
         ## Recall that solve_algo=7 and stack_solve_algo=2 are not supported
@@ -131,7 +131,7 @@ for blockFlag = 0:1
         endfor
     endfor
 endfor
-ecput = cputime - cput;
+ecput = toc;
 delete('wsOct');
 cd(getenv('TOP_TEST_DIR'));
 fid = fopen('run_block_byte_tests_octave.o.trs', 'w+');
@@ -145,7 +145,7 @@ else
   fprintf(fid,':number-tests: %d\n', num_block_tests);
   fprintf(fid,':number-failed-tests: 0\n');
 end
-fprintf(fid,':cputime: %f\n', ecput);
+fprintf(fid,':elapsed-time: %f\n', ecput);
 fclose(fid);
 ## Local variables:
 ## mode: Octave
diff --git a/tests/run_reporting_test_matlab.m b/tests/run_reporting_test_matlab.m
index e5729c732..00b3356e7 100644
--- a/tests/run_reporting_test_matlab.m
+++ b/tests/run_reporting_test_matlab.m
@@ -1,4 +1,4 @@
-% Copyright (C) 2013-2016 Dynare Team
+% Copyright (C) 2013-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -54,6 +54,6 @@ else
   fprintf(fid,':number-failed-tests: 0\n');
   fprintf(fid,':list-of-passed-tests: run_reporting_test_matlab.m\n');
 end
-fprintf(fid,':cputime: %f\n',0.0);
+fprintf(fid,':elapsed-time: %f\n',0.0);
 fclose(fid);
 exit;
diff --git a/tests/run_reporting_test_octave.m b/tests/run_reporting_test_octave.m
index 43c6067fc..a992b9a46 100644
--- a/tests/run_reporting_test_octave.m
+++ b/tests/run_reporting_test_octave.m
@@ -1,4 +1,4 @@
-## Copyright (C) 2013-2016 Dynare Team
+## Copyright (C) 2013-2017 Dynare Team
 ##
 ## This file is part of Dynare.
 ##
@@ -60,7 +60,7 @@ else
   fprintf(fid,':number-failed-tests: 0\n');
   fprintf(fid,':list-of-passed-tests: run_reporting_test_octave.m\n');
 end
-fprintf(fid,':cputime: %f\n',0.0);
+fprintf(fid,':elapsed-time: %f\n',0.0);
 fclose(fid);
 
 ## Local variables:
diff --git a/tests/run_test_matlab.m b/tests/run_test_matlab.m
index 191087c69..7727032f7 100644
--- a/tests/run_test_matlab.m
+++ b/tests/run_test_matlab.m
@@ -1,4 +1,4 @@
-% Copyright (C) 2011-2012 Dynare Team
+% Copyright (C) 2011-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -32,7 +32,7 @@ cd(directory);
 disp('');
 disp(['***  TESTING: ' modfile ' ***']);
 
-cput = cputime;
+tic;
 save(['wsMat' testfile '.mat']);
 try
   dynare([testfile ext], 'console')
@@ -45,7 +45,7 @@ top_test_dir = getenv('TOP_TEST_DIR');
 [modfile, name] = strtok(getenv('FILESTEM'));
 [directory, testfile, ext] = fileparts([top_test_dir '/' modfile]);
 load(['wsMat' testfile '.mat']);
-ecput = cputime - cput;
+ecput = toc;
 delete(['wsMat' testfile '.mat']);
 
 cd(top_test_dir);
@@ -67,7 +67,7 @@ else
   fprintf(fid,':number-failed-tests: 0\n');
   fprintf(fid,':list-of-passed-tests: %s\n', [name '.mod']);
 end
-fprintf(fid,':cputime: %f\n', ecput);
+fprintf(fid,':elapsed-time: %f\n', ecput);
 fclose(fid);
 warning off
 exit
diff --git a/tests/run_test_octave.m b/tests/run_test_octave.m
index cc834e31c..4a7854dda 100644
--- a/tests/run_test_octave.m
+++ b/tests/run_test_octave.m
@@ -1,4 +1,4 @@
-## Copyright (C) 2009-2016 Dynare Team
+## Copyright (C) 2009-2017 Dynare Team
 ##
 ## This file is part of Dynare.
 ##
@@ -25,7 +25,6 @@ load_octave_packages
 
 top_test_dir = getenv('TOP_TEST_DIR');
 addpath(top_test_dir);
-addpath('.'); % workaround for bug in Octave 4.2.0-rc2: https://savannah.gnu.org/bugs/?49334
 addpath([top_test_dir filesep '..' filesep 'matlab']);
 
 ## Test Dynare Version
@@ -44,7 +43,7 @@ cd(directory);
 
 printf("\n***  TESTING: %s ***\n", name);
 
-cput = cputime;
+tic;
 save(['wsOct' testfile '.mat']);
 try
   dynare([testfile ext])
@@ -57,7 +56,7 @@ top_test_dir = getenv('TOP_TEST_DIR');
 name = getenv("FILESTEM");
 [directory, testfile, ext] = fileparts([top_test_dir '/' name]);
 load(['wsOct' testfile '.mat']);
-ecput = cputime - cput;
+ecput = toc;
 delete(['wsOct' testfile '.mat']);
 
 cd(top_test_dir);
@@ -73,7 +72,7 @@ else
   fprintf(fid,':number-failed-tests: 0\n');
   fprintf(fid,':list-of-passed-tests: %s\n', [name '.mod']);
 end
-fprintf(fid,':cputime: %f\n', ecput);
+fprintf(fid,':elapsed-time: %f\n', ecput);
 fclose(fid);
 
 ## Local variables:
diff --git a/tests/shock_decomposition/ls2003_plot.mod b/tests/shock_decomposition/ls2003_plot.mod
new file mode 100644
index 000000000..7faa00d0c
--- /dev/null
+++ b/tests/shock_decomposition/ls2003_plot.mod
@@ -0,0 +1,135 @@
+var y y_s R pie dq pie_s de A y_obs pie_obs R_obs;
+varexo e_R e_q e_ys e_pies e_A;
+
+parameters psi1 psi2 psi3 rho_R tau alpha rr k rho_q rho_A rho_ys rho_pies;
+
+psi1 = 1.54;
+psi2 = 0.25;
+psi3 = 0.25;
+rho_R = 0.5;
+alpha = 0.3;
+rr = 2.51;
+k = 0.5;
+tau = 0.5;
+rho_q = 0.4;
+rho_A = 0.2;
+rho_ys = 0.9;
+rho_pies = 0.7;
+
+
+model(linear);
+y = y(+1) - (tau +alpha*(2-alpha)*(1-tau))*(R-pie(+1))-alpha*(tau +alpha*(2-alpha)*(1-tau))*dq(+1) + alpha*(2-alpha)*((1-tau)/tau)*(y_s-y_s(+1))-A(+1);
+pie = exp(-rr/400)*pie(+1)+alpha*exp(-rr/400)*dq(+1)-alpha*dq+(k/(tau+alpha*(2-alpha)*(1-tau)))*y+alpha*(2-alpha)*(1-tau)/(tau*(tau+alpha*(2-alpha)*(1-tau)))*y_s;
+pie = de+(1-alpha)*dq+pie_s;
+R = rho_R*R(-1)+(1-rho_R)*(psi1*pie+psi2*(y+alpha*(2-alpha)*((1-tau)/tau)*y_s)+psi3*de)+e_R;
+dq = rho_q*dq(-1)+e_q;
+y_s = rho_ys*y_s(-1)+e_ys;
+pie_s = rho_pies*pie_s(-1)+e_pies;
+A = rho_A*A(-1)+e_A;
+y_obs = y-y(-1)+A;
+pie_obs = 4*pie;
+R_obs = 4*R;
+end;
+
+shocks;
+var e_R = 1.25^2;
+var e_q = 2.5^2;
+var e_A = 1.89;
+var e_ys = 1.89;
+var e_pies = 1.89;
+end;
+
+varobs y_obs R_obs pie_obs dq de;
+
+estimated_params;
+psi1 , gamma_pdf,1.5,0.5;
+psi2 , gamma_pdf,0.25,0.125;
+psi3 , gamma_pdf,0.25,0.125;
+rho_R ,beta_pdf,0.5,0.2;
+alpha ,beta_pdf,0.3,0.1;
+rr ,gamma_pdf,2.5,1;
+k , gamma_pdf,0.5,0.25;
+tau ,gamma_pdf,0.5,0.2;
+rho_q ,beta_pdf,0.4,0.2;
+rho_A ,beta_pdf,0.5,0.2;
+rho_ys ,beta_pdf,0.8,0.1;
+rho_pies,beta_pdf,0.7,0.15;
+stderr e_R,inv_gamma_pdf,1.2533,0.6551;
+stderr e_q,inv_gamma_pdf,2.5066,1.3103;
+stderr e_A,inv_gamma_pdf,1.2533,0.6551;
+stderr e_ys,inv_gamma_pdf,1.2533,0.6551;
+stderr e_pies,inv_gamma_pdf,1.88,0.9827;
+end;
+
+options_.TeX=1;
+estimation(datafile='../ls2003/data_ca1',first_obs=8,nobs=79,mh_nblocks=10,prefilter=1,mh_jscale=0.5,mh_replic=0);
+close all
+
+shock_groups(name=trade);
+supply = e_A ;
+trade = e_q ;
+monetary = e_R ;
+end;
+
+shock_groups(name=row);
+supply = e_A ;
+'RoW shocks' = e_q e_ys e_pies  ;
+monetary = e_R ;
+end;
+options_.initial_date=dates('1989Q4'); % date arbitrarily set for testing purposes
+shock_decomposition(use_shock_groups=trade) y_obs R_obs pie_obs dq de;
+
+// various tests for plot_shock_decompositions
+// standard plot [using trade group defined before]
+plot_shock_decomposition;
+
+// test datailed, custom name and yoy plots
+plot_shock_decomposition(detail_plot, fig_name = MR, type = yoy);
+
+
+close all,
+
+
+// testing realtime decomposition
+// first compute realtime decompositions [pre-processor not yet available]
+realtime_shock_decomposition(forecast=8, save_realtime=[5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65 69 73 77]);
+
+//realtime pooled
+plot_shock_decomposition(realtime = 1);
+
+//conditional pooled
+plot_shock_decomposition(realtime = 2);
+
+// conditional 8-step ahead decomposition, given 1989q4
+plot_shock_decomposition(detail_plot, realtime = 2, vintage = 29);
+
+close all,
+
+//forecast pooled
+plot_shock_decomposition(realtime = 3);
+
+// forecast 8-step ahead decomposition, given 1989q4
+plot_shock_decomposition(detail_plot, realtime = 3, vintage = 29);
+
+close all,
+
+// now I test annualized variables
+options_.plot_shock_decomp.q2a=1;
+options_.plot_shock_decomp.islog=1;
+plot_shock_decomposition(detail_plot, type = aoa) y;
+
+plot_shock_decomposition(realtime = 1) y;
+plot_shock_decomposition(realtime = 1, vintage = 29) y;
+plot_shock_decomposition(realtime = 2, vintage = 29) y;
+plot_shock_decomposition(realtime = 3, vintage = 29) y;
+
+close all
+
+//test uimenu for groups
+plot_shock_decomposition(detail_plot, interactive, use_shock_groups = row, type = qoq);
+plot_shock_decomposition(detail_plot, interactive, realtime = 3, vintage = 29);
+
+collect_latex_files;
+if system(['pdflatex -halt-on-error -interaction=batchmode ' M_.fname '_TeX_binder.tex'])
+    error('TeX-File did not compile.')
+end
diff --git a/tests/stochastic-backward-models/solow_cd_with_steadystate.mod b/tests/stochastic-backward-models/solow_cd_with_steadystate.mod
index 90dfb7400..500cc137c 100644
--- a/tests/stochastic-backward-models/solow_cd_with_steadystate.mod
+++ b/tests/stochastic-backward-models/solow_cd_with_steadystate.mod
@@ -53,15 +53,15 @@ T = 5*floor(log(precision)/log(max(rho_x, rho_n)));
 oo_ = simul_backward_model(M_.endo_histval, T, options_, M_, oo_, zeros(T+1,2));
 
 if abs(oo_.endo_simul(1,end)-LongRunEfficiency)>1e-10
-    error('Wrong long run level!')
+   error('Wrong long run level!')
 end
 
 if abs(oo_.endo_simul(3,end)-LongRunPopulation)>1e-10
-    error('Wrong long run level!')
+   error('Wrong long run level!')
 end
 
 IntensiveCapitalStock = oo_.endo_simul(6,1:end)./(oo_.endo_simul(1,1:end).*oo_.endo_simul(3,1:end));
 
-if abs(IntensiveCapitalStock-LongRunIntensiveCapitalStock)>1e-6
-    error('Wrong long run level!')
+if abs(IntensiveCapitalStock(end)-LongRunIntensiveCapitalStock>1e-10)
+   error('Wrong long run level!')
 end
diff --git a/windows/README.txt b/windows/README.txt
index 02ee18ecf..56d8a6aa4 100644
--- a/windows/README.txt
+++ b/windows/README.txt
@@ -57,7 +57,7 @@ Using Dynare with Octave
 Dynare also works on top of GNU Octave, a free clone of MATLAB (R) (see
 <http://www.octave.org>).
 
-This version of Dynare is compiled for Octave 3.6 (MinGW), and may not work
+This version of Dynare is compiled for Octave 4.2.1 (MinGW, 32bit and 64bit), and may not work
 with other versions of Octave. The recommended version of Octave can be
 downloaded at:
 
diff --git a/windows/dynare.nsi b/windows/dynare.nsi
index c72bc4c0f..60b575149 100644
--- a/windows/dynare.nsi
+++ b/windows/dynare.nsi
@@ -54,7 +54,7 @@ Section "Dynare core (preprocessor and M-files)"
  SectionIn RO
 !insertmacro DETERMINE_CONTEXT
  SetOutPath $INSTDIR
- File README.txt ..\NEWS mexopts-win32.bat mexopts-win64.bat ..\license.txt
+ File README.txt ..\NEWS mexopts-win32.bat mexopts-win64.bat ..\license.txt ..\VERSION
 
  SetOutPath $INSTDIR\matlab
  File /r ..\matlab\*.m
@@ -98,21 +98,30 @@ Section "MEX files for MATLAB 64-bit, version 7.5 to 7.7 (R2007b to R2008b)"
  File ..\mex\matlab\win64-7.5-7.7\*.mexw64
 SectionEnd
 
-Section "MEX files for MATLAB 64-bit, version 7.8 to 9.1 (R2009a to R2016b)"
- SetOutPath $INSTDIR\mex\matlab\win64-7.8-9.1
- File ..\mex\matlab\win64-7.8-9.1\*.mexw64
+Section "MEX files for MATLAB 64-bit, version 7.8 to 9.2 (R2009a to R2017a)"
+ SetOutPath $INSTDIR\mex\matlab\win64-7.8-9.2
+ File ..\mex\matlab\win64-7.8-9.2\*.mexw64
 SectionEnd
 
 SectionGroupEnd
 
-Section "MEX files for Octave 3.6 (MinGW)"
+SectionGroup "MEX files for OCTAVE"
+
+Section "MEX files for Octave 4.2.1 (MinGW, 64bit)"
  SetOutPath $INSTDIR\mex\octave
  File ..\mex\octave\*.mex ..\mex\octave\*.oct
 SectionEnd
 
+Section "MEX files for Octave 4.2.1 (MinGW, 32bit)"
+ SetOutPath $INSTDIR\mex\octave32
+ File ..\mex\octave32\*.mex ..\mex\octave32\*.oct
+SectionEnd
+
+SectionGroupEnd
+
 Section "Dynare++ (standalone executable)"
  SetOutPath $INSTDIR\dynare++
- File ..\dynare++\src\dynare++.exe ..\dynare++\extern\matlab\dynare_simul.m
+ File ..\dynare++\src\dynare++.exe ..\dynare++\extern\matlab\dynare_simul.m ..\dynare++\*.dll
 SectionEnd
 
 Section "Documentation and examples (Dynare and Dynare++)"