Merge branch 'master' into json

.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

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)
 =============================================
 

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```

VERSION.in

@@ -0,0 +1 @@
+@PACKAGE_VERSION@

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

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}
 

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;

dynare++/parser/cc/atom_assignings.h

@@ -12,7 +12,8 @@
 #include <vector>
 #include <map>
 
-namespace ogp {
+namespace ogp
+{
 
   class AtomAsgnEvaluator;
 
@@ -21,14 +22,15 @@ namespace ogp {
    * 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 {
+  class AtomAssignings
+  {
     friend class AtomAsgnEvaluator;
   protected:
-		typedef std::map<const char*, int, ltstr> Tvarintmap;
+    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;
+    StaticAtoms &atoms;
     /** The formulas of right hand sides. */
     FormulaParser expr;
     /** Name storage of the names from left hand sides. */
@@ -43,22 +45,24 @@ namespace ogp {
     std::vector<int> order;
   public:
     /** Construct the object using the provided static atoms. */
-		AtomAssignings(StaticAtoms& a) : atoms(a), expr(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);
+    AtomAssignings(const AtomAssignings &aa, StaticAtoms &a);
     virtual ~AtomAssignings()
-			{}
+    {
+    }
     /** Parse the assignments from the given string. */
-		void parse(int length, const char* stream);
+    void parse(int length, const char *stream);
     /** Process a syntax error from bison. */
-		void error(const char* mes);
+    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);
+    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,
+    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
@@ -66,7 +70,7 @@ namespace ogp {
      * 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);
+    void apply_subst(const AtomSubstitutions::Toldnamemap &mm);
     /** Debug print. */
     void print() const;
   };
@@ -82,27 +86,32 @@ namespace ogp {
   class AtomAsgnEvaluator : public FormulaEvalLoader,
                             public AtomValues,
                             protected FormulaEvaluator,
-							  public std::vector<double> {
+                            public std::vector<double>
+  {
   protected:
     typedef std::map<int, double> Tusrvalmap;
     Tusrvalmap user_values;
-		const AtomAssignings& aa;
+    const AtomAssignings &aa;
   public:
-		AtomAsgnEvaluator(const AtomAssignings& a)
+    AtomAsgnEvaluator(const AtomAssignings &a)
       : FormulaEvaluator(a.expr),
-			  std::vector<double>(a.expr.nformulas()), aa(a) {}
-		virtual ~AtomAsgnEvaluator() {}
+        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;
+    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);
+    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
@@ -113,12 +122,15 @@ namespace ogp {
      * 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);}
+    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;
+    double get_value(const char *name) const;
   };
 
 };

dynare++/parser/cc/atom_substitutions.h

@@ -9,7 +9,8 @@
 
 #include <string>
 
-namespace ogp {
+namespace ogp
+{
 
   using std::string;
   using std::map;
@@ -18,19 +19,23 @@ namespace ogp {
   /** 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 {
+  struct SubstInfo
+  {
     int num_substs;
-		SubstInfo() : num_substs(0) {}
+    SubstInfo() : num_substs(0)
+    {
+    }
   };
 
   /** This class tracks all atom substitutions during the job and
    * then builds structures when all substitutions are finished. */
-	class AtomSubstitutions {
+  class AtomSubstitutions
+  {
   public:
-		typedef pair<const char*, int> Tshiftname;
-		typedef map<const char*, Tshiftname, ltstr> Tshiftmap;
+    typedef pair<const char *, int> Tshiftname;
+    typedef map<const char *, Tshiftname, ltstr> Tshiftmap;
     typedef set<Tshiftname> Tshiftnameset;
-		typedef map<const char*, Tshiftnameset, ltstr> Toldnamemap;
+    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
@@ -47,10 +52,10 @@ namespace ogp {
      * lags. They are supposed to be used with parsing finished
      * being had called, so that the external ordering is
      * available. */
-		const FineAtoms& old_atoms;
+    const FineAtoms &old_atoms;
     /** This is a reference to new atoms. All name pointers point
      * to storage of these atoms. */
-		FineAtoms& new_atoms;
+    FineAtoms &new_atoms;
     /** Substitutions information. */
     SubstInfo info;
   public:
@@ -60,18 +65,22 @@ namespace ogp {
      * 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) {}
+    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() {}
+    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);
+    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. */
@@ -79,51 +88,79 @@ namespace ogp {
     /** 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;
+    const char *get_new4old(const char *oldname, int tshift) const;
     /** Return new2old. */
-		const Tshiftmap& get_new2old() const
-			{return new2old;}
+    const Tshiftmap &
+    get_new2old() const
+    {
+      return new2old;
+    }
     /** Return old2new. */
-		const Toldnamemap& get_old2new() const
-			{return old2new;}
+    const Toldnamemap &
+    get_old2new() const
+    {
+      return old2new;
+    }
     /** Return substitution info. */
-		const SubstInfo& get_info() const
-			{return info;}
+    const SubstInfo &
+    get_info() const
+    {
+      return info;
+    }
     /** Return old atoms. */
-		const FineAtoms& get_old_atoms() const
-			{return old_atoms;}
+    const FineAtoms &
+    get_old_atoms() const
+    {
+      return old_atoms;
+    }
     /** Return new atoms. */
-		const FineAtoms& get_new_atoms() const
-			{return new_atoms;}
+    const FineAtoms &
+    get_new_atoms() const
+    {
+      return new_atoms;
+    }
     /** Debug print. */
     void print() const;
   };
 
-	class SAtoms : public FineAtoms {
+  class SAtoms : public FineAtoms
+  {
   public:
     SAtoms()
-			: FineAtoms() {}
-		SAtoms(const SAtoms& sa)
-			: FineAtoms(sa) {}
-		virtual ~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);
+    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);
+    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);}
+    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);}
+    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
@@ -131,7 +168,7 @@ namespace ogp {
      * 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;
+    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
@@ -142,12 +179,12 @@ namespace ogp {
      * 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);
+    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,
+    const char *findNameWithLeadInInterval(const vector<const char *> &names,
                                            int ll1, int ll2) const;
 
   };

dynare++/parser/cc/csv_parser.h

@@ -5,37 +5,57 @@
 #ifndef OGP_CSV_PARSER
 #define OGP_CSV_PARSER
 
-namespace ogp {
+namespace ogp
+{
 
-	class CSVParserPeer {
+  class CSVParserPeer
+  {
   public:
-		virtual ~CSVParserPeer() {}
-		virtual void item(int irow, int icol, const char* str, int length) = 0;
+    virtual ~CSVParserPeer()
+    {
+    }
+    virtual void item(int irow, int icol, const char *str, int length) = 0;
   };
 
-	class CSVParser {
+  class CSVParser
+  {
   private:
-		CSVParserPeer& peer;
+    CSVParserPeer &peer;
     int row;
     int col;
-		const char* parsed_string;
+    const char *parsed_string;
   public:
-		CSVParser(CSVParserPeer& p)
-			: peer(p), row(0), col(0), parsed_string(0) {}
-		CSVParser(const CSVParser& csvp)
+    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() {}
+        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);
+    }
   };
 };
 

dynare++/parser/cc/dynamic_atoms.h

@@ -13,15 +13,20 @@
 #include <string>
 #include <cstring>
 
-namespace ogp {
+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
@@ -30,56 +35,73 @@ namespace ogp {
    * 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 {
+  class NameStorage
+  {
   protected:
     /** Vector of names allocated, this is the storage. */
-		vector<char*> name_store;
+    vector<char *> name_store;
     /** Map useful to quickly decide if the name is already
      * allocated or not. */
-		set<const char*, ltstr> name_set;
+    set<const char *, ltstr> name_set;
   public:
-		NameStorage() {}
-		NameStorage(const NameStorage& stor);
-		virtual ~NameStorage();
+    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;
+    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];}
+    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 {
+  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;
+    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() {}
+    Constants()
+    {
+    }
     /** Copy constructor. */
-		Constants(const Constants& c)
-			: cmap(c.cmap), cinvmap(c.cinvmap) {}
+    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);}
+    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);
+    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;
+    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. */
@@ -93,14 +115,17 @@ namespace ogp {
     /** 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;
+    int check(const char *str) const;
     /** Debug print. */
     void print() const;
-		const Tconstantmap& get_constantmap() const
-			{return cmap;}
+    const Tconstantmap &
+    get_constantmap() const
+    {
+      return cmap;
+    }
   private:
     /** Inverse map to Tconstantmap. */
-		typedef map<double,int> Tconstantinvmap;
+    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. */
@@ -112,15 +137,16 @@ namespace ogp {
    * 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 {
+  class DynamicAtoms : public Atoms, public Constants
+  {
   public:
     /** Definition of a type mapping lags to the indices of the variables. */
-		typedef map<int,int> Tlagmap;
+    typedef map<int, int> Tlagmap;
   protected:
     /** Definition of a type mapping names of the atoms to Tlagmap. */
-		typedef map<const char*, Tlagmap, ltstr> Tvarmap;
+    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;
+    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. */
@@ -143,8 +169,10 @@ namespace ogp {
   public:
     /** Construct empty DynamicAtoms. */
     DynamicAtoms();
-		DynamicAtoms(const DynamicAtoms& da);
-		virtual ~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
@@ -152,27 +180,30 @@ namespace ogp {
      * 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;
+    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);
+    void assign(const char *name, int t);
     /** Return a number of all variables. */
-		int nvar() const
-			{ return nv; }
+    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;
+    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;
+    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;
+    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
@@ -181,51 +212,60 @@ namespace ogp {
     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;
+    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;
+    bool is_referenced(const char *name) const;
     /** Return the lag map for the variable name. */
-		const Tlagmap& lagmap(const char* name) const;
+    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;
+    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;}
+    int
+    get_maxlead() const
+    {
+      return maxlead;
+    }
     /** Return minimum lag. */
-		int get_minlag() const
-			{return minlag;}
+    int
+    get_minlag() const
+    {
+      return minlag;
+    }
     /** Return the name storage to allow querying to other
      * classes. */
-		const NameStorage& get_name_storage() const
-			{return varnames;}
+    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);
+    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);
+    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;
+    virtual int check_variable(const char *name) const;
     /** Assign the constant. */
-		void assign_constant(const char* name, int t);
+    void assign_constant(const char *name, int t);
     /** Assign the variable. */
-		void assign_variable(const char* name, int t);
+    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
@@ -233,13 +273,12 @@ namespace ogp {
     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;
+    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);
+    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
@@ -261,7 +300,8 @@ namespace ogp {
    * preimplemented method, or plugging your own implementation. The
    * method do_ordering() is called by the user after the constructor.
    */
-	class VarOrdering {
+  class VarOrdering
+  {
   protected:
     /** Number of static variables. */
     int n_stat;
@@ -290,7 +330,7 @@ namespace ogp {
      * 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;
+    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. */
@@ -301,10 +341,10 @@ namespace ogp {
     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;
+    const vector<const char *> &varnames;
     /** This is just a reference to atoms to keep it from
      * constructor to do_ordering() implementations. */
-		const DynamicAtoms& atoms;
+    const DynamicAtoms &atoms;
   public:
     /** This is an enum type for an ordering type implemented by
      * do_general. */
@@ -313,41 +353,65 @@ namespace ogp {
      * 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)
+    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;
+    {
+    }
+    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() {}
+    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;}
+    int
+    nstat() const
+    {
+      return n_stat;
+    }
     /** Return number of predetermined. */
-		int npred() const
-			{return n_pred;}
+    int
+    npred() const
+    {
+      return n_pred;
+    }
     /** Return number of both. */
-		int nboth() const
-			{return n_both;}
+    int
+    nboth() const
+    {
+      return n_both;
+    }
     /** Return number of forward looking. */
-		int nforw() const
-			{return n_forw;}
+    int
+    nforw() const
+    {
+      return n_forw;
+    }
     /** Return the set of tree indices for derivatives. */
-		const vector<int>& get_der_atoms() const
-			{return der_atoms;}
+    const vector<int> &
+    get_der_atoms() const
+    {
+      return der_atoms;
+    }
     /** Return the y2outer. */
-		const vector<int>& get_y2outer() const
-			{return y2outer;}
+    const vector<int> &
+    get_y2outer() const
+    {
+      return y2outer;
+    }
     /** Return the outer2y. */
-		const vector<int>& get_outer2y() const
-			{return 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;
@@ -358,8 +422,11 @@ namespace ogp {
     /** 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;}
+    int
+    length() const
+    {
+      return n_stat+2*n_pred+3*n_both+2*n_forw;
+    }
     /** Debug print. */
     void print() const;
   protected:
@@ -373,16 +440,22 @@ namespace ogp {
      * 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);}
+    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);}
+    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
@@ -394,7 +467,7 @@ namespace ogp {
     void do_increasing_time();
   private:
     /** Declare this copy constructor as private to hide it. */
-		VarOrdering(const VarOrdering& vo);
+    VarOrdering(const VarOrdering &vo);
   };
 
 };

dynare++/parser/cc/fine_atoms.h

@@ -10,7 +10,8 @@
 #include <vector>
 #include <string>
 
-namespace ogp {
+namespace ogp
+{
 
   using std::vector;
   using std::string;
@@ -19,50 +20,83 @@ namespace ogp {
    * 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 {
+  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();}
+    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 {
+  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();}
+    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 {
+  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();}
+    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;
@@ -71,15 +105,16 @@ namespace ogp {
    * and exo). It maps the ordering to the particular outer
    * orderings of endo and exo. It works tightly with the FineAtoms
    * class. */
-	class AllvarOuterOrdering {
+  class AllvarOuterOrdering
+  {
   protected:
     /** Type for a map mapping a variable name to an integer. */
-		typedef map<const char*, int, ltstr> Tvarintmap;
+    typedef map<const char *, int, ltstr> Tvarintmap;
     /** Reference to atoms. */
-		const FineAtoms& 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;
+    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. */
@@ -94,18 +129,27 @@ namespace ogp {
      * 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);
+    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);
+    AllvarOuterOrdering(const AllvarOuterOrdering &allvar_outer, const FineAtoms &a);
     /** Return endo2all mapping. */
-		const vector<int>& get_endo2all() const
-			{return endo2all;}
+    const vector<int> &
+    get_endo2all() const
+    {
+      return endo2all;
+    }
     /** Return exo2all mapping. */
-		const vector<int>& get_exo2all() const
-			{return exo2all;}
+    const vector<int> &
+    get_exo2all() const
+    {
+      return exo2all;
+    }
     /** Return the allvar ordering. */
-		const vector<const char*>& get_allvar() const
-			{return allvar;}
+    const vector<const char *> &
+    get_allvar() const
+    {
+      return allvar;
+    }
   };
 
   /** This class refines the DynamicAtoms by distinguishing among
@@ -127,26 +171,27 @@ namespace ogp {
    * 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 {
+  class FineAtoms : public DynamicAtoms
+  {
     friend class AllvarOuterOrdering;
   protected:
-		typedef map<const char*, int, ltstr> Tvarintmap;
+    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;
+    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;
+    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;
+    vector<const char *> exovars;
     /** A map mapping a name of an exogenous variable to an index
      * in the outer ordering. */
     Tvarintmap exo_outer_map;
@@ -156,14 +201,14 @@ namespace ogp {
      * to endogenous variables. It is constructed by
      * parsing_finished() method, which should be called after all
      * parsing jobs have been finished. */
-		VarOrdering* endo_order;
+    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;
+    VarOrdering *exo_order;
     /** This is the all variables outer ordering. It is
      * constructed by parsing finished. */
-		AllvarOuterOrdering* allvar_order;
+    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
@@ -184,39 +229,59 @@ namespace ogp {
     vector<int> exo_atoms_map;
   public:
     FineAtoms()
-			: endo_order(NULL), exo_order(NULL), allvar_order(NULL) {}
-		FineAtoms(const FineAtoms& fa);
+      : 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;
+      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;
+    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);}
+    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);}
+    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;}
+    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;}
+    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;}
+    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
@@ -228,20 +293,20 @@ namespace ogp {
      * 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);
+    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;
+    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;
+    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;
+    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. */
@@ -269,68 +334,83 @@ namespace ogp {
     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;
+    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;
+    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;
+    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;
+    const vector<int>&outer2y_exo() const;
     /** Return the endo_atoms_map. */
-		const vector<int>& get_endo_atoms_map() const;
+    const vector<int>&get_endo_atoms_map() const;
     /** Return the exo_atoms_map. */
-		const vector<int>& get_exo_atoms_map() const;
+    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;
+    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;
+    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;
+    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;
+    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();}
+    int
+    nys() const
+    {
+      return npred()+nboth();
+    }
     /** Return the number of endogenous variables at time t+1. */
-		int nyss() const
-			{return nboth()+nforw();}
+    int
+    nyss() const
+    {
+      return nboth()+nforw();
+    }
     /** Return the number of endogenous variables. */
-		int ny() const
-			{return endovars.size();}
+    int
+    ny() const
+    {
+      return endovars.size();
+    }
     /** Return the number of exogenous variables. */
-		int nexo() const
-			{return (int)exovars.size();}
+    int
+    nexo() const
+    {
+      return (int) exovars.size();
+    }
     /** Return the number of parameters. */
-		int np() const
-			{return (int)(params.size());}
+    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);
+    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);
+    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);
+    virtual void register_uniq_param(const char *name);
     /** Debug print. */
     void print() const;
   private:

dynare++/parser/cc/formula_parser.h

@@ -5,25 +5,31 @@
 
 #include "tree.h"
 
-namespace ogp {
+namespace ogp
+{
   using std::vector;
 
   /** Pure virtual class defining a minimal interface for
    * representation of nulary terms within FormulaParser. */
-	class Atoms {
+  class Atoms
+  {
   public:
-		Atoms() {}
-		virtual ~Atoms() {}
+    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;
+    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;
+    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;
@@ -39,17 +45,21 @@ namespace ogp {
    * 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 {
+  class AtomValues
+  {
   public:
-		virtual ~AtomValues() {}
-		virtual void setValues(EvalTree& et) const = 0;
+    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;
+  struct ltfmi
+  {
+    bool operator()(const FoldMultiIndex &i1, const FoldMultiIndex &i2) const;
   };
 
   /** This class stores derivatives (tree indices) of one formula
@@ -64,7 +74,8 @@ namespace ogp {
    * iterators of the map do not survive the insertions to the map,
    * and implementation of the constructor has to be very difficult.
    */
-	class FormulaDerivatives {
+  class FormulaDerivatives
+  {
     friend class FormulaDerEvaluator;
   protected:
     /** Vector of derivatives. This is a list of derivatives (tree
@@ -97,17 +108,22 @@ namespace ogp {
      * 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);
+    FormulaDerivatives(OperationTree &otree, const vector<int> &vars, int f, int max_order);
     /** Copy constructor. */
-		FormulaDerivatives(const FormulaDerivatives& fd);
-		virtual ~FormulaDerivatives(){}
+    FormulaDerivatives(const FormulaDerivatives &fd);
+    virtual ~FormulaDerivatives()
+    {
+    }
     /** Random access to the derivatives via multiindex. */
-		int derivative(const FoldMultiIndex& mi) const;
+    int derivative(const FoldMultiIndex &mi) const;
     /** Return the order. */
-		int get_order() const
-			{return order;}
+    int
+    get_order() const
+    {
+      return order;
+    }
     /** Debug print. */
-		void print(const OperationTree& otree) const;
+    void print(const OperationTree &otree) const;
   };
 
   class FormulaEvaluator;
@@ -122,7 +138,8 @@ namespace ogp {
    * be used in constructors of FormulaEvaluator and
    * FormulaDerEvaluator in order to evaluate formulas (zero
    * derivatives) and higher derivatives resp. */
-	class FormulaParser {
+  class FormulaParser
+  {
     friend class FormulaCustomEvaluator;
     friend class FormulaDerEvaluator;
   protected:
@@ -130,20 +147,23 @@ namespace ogp {
     OperationTree otree;
     /** Reference to Atoms. The Atoms are filled with nulary terms
      * during execution of parse(). */
-		Atoms& atoms;
+    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;
+    vector<FormulaDerivatives *> ders;
   public:
     /** Construct an empty formula parser. */
-		FormulaParser(Atoms& a)
-			: atoms(a) {}
+    FormulaParser(Atoms &a)
+      : atoms(a)
+    {
+    }
     /** Copy constructor using a different instance of Atoms. */
-		FormulaParser(const FormulaParser& fp, Atoms& a);
-		virtual ~FormulaParser();
+    FormulaParser(const FormulaParser &fp, Atoms &a);
+    virtual
+    ~FormulaParser();
 
     /** Requires an addition of the formula; called from the
      * parser. */
@@ -158,48 +178,63 @@ namespace ogp {
      * 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);
+    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);}
+    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);}
+    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);}
+    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);
+    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);
+    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);}
+    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);}
+    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);
+    void parse(int length, const char *stream);
     /** Processes a syntax error from bison. */
-		void error(const char* mes) const;
+    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,
@@ -207,7 +242,7 @@ namespace ogp {
      * different order). */
     void differentiate(int max_order);
     /** Return i-th formula derivatives. */
-		const FormulaDerivatives& derivatives(int i) const;
+    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
@@ -216,9 +251,11 @@ namespace ogp {
     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];}
-
+    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
@@ -228,26 +265,41 @@ namespace ogp {
     int pop_last_formula();
 
     /** This returns a number of formulas. */
-		int nformulas() const
-			{return (int)(formulas.size());}
+    int
+    nformulas() const
+    {
+      return (int) (formulas.size());
+    }
 
     /** This returns a reference to atoms. */
-		const Atoms& getAtoms() const
-			{return atoms;}
-		Atoms& getAtoms()
-			{return 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;}
+    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);
+    FormulaParser(const FormulaParser &fp);
     /** Destroy all derivatives. */
     void destroy_derivatives();
   };
@@ -256,9 +308,12 @@ namespace ogp {
    * 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 {
+  class FormulaEvalLoader
+  {
   public:
-		virtual ~FormulaEvalLoader() {}
+    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
@@ -272,7 +327,8 @@ namespace ogp {
    * 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 {
+  class FormulaCustomEvaluator
+  {
   protected:
     /** The evaluation tree. */
     EvalTree etree;
@@ -280,56 +336,66 @@ namespace ogp {
     vector<int> terms;
   public:
     /** Construct from FormulaParser and given list of terms. */
-		FormulaCustomEvaluator(const FormulaParser& fp, const vector<int>& ts)
+    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)
+    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);
+    void eval(const AtomValues &av, FormulaEvalLoader &loader);
   protected:
-		FormulaCustomEvaluator(const FormulaParser& fp)
+    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 {
+  class FormulaEvaluator : public FormulaCustomEvaluator
+  {
   public:
     /** Construct from FormulaParser. */
-		FormulaEvaluator(const FormulaParser& fp)
-			: FormulaCustomEvaluator(fp) {}
+    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 {
+  class FormulaDerEvalLoader
+  {
   public:
-		virtual ~FormulaDerEvalLoader() {}
+    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;
+    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 {
+  class FoldMultiIndex
+  {
     /** Number of variables. */
     int nvar;
     /** Dimension. */
     int ord;
     /** The multiindex. */
-		int* data;
+    int *data;
   public:
     /** Initializes to the zero derivative. Order is 0, data is
      * empty. */
@@ -338,73 +404,91 @@ namespace ogp {
     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);
+    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);
+    FoldMultiIndex(const FoldMultiIndex &fmi, int new_orders);
     /** Copy constructor. */
-		FoldMultiIndex(const FoldMultiIndex& fmi);
+    FoldMultiIndex(const FoldMultiIndex &fmi);
     /** Desctructor. */
     virtual ~FoldMultiIndex()
-			{delete [] data;}
+    {
+      delete [] data;
+    }
     /** Assignment operator. */
-		const FoldMultiIndex& operator=(const FoldMultiIndex& fmi);
+    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;
+    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];}
+    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;}
+    int
+    order() const
+    {
+      return ord;
+    }
     /** Return the number of variables. */
-		int nv() const
-			{return nvar;}
+    int
+    nv() const
+    {
+      return nvar;
+    }
     /** Return the data. */
-		const int* ind() const
-			{return 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);}
+    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);
+    static int offset_recurse(int *data, int len, int nv);
   };
 
   /** This class evaluates derivatives of the FormulaParser. */
-	class FormulaDerEvaluator {
+  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;
+    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);
+    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);
+    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,
+    void eval(const vector<int> &mp, const AtomValues &av, FormulaDerEvalLoader &loader,
               int order);
   };
 };

dynare++/parser/cc/location.h

@@ -15,16 +15,19 @@
 // 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 {
+  struct location_type
+  {
     int off; // offset of the token
     int ll; // length ot the token
-		location_type() : off(0), ll(0) {}
+    location_type() : off(0), ll(0)
+    {
+    }
   };
 
 };
@@ -35,9 +38,9 @@ namespace ogp {
 #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;}
+    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
 

dynare++/parser/cc/matrix_parser.h

@@ -8,7 +8,8 @@
 #include <cstdlib> // For NULL
 #include <vector>
 
-namespace ogp {
+namespace ogp
+{
   using std::vector;
 
   /** This class reads the given string and parses it as a
@@ -21,7 +22,8 @@ namespace ogp {
    * read items, the iterator provides information on row number and
    * column number of the item. */
   class MPIterator;
-	class MatrixParser {
+  class MatrixParser
+  {
     friend class MPIterator;
   protected:
     /** Raw data as they were read. */
@@ -32,18 +34,30 @@ namespace ogp {
     int nc;
   public:
     MatrixParser()
-			: nc(0) {}
-		MatrixParser(const MatrixParser& mp)
-			: data(mp.data), row_lengths(mp.row_lengths), nc(mp.nc) {}
-		virtual ~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();}
+    int
+    nrows() const
+    {
+      return (int) row_lengths.size();
+    }
     /** Return a maximum number of items in the rows. */
-		int ncols() const
-			{return nc;}
+    int
+    ncols() const
+    {
+      return nc;
+    }
     /** Parses a given data. This initializes the object data. */
-		void parse(int length, const char* stream);
+    void parse(int length, const char *stream);
     /** Adds newly read item. This should be called from bison
      * parser. */
     void add_item(double v);
@@ -51,7 +65,7 @@ namespace ogp {
      * parser. */
     void start_row();
     /** Process a parse error from the parser. */
-		void error(const char* mes) const;
+    void error(const char *mes) const;
     /** Return begin iterator. */
     MPIterator begin() const;
     /** Return end iterator. */
@@ -66,11 +80,12 @@ namespace ogp {
 
   /** This is an iterator intended to iterate through a matrix parsed
    * by MatrixParser. The iterator provides only read-only access. */
-	class MPIterator {
+  class MPIterator
+  {
     friend class MatrixParser;
   protected:
     /** Reference to the matrix parser. */
-		const MatrixParser* p;
+    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. */
@@ -79,39 +94,57 @@ namespace ogp {
     int r;
 
   public:
-		MPIterator() : p(NULL), i(0), c(0), r(0) {}
+    MPIterator() : p(NULL), i(0), c(0), r(0)
+    {
+    }
     /** Constructs an iterator pointing to the beginning of the
      * parsed matrix. */
-		MPIterator(const MatrixParser& mp);
+    MPIterator(const MatrixParser &mp);
     /** Constructs an iterator pointing to the past-the-end of the
      * parsed matrix. */
-		MPIterator(const MatrixParser& mp, const char* dummy);
+    MPIterator(const MatrixParser &mp, const char *dummy);
     /** Return read-only reference to the pointed item. */
-		const double& operator*() const
-			{return p->data[i];}
+    const double &
+    operator*() const
+    {
+      return p->data[i];
+    }
     /** Return a row index of the pointed item. */
-		int row() const
-			{return r;}
+    int
+    row() const
+    {
+      return r;
+    }
     /** Return a column index of the pointed item. */
-		int col() const
-			{return c;}
+    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;}
+    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;}
+    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);} 
+    bool
+    operator!=(const MPIterator &it) const
+    {
+      return !(it == *this);
+    }
     /** Increment operator. */
-		MPIterator& operator++();
+    MPIterator &operator++();
   };
 };
 
-
-
 #endif
 
 // Local Variables:

dynare++/parser/cc/namelist.h

@@ -5,7 +5,8 @@
 #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
@@ -16,12 +17,15 @@ namespace ogp {
    * NameListParser::namelist_parse(int lengt, const char*
    * text). When implementing error(), one may consult global
    * location_type namelist_lloc. */
-	class NameListParser {
+  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);
+    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);
   };
 };
 

dynare++/parser/cc/parser_exception.h

@@ -7,7 +7,8 @@
 
 #include <string>
 
-namespace ogp {
+namespace ogp
+{
   using std::string;
 
   /** This is an easy exception, which, besides the message, stores
@@ -17,50 +18,76 @@ namespace ogp {
    * 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 {
+  class ParserException
+  {
   protected:
-		char* mes;
+    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);
+    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);
+    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);
+    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;}
+    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);
+    void copy(const ParserException &e);
   };
 };
 

dynare++/parser/cc/static_atoms.h

@@ -7,16 +7,18 @@
 
 #include "dynamic_atoms.h"
 
-namespace ogp {
+namespace ogp
+{
 
-	class StaticAtoms : public Atoms, public Constants {
+  class StaticAtoms : public Atoms, public Constants
+  {
   protected:
-		typedef map<const char*, int, ltstr> Tvarmap;
-		typedef map<int, const char*> Tinvmap;
+    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;
+    vector<const char *> varorder;
     /** This is the map mapping a variable name to the tree
      * index. */
     Tvarmap vars;
@@ -25,60 +27,74 @@ namespace ogp {
     Tinvmap indices;
   public:
     StaticAtoms() : Atoms(), Constants(), varnames(), varorder(), vars()
-			{}
+    {
+    }
     /* Copy constructor. */
-		StaticAtoms(const StaticAtoms& a);
+    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)
+    StaticAtoms(const DynamicAtoms &da, OperationTree &otree, Tintintmap &tmap)
       : Atoms(), Constants(), varnames(), varorder(), vars()
-			{import_atoms(da, otree, tmap);}
+    {
+      import_atoms(da, otree, tmap);
+    }
     /* Destructor. */
-		virtual ~StaticAtoms() {}
+    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);
+    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;
+    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();}
+    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;
+    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;
+    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];}
+    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);
+    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;}
+    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;
+    virtual int check_variable(const char *name) const = 0;
   };
 };
 

dynare++/parser/cc/static_fine_atoms.h

@@ -8,7 +8,8 @@
 #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
@@ -18,26 +19,27 @@ namespace ogp {
    * 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 {
+  class StaticFineAtoms : public StaticAtoms
+  {
   public:
-		typedef map<int,int> Tintintmap;
+    typedef map<int, int> Tintintmap;
   protected:
-		typedef map<const char*, int, ltstr> Tvarintmap;
+    typedef map<const char *, int, ltstr> Tvarintmap;
   private:
     /** The vector of parameter names, gives the parameter
      * ordering. */
-		vector<const char*> params;
+    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;
+    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;
+    vector<const char *> exovars;
     /** A map mapping a name of an exogenous variable to an index
      * in the outer ordering. */
     Tvarintmap exo_outer_map;
@@ -59,113 +61,148 @@ namespace ogp {
      * atoms of exogenous variables. */
     vector<int> exo_atoms_map;
   public:
-		StaticFineAtoms() {}
+    StaticFineAtoms()
+    {
+    }
     /** Copy constructor making a new storage for atom names. */
-		StaticFineAtoms(const StaticFineAtoms& sfa);
+    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);}
+    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() {}
+    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);
+    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);
+    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;
+    int check_variable(const char *name) const;
     /** Return an (external) ordering of parameters. */
-		const vector<const char*>& get_params() const
-			{return params;}
+    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;}
+    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;}
+    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;}
+    vector<int>
+    variables() const
+    {
+      return der_atoms;
+    }
     /** Return the endo_atoms_map. */
-		const vector<int>& get_endo_atoms_map() const
-			{return 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;}
+    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;
+    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;
+    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;
+    int name2outer_exo(const char *name) const;
     /** Return the number of endogenous variables. */
-		int ny() const
-			{return endovars.size();}
+    int
+    ny() const
+    {
+      return endovars.size();
+    }
     /** Return the number of exogenous variables. */
-		int nexo() const
-			{return (int)exovars.size();}
+    int
+    nexo() const
+    {
+      return (int) exovars.size();
+    }
     /** Return the number of parameters. */
-		int np() const
-			{return (int)(params.size());}
+    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);
+    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);
+    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);
+    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);
+    void register_endo(const char *name);
     /** Add exogenous variable name, which is already in the name
      * storage. */
-		void register_exo(const char* name);
+    void register_exo(const char *name);
     /** Add parameter name, which is already in the name
      * storage. */
-		void register_param(const char* name);
+    void register_param(const char *name);
   };
 
 };

dynare++/parser/cc/tree.h

@@ -10,7 +10,8 @@
 #include <boost/unordered_set.hpp>
 #include <cstdio>
 
-namespace ogp {
+namespace ogp
+{
 
   using boost::unordered_set;
   using boost::unordered_map;
@@ -27,7 +28,8 @@ namespace ogp {
                ERFC, PLUS, MINUS, TIMES, DIVIDE, POWER};
 
   /** Class representing a nulary, unary, or binary operation. */
-	class Operation {
+  class Operation
+  {
   protected:
     /** Code of the operation. */
     code_t code;
@@ -39,19 +41,28 @@ namespace ogp {
   public:
     /** Constructs a binary operation. */
     Operation(code_t cd, int oper1, int oper2)
-			: code(cd), op1(oper1), op2(oper2) {}
+      : code(cd), op1(oper1), op2(oper2)
+    {
+    }
     /** Constructs a unary operation. */
     Operation(code_t cd, int oper1)
-			: code(cd), op1(oper1), op2(-1) {}
+      : code(cd), op1(oper1), op2(-1)
+    {
+    }
     /** Constructs a nulary operation. */
     Operation()
-			: code(NONE), op1(-1), op2(-1) {}
+      : code(NONE), op1(-1), op2(-1)
+    {
+    }
     /** A copy constructor. */
-		Operation(const Operation& op)
-			: code(op.code), op1(op.op1), op2(op.op2) {}
+    Operation(const Operation &op)
+      : code(op.code), op1(op.op1), op2(op.op2)
+    {
+    }
 
     /** Operator =. */
-		const Operation& operator=(const Operation& op)
+    const Operation &
+    operator=(const Operation &op)
     {
       code = op.code;
       op1 = op.op1;
@@ -59,55 +70,79 @@ namespace ogp {
       return *this;
     }
     /** Operator ==. */
-		bool operator==(const Operation& op) const
+    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
+    bool
+    operator<(const Operation &op) const
     {
-				return (code < op.code ||
-						code == op.code &&
-						(op1 < op.op1 || op1 == op.op1 && op2 < op.op2));
+      return (code < op.code
+              || code == op.code
+              && (op1 < op.op1 || op1 == op.op1 && op2 < op.op2));
     }
     /** Returns a number of operands. */
-		int nary() const
+    int
+    nary() const
     {
-				return (op2 == -1)? ((op1 == -1) ? 0 : 1) : 2;
+      return (op2 == -1) ? ((op1 == -1) ? 0 : 1) : 2;
     }
     /** Returns a hash value of the operation. */
-		size_t hashval() const
+    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;}
+  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(); }
+  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 {
+  struct opselector
+  {
     virtual bool operator()(int t) const = 0;
-		virtual ~opselector() {}
+    virtual ~opselector()
+    {
+    }
   };
 
   /** Forward declaration of OperationFormatter. */
@@ -143,7 +178,8 @@ namespace ogp {
    * differentiate wrt more and more variables, these maps will
    * become richer and richer.
    */
-	class OperationTree {
+  class OperationTree
+  {
     friend class EvalTree;
     friend class DefaultOperationFormatter;
   protected:
@@ -185,18 +221,19 @@ namespace ogp {
      * 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};
+    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();
 
     /** Copy constructor. */
-		OperationTree(const OperationTree& ot)
+    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.
@@ -236,13 +273,13 @@ namespace ogp {
      * 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);
+    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);
+    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
@@ -256,8 +293,11 @@ namespace ogp {
     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];}
+    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
@@ -265,7 +305,7 @@ namespace ogp {
      * 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;
+    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
@@ -273,7 +313,7 @@ namespace ogp {
      * 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;
+    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
@@ -285,23 +325,32 @@ namespace ogp {
     void forget_derivative_maps();
 
     /** This returns an operation of a given term. */
-		const Operation& operation(int t) const
-			{return terms[t];}
+    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;
+    void print_operation_tree(int t, FILE *fd, OperationFormatter &f) 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;}
+    int
+    get_last_nulary() const
+    {
+      return last_nulary;
+    }
 
     /** Get the number of all operations. */
-		int get_num_op() const
-			{return (int)(terms.size());}
+    int
+    get_num_op() const
+    {
+      return (int) (terms.size());
+    }
   private:
     /** This registers a calculated derivative of the term in the
      * #derivatives vector.
@@ -314,12 +363,12 @@ namespace ogp {
     /** 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; 
+    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; 
+    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
@@ -345,15 +394,16 @@ namespace ogp {
    * subclasses of OperationTree and EvalTree, since we need a
    * support for this in OperationTree.
    */
-	class EvalTree {
+  class EvalTree
+  {
   protected:
     /** Reference to the OperationTree over which all evaluations
      * are done. */
-		const OperationTree& otree;
+    const OperationTree &otree;
     /** The array of values. */
-		double* const values;
+    double *const values;
     /** The array of evaluation flags. */
-		bool* const 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;
@@ -362,9 +412,11 @@ namespace ogp {
      * 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);
+    EvalTree(const OperationTree &otree, int last = -1);
     virtual ~EvalTree()
-			{ delete [] values; delete [] flags; }
+    {
+      delete [] values; delete [] flags;
+    }
     /** Set evaluation flag to all terms (besides the first
      * special terms) to false. */
     void reset_all();
@@ -375,18 +427,24 @@ namespace ogp {
     /** Debug print. */
     void print() const;
     /* Return the operation tree. */
-		const OperationTree& getOperationTree() const
-			{return otree;}
+    const OperationTree &
+    getOperationTree() const
+    {
+      return otree;
+    }
   private:
-		EvalTree(const EvalTree&);
+    EvalTree(const EvalTree &);
   };
 
   /** This is an interface describing how a given operation is
    * formatted for output. */
-	class OperationFormatter {
+  class OperationFormatter
+  {
   public:
     /** Empty virtual destructor. */
-		virtual ~OperationFormatter() {}
+    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
@@ -395,7 +453,7 @@ namespace ogp {
      * 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;
+    virtual void format(const Operation &op, int t, FILE *fd) = 0;
   };
 
   /** The default formatter formats the formulas with a usual syntax
@@ -403,48 +461,59 @@ namespace ogp {
    * 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 {
+  class DefaultOperationFormatter : public OperationFormatter
+  {
   protected:
-		const OperationTree& otree;
+    const OperationTree &otree;
     set<int> stop_set;
   public:
-		DefaultOperationFormatter(const OperationTree& ot)
-			: otree(ot) {}
+    DefaultOperationFormatter(const OperationTree &ot)
+      : otree(ot)
+    {
+    }
     /** Format the operation with the default syntax. */
-		void format(const Operation& op, int t, FILE* fd);
+    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;
+    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;
+    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;
+    virtual void print_delim(FILE *fd) const;
   };
 
-	class NularyStringConvertor {
+  class NularyStringConvertor
+  {
   public:
-		virtual ~NularyStringConvertor() {}
+    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 {
+  class OperationStringConvertor
+  {
   protected:
-		const NularyStringConvertor& nulsc;
-		const OperationTree& otree;
+    const NularyStringConvertor &nulsc;
+    const OperationTree &otree;
   public:
-		OperationStringConvertor(const NularyStringConvertor& nsc, const OperationTree& ot)
-			: nulsc(nsc), otree(ot) {}
+    OperationStringConvertor(const NularyStringConvertor &nsc, const OperationTree &ot)
+      : nulsc(nsc), otree(ot)
+    {
+    }
     /** Empty virtual destructor. */
-		virtual ~OperationStringConvertor() {}
+    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;
+    std::string convert(const Operation &op, int t) const;
   };
 };
 

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];}
+  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;
+  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 {
+class Dynare : public DynamicModel
+{
   friend class DynareNameList;
   friend class DynareExogNameList;
   friend class DynareStateNameList;
   friend class DynareJacobian;
-	Journal& journal;
-	ogdyn::DynareModel* model;
-	Vector* ysteady;
+  Journal &journal;
+  ogdyn::DynareModel *model;
+  Vector *ysteady;
   TensorContainer<FSSparseTensor> md;
-	DynareNameList* dnl;
-	DynareExogNameList* denl;
-	DynareStateNameList* dsnl;
-	ogp::FormulaEvaluator* fe;
-	ogp::FormulaDerEvaluator* fde;
+  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);
+  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);
+  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();}
+  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 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,
+  DynareDerEvalLoader(const ogp::FineAtoms &a, TensorContainer<FSSparseTensor> &mod_ders,
                       int order);
-	void load(int i, int iord, const int* vars, double res);
+  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

dynare++/src/dynare_atoms.h

@@ -15,7 +15,8 @@
 #include <map>
 #include <vector>
 
-namespace ogdyn {
+namespace ogdyn
+{
 
   using std::map;
   using std::vector;
@@ -23,66 +24,77 @@ namespace ogdyn {
   /** 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;
+  typedef map<const char *, int, ogp::ltstr> Tsubstmap;
 
-	class DynareStaticAtoms : public ogp::StaticAtoms {
+  class DynareStaticAtoms : public ogp::StaticAtoms
+  {
   public:
     DynareStaticAtoms()
-			: StaticAtoms() {}
-		DynareStaticAtoms(const DynareStaticAtoms& a)
-			: StaticAtoms(a) {}
-		virtual ~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);
+    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;
+    int check_variable(const char *name) const;
   };
 
-
-	class DynareDynamicAtoms : public ogp::SAtoms, public ogp::NularyStringConvertor {
+  class DynareDynamicAtoms : public ogp::SAtoms, public ogp::NularyStringConvertor
+  {
   public:
     enum atype {endovar, exovar, param};
   protected:
-		typedef map<const char*, atype, ogp::ltstr> Tatypemap;
+    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() {}
+      : 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;
+    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);
+    void register_uniq_endo(const char *name);
     /** Registers unique name of exogenous variable. */
-		void register_uniq_exo(const char* name);
+    void register_uniq_exo(const char *name);
     /** Registers unique name of parameter. */
-		void register_uniq_param(const char* name);
+    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;
+    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 {
+  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;
+    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
@@ -97,20 +109,25 @@ namespace ogdyn {
     /** 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;
+    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 {
+  class DynareSteadyAtomValues : public ogp::AtomValues
+  {
   protected:
     /** Subvector of yy. */
     const ConstVector yym;
@@ -121,24 +138,30 @@ namespace ogdyn {
     /** Atom values using this yym, yyp and xx. */
     DynareAtomValues av;
   public:
-		DynareSteadyAtomValues(const ogp::FineAtoms& a, const Vector& pvals, const Vector& y)
+    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);}
+    {
+      xx.zeros();
+    }
+    void
+    setValues(ogp::EvalTree &et) const
+    {
+      av.setValues(et);
+    }
   };
 
-	class DynareStaticSteadyAtomValues : public ogp::AtomValues {
+  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;
+    const ogp::StaticFineAtoms &atoms_static;
     /** Reference to dynamic atoms for which the class gets input
      * data. */
-		const ogp::FineAtoms& atoms;
+    const ogp::FineAtoms &atoms;
     /** De facto reference to input data, this is a vector of
      * endogenous variables in internal ordering of the dynamic
      * atoms. */
@@ -148,14 +171,16 @@ namespace ogdyn {
     ConstVector paramvals;
   public:
     /** Construct the object. */
-		DynareStaticSteadyAtomValues(const ogp::FineAtoms& a, const ogp::StaticFineAtoms& sa,
-									 const Vector& pvals, const Vector& yyy)
+    DynareStaticSteadyAtomValues(const ogp::FineAtoms &a, const ogp::StaticFineAtoms &sa,
+                                 const Vector &pvals, const Vector &yyy)
       : atoms_static(sa),
         atoms(a),
         yy(yyy),
-			  paramvals(pvals) {}
+        paramvals(pvals)
+    {
+    }
     /** Set the values to the tree defined over the static atoms. */
-		void setValues(ogp::EvalTree& et) const;
+    void setValues(ogp::EvalTree &et) const;
   };
 
   /** This class takes a vector of endogenous variables and a
@@ -166,17 +191,18 @@ namespace ogdyn {
    * 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 {
+  class DynareSteadySubstitutions : public ogp::FormulaEvalLoader
+  {
   protected:
-		const ogp::FineAtoms& atoms;
+    const ogp::FineAtoms &atoms;
   public:
-		DynareSteadySubstitutions(const ogp::FineAtoms& a, const ogp::OperationTree& tree,
-								  const Tsubstmap& subst,
-								  const Vector& pvals, Vector& yy);
+    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 &y;
+    vector<const char *> left_hand_sides;
     vector<int> right_hand_sides;
   };
 
@@ -185,26 +211,26 @@ namespace ogdyn {
    * 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 {
+  class DynareStaticSteadySubstitutions : public ogp::FormulaEvalLoader
+  {
   protected:
-		const ogp::FineAtoms& atoms;
-		const ogp::StaticFineAtoms& atoms_static;
+    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);
+    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 &y;
+    vector<const char *> left_hand_sides;
     vector<int> right_hand_sides;
   };
 
 };
 
-
 #endif
 
 // Local Variables:

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)
+  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)
+  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)
+  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)
+  DynareException(const DynareException &e)
     : mes(new char[strlen(e.mes)+1])
-		{strcpy(mes, e.mes);}
+  {
+    strcpy(mes, e.mes);
+  }
   virtual ~DynareException()
-		{delete [] mes;}
-	const char* message() const
-		{return mes;}
+  {
+    delete [] mes;
+  }
+  const char *
+  message() const
+  {
+    return mes;
+  }
 };
 
 #endif

dynare++/src/dynare_model.h

@@ -15,7 +15,8 @@
 #include <map>
 #include <boost/unordered_set.hpp>
 
-namespace ogdyn {
+namespace ogdyn
+{
   using boost::unordered_set;
   using std::map;
 
@@ -23,33 +24,44 @@ namespace ogdyn {
    * 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 {
+  struct PosInterval
+  {
     int fl;
     int fc;
     int ll;
     int lc;
-		PosInterval() {}
+    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;}
+      : 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;
+    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);}
+    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 {
+  class ParsedMatrix : public TwoDMatrix
+  {
   public:
     /** Construct the object from the parsed data of ogp::MatrixParser. */
-		ParsedMatrix(const ogp::MatrixParser& mp);
+    ParsedMatrix(const ogp::MatrixParser &mp);
   };
 
-
   class PlannerBuilder;
   class PlannerInfo;
   class ForwSubstBuilder;
@@ -59,7 +71,8 @@ namespace ogdyn {
 
   /** A subclass is responsible for creating param_vals, init_vals,
    * and vcov_mat. */
-	class DynareModel {
+  class DynareModel
+  {
     friend class PlannerBuilder;
     friend class ForwSubstBuilder;
     friend class MultInitSS;
@@ -74,12 +87,12 @@ namespace ogdyn {
     /** 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;
+    Vector *param_vals;
     /** A vector of initial values created by a subclass. It is
      * stored with internal ordering given by atoms. */
-		Vector* init_vals;
+    Vector *init_vals;
     /** A matrix for vcov. It is created by a subclass. */
-		TwoDMatrix* vcov_mat;
+    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;
@@ -88,55 +101,83 @@ namespace ogdyn {
     int t_pldiscount;
     /** Pointer to PlannerBuilder, which is created only if the
      * planner's FOC are added to the model. */
-		PlannerBuilder* pbuilder;
+    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;
+    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;
+    ogp::AtomSubstitutions *atom_substs;
     /** Pointer to a copy of original atoms before substitutions
      * took place. */
-		ogp::SAtoms* old_atoms;
+    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;}
+    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;}
+    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;}
+    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;}
+    const TwoDMatrix &
+    getVcov() const
+    {
+      return *vcov_mat;
+    }
+    TwoDMatrix &
+    getVcov()
+    {
+      return *vcov_mat;
+    }
     /** Return planner info. */
-		const PlannerInfo* get_planner_info() const;
+    const PlannerInfo *get_planner_info() const;
     /** Return forward substitutions info. */
-		const ForwSubstInfo* get_forw_subst_info() const;
+    const ForwSubstInfo *get_forw_subst_info() const;
     /** Return substitutions info. */
-		const ogp::SubstInfo* get_subst_info() const;
+    const ogp::SubstInfo *get_subst_info() const;
     /** This sets initial values given in outer ordering. */
-		void setInitOuter(const Vector& x);
+    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;
@@ -145,13 +186,13 @@ namespace ogdyn {
     /** 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;
+    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);
+    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
@@ -170,13 +211,13 @@ namespace ogdyn {
      * 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);
+    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;
+    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. */
@@ -186,7 +227,7 @@ namespace ogdyn {
      * 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);
+    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
@@ -199,7 +240,8 @@ namespace ogdyn {
    * parses variable declarations, model equations, parameter
    * assignments, initval assignments, vcov matrix and order of
    * approximation. */
-	class DynareParser : public DynareModel {
+  class DynareParser : public DynareModel
+  {
   protected:
     /** Static atoms for parameter assignments. */
     DynareStaticAtoms pa_atoms;
@@ -216,51 +258,76 @@ namespace ogdyn {
      * 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);}
+    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);
+    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;}
+    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;}
+    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;}
+    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;}
+    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;}
+    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;}
+    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;}		
+    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);
+    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);
+    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. */
@@ -289,28 +356,39 @@ namespace ogdyn {
    * 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 {
+  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);}
+    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 {
+  class NLSelector : public ogp::opselector
+  {
   private:
-		const DynareModel& model;
+    const DynareModel &model;
   public:
-		NLSelector(const DynareModel& m) : model(m) {}
+    NLSelector(const DynareModel &m) : model(m)
+    {
+    }
     bool operator()(int t) const;
   };
 
@@ -318,73 +396,81 @@ namespace ogdyn {
    * 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 {
+  class ModelSSWriter : public ogp::DefaultOperationFormatter
+  {
   protected:
-		const DynareModel& model;
+    const DynareModel &model;
   public:
-		ModelSSWriter(const DynareModel& m)
+    ModelSSWriter(const DynareModel &m)
       : DefaultOperationFormatter(m.eqs.getTree()),
-			  model(m) {}
+        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);
+    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);
+    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;
+    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 {
+  class MatlabSSWriter : public ModelSSWriter
+  {
   protected:
     /** Identifier used in function names. */
-		char* id;
+    char *id;
   public:
-		MatlabSSWriter(const DynareModel& dm, const char* idd);
+    MatlabSSWriter(const DynareModel &dm, const char *idd);
     virtual ~MatlabSSWriter()
-			{delete [] id;}
+    {
+      delete [] id;
+    }
   protected:
     // from ModelSSWriter
-		void write_der0_preamble(FILE* fd) const;
-		void write_der1_preamble(FILE* fd) const;
+    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;
+    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;
+    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;
+    void format_nulary(int t, FILE *fd) const;
   private:
-		void write_common1_preamble(FILE* fd) const;
-		void write_common2_preamble(FILE* fd) const;
+    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 {
+  class DebugOperationFormatter : public ogp::DefaultOperationFormatter
+  {
   protected:
-		const DynareModel& model;
+    const DynareModel &model;
   public:
-		DebugOperationFormatter(const DynareModel& m)
+    DebugOperationFormatter(const DynareModel &m)
       : DefaultOperationFormatter(m.getParser().getTree()),
-			  model(m) {}
-		void format_nulary(int t, FILE* fd) const;
+        model(m)
+    {
+    }
+    void format_nulary(int t, FILE *fd) const;
   };
 };
 

dynare++/src/dynare_params.h

@@ -3,18 +3,19 @@
 // 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;
+struct DynareParams
+{
+  const char *modname;
   std::string basename;
   int num_per;
   int num_burn;
@@ -25,7 +26,7 @@ struct DynareParams {
   int num_condsim;
   int num_threads;
   int num_steps;
-	const char* prefix;
+  const char *prefix;
   int seed;
   int order;
   /** Tolerance used for steady state calcs. */
@@ -39,23 +40,38 @@ struct DynareParams {
   /** 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;
+  std::vector<const char *> irf_list;
   bool do_centralize;
   double qz_criterium;
   bool help;
   bool version;
-	DynareParams(int argc, char** argv);
+  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;}
+  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,
@@ -63,11 +79,11 @@ private:
         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);
+  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);
+  void processIRFList(int argc, char **argv);
 };
 
 // Local Variables:

dynare++/src/forw_subst_builder.h

@@ -5,14 +5,15 @@
 #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 {
+  struct ForwSubstInfo
+  {
     int num_affected_equations;
     int num_subst_terms;
     int num_aux_variables;
@@ -21,15 +22,18 @@ namespace ogdyn {
       : num_affected_equations(0),
         num_subst_terms(0),
         num_aux_variables(0),
-			  num_new_terms(0) {}
+        num_new_terms(0)
+    {
+    }
   };
 
-	class ForwSubstBuilder {
-		typedef map<int, const char*> Ttermauxmap;
+  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;
+    DynareModel &model;
     /** A map mapping new auxiliary variables to the terms in the
      * tree in the DynareModel. */
     Tsubstmap aux_map;
@@ -45,17 +49,23 @@ namespace ogdyn {
      * 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);
+    ForwSubstBuilder(DynareModel &m);
     /** Copy constructor with a new instance of the model. */
-		ForwSubstBuilder(const ForwSubstBuilder& b, DynareModel& m);
+    ForwSubstBuilder(const ForwSubstBuilder &b, DynareModel &m);
     /** Return the auxiliary variable mapping. */
-		const Tsubstmap& get_aux_map() const
-			{return aux_map;}
+    const Tsubstmap &
+    get_aux_map() const
+    {
+      return aux_map;
+    }
     /** Return the information. */
-		const ForwSubstInfo& get_info() const
-			{return info;}
+    const ForwSubstInfo &
+    get_info() const
+    {
+      return info;
+    }
   private:
-		ForwSubstBuilder(const ForwSubstBuilder& b);
+    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
@@ -72,7 +82,7 @@ namespace ogdyn {
      * 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);
+    void unassign_gt_1_leads(const char *name);
   };
 };
 

dynare++/src/nlsolve.h

@@ -8,20 +8,25 @@
 #include "twod_matrix.h"
 #include "journal.h"
 
-namespace ogu {
+namespace ogu
+{
 
-	class OneDFunction {
+  class OneDFunction
+  {
   public:
-		virtual ~OneDFunction() {}
+    virtual ~OneDFunction()
+    {
+    }
     virtual double eval(double) = 0;
   };
 
-	class GoldenSectionSearch {
+  class GoldenSectionSearch
+  {
   protected:
     static double tol;
     static double golden;
   public:
-		static double search(OneDFunction& f, double x1, double x2);
+    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
@@ -30,39 +35,50 @@ namespace ogu {
      * 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);
+    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);
+    static bool search_for_finite(OneDFunction &f, double x1, double &x2, double &b);
   };
 
-	class VectorFunction {
+  class VectorFunction
+  {
   public:
-		VectorFunction() {}
-		virtual ~VectorFunction() {}
+    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;
+    void check_for_eval(const ConstVector &in, Vector &out) const;
     /** Evaluate the vector function. */
-		virtual void eval(const ConstVector& in, Vector& out) = 0;
+    virtual void eval(const ConstVector &in, Vector &out) = 0;
   };
 
-	class Jacobian : public TwoDMatrix {
+  class Jacobian : public TwoDMatrix
+  {
   public:
     Jacobian(int n)
-			: TwoDMatrix(n,n) {}
-		virtual ~Jacobian() {}
-		virtual void eval(const Vector& in) = 0;
+      : TwoDMatrix(n, n)
+    {
+    }
+    virtual ~Jacobian()
+    {
+    }
+    virtual void eval(const Vector &in) = 0;
   };
 
-	class NLSolver : public OneDFunction {
+  class NLSolver : public OneDFunction
+  {
   protected:
-		Journal& journal;
-		VectorFunction& func;
-		Jacobian& jacob;
+    Journal &journal;
+    VectorFunction &func;
+    Jacobian &jacob;
     const int max_iter;
     const double tol;
   private:
@@ -70,14 +86,18 @@ namespace ogu {
     Vector xcauchy;
     Vector x;
   public:
-		NLSolver(VectorFunction& f, Jacobian& j, int maxit, double tl, Journal& jr)
+    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() {}
+    {
+      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);
+    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

dynare++/src/planner_builder.h

@@ -5,7 +5,8 @@
 
 #include "dynare_model.h"
 
-namespace ogdyn {
+namespace ogdyn
+{
 
   using boost::unordered_set;
   using std::map;
@@ -13,39 +14,59 @@ namespace ogdyn {
 
   /** This is a two dimensional array of integers. Nothing
    * difficult. */
-	class IntegerMatrix {
+  class IntegerMatrix
+  {
   protected:
     /** Number of rows. */
     int nr;
     /** Number of columns. */
     int nc;
     /** The pointer to the data. */
-		int* data;
+    int *data;
   public:
     /** Construct uninitialized array. */
     IntegerMatrix(int nrr, int ncc)
-			: nr(nrr), nc(ncc), data(new int[nr*nc]) {}
+      : nr(nrr), nc(ncc), data(new int[nr*nc])
+    {
+    }
     /** Copy constructor. */
-		IntegerMatrix(const IntegerMatrix& im)
+    IntegerMatrix(const IntegerMatrix &im)
       : nr(im.nr), nc(im.nc), data(new int[nr*nc])
-			{memcpy(data, im.data, nr*nc*sizeof(int));}
+    {
+      memcpy(data, im.data, nr*nc*sizeof(int));
+    }
     virtual ~IntegerMatrix()
-			{delete [] data;}
+    {
+      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;}
+    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 {
+  class IntegerArray3
+  {
   protected:
     /** First dimension. */
     int n1;
@@ -54,41 +75,65 @@ namespace ogdyn {
     /** Third dimension. */
     int n3;
     /** The data. */
-		int* 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]) {}
+      : n1(nn1), n2(nn2), n3(nn3), data(new int[n1*n2*n3])
+    {
+    }
     /** Copy constructor. */
-		IntegerArray3(const IntegerArray3& ia3)
+    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));}
+    {
+      memcpy(data, ia3.data, n1*n2*n3*sizeof(int));
+    }
     virtual ~IntegerArray3()
-			{delete [] data;}
+    {
+      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;}
+    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 {
+  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) {}
+        num_new_terms(0)
+    {
+    }
   };
 
   class MultInitSS;
@@ -102,11 +147,12 @@ namespace ogdyn {
    * 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 {
+  class PlannerBuilder
+  {
     friend class MultInitSS;
   public:
     /** Type for a set of variable names. */
-		typedef unordered_set<const char*> Tvarset;
+    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
@@ -128,7 +174,7 @@ namespace ogdyn {
      * yset. */
     const Teqset fset;
     /** Reference to the model. */
-		ogdyn::DynareModel& model;
+    ogdyn::DynareModel &model;
     /** Tree index of the planner objective. */
     int tb;
     /** Tree index of the planner discount parameter. */
@@ -185,14 +231,17 @@ namespace ogdyn {
      * 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);
+    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);
+    PlannerBuilder(const PlannerBuilder &pb, ogdyn::DynareModel &m);
     /** Return the information. */
-		const PlannerInfo& get_info() const
-			{return info;}
+    const PlannerInfo &
+    get_info() const
+    {
+      return info;
+    }
   protected:
     /** Differentiate the planner objective wrt endogenous
      * variables with different lags. */
@@ -218,15 +267,15 @@ namespace ogdyn {
     void form_equations();
   private:
     /** Fill yset for a given yyset and given name storage. */
-		void fill_yset(const ogp::NameStorage& ns, const Tvarset& yyset);
+    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);
+    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);
+    PlannerBuilder(const PlannerBuilder &pb);
   };
 
   /** This class only calculates for the given initial guess of
@@ -240,10 +289,11 @@ namespace ogdyn {
    *
    * The code can be run only after the parsing has been finished in
    * atoms. */
-	class MultInitSS : public ogp::FormulaEvalLoader {
+  class MultInitSS : public ogp::FormulaEvalLoader
+  {
   protected:
     /** The constant reference to the builder. */
-		const PlannerBuilder& builder;
+    const PlannerBuilder &builder;
     /** The constant term of the problem. Its length is the number
      * of endogenous variable wrt the planner optimizes. */
     Vector b;
@@ -260,7 +310,7 @@ namespace ogdyn {
      * 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);
+    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
@@ -271,7 +321,6 @@ namespace ogdyn {
   };
 };
 
-
 #endif
 
 // Local Variables:

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;}
+  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);
+  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;
+                     KronVector &x, Vector &work) const;
   void multKronBlockTrans(const_diag_iter start, const_diag_iter end,
-							KronVector& x, Vector& work) const;
+                          KronVector &x, Vector &work) const;
 };
 
 #endif /* BLOCK_DIAGONAL_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/GeneralMatrix.h

@@ -11,7 +11,8 @@
 
 class GeneralMatrix;
 
-class ConstGeneralMatrix {
+class ConstGeneralMatrix
+{
   friend class GeneralMatrix;
 protected:
   ConstVector data;
@@ -19,47 +20,86 @@ protected:
   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;
+  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;
+  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);}
+  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);}
+  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);}
+  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);}
+  void
+  multsVecTrans(Vector &x, const ConstVector &d) const
+  {
+    multVecTrans(1.0, x, -1.0, d);
+  }
   /* m = inv(this)*m */
-	void multInvLeft(GeneralMatrix& m) const;
+  void multInvLeft(GeneralMatrix &m) const;
   /* m = inv(this')*m */
-	void multInvLeftTrans(GeneralMatrix& m) const;
+  void multInvLeftTrans(GeneralMatrix &m) const;
   /* d = inv(this)*d */
-	void multInvLeft(Vector& d) const;
+  void multInvLeft(Vector &d) const;
   /* d = inv(this')*d */
-	void multInvLeftTrans(Vector& d) const;
+  void multInvLeftTrans(Vector &d) const;
 
   bool isFinite() const;
   /** Returns true of the matrix is exactly zero. */
@@ -67,11 +107,11 @@ public:
 
   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 {
+class GeneralMatrix
+{
   friend class ConstGeneralMatrix;
 protected:
   Vector data;
@@ -80,134 +120,235 @@ protected:
   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);
+    : 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);
+  GeneralMatrix(const GeneralMatrix &a, const GeneralMatrix &b);
   /* this = a*b' */
-	GeneralMatrix(const GeneralMatrix& a, const GeneralMatrix& b, const char* dum);
+  GeneralMatrix(const GeneralMatrix &a, const GeneralMatrix &b, const char *dum);
   /* this = a'*b */
-	GeneralMatrix(const GeneralMatrix& a, const char* dum, const GeneralMatrix& 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(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);}
+  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));}
+  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);}
+  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);}
+  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);}
+  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);}
+  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);}
+  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));}
+  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));}
+  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));}
+  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));}
+  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);}
+  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);}
+  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);}
+  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);}
+  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);}
+  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);}
+  void
+  multsVecTrans(Vector &x, const ConstVector &d) const
+  {
+    ConstGeneralMatrix(*this).multsVecTrans(x, d);
+  }
 
   /* this = zero */
   void zeros();
@@ -225,56 +366,84 @@ public:
   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));}
+  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);}
+  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,
+  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,
+  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);}
+  {
+    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,
+  void gemm_partial_right(const char *trans, const ConstGeneralMatrix &m,
                           double alpha, double beta);
-	void gemm_partial_right(const char* trans, const GeneralMatrix& m,
+  void
+  gemm_partial_right(const char *trans, const GeneralMatrix &m,
                      double alpha, double beta)
-		{gemm_partial_right(trans, ConstGeneralMatrix(m), alpha, 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,
+  void gemm_partial_left(const char *trans, const ConstGeneralMatrix &m,
                          double alpha, double beta);
-	void gemm_partial_left(const char* trans, const GeneralMatrix& m,
+  void
+  gemm_partial_left(const char *trans, const GeneralMatrix &m,
                     double alpha, double beta)
-		{gemm_partial_left(trans, ConstGeneralMatrix(m), alpha, beta);}
+  {
+    gemm_partial_left(trans, ConstGeneralMatrix(m), alpha, beta);
+  }
 
   /* 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. */
@@ -288,33 +457,38 @@ protected:
   /** Convered flag. */
   bool conv;
 public:
-    SVDDecomp(const GeneralMatrix& A)
+  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
+  {
+    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:

dynare++/sylv/cc/GeneralSylvester.h

@@ -10,7 +10,8 @@
 #include "SimilarityDecomp.h"
 #include "SylvesterSolver.h"
 
-class GeneralSylvester {
+class GeneralSylvester
+{
   SylvParams pars;
   SylvMemoryDriver mem_driver;
   int order;
@@ -19,43 +20,63 @@ class GeneralSylvester {
   const SqSylvMatrix c;
   SylvMatrix d;
   bool solved;
-	SchurDecompZero* bdecomp;
-	SimilarityDecomp* cdecomp;
-	SylvesterSolver* sylv;
+  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);
+                   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,
+                   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,
+                   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;}
+                   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);
+  void check(const double *ds);
 private:
   void init();
 };
 
 #endif /* GENERAL_SYLVESTER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

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:

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);
+  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);
+  static void multKron(const QuasiTriangular &f, const QuasiTriangular &k,
+                       KronVector &x);
 };
 
 #endif /* KRON_UTILS_H */

dynare++/sylv/cc/KronVector.h

@@ -9,26 +9,47 @@
 
 class ConstKronVector;
 
-class KronVector : public Vector {
+class KronVector : public Vector
+{
 protected:
   int m;
   int n;
   int depth;
 public:
-	KronVector() : Vector((double*)0, 0), m(0), n(0), depth(0)  {}
+  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 &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
@@ -38,15 +59,27 @@ protected:
   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);

dynare++/sylv/cc/QuasiTriangular.h

@@ -15,32 +15,56 @@ 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;}
+  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;
+  double *beta1;
+  double *beta2;
 
-	void copy(const DiagonalBlock& b) {
+  void
+  copy(const DiagonalBlock &b)
+  {
     jbar = b.jbar;
     real = b.real;
     alpha = b.alpha;
@@ -49,9 +73,11 @@ private:
   }
 
 public:
-	DiagonalBlock() {}
-	DiagonalBlock(int jb, bool r, double* a1, double* a2,
-				  double* b1, double* b2)
+  DiagonalBlock()
+  {
+  }
+  DiagonalBlock(int jb, bool r, double *a1, double *a2,
+                double *b1, double *b2)
     : alpha(a1, a2)
   {
     jbar = jb;
@@ -60,7 +86,7 @@ public:
     beta2 = b2;
   }
   // construct complex block
-	DiagonalBlock(int jb, double* a1, double* a2)
+  DiagonalBlock(int jb, double *a1, double *a2)
     : alpha(a1, a2)
   {
     jbar = jb;
@@ -69,7 +95,7 @@ public:
     beta2 = a1 + 1;
   }
   // construct real block
-	DiagonalBlock(int jb, double* a1)
+  DiagonalBlock(int jb, double *a1)
     : alpha(a1, a1)
   {
     jbar = jb;
@@ -77,69 +103,151 @@ public:
     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;}
+  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);
+  void checkBlock(const double *d, int d_size);
   friend class Diagonal;
 };
 
 template <class _Tdiag, class _Tblock, class _Titer>
-struct _diag_iter {
+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&);
+  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;
+  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);
@@ -147,112 +255,178 @@ public:
   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);
+  void changeBase(double *p);
 private:
   static double EPS;
-	static int getNumComplex(const double* data, int d_size);
+  static int getNumComplex(const double *data, int d_size);
   static bool isZero(double p);
 };
 
 template <class _TRef, class _TPtr>
-struct _matrix_iter {
+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;
+  {
+    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> {
+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
+    : _matrix_iter<_TRef, _TPtr>(base, ds, r), row(rw)
+  {
+  };
+  _Self &
+  operator++()
+  {
+    _Tparent::ptr++; row++; return *this;
+  }
+  _TRef
+  b() const
+  {
+    if (_Tparent::real)
       {
-			if (_Tparent::real) {
         return *(_Tparent::ptr);
-			} else {
+      }
+    else
+      {
         return *(_Tparent::ptr+_Tparent::d_size);
       }
   }
-	int getRow() const {return row;}
+  int
+  getRow() const
+  {
+    return row;
+  }
 };
 
 template <class _TRef, class _TPtr>
-class _row_iter : public _matrix_iter<_TRef, _TPtr> {
+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
+    : _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)
       {
-			if (_Tparent::real) {
         return *(_Tparent::ptr);
-			}else {
+      }
+    else
+      {
         return *(_Tparent::ptr+1);
       }
   }
-	int getCol() const {return col;}
+  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 _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;
 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;}
+  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);
@@ -260,80 +434,102 @@ public:
   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);
+  virtual void solvePre(Vector &x, double &eig_min);
   /* (I+T')y = x, y-->x */
-	virtual void solvePreTrans(Vector& x, double& eig_min);
+  virtual void solvePreTrans(Vector &x, double &eig_min);
   /* (I+T)x = b */
-	virtual void solve(Vector& x, const ConstVector& b, double& eig_min);
+  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);
+  virtual void solveTrans(Vector &x, const ConstVector &b, double &eig_min);
   /* x = Tb */
-	virtual void multVec(Vector& x, const ConstVector& b) const;
+  virtual void multVec(Vector &x, const ConstVector &b) const;
   /* x = T'b */
-	virtual void multVecTrans(Vector& x, const ConstVector& b) const;
+  virtual void multVecTrans(Vector &x, const ConstVector &b) const;
   /* x = x + Tb */
-	virtual void multaVec(Vector& x, const ConstVector& b) const;
+  virtual void multaVec(Vector &x, const ConstVector &b) const;
   /* x = x + T'b */
-	virtual void multaVecTrans(Vector& x, const ConstVector& b) const;
+  virtual void multaVecTrans(Vector &x, const ConstVector &b) const;
   /* x = (T\otimes I)x */
-	virtual void multKron(KronVector& x) const;
+  virtual void multKron(KronVector &x) const;
   /* x = (T'\otimes I)x */
-	virtual void multKronTrans(KronVector& x) const;
+  virtual void multKronTrans(KronVector &x) const;
   /* A = T*A */
-	virtual void multLeftOther(GeneralMatrix& a) const;
+  virtual void multLeftOther(GeneralMatrix &a) const;
   /* A = T'*A */
-	virtual void multLeftOtherTrans(GeneralMatrix& a) const;
+  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);
+  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);}
+  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;
+  void multaKron(KronVector &x, const ConstKronVector &b) const;
   /* x = x + (T'\otimes I)b */
-	void multaKronTrans(KronVector& x, const ConstKronVector& b) const;
+  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);	
+  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 multsVec(Vector &x, const ConstVector &d) const;
+  void multsVecTrans(Vector &x, const ConstVector &d) const;
 };
 
 #endif /* QUASI_TRIANGULAR_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/QuasiTriangularZero.h

@@ -8,36 +8,49 @@
 #include "QuasiTriangular.h"
 #include "GeneralMatrix.h"
 
-class QuasiTriangularZero : public QuasiTriangular {
+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(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;
+  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);}
+  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;
 };
 

dynare++/sylv/cc/SchurDecomp.h

@@ -9,35 +9,61 @@
 #include "QuasiTriangular.h"
 
 class QuasiTriangular;
-class SchurDecomp {
+class SchurDecomp
+{
   bool q_destroy;
-	SqSylvMatrix* q;
+  SqSylvMatrix *q;
   bool t_destroy;
-	QuasiTriangular* t;
+  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;}
+  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();
+  virtual
+  ~SchurDecomp();
 };
 
-class SchurDecompZero : public SchurDecomp {
+class SchurDecompZero : public SchurDecomp
+{
   GeneralMatrix ru; /* right upper matrix */
 public:
-	SchurDecompZero(const GeneralMatrix& m);
-	const GeneralMatrix& getRU() const {return ru;}
+  SchurDecompZero(const GeneralMatrix &m);
+  const GeneralMatrix &
+  getRU() const
+  {
+    return ru;
+  }
   int getDim() const;
-	int getZeroCols() const {return ru.numRows();}
+  int
+  getZeroCols() const
+  {
+    return ru.numRows();
+  }
 };
 
 #endif /* SCHUR_DECOMP_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

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) {}
+  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:
-

dynare++/sylv/cc/SimilarityDecomp.h

@@ -9,33 +9,43 @@
 #include "BlockDiagonal.h"
 #include "SylvParams.h"
 
-class SimilarityDecomp {
-	SqSylvMatrix* q;
-	BlockDiagonal* b;
-	SqSylvMatrix* invq;
+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 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:

dynare++/sylv/cc/SylvException.h

@@ -7,24 +7,26 @@
 
 #include "SylvMemory.h"
 
-
-class SylvException : public MallocAllocator {
+class SylvException : public MallocAllocator
+{
 protected:
   char file[50];
   int line;
-	const SylvException* source;
+  const SylvException *source;
 public:
-	SylvException(const char* f, int l, const SylvException* s);
-	virtual ~SylvException();
-	virtual int printMessage(char* str, int maxlen) 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 {
+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:
@@ -33,7 +35,6 @@ public:
 
 #endif /* SYLV_EXCEPTION_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

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) {}
+    : 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);
+  void multLeftI(const SqSylvMatrix &m);
   /* this = |I  0|* this
      |0 m'|         */
-	void multLeftITrans(const SqSylvMatrix& 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);
+  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);
+  void multRightKron(const SqSylvMatrix &m, int order);
   /* this = this * (m'\otimes m'..\otimes m') */
-	void multRightKronTrans(const SqSylvMatrix& m, int order);
+  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);
+  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);
+  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;}
+  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;
+  void multVecKron(KronVector &x, const KronVector &d) const;
   /* x = (this' \otimes this'..\otimes this')*d */
-	void multVecKronTrans(KronVector& x, const KronVector& d) const;
+  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;
+  void multInvLeft2(GeneralMatrix &a, GeneralMatrix &b,
+                    double &rcond1, double &rcondinf) const;
   /* this = I */
   void setUnit();
 };
 
-
 #endif /* SYLV_MATRIX_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/SylvMemory.h

@@ -9,46 +9,49 @@
 
 #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;
+class SylvMemoryPool
+{
+  char *base;
   size_t length;
   size_t allocated;
   bool stack_mode;
-	SylvMemoryPool(const SylvMemoryPool&);
-	const SylvMemoryPool& operator=(const SylvMemoryPool&);
+  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 *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);
+  SylvMemoryDriver(const SylvParams &pars, int num_d, int m, int n, int order);
   static void setStackMode(bool);
   ~SylvMemoryDriver();
 protected:
@@ -57,7 +60,6 @@ protected:
 
 #endif /* SYLV_MEMORY_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/SylvParams.h

@@ -15,27 +15,47 @@
 typedef enum {def, changed, undef} status;
 
 template <class _Type>
-struct ParamItem {
+struct ParamItem
+{
 protected:
   typedef ParamItem<_Type> _Self;
   status s;
   _Type value;
 public:
   ParamItem()
-		{s = undef;}
+  {
+    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
+  {
+    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;
@@ -46,61 +66,102 @@ public:
     strcat(out, fmt);
     if (s == def)
       strcat(out, " <default>");
-			strcat(out,"\n");
+    strcat(out, "\n");
     fprintf(f, out, value);
   }
 };
 
-class SylvParams {
+class SylvParams
+{
 public:
   typedef enum {iter, recurse} solve_method;
 
 protected:
-	class DoubleParamItem : public ParamItem<double> {
+  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;}
+    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> {
+  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;}
+    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> {
+  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;}
+    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> {
+  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;}
+    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
   };
 
@@ -138,25 +199,33 @@ public:
 
   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;
+      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:

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));
+  static bool
+  zeroPad(const SchurDecompZero &kdecomp)
+  {
+    return ((kdecomp.getZeroCols()*3 < kdecomp.getDim()*2)
+            || (kdecomp.getZeroCols() < 10));
   }
 public:
-	SylvesterSolver(const QuasiTriangular& k, const QuasiTriangular& f)
+  SylvesterSolver(const QuasiTriangular &k, const QuasiTriangular &f)
     : matrixK(new QuasiTriangular(k)),
       matrixF(new QuasiTriangular(f))
-		{}
-	SylvesterSolver(const SchurDecompZero& kdecomp, const SchurDecomp& fdecomp)
+  {
+  }
+  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)
+  {
+  }
+  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;
+  {
+    delete matrixK; delete matrixF;
+  }
+  virtual void solve(SylvParams &pars, KronVector &x) const = 0;
 };
 
 #endif /* SYLVESTER_SOLVER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/SymSchurDecomp.h

@@ -7,24 +7,35 @@
 
 #include "SylvMatrix.h"
 
-class SymSchurDecomp {
+class SymSchurDecomp
+{
 protected:
   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;}
+  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;
+  void getFactor(GeneralMatrix &f) const;
   /** Returns true if A is positive semidefinite. */
   bool isPositiveSemidefinite() const;
   /** Correct definitness. This sets all eigenvalues between minus
@@ -35,7 +46,6 @@ public:
 
 #endif
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/TriangularSylvester.h

@@ -11,36 +11,41 @@
 #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();
+  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 solve(SylvParams &pars, KronVector &d) const;
 
-	void solvi(double r, KronVector& d, double& eig_min) 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;
+              KronVector &d1, KronVector &d2,
+              double &eig_min) const;
   void solviip(double alpha, double betas,
-				 KronVector& d, double& eig_min) const;
+               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));}
+               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|
@@ -53,55 +58,58 @@ public:
   */
   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,
+               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));}
+          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);
+  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;
+                             KronVector &d, double &eig_min) const;
   void solviComplexAndEliminate(double r, const_diag_iter di,
-								  KronVector& d, double& eig_min) const;
+                                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;
+                               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;
+                                  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,
+  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,
+                            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,
+                               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;
+                      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
@@ -109,7 +117,6 @@ private:
 
 #endif /* TRIANGULAR_SYLVESTER_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/cc/Vector.h

@@ -14,68 +14,104 @@
 class GeneralMatrix;
 class ConstVector;
 
-class Vector {
+class Vector
+{
 protected:
   int len;
   int s;
-	double* data;
+  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)
+  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;}
+  {
+    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;
+  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;
+  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();
+  virtual
+  ~Vector();
   void zeros();
   void nans();
   void infs();
-	bool toBeDestroyed() const {return destroy;}
+  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 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;
+  double dot(const Vector &y) const;
   bool isFinite() const;
   void print() const;
 
@@ -84,92 +120,139 @@ public:
      | -beta2 alpha|           |b2|   |x2|
   */
   static void mult2(double alpha, double beta1, double beta2,
-					  Vector& x1, Vector& x2,
-					  const Vector& b1, const Vector& b2);
+                    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);
+                     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);}
+  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;
+  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);
+  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() {}
+  virtual ~ConstVector()
+  {
+  }
   /** Exact equality. */
-	bool operator==(const ConstVector& y) const;
-	bool operator!=(const ConstVector& y) const
-		{return ! operator==(y);}
+  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);}
+  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;
+  double dot(const ConstVector &y) const;
   bool isFinite() const;
   void print() const;
 };
 
-class ZeroPad {
+class ZeroPad
+{
 public:
   static const int length = 16;
 private:
   double pad[16];
 public:
   ZeroPad();
-	const double* getBase() const {return pad;} 
+  const double *
+  getBase() const
+  {
+    return pad;
+  }
 };
 
 #endif /* VECTOR_H */
 
-
 // Local Variables:
 // mode:C++
 // End:

dynare++/sylv/testing/MMMatrix.h

@@ -12,31 +12,58 @@
 
 using namespace std;
 
-class MMException : public MallocAllocator {
+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;
+class MMMatrixIn : public MallocAllocator
+{
+  double *data;
   int rows;
   int cols;
 public:
-	MMMatrixIn(const char* fname);
+  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;}
+  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 */

dynare++/tl/testing/factory.h

@@ -11,17 +11,19 @@
 #include "rfs_tensor.h"
 #include "t_container.h"
 
-class Factory {
-	void init(const Symmetry& s, const IntSequence& nvs);
+class Factory
+{
+  void init(const Symmetry &s, const IntSequence &nvs);
   void init(int dim, int nv);
-	void fillMatrix(TwoDMatrix& m) const;
+  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 *
+  make(int r, const Symmetry &s, const IntSequence &nvs)
   {
-			_Ttype* res = new _Ttype(r, TensorDimens(s, nvs));
+    _Ttype *res = new _Ttype(r, TensorDimens(s, nvs));
     init(s, nvs);
     fillMatrix(*res);
     return res;
@@ -29,30 +31,37 @@ public:
 
   // this can be used with FFSTensor, UFSTensor, FRTensor, URTensor
   template <class _Ttype>
-	_Ttype* make(int r, int nv, int dim)
+  _Ttype *
+  make(int r, int nv, int dim)
   {
-			_Ttype* res = new _Ttype(r, nv, 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)
+  _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) {
+    _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);
+            _Ttype *t = make<_Ttype>(r, sym, nvs);
             res->insert(t);
-				} else {
+          }
+        else
+          {
             // general symmetry
-					for (int i = 0; i <= dim; i++) {
+            for (int i = 0; i <= dim; i++)
+              {
                 Symmetry sym(i, dim-i);
-						_Ttype* t = make<_Ttype>(r, sym, nvs);
+                _Ttype *t = make<_Ttype>(r, sym, nvs);
                 res->insert(t);
               }
           }
@@ -61,17 +70,19 @@ public:
   }
 
   template <class _Ttype, class _Ptype>
-	_Ptype* makePoly(int r, int nv, int maxdim)
+  _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);
+    _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

dynare++/tl/testing/monoms.h

@@ -10,72 +10,78 @@
 #include "sparse_tensor.h"
 #include "Vector.h"
 
-class IntGenerator {
+class IntGenerator
+{
   int maxim;
   double probab;
 public:
   IntGenerator()
-		: maxim(5), probab(0.3) {}
+    : 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;
+  double deriv(const IntSequence &vars) const;
   // this = this*m^ex (in monomial sense)
-	void multiplyWith(int ex, const Monom& m);
+  void multiplyWith(int ex, const Monom &m);
   void print() const;
 };
 
 class Monom2Vector;
-class Monom1Vector {
+class Monom1Vector
+{
   friend class Monom2Vector;
   int nx;
   int len;
-	Monom** const x;
+  Monom **const x;
 public:
   Monom1Vector(int nxx, int l);
   ~Monom1Vector();
-	void deriv(const IntSequence& c, Vector& out) const;
-	FGSTensor* deriv(int dim) const;
+  void deriv(const IntSequence &c, Vector &out) const;
+  FGSTensor *deriv(int dim) const;
   void print() const;
 };
 
 //class Monom3Vector;
-class Monom2Vector {
+class Monom2Vector
+{
   int ny;
   int nu;
   int len;
-	Monom** const y;
-	Monom** const u;
+  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(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 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 {
+class Monom4Vector
+{
   int len;
   int nx1;
   int nx2;
   int nx3;
   int nx4;
-	Monom** const x1;
-	Monom** const x2;
-	Monom** const x3;
-	Monom** const x4;
+  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);
@@ -84,37 +90,37 @@ public:
   /* 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(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;
+  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();
 };
 
-
-struct SparseDerivGenerator {
+struct SparseDerivGenerator
+{
   int maxdimen;
-	FGSContainer* bigg;
-	FGSContainer* g;
-	FGSContainer* rcont;
-	FSSparseTensor** const ts;
+  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 {
+struct DenseDerivGenerator
+{
   int maxdimen;
-	FGSContainer* xcont;
-	FGSContainer* rcont;
-	FGSTensor** const ts;
-	UGSContainer* uxcont;
-	UGSTensor** const uts;
+  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();

dynare++/utils/cc/exception.h

@@ -11,10 +11,12 @@
 #include <string>
 #include <algorithm>
 
-namespace ogu {
+namespace ogu
+{
 
   /** A primitive exception. */
-	class Exception {
+  class Exception
+  {
     static const int file_length = 100;
     static const int mes_length = 500;
   protected:
@@ -22,29 +24,40 @@ namespace ogu {
     int line;
     char mes[mes_length];
   public:
-		Exception(const char* f, int l, const char* m)
+    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)));
+      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)
+    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()));
+      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; }
+    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;
+    }
   };
 };
 

dynare++/utils/cc/memory_file.h

@@ -5,16 +5,17 @@
 #ifndef OGU_MEMORY_FILE
 #define OGU_MEMORY_FILE
 
-namespace ogu {
+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);
+  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);
+  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
@@ -22,34 +23,51 @@ namespace ogu {
    * 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 {
+  class MemoryFile
+  {
   protected:
     int len;
-		char* data;
+    char *data;
   public:
-		MemoryFile(const char* fname);
+    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;}
+    {
+      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);}
+    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);}
+    void
+    line_and_col(int offset, int &line, int &col) const
+    {
+      calc_pos_line_and_col(len, data, offset, line, col);
+    }
   };
 
-	
 };
 
-
 #endif
 
 // Local Variables:

dynare++/utils/cc/pascal_triangle.h

@@ -7,31 +7,43 @@
 
 #include <vector>
 
-namespace ogu {
+namespace ogu
+{
 
   using std::vector;
 
-	class PascalRow : public vector<int> {
+  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);
+    {
+      push_back(2);
+    }
+    void setFromPrevious(const PascalRow &prev);
+    void prolong(const PascalRow &prev);
     void prolongFirst(int n);
     void print() const;
   };
 
-	class PascalTriangle {
+  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;}
+    {
+      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:
@@ -43,7 +55,6 @@ namespace ogu {
 
 extern ogu::PascalTriangle ptriang;
 
-
 #endif
 
 // Local Variables:

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);
 */
 
 

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);

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;

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

m4/ax_latex_bibtex_test.m4

@@ -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])
-])

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"
       ;;

matlab/@dynTimeIndex/dynTimeIndex.m

@@ -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

matlab/@dynTimeIndex/minus.m

@@ -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

matlab/@dynTimeIndex/mpower.m

@@ -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

matlab/@dynTimeIndex/plus.m

@@ -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

matlab/@dynTimeIndex/subsref.m

@@ -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

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,31 +26,31 @@ 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));
 %     end
 
-    while notsteady && t<smpl
+while notsteady && t<smpl
     t  = t+1;
     v  = Y(:,t)-a(mf);
     F  = P(mf,mf) + H;
@@ -77,7 +77,7 @@ end
             end
         end
         vecDPmf = reshape(DP(mf,mf,:),[],k);
-%                     iPmf = inv(P(mf,mf));
+        %                     iPmf = inv(P(mf,mf));
         if t>=start
             AHess = AHess + Dv'*iF*Dv + .5*(vecDPmf' * kron(iF,iF) * vecDPmf);
         end
@@ -87,14 +87,14 @@ end
     end
     notsteady = max(max(abs(K-oldK))) > riccati_tol;
     oldK = K;
-    end
+end
 
-    if F_singular
+if F_singular
     error('The variance of the forecast error remains singular until the end of the sample')
-    end
+end
 
 
-    if t < smpl
+if t < smpl
     t0 = t+1;
     while t < smpl
         t = t+1;
@@ -115,31 +115,31 @@ 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) );
+            %             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    
+    %         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,
+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);
@@ -150,6 +150,3 @@ for ii = 1:k
 end
 
 % end of computeDKalman
-
-
-            

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.';

matlab/AIM/SPAmalg.m

@@ -66,12 +66,12 @@ 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)
@@ -81,7 +81,7 @@ if (ia ~= 0)
         return
     end
     [w,rts,lgroots,flag_trouble]=SPEigensystem(a,uprbnd,min(length(js),qrows-iq+1));
-    if flag_trouble==1; 
+    if flag_trouble==1
         disp('Problem in SPEIG');
         aimcode=64;
         return

matlab/AIM/SPEigensystem.m

@@ -39,22 +39,22 @@ 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
+%disp('Catch in SPE');
+%pause(0.5);
+%aStr=datestr(clock);
+%eval(['save ' regexprep(aStr,' ','')  ' a']);
+try
     [w,d]=eig(a');
-    catch
+catch
     lasterr
     w=[];rts=[];lgroots=[];
     flag_trouble=1;
     return
-    end
-    rts     = diag(d);
-    mag     = abs(rts);
-    [mag,k] = sort(-mag);
-    rts     = rts(k);
+end
+rts     = diag(d);
+mag     = abs(rts);
+[mag,k] = sort(-mag);
+rts     = rts(k);
 %end
 flag_trouble=0;
 

matlab/AIM/SPExact_shift.m

@@ -44,4 +44,3 @@ while( any(zerorows) && iq <= qrows )
     zerorows = find( sum(abs( hs(:,right)' ))==0 );
 end
 h=full(hs);
-

matlab/AIM/SPObstruct.m

@@ -61,7 +61,7 @@ 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);

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.
@@ -48,4 +48,3 @@ else  %rescale by dividing row by maximal qr element
         b = full(b);
     end
 end
-

matlab/AIM/dynAIMsolver1.m

@@ -3,12 +3,12 @@ function [dr,aimcode,rts]=dynAIMsolver1(jacobia_,M_,dr)
 % 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, . . . ,?
+% 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 
+% 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'= £
+% where [fy'-$...  fy'i ... fy'+&]=[H-$...  Hi ... H+&] and fu'= £
 %
 % INPUTS
 %   jacobia_   [matrix]           1st order derivative of the model
@@ -46,7 +46,7 @@ function [dr,aimcode,rts]=dynAIMsolver1(jacobia_,M_,dr)
 %
 % GP July 2008
 
-% Copyright (C) 2008-2012 Dynare Team
+% Copyright (C) 2008-2017 Dynare Team
 %
 % This file is part of Dynare.
 %

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.
 %
@@ -68,34 +68,33 @@ 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;
+info = 0;
 
-    [dr,aimcode]=dynAIMsolver1(jacobia,M,dr);
+[dr,aimcode]=dynAIMsolver1(jacobia,M,dr);
 
-    if aimcode ~=1
+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,...
+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 );
+dr.eigval = eig(A);
+disp(dr.eigval)
+nd = size(dr.kstate,1);
+nba = nd-sum( abs(dr.eigval) < qz_criterium );
 
-    nsfwrd = M.nsfwrd;
+nsfwrd = M.nsfwrd;
 
-    if nba ~= 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;
+    elseif nba < nsfwrd
         temp = temp(nd-nsfwrd+1:nd-nba)-1-qz_criterium;
         info(1) = 4;
     end
     info(2) = temp'*temp;
     return
-    end
-
+end

matlab/CheckPath.m

@@ -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.
 %

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.
 %

matlab/DsgeSmoother.m

@@ -58,7 +58,7 @@ function [alphahat,etahat,epsilonhat,ahat,SteadyState,trend_coeff,aK,T,R,P,PK,de
 % SPECIAL REQUIREMENTS
 %   None
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -255,8 +255,10 @@ if kalman_algo == 2 || kalman_algo == 4
                 [Pstar,Pinf] = compute_Pinf_Pstar(mf,ST,R1,Q,options_.qz_criterium);
             else
                 Pstar = blkdiag(Pstar,H);
+                if ~isempty(Pinf)
                     Pinf  = blkdiag(Pinf,zeros(vobs));
                 end
+            end
             %now reset H to 0
             H   = zeros(vobs,vobs);
         else

matlab/GetAllPosteriorDraws.m

@@ -16,7 +16,7 @@ function Draws = GetAllPosteriorDraws(column, FirstMhFile, FirstLine, TotalNumbe
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2011 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %

matlab/GetOneDraw.m

@@ -13,7 +13,7 @@ function [xparams, logpost] = GetOneDraw(type)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2015 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %

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.
 %
@@ -17,18 +17,18 @@ 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;
+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
+NbrKeptDraws = 0;
+for i=1:NbrBlocks
     NbrDrawsCurrentBlock = 0;
     for j=1:NbrFiles
         o = load([BaseName '_mh' int2str(j) '_blck' int2str(i),'.mat']);
@@ -50,4 +50,4 @@ function [mean,variance] = GetPosteriorMeanVariance(M,drop)
         NbrDrawsCurrentBlock = NbrDrawsCurrentBlock + NbrDrawsCurrentFile;
         NbrKeptDraws = NbrKeptDraws + NbrKeptDrawsCurrentFile;
     end
-    end
+end

matlab/GetPosteriorParametersStatistics.m

@@ -16,7 +16,7 @@ function oo_ = GetPosteriorParametersStatistics(estim_params_, M_, options_, bay
 % SPECIAL REQUIREMENTS
 %   None.
 
-% Copyright (C) 2006-2016 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -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);
@@ -311,7 +311,7 @@ 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);

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.
 %

matlab/PlotPosteriorDistributions.m

@@ -16,7 +16,7 @@ function oo_ = PlotPosteriorDistributions(estim_params_, M_, options_, bayestopt
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2005-2016 Dynare Team
+% Copyright (C) 2005-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -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
@@ -151,8 +151,8 @@ 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)

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(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,34 +368,34 @@ 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)
+    Check=options_.TeX;
+    if (Check)
         localVars.varlist_TeX=varlist_TeX;
-end
+    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.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
+    end
 
-% The files .TeX are genereted in sequential way always!
+    % 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)))
+    % 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']);
@@ -431,18 +436,18 @@ if options_.TeX && any(strcmp('eps',cellstr(options_.graph_format)))
         end
         fprintf(fidTeX,'%% End of TeX file.\n');
         fclose(fidTeX);
-end
+    end
 
-% The others file format are generated in parallel by PosteriorIRF_core2!
+    % 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,
+    % 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),
+            for indPC=1:length(options_.parallel)
                 isRemoteOctave = isRemoteOctave + (findstr(options_.parallel(indPC).MatlabOctavePath, 'octave'));
             end
             if isRemoteOctave
@@ -454,10 +459,10 @@ if ~isoctave
                 [fout] = masterParallel(options_.parallel, 1, M_.exo_nbr,NamFileInput,'PosteriorIRF_core2', localVars, globalVars, options_.parallel_info);
             end
         end
-else
+    else
         [fout] = PosteriorIRF_core2(localVars,1,M_.exo_nbr,0);
-end
-% END parallel code!
+    end
+    % END parallel code!
 
 end
 

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;

matlab/PosteriorIRF_core2.m

@@ -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)
@@ -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

matlab/ReshapeMatFiles.m

@@ -25,7 +25,7 @@ function ReshapeMatFiles(type, type2)
 % 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 ];

matlab/TaRB_optimizer_wrapper.m

@@ -21,7 +21,8 @@ function [fval,info,exit_flag,DLIK,Hess,SteadyState,trend_coeff]  = TaRB_optimiz
 %   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
-

matlab/Tracing.m

@@ -14,7 +14,7 @@ function [] = Tracing()
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright (C) 2010 Dynare Team
+% Copyright (C) 2010-2017 Dynare Team
 %
 % This file is part of Dynare.
 %

matlab/UnivariateSpectralDensity.m

@@ -19,7 +19,7 @@ function [oo_] = UnivariateSpectralDensity(M_,oo_,options_,var_list)
 
 % Adapted from th_autocovariances.m.
 
-% Copyright (C) 2006-2015 Dynare Team
+% Copyright (C) 2006-2017 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -134,7 +134,7 @@ 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
@@ -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_)
+        dyn_saveas(hh,[M_.fname ,filesep,'graphs', filesep, 'SpectralDensity_' deblank(M_.endo_names(ivar(i),:))],options_.nodisplay,options_.graph_format)
     end
 end

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

matlab/add_filter_subtitle.m

@@ -1,5 +1,22 @@
 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
 elseif ~options_.hp_filter && ~options_.one_sided_hp_filter && options_.bandpass.indicator

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.
 %
@@ -22,7 +22,11 @@ if nargin<2
 end
 
 if exist('OCTAVE_VERSION')
+    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

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

matlab/autoregressive_process_specification.m

@@ -43,7 +43,7 @@ function [InnovationVariance,AutoregressiveParameters] = autoregressive_process_
 %
 %           \sigma^2 = \gamma(0)*(1-PHI'*v)
 
-% Copyright (C) 2009 Dynare Team
+% Copyright (C) 2009-2017 Dynare Team
 %
 % This file is part of Dynare.
 %

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

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);

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

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);

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);