Create a sparse identifty matrix when it makes sense.

selec_posterior_draws.m: fix bug introduced when removing oo_ as an input

See merge request Dynare/dynare!2274

NEWS.md

@@ -1,3 +1,405 @@
+Announcement for Dynare 6.0 (on 2024-02-02)
+===========================================
+
+We are pleased to announce the release of Dynare 6.0.
+
+This major release adds new features and fixes various bugs.
+
+The Windows, macOS, MATLAB Online and source packages are already available for
+download at [the Dynare website](https://www.dynare.org/download/).
+
+This release is compatible with MATLAB versions ranging from 9.5 (R2018b) to
+23.2 (R2023b), and with GNU Octave versions ranging from 7.1.0 to 8.4.0 (NB:
+the Windows package requires version 8.4.0 specifically).
+
+Major user-visible changes
+--------------------------
+
+ - The Sequential Monte Carlo sampler as described by Herbst and Schorfheide
+   (2014) is now available under value `hssmc` for option
+   `posterior_sampling_method`.
+
+ - New routines for perfect foresight simulation with expectation errors. In
+   such a scenario, agents make expectation errors in that the path they had
+   anticipated in period 1 is not realized exactly. More precisely, in some
+   simulation periods, they may receive new information that makes them revise
+   their anticipation for the path of future shocks. Also, under this scenario,
+   it is assumed that agents behave as under perfect foresight, *i.e.* they
+   make their decisions as if there were no uncertainty and they knew exactly
+   the path of future shocks; the new information that they may receive comes
+   as a total surprise to them. Available under new
+   `perfect_foresight_with_expectation_errors_setup` and
+   `perfect_foresight_with_expectation_errors_solver` commands, and
+   `shocks(learnt_in=…)`, `mshocks(learnt_in=…)` and `endval(learnt_in=…)`
+   blocks.
+
+ - New routines for IRF matching with stochastic simulations:
+
+   - Both frequentist (as in Christiano, Eichenbaum, and Evans, 2005) and
+     Bayesian (as in Christiano, Trabandt, and Walentin, 2010) IRF matching
+     approaches are implemented. The core idea of IRF matching is to treat
+     empirical impulse responses (*e.g.* given from an SVAR or local projection
+     estimation) as data and select model parameters that align the model’s
+     IRFs closely with their empirical counterparts.
+
+   - Available under option `mom_method = irf_matching` option to the
+     `method_of_moments` command.
+
+   - New blocks `matched_irfs` and `matched_irfs_weights` for specifying the
+     values and weights of the empirical impulse response functions.
+
+ - Pruning à la Andreasen et al. (2018) is now available at an arbitrary
+   approximation order when performing stochastic simulations with
+   `stoch_simul`, and at 3rd order when performing particle filtering.
+
+ - New `log` option to the `var` statement. In addition to the endogenous
+   variable(s) thus declared, this option also triggers the creation of
+   auxiliary variable(s) equal to the log of the corresponding endogenous
+   variable(s). For example, given a `var(log) y;` statement, two endogenous
+   will be created (`y` and `LOG_y`), and an auxiliary equation linking the two
+   will also be added (equal to `y = exp(LOG_y);`). Moreover, every occurrence
+   of `y` in the model will be replaced by `exp(LOG_y)`. This option is, for
+   example, useful for performing a loglinear approximation of some variable(s)
+   in the context of a first-order stochastic approximation; or for ensuring
+   that the variable(s) stay(s) in the definition domain of the function
+   defining the steady state or the dynamic residuals when the nonlinear solver
+   is used.
+
+ - New model editing features
+
+   - Multiple `model` blocks are now supported (this was already working but
+     not explicitly documented).
+
+   - Multiple `estimated_params` blocks now concatenate their contents (instead
+     of overwriting previous ones, which was the former undocumented behavior);
+     an `overwrite` option has been added to provide the old behavior.
+
+   - New `model_options` statement to set model options in a global fashion.
+
+   - New `model_remove` command to remove equations.
+
+   - New `model_replace` block to replace equations.
+
+   - New `var_remove` command to remove variables (or parameters).
+
+   - New `estimated_params_remove` block to remove estimated parameters.
+
+ - Stochastic simulations
+
+   - Performance improvements for simulation of the solution under perturbation
+     and for particle filtering at higher order (⩾ 3).
+
+   - Performance improvement for the first order perturbation solution using
+     either cycle reduction (`dr=cycle_reduction` option) or logarithmic
+     reduction (`dr=logarithmic_reduction`).
+
+   - New `nomodelsummary` option to the `stoch_simul` command, to suppress the
+     printing of the model summary and the covariance of the exogenous shocks.
+
+ - Estimation
+
+   - A truncated normal distribution can now be specified as a prior, using the
+     3rd and 4th parameters of the `estimated_params` block as the bounds.
+
+   - New `conditional_likelihood` option to the `estimation` command. When the
+     option is set, instead of using the Kalman filter to evaluate the
+     likelihood, Dynare will evaluate the conditional likelihood based on the
+     first-order reduced form of the model by assuming that the initial state
+     vector is at its steady state.
+
+   - New `additional_optimizer_steps` option to the `estimation` command to
+     trigger the sequential execution of several optimizers when looking for
+     the posterior mode.
+
+   - The `generate_trace_plots` command now allows comparing multiple chains.
+
+   - The Geweke and Raftery-Lewis convergence diagnostics will now also be
+     displayed when `mh_nblocks>1`.
+
+   - New `robust`, `TolGstep`, and `TolGstepRel` options to the optimizer
+     available under `mode_compute=5` (“newrat”).
+
+   - New `brooks_gelman_plotrows` option to the `estimation` command for
+     controlling the number of parameters to depict along the rows of the
+     figures depicting the Brooks and Gelman (1998) convergence diagnostics.
+
+   - New `mh_init_scale_factor` option to the `estimation` command tor govern
+     the overdispersion of the starting draws when initializing several Monte
+     Carlo Markov Chains. This option supersedes the `mh_init_scale` option,
+     which is now deprecated.
+
+ - Steady state computation
+
+   - Steady state computation now accounts for occasionally-binding constraints
+     of mixed-complementarity problems (as defined by `mcp` tags).
+
+   - New `tolx` option to the `steady` command for governing the termination
+     based on the step tolerance.
+
+   - New `fsolve_options` option to the `steady` command for passing options to
+     `fsolve` (in conjunction with the `solve_algo=0` option).
+
+   - New option `from_initval_to_endval` option to the `homotopy_setup` block,
+     for easily computing homotopy from initial to terminal steady state (when
+     the former is already computed).
+
+   - New `non_zero` option to `resid` command to restrict display to non-zero
+     residuals.
+
+ - Perfect foresight
+
+   - Significant performance improvement of the `stack_solve_algo=1` option to
+     the `perfect_foresight_solver` command (Laffargue-Boucekkine-Juillard
+     algorithm) when used in conjunction with options `block` and/or `bytecode`
+     of the `model` block.
+
+   - New `relative_to_initval` option to the `mshocks` block, to use the
+     initial steady state as a basis for the multiplication when there is an
+     `endval` block.
+
+   - New `static_mfs` option to the `model` block (and to the `model_options`
+     command), for controlling the minimum feedback set computation for the
+     static model. It defaults to `0` (corresponding to the behavior in Dynare
+     version 5).
+
+   - Various improvements to homotopy
+
+     - New `endval_steady` option to the `perfect_foresight_setup` command for
+       computing the terminal steady state at the same time as the transitory
+       dynamics (and new options `steady_solve_algo`, `steady_tolf`,
+       `steady_tolx`, `steady_maxit` and `steady_markowitz` for controlling the
+       steady state nonlinear solver).
+
+     - New `homotopy_linearization_fallback` and
+       `homotopy_marginal_linearization_fallback` options to the
+       `perfect_foresight_solver` command to get an approximate solution when
+       homotopy fails to go to 100%.
+
+     - New `homotopy_initial_step_size`, `homotopy_min_step_size`,
+       `homotopy_step_size_increase_success_count` and
+       `homotopy_max_completion_share` options to the
+       `perfect_foresight_solver` command to fine tune the homotopy behavior.
+
+     - Purely backward, forward and static models are now supported by the
+       homotopy procedure.
+
+   - The `stack_solve_algo=1` and `stack_solve_algo=6` options of the
+     `perfect_foresight_solver` command were merged and are now synonymous.
+     They both provide the Laffargue-Boucekkine-Juillard algorithm and work
+     with and without the `block` and `bytecode` options of the `model` block.
+     Using `stack_solve_algo=1` is now recommended, but `stack_solve_algo=6` is
+     kept for backward compatibility.
+
+ - OccBin
+
+   - New `simul_reset_check_ahead_periods` option to the `occbin_setup` and
+     `occbin_solver` commands, for resetting `check_ahead_periods` in each
+     simulation period.
+
+   - new `simul_max_check_ahead_periods`, `likelihood_max_check_ahead_periods`,
+     and `smoother_max_check_ahead_periods` options to the `occbin_setup`
+     command, for truncating the number of periods for which agents check ahead
+     which regime is present.
+
+ - Optimal policy
+
+   - The `osr` command now accepts the `analytic_derivation` and
+     `analytic_derivation_mode` options.
+
+   - The `evaluate_planner_objective` command now computes the unconditional
+     welfare for higher-order approximations (⩾ 3).
+
+   - New `periods` and `drop` options to the `evaluate_planner_objective`
+     command.
+
+ - Semi-structural models
+
+   - New `pac_target_info` block for decomposing the PAC target into an
+     arbitrary number of components. Furthermore, in the presence of such a
+     block, the new `pac_target_nonstationary` operator can be used to select
+     the non stationary part of the target (typically useful in the error
+     correction term of the PAC equation).
+
+   - New `kind` option to the `pac_model` command. This option allows the user
+     to select the formula used to compute the weights on the VAR companion
+     matrix variables that are used to form PAC expectations.
+
+   - Performance improvement to `solve_algo=12` and `solve_algo=14`, which
+     significantly accelerates the simulation of purely backward, forward and
+     static models with the `perfect_foresight_solver` command and the routines
+     for semi-structural models.
+
+ - dseries classes
+
+   - The `remove` and `remove_` methods now accept a list of variables (they
+     would previously only accept a single variable).
+
+   - New MATLAB/Octave command `dplot` to plot mathematical expressions
+     generated from variables fetched from (different) dseries objects.
+
+ - Misc
+
+   - New `display_parameter_values` command to print the parameter values in
+     the command window.
+
+   - New `collapse_figures_in_tabgroup` command to dock all figures.
+
+   - Performance improvement for the `use_dll` option of the `model` block. The
+     preprocessor now takes advantage of parallelization when compiling the MEX
+     files.
+
+   - New mathematical primitives available: complementary error function
+     (`erfc`), hyperbolic functions (`cosh`, `sinh`, `tanh`, `acosh`, `asinh`,
+     `atanh`).
+
+   - New `last_simulation_period` option to the `initval_file` command.
+
+   - The `calib_smoother` command now accepts the `nobs` and
+     `heteroskedastic_filter` options.
+
+   - Under the MATLAB Desktop, autocompletion is now available for the `dynare`
+     command and other CLI commands (thanks to Eduard Benet Cerda from
+     MathWorks).
+
+   - Model debugging: The preprocessor now creates files for evaluating the
+     left- and right-hand sides of model equations separately. For a model file
+     called `ramst.mod`, you can call
+     `[lhs,rhs]=ramst.debug.static_resid(y,x,params);` (for the static model)
+     and `[lhs,rhs]=ramst.debug.dynamic_resid(y,x,params,steady_state);` (for
+     the dynamic model), where `y` are the endogenous, `x` the exogenous,
+     `params` the parameters, and `steady_state` is self-explanatory. NB: In
+     the dynamic case, the vector `y` of endogenous must have 3n elements
+     where n is the number of endogenous (including auxiliary ones); the
+     first n elements correspond to the lagged values, the middle n
+     elements to the contemporaneous values, and the last n elements to the
+     lead values.
+
+   - New interactive MATLAB/Octave command `search` for listing the equations
+     in which given variable(s) appear (requires `json` command line option).
+
+   - The `model_info` command allows to print the block decomposition even if
+     the `block` option of the `model` block has not been used, by specifying
+     the new options `block_static` and `block_dynamic`.
+
+   - There is now a default value for the global initialization file
+     (`GlobalInitFile` option of the configuration file): the `global_init.m`
+     in the Dynare configuration directory (typically
+     `$HOME/.config/dynare/global_init.m` under Linux and macOS, and
+     `c:\Users\USERNAME\AppData\Roaming\dynare\global_init.m` under Windows).
+
+   - For those compiling Dynare from source, the build system has been entirely
+     rewritten and now uses Meson; as a consequence, it is now faster and
+     easier to understand.
+
+- References:
+
+  - Andreasen, Martin M., Jesús Fernández-Villaverde, and Juan Rubio-Ramírez
+    (2018): “The Pruned State-Space System for Non-Linear DSGE Models: Theory
+    and Empirical Applications,” *Review of Economic Studies*, 85(1), 1-49.
+  - Brooks, Stephen P., and Andrew Gelman (1998): “General methods for
+    monitoring convergence of iterative simulations,” *Journal of Computational
+    and Graphical Statistics*, 7, pp. 434–455.
+  - Christiano, Eichenbaum and Charles L. Evans (2005): “Nominal Rigidities and
+    the Dynamic Effects of a Shock to Monetary Policy,” *Journal of Political
+    Economy*, 113(1), 1–45.
+  - Christiano, Lawrence J., Mathias Trabandt, and Karl Walentin (2010): “DSGE
+    Models for Monetary Policy Analysis,” In: *Handbook of Monetary Economics
+    3*, 285–367.
+  - Herbst, Edward and Schorfheide, Frank (2014): "Sequential Monte Carlo
+    Sampling for DSGE Models," *Journal of Applied Econometrics*, 29,
+    1073-1098.
+
+Incompatible changes
+--------------------
+
+ - The default value of the `mode_compute` option of the `estimation` command
+   has been changed to `5` (it was previously `4`).
+
+ - When using block decomposition (with the `block` option of the `model`
+   block), the option `mfs` now defaults to `1`. This setting should deliver
+   better performance in perfect foresight simulation on most models.
+
+ - The default location for the configuration file has changed. On Linux and
+   macOS, the configuration file is now searched by default under
+   `dynare/dynare.ini` in the configuration directories defined by the XDG
+   specification (typically `$HOME/.config/dynare/dynare.ini` for the
+   user-specific configuration and `/etc/xdg/dynare/dynare.ini` for the
+   system-wide configuration, the former having precedence over the latter).
+   Under Windows, the configuration file is now searched by default in
+   `%APPDATA%\dynare\dynare.ini` (typically
+   `c:\Users\USERNAME\AppData\Roaming\dynare\dynare.ini`).
+
+ - The information stored in `oo_.endo_simul, oo_.exo_simul`, and `oo_.irfs` is
+   no longer duplicated in the base workspace. New helper functions
+   `send_endogenous_variables_to_workspace`,
+   `send_exogenous_variables_to_workspace`, and `send_irfs_to_workspace` have
+   been introduced to explicitly request these outputs and to mimic the old
+   behavior.
+
+ - The `dynare_sensitivity` command has been renamed `sensitivity`. The old
+   name is still accepted but triggers a warning.
+
+ - The syntax `resid(1)` is no longer supported.
+
+ - The `mode_compute=6` option to the `estimation` command now recursively
+   updates the covariance matrix across the `NumberOfMh` Metropolis-Hastings
+   runs, starting with the `InitialCovarianceMatrix` in the first run, instead
+   of computing it from scratch in every Metropolis-Hastings run.
+
+ - The `periods` command has been removed.
+
+ - The `Sigma_e` command has been removed.
+
+ - The `block` option of the `model` block no longer has an effect when used in
+   conjunction with `stoch_simul` or `estimation` commands.
+
+ - The Dynare++ executable is no longer distributed since almost all of its
+   functionalities have been integrated inside Dynare for MATLAB/Octave.
+
+ - A macro-processor variable defined without a value (such as `@#define var`
+   in the `.mod` file or alternatively `-Dvar` on the `dynare` command line) is
+   now assigned the `true` logical value (it was previously assigned `1`).
+
+ - The `parallel_slave_open_mode` option of the `dynare` command has been
+   renamed `parallel_follower_open_mode`.
+
+ - The `static` option of the `model_info` command is now deprecated and is
+   replaced by the `block_static` option.
+
+Bugs that were present in 5.5 and that have been fixed in 6.0
+-------------------------------------------------------------
+
+* The `mh_initialize_from_previous_mcmc` option of the `estimation` command
+  would not work if estimation was conducted with a different prior and the
+  last draw in the previous MCMC fell outside the new prior bounds
+* When specifying a generalized inverse Gamma prior, the hyperparameter
+  computation would erroneously ignore the resulting mean shift
+* When using the `mh_recover` option of the `estimation` command, the status
+  bar always started at zero instead of showing the overall progress of the
+  recovered chain
+* The `model_diagnostics` command would fail to check the correctness of
+  user-defined steady state files
+* GSA: LaTeX output was not working as expected
+* Forecasts and filtered variables could not be retrieved with the
+ `heteroskedastic_shocks` block
+* The OccBin smoother would potentially not display all smoothed shocks with
+  `heteroskedastic_filter` option
+* The OccBin smoother would crash if the number of requested periods was
+  smaller than the data length
+* The multivariate OccBin smoother would return wrong results if the constraint
+  was binding in the first period
+* The `plot_shock_decomposition` command would fail with the `init2shocks`
+  block if the `initial_condition_decomposition` was not run before
+* LaTeX output under Windows failed to compile for `plot_priors=1` option of
+  the `estimation` command and Brooks and Gelman (1998) convergence diagnostics
+* The plot produced by the `shock_decomposition` command was too big, making
+  the close button inaccessible
+* Monthly dates for October, November and December (*i.e.* with a 2-digit month
+  number) were not properly interpreted by the preprocessor
+* Theoretical moments computed by `stoch_simul` at `order=2` with `pruning`
+  would not contain unconditional and conditional variance decomposition
+
+
 Announcement for Dynare 5.5 (on 2023-10-23)
 ===========================================
 

doc/manual/source/bibliography.rst

@@ -16,8 +16,8 @@ Bibliography
 * Bini, Dario A., Guy Latouche, and Beatrice Meini (2002): “Solving matrix polynomial equations arising in queueing problems,” *Linear Algebra and its Applications*, 340, 225–244.
 * Born, Benjamin and Johannes Pfeifer (2014): “Policy risk and the business cycle”, *Journal of Monetary Economics*, 68, 68-85.
 * Boucekkine, Raouf (1995): “An alternative methodology for solving nonlinear forward-looking models,” *Journal of Economic Dynamics and Control*, 19, 711–734.
-* Brayton, Flint and Peter Tinsley (1996): "A Guide to FRB/US: A Macroeconomic Model of the United States", *Finance and Economics Discussion Series*, 1996-42.
-* Brayton, Flint, Morris Davis and Peter Tulip (2000): "Polynomial Adjustment Costs in FRB/US", *Unpublished manuscript*.
+* Brayton, Flint and Peter Tinsley (1996): “A Guide to FRB/US: A Macroeconomic Model of the United States,” *Finance and Economics Discussion Series*, 1996-42.
+* Brayton, Flint, Morris Davis and Peter Tulip (2000): “Polynomial Adjustment Costs in FRB/US,” *Unpublished manuscript*.
 * Brooks, Stephen P., and Andrew Gelman (1998): “General methods for monitoring convergence of iterative simulations,” *Journal of Computational and Graphical Statistics*, 7, pp. 434–455.
 * Cardoso, Margarida F., R. L. Salcedo and S. Feyo de Azevedo (1996): “The simplex simulated annealing approach to continuous non-linear optimization,” *Computers & Chemical Engineering*, 20(9), 1065-1080.
 * Chib, Siddhartha and Srikanth Ramamurthy (2010): “Tailored randomized block MCMC methods with application to DSGE models,” *Journal of Econometrics*, 155, 19–38.
@@ -29,7 +29,7 @@ Bibliography
 * Collard, Fabrice and Michel Juillard (2001a): “Accuracy of stochastic perturbation methods: The case of asset pricing models,” *Journal of Economic Dynamics and Control*, 25, 979–999.
 * Collard, Fabrice and Michel Juillard (2001b): “A Higher-Order Taylor Expansion Approach to Simulation of Stochastic Forward-Looking Models with an Application to a Non-Linear Phillips Curve,” *Computational Economics*, 17, 125–139.
 * Corana, Angelo, M. Marchesi, Claudio Martini, and Sandro Ridella (1987): “Minimizing multimodal functions of continuous variables with the “simulated annealing” algorithm”, *ACM Transactions on Mathematical Software*, 13(3), 262–280.
-* Cuba-Borda, Pablo, Luca Guerrieri, Matteo Iacoviello, and Molin Zhong (2019): "Likelihood evaluation of models with occasionally binding constraints", Journal of Applied Econometrics, 34(7), 1073-1085
+* Cuba-Borda, Pablo, Luca Guerrieri, Matteo Iacoviello, and Molin Zhong (2019): “Likelihood evaluation of models with occasionally binding constraints,” Journal of Applied Econometrics, 34(7), 1073-1085
 * Del Negro, Marco and Frank Schorfheide (2004): “Priors from General Equilibrium Models for VARs”, *International Economic Review*, 45(2), 643–673.
 * Dennis, Richard (2007): “Optimal Policy In Rational Expectations Models: New Solution Algorithms”, *Macroeconomic Dynamics*, 11(1), 31–55.
 * Duffie, Darrel and Kenneth J. Singleton (1993): “Simulated Moments Estimation of Markov Models of Asset Prices”, *Econometrica*, 61(4), 929-952.
@@ -49,7 +49,7 @@ Bibliography
 * Hansen, Lars P. (1982): “Large sample properties of generalized method of moments estimators,” Econometrica, 50(4), 1029–1054.
 * Hansen, Nikolaus and Stefan Kern (2004): “Evaluating the CMA Evolution Strategy on Multimodal Test Functions”. In: *Eighth International Conference on Parallel Problem Solving from Nature PPSN VIII*, Proceedings, Berlin: Springer, 282–291.
 * Harvey, Andrew C. and Garry D.A. Phillips (1979): “Maximum likelihood estimation of regression models with autoregressive-moving average disturbances,” *Biometrika*, 66(1), 49–58.
-* Herbst, Edward and Schorfheide, Frank (2014): "Sequential monte-carlo sampling for DSGE models," *Journal of Applied Econometrics*, 29, 1073-1098.
+* Herbst, Edward and Schorfheide, Frank (2014): “Sequential Monte Carlo Sampling for DSGE Models,” *Journal of Applied Econometrics*, 29, 1073-1098.
 * Herbst, Edward (2015): “Using the “Chandrasekhar Recursions” for Likelihood Evaluation of DSGE Models,” *Computational Economics*, 45(4), 693–705.
 * Ireland, Peter (2004): “A Method for Taking Models to the Data,” *Journal of Economic Dynamics and Control*, 28, 1205–26.
 * Iskrev, Nikolay (2010): “Local identification in DSGE models,” *Journal of Monetary Economics*, 57(2), 189–202.

doc/manual/source/conf.py

@@ -75,7 +75,7 @@ latex_elements = {
 
 latex_documents = [
     (master_doc, 'dynare-manual.tex', u'Dynare Reference Manual',
-     u'Dynare team', 'manual'),
+     u'Dynare Team', 'manual'),
 ]
 
 man_pages = [

doc/manual/source/dynare-misc-commands.rst

@@ -281,7 +281,7 @@ Dynare misc commands
 
       This option is not mandatory and allows to plot the expressions
       only over a sub-range. ``DATE1`` and ``DATE2`` must be dates as
-      defined in :ref:`dates in mod file`.
+      defined in :ref:`dates in a mod file`.
 
    .. option:: --style MATLAB_SCRIPT_NAME
 

doc/manual/source/introduction.rst

@@ -94,26 +94,24 @@ Citing Dynare in your research
 You should cite Dynare if you use it in your research. The
 recommended way todo this is to cite the present manual, as:
 
-    Stéphane Adjemian, Houtan Bastani, Michel Juillard, Frédéric Karamé,
-    Ferhat Mihoubi, Willi Mutschler, Johannes Pfeifer, Marco Ratto,
-    Normann Rion and Sébastien Villemot (2022), “Dynare: Reference Manual,
-    Version 5,” *Dynare Working Papers*, 72, CEPREMAP
+    Stéphane Adjemian, Michel Juillard, Frédéric Karamé, Willi Mutschler,
+    Johannes Pfeifer, Marco Ratto, Normann Rion and Sébastien Villemot (2024),
+    “Dynare: Reference Manual, Version 6,” *Dynare Working Papers*, 80, CEPREMAP
 
 For convenience, you can copy and paste the following into your BibTeX file:
 
     .. code-block:: bibtex
 
-        @TechReport{Adjemianetal2022,
-          author      = {Adjemian, St\'ephane and Bastani, Houtan and
-                         Juillard, Michel and Karam\'e, Fr\'ederic and
-                         Mihoubi, Ferhat and Mutschler, Willi
-                         and Pfeifer, Johannes and Ratto, Marco and
+        @TechReport{Adjemianetal2024,
+          author      = {Adjemian, St\'ephane and Juillard, Michel and
+                         Karam\'e, Fr\'ederic and Mutschler, Willi and
+                         Pfeifer, Johannes and Ratto, Marco and
                          Rion, Normann and Villemot, S\'ebastien},
-          title       = {Dynare: Reference Manual Version 5},
-          year        = {2022},
+          title       = {Dynare: Reference Manual, Version 6},
+          year        = {2024},
           institution = {CEPREMAP},
           type        = {Dynare Working Papers},
-          number      = {72},
+          number      = {80},
         }
 
 If you want to give a URL, use the address of the Dynare website:

doc/manual/source/the-model-file.rst

@@ -3003,19 +3003,23 @@ Finding the steady state with Dynare nonlinear solver
                 blocks that can be evaluated rather than solved; and evaluations
                 of the residual and Jacobian of the model are more efficient
                 because only the relevant elements are recomputed at every
-                iteration.
+                iteration. This option is typically used with the
+                ``perfect_foresight_solver`` command with purely backward,
+                forward or static models, or with routines for semi-structural
+                models, and it must *not* be combined with option ``block`` of
+                the ``model`` block. Also note that for those models, the block
+                decomposition is performed as if ``mfs=3`` had been passed to
+                the ``model`` block, and the decomposition is slightly
+                different because it is computed in a time-recursive fashion
+                (*i.e.* in such a way that the simulation is meant to be done
+                with the outer loop on periods and the inner loop on blocks;
+                while for models with both leads and lags, the outer loop is on
+                blocks and the inner loop is on periods).
 
            ``14``
 
-                Computes a block decomposition and then applies a trust region
-                solver with autoscaling on those smaller blocks rather than on
-                the full nonlinear system. This is similar to ``4``, but is
-                typically more efficient. The block decomposition is done at
-                the preprocessor level, which brings two benefits: it
-                identifies blocks that can be evaluated rather than solved; and
-                evaluations of the residual and Jacobian of the model are more
-                efficient because only the relevant elements are recomputed at
-                every iteration.
+                Same as ``12``, except that it applies a trust region solver
+                (similar to ``4``) to the blocks.
 
        |br| Default value is ``4``.
 
@@ -3738,7 +3742,7 @@ speed-up on large models.
                solvers available through option ``solve_algo``, applied on the
                stacked system of all equations in all periods (See
                :ref:`solve_algo <solvalg>` for a list of possible values, note
-               that values 5, 6, 7 and 8, which require ``bytecode`` and/or
+               that values ``5``, ``6``, ``7`` and ``8``, which require ``bytecode`` and/or
                ``block`` options, are not allowed). For instance, the following
                commands::
 
@@ -3756,7 +3760,10 @@ speed-up on large models.
     .. option:: solve_algo
 
        See :ref:`solve_algo <solvalg>`. Allows selecting the solver
-       used with ``stack_solve_algo=7``.
+       used with ``stack_solve_algo=7``. Also used for purely backward, forward
+       and static models (when neither the ``block`` nor the ``bytecode`` option
+       of the ``model`` block is specified); for those models, the values
+       ``12`` and ``14`` are especially relevant.
 
     .. option:: no_homotopy
 
@@ -5774,6 +5781,14 @@ All of these elements are discussed in the following.
 
         See :opt:`simul_check_ahead_periods <simul_check_ahead_periods = INTEGER>`.
 
+    .. option:: simul_reset_check_ahead_periods
+
+        See :opt:`simul_reset_check_ahead_periods`.
+
+    .. option:: simul_max_check_ahead_periods
+
+        See :opt:`simul_max_check_ahead_periods <simul_max_check_ahead_periods = INTEGER>`.
+
     .. option:: simul_curb_retrench
 
         See :opt:`simul_curb_retrench`.
@@ -6513,7 +6528,7 @@ observed variables.
        Note however that the conditional likelihood is sensitive to the choice
        for the initial condition, which can be an issue if the data are
        initially far from the steady state. This option is not compatible with
-       ``analytical_derivation``.
+       ``analytic_derivation``.
 
     .. option:: conf_sig = DOUBLE
 
@@ -14262,7 +14277,7 @@ assumed that each equation is written as ``VARIABLE = EXPRESSION`` or
 ``T(VARIABLE) = EXPRESSION`` where ``T(VARIABLE)`` stands for a transformation
 of an endogenous variable (``log`` or ``diff``). This representation, where each
 equation determines the endogenous variable on the LHS, can be exploited when
-simulating the model (see algorithms 12 and 14 in :ref:`solve_algo <solvalg>`)
+simulating the model (see algorithms ``12`` and ``14`` in :ref:`solve_algo <solvalg>`)
 and is mandatory to define auxiliary models used for computing expectations (see
 below).
 

macOS/deps/Makefile

@@ -53,17 +53,16 @@ clean-all: clean-lib clean-src clean-tar
 #
 tarballs/slicot-$(SLICOT_VERSION).tar.gz:
 	mkdir -p tarballs
-	wget $(WGET_OPTIONS) -O $@ https://deb.debian.org/debian/pool/main/s/slicot/slicot_$(SLICOT_VERSION).orig.tar.gz
+	wget $(WGET_OPTIONS) -O $@ https://deb.debian.org/debian/pool/main/s/slicot/slicot_$(SLICOT_VERSION).orig.tar.xz
 
 $(DEPS_ARCH)/sources64/slicot-$(SLICOT_VERSION): tarballs/slicot-$(SLICOT_VERSION).tar.gz
 	rm -rf $(DEPS_ARCH)/sources64/slicot-*
 	mkdir -p $@
 	tar xf $< --directory $@ --strip-components=1
-	patch -d $@ -p1 < ../../windows/deps/slicot-build-system.patch
 	touch $@
 
 $(DEPS_ARCH)/lib64/slicot/libslicot64_pic.a: $(DEPS_ARCH)/sources64/slicot-$(SLICOT_VERSION)
-	make -C $< -f makefile_Unix FC=$(BREWDIR)/bin/gfortran LOADER=$(BREWDIR)/bin/gfortran SLICOTLIB=../libslicot64_pic.a FFLAGS="-O3 -fdefault-integer-8" lib -j$(NTHREADS)
+	make -C $< -f makefile_Unix FORTRAN=$(BREWDIR)/bin/gfortran LOADER=$(BREWDIR)/bin/gfortran SLICOTLIB=../libslicot64_pic.a OPTS="-O3 -fdefault-integer-8" lib -j$(NTHREADS)
 	strip -S $</libslicot64_pic.a
 	mkdir -p $(dir $@)
 	cp $</libslicot64_pic.a $@

macOS/deps/versions.mk

@@ -1,2 +1,2 @@
-SLICOT_VERSION = 5.8+20230223.git401037e
+SLICOT_VERSION = 5.9~20240205.gita037f7e
 X13AS_VERSION = 1-1-b60

matlab/+identification/get_perturbation_params_derivs.m

@@ -93,7 +93,8 @@ function DERIVS = get_perturbation_params_derivs(M_, options_, estim_params_, dr
 % This function calls
 %   * [fname,'.dynamic']
 %   * [fname,'.dynamic_params_derivs']
-%   * [fname,'.static']
+%   * [fname,'.sparse.static_g1']
+%   * [fname,'.sparse.static_g2']
 %   * [fname,'.static_params_derivs']
 %   * commutation
 %   * dyn_vech
@@ -109,7 +110,7 @@ function DERIVS = get_perturbation_params_derivs(M_, options_, estim_params_, dr
 %   * sylvester3a
 %   * get_perturbation_params_derivs_numerical_objective
 % =========================================================================
-% Copyright © 2019-2020 Dynare Team
+% Copyright © 2019-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -454,12 +455,13 @@ elseif (analytic_derivation_mode == 0 || analytic_derivation_mode == 1)
         error('For analytical parameter derivatives ''dynamic_params_derivs.m'' file is needed, this can be created by putting identification(order=%d) into your mod file.',order)
     end
     %% Analytical computation of Jacobian and Hessian (wrt selected model parameters) of steady state, i.e. dYss and d2Yss
-    [~, g1_static] = feval([fname,'.static'], ys, exo_steady_state', params); %g1_static is [endo_nbr by endo_nbr] first-derivative (wrt all endogenous variables) of static model equations f, i.e. df/dys, in declaration order
+    [g1_static, T_order_static, T_static] = feval([fname,'.sparse.static_g1'], ys, exo_steady_state', params, M_.static_g1_sparse_rowval, M_.static_g1_sparse_colval, M_.static_g1_sparse_colptr); %g1_static is [endo_nbr by endo_nbr] first-derivative (wrt all endogenous variables) of static model equations f, i.e. df/dys, in declaration order
     rp_static = feval([fname,'.static_params_derivs'], ys, exo_steady_state', params); %rp_static is [endo_nbr by param_nbr] first-derivative (wrt all model parameters) of static model equations f, i.e. df/dparams, in declaration order
     dys = -g1_static\rp_static; %use implicit function theorem (equation 5 of Ratto and Iskrev (2012) to compute [endo_nbr by param_nbr] first-derivative (wrt all model parameters) of steady state for all endogenous variables analytically, note that dys is in declaration order
     d2ys = zeros(endo_nbr, param_nbr, param_nbr); %initialize in tensor notation, note that d2ys is only needed for d2flag, i.e. for g1pp
     if d2flag
-        [~, ~, g2_static] = feval([fname,'.static'], ys, exo_steady_state', params); %g2_static is [endo_nbr by endo_nbr^2] second derivative (wrt all endogenous variables) of static model equations f, i.e. d(df/dys)/dys, in declaration order
+        g2_static_v = feval([fname,'.sparse.static_g2'], ys, exo_steady_state', params, T_order_static, T_static);
+        g2_static = build_two_dim_hessian(M_.static_g2_sparse_indices, g2_static_v, endo_nbr, endo_nbr); %g2_static is [endo_nbr by endo_nbr^2] second derivative (wrt all endogenous variables) of static model equations f, i.e. d(df/dys)/dys, in declaration order
         if order < 3
             [~, g1, g2, g3] = feval([fname,'.dynamic'], ys(I), exo_steady_state', params, ys, 1); %note that g3 does not contain symmetric elements
             g3 = identification.unfold_g3(g3, yy0ex0_nbr); %add symmetric elements to g3
@@ -505,7 +507,7 @@ elseif (analytic_derivation_mode == 0 || analytic_derivation_mode == 1)
     end
     %handling of steady state for nonstationary variables
     if any(any(isnan(dys)))
-        [U,T] = schur(g1_static);
+        [U,T] = schur(full(g1_static));
         e1 = abs(ordeig(T)) < qz_criterium-1;
         k = sum(e1);       % Number of non stationary variables.
                            % Number of stationary variables: n = length(e1)-k

matlab/backward/simul_static_model.m

@@ -15,7 +15,7 @@ function simulation = simul_static_model(samplesize, innovations)
 % [2] The last input argument is not mandatory. If absent we use random draws and rescale them with the informations provided
 %     through the shocks block.
 
-% Copyright © 2019-2022 Dynare Team
+% Copyright © 2019-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -83,12 +83,17 @@ else
     oo_.exo_simul = Innovations;
 end
 
-staticmodel = str2func(sprintf('%s.static', M_.fname));
+static_resid = str2func(sprintf('%s.sparse.static_resid', M_.fname));
+static_g1 = str2func(sprintf('%s.sparse.static_g1', M_.fname));
+function [resid, g1] = staticmodel(y, x, params)
+    [resid, T_order, T] = static_resid(y, x, params);
+    g1 = static_g1(y, x, params, M_.static_g1_sparse_rowval, M_.static_g1_sparse_colval, M_.static_g1_sparse_colptr, T_order, T);
+end
 
 % Simulations (call a Newton-like algorithm for each period).
 for t=1:samplesize
     y = zeros(M_.endo_nbr, 1);
-    [oo_.endo_simul(:,t), errorflag, ~, ~, errorcode] = dynare_solve(staticmodel, y, options_.simul.maxit, options_.dynatol.f, options_.dynatol.x, options_, oo_.exo_simul(t,:), M_.params);
+    [oo_.endo_simul(:,t), errorflag, ~, ~, errorcode] = dynare_solve(@staticmodel, y, options_.simul.maxit, options_.dynatol.f, options_.dynatol.x, options_, oo_.exo_simul(t,:), M_.params);
     if errorflag
         dprintf('simul_static_mode: Nonlinear solver failed with errorcode=%i in period %i.', errorcode, t)
         oo_.endo_simul(:,t) = nan;
@@ -103,4 +108,6 @@ if isdseries(innovations)
     initperiod = innovations.dates(1);
 end
 
-simulation = [dseries(ysim', initperiod, M_.endo_names(1:M_.orig_endo_nbr)), dseries(xsim, initperiod, M_.exo_names)];
+simulation = [dseries(ysim', initperiod, M_.endo_names(1:M_.orig_endo_nbr)), dseries(xsim, initperiod, M_.exo_names)];
+
+end

matlab/build_two_dim_hessian.m

@@ -0,0 +1,58 @@
+function H = build_two_dim_hessian(sparse_indices, g2_v, neq, nvar)
+% Creates a 2D Hessian (equations in rows, pairs of variables in columns),
+% given the output from the sparse {static,dynamic}_g2.m
+%
+% – sparse_indices is typically equal to M_.{static,dynamic}_g2_sparse_indices
+% – g2_v is the vector of non zero values returned by {static,dynamic}_g2.m
+% – neq is the number of equations (equal to number of rows of the output matrix)
+% – nvar is the number of variables (the output matrix will have nvar² columns)
+
+% Copyright © 2024 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 <https://www.gnu.org/licenses/>.
+
+nnz = size(sparse_indices, 1);
+
+%% The g2_* arrays may be expanded if there are symmetric elements added
+g2_i = int32(zeros(nnz, 1));
+g2_j = int32(zeros(nnz, 1));
+
+next_sym_idx = nnz + 1; % Index of next symmetric element to be added
+
+for k = 1:length(g2_v)
+    eq = sparse_indices(k, 1);
+    var1 = sparse_indices(k, 2)-1;
+    var2 = sparse_indices(k, 3)-1;
+
+    g2_i(k) = eq;
+    g2_j(k) = var1 * nvar + var2 + 1;
+
+    %% Add symmetric elements, which are not included by sparse {static,dynamic}_g2.m
+    if var1 ~= var2
+        g2_i(next_sym_idx) = eq;
+        g2_j(next_sym_idx) = var2 * nvar + var1 + 1;
+        g2_v(next_sym_idx) = g2_v(k);
+        next_sym_idx = next_sym_idx + 1;
+    end
+end
+
+%% On MATLAB < R2020a, sparse() does not accept int32 indices
+if ~isoctave && matlab_ver_less_than('9.8')
+    g2_i = double(g2_i);
+    g2_j = double(g2_j);
+end
+
+H = sparse(g2_i, g2_j, g2_v, neq, nvar*nvar);

matlab/discretionary_policy/discretionary_policy_1.m

@@ -13,7 +13,7 @@ function [dr, info, params]=discretionary_policy_1(M_, options_, dr, endo_steady
 % - info          [integer]       scalar or vector, error code.
 % - params        [double]        vector of potentially updated parameters
 
-% Copyright © 2007-2020 Dynare Team
+% Copyright © 2007-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -49,7 +49,9 @@ else
 end
 params=M_.params;
 
-[~,Uy,W] = feval([M_.fname,'.objective.static'],zeros(M_.endo_nbr,1),[], M_.params);
+y = zeros(M_.endo_nbr,1);
+[Uy, T_order, T] = feval([M_.fname,'.objective.sparse.static_g1'], y, [], params, M_.objective_g1_sparse_rowval, M_.objective_g1_sparse_colval, M_.objective_g1_sparse_colptr);
+
 if any(any(isnan(Uy)))
     info = 64 ; %the derivatives of the objective function contain NaN
     return;
@@ -70,6 +72,8 @@ if any(any(Uy~=0))
     return;
 end
 
+g2_v = feval([M_.fname,'.objective.sparse.static_g2'], y, [], params, T_order, T);
+W = build_two_dim_hessian(M_.objective_g2_sparse_indices, g2_v, 1, M_.endo_nbr);
 W=reshape(W,M_.endo_nbr,M_.endo_nbr);
 
 klen = M_.maximum_lag + M_.maximum_lead + 1;
@@ -122,4 +126,4 @@ dr.ghu=G(dr.order_var,:);
 if M_.maximum_endo_lag
     Selection=M_.lead_lag_incidence(1,dr.order_var)>0;%select state variables
 end
-dr.ghx=T(:,Selection);
+dr.ghx=T(:,Selection);

matlab/estimation/selec_posterior_draws.m

@@ -26,7 +26,7 @@ function SampleAddress = selec_posterior_draws(M_,options_,dr,endo_steady_state,
 %   None.
 %
 
-% Copyright © 2006-2022 Dynare Team
+% Copyright © 2006-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -146,7 +146,7 @@ if info
             pdraws(linee,1) = {x2(SampleAddress(i,4),:)};
             if info==2
                 M_ = set_parameters_locally(M_,pdraws{i,1});
-                [dr,~,M_.params] = compute_decision_rules(M_,options_,oo_.dr, oo_.steady_state, oo_.exo_steady_state, oo_.exo_det_steady_state);
+                [dr,~,M_.params] = compute_decision_rules(M_,options_,dr, endo_steady_state, exo_steady_state, exo_det_steady_state);
                 pdraws(linee,2) = { dr };
             end
             old_mhfile = mhfile;

matlab/optimal_policy/evaluate_planner_objective.m

@@ -59,7 +59,7 @@ function planner_objective_value = evaluate_planner_objective(M_,options_,oo_)
 
 % In the deterministic case, resorting to approximations for welfare is no longer required as it is possible to simulate the model given initial conditions for pre-determined variables and terminal conditions for forward-looking variables, whether these initial and terminal conditions are explicitly or implicitly specified. Assuming that the number of simulated periods is high enough for the new steady-state to be reached, the new unconditional welfare is thus the last period's welfare. As for the conditional welfare, it can be derived using backward recursions on the equation W = U + beta*W(+1) starting from the final unconditional steady-state welfare.
 
-% Copyright © 2007-2022 Dynare Team
+% Copyright © 2007-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -92,11 +92,11 @@ end
 
 if options_.ramsey_policy && oo_.gui.ran_perfect_foresight
     T = size(oo_.endo_simul,2);
-    [U_term] = feval([M_.fname '.objective.static'],oo_.endo_simul(:,T-M_.maximum_lead),oo_.exo_simul(T-M_.maximum_lead,:), M_.params);
+    U_term = feval([M_.fname '.objective.sparse.static_resid'], oo_.endo_simul(:,T-M_.maximum_lead), oo_.exo_simul(T-M_.maximum_lead,:), M_.params);
     EW = U_term/(1-beta);
     W = EW;
     for t=T-M_.maximum_lead:-1:1+M_.maximum_lag
-        [U] = feval([M_.fname '.objective.static'],oo_.endo_simul(:,t),oo_.exo_simul(t,:), M_.params);
+        U = feval([M_.fname '.objective.sparse.static_resid'], oo_.endo_simul(:,t), oo_.exo_simul(t,:), M_.params);
         W = U + beta*W;
     end
     planner_objective_value = struct('conditional', W, 'unconditional', EW);
@@ -108,7 +108,8 @@ else
         ys = oo_.dr.ys;
     end
     if options_.order == 1 && ~options_.discretionary_policy
-        [U,Uy] = feval([M_.fname '.objective.static'],ys,zeros(1,exo_nbr), M_.params);
+        [U, T_order, T] = feval([M_.fname '.objective.sparse.static_resid'], ys, zeros(1,exo_nbr), M_.params);
+        Uy = feval([M_.fname '.objective.sparse.static_g1'], ys, zeros(1,exo_nbr), M_.params, M_.objective_g1_sparse_rowval, M_.objective_g1_sparse_colval, M_.objective_g1_sparse_colptr, T_order, T);
 
         Gy = dr.ghx(nstatic+(1:nspred),:);
         Gu = dr.ghu(nstatic+(1:nspred),:);
@@ -137,7 +138,9 @@ else
         planner_objective_value.conditional.zero_initial_multiplier = W_L_0;
 
     elseif options_.order == 2 && ~M_.hessian_eq_zero %full second order approximation
-        [U,Uy,Uyy] = feval([M_.fname '.objective.static'],ys,zeros(1,exo_nbr), M_.params);
+        [U, T_order, T] = feval([M_.fname '.objective.sparse.static_resid'], ys, zeros(1,exo_nbr), M_.params);
+        [Uy, T_order, T] = feval([M_.fname '.objective.sparse.static_g1'], ys, zeros(1,exo_nbr), M_.params, M_.objective_g1_sparse_rowval, M_.objective_g1_sparse_colval, M_.objective_g1_sparse_colptr, T_order, T);
+        Uyy_v = feval([M_.fname '.objective.sparse.static_g2'], ys, zeros(1,exo_nbr), M_.params, T_order, T);
 
         Gy = dr.ghx(nstatic+(1:nspred),:);
         Gu = dr.ghu(nstatic+(1:nspred),:);
@@ -153,6 +156,7 @@ else
         guu(dr.order_var,:) = dr.ghuu;
         gss(dr.order_var,:) = dr.ghs2;
 
+        Uyy = build_two_dim_hessian(M_.objective_g2_sparse_indices, Uyy_v, 1, M_.endo_nbr);
         Uyy = full(Uyy);
 
         Uyygygy = A_times_B_kronecker_C(Uyy,gy,gy);
@@ -228,13 +232,16 @@ else
         planner_objective_value.conditional.steady_initial_multiplier = W_L_SS;
         planner_objective_value.conditional.zero_initial_multiplier = W_L_0;
     elseif (options_.order == 2 && M_.hessian_eq_zero) || options_.discretionary_policy %linear quadratic problem
-        [U,Uy,Uyy] = feval([M_.fname '.objective.static'],ys,zeros(1,exo_nbr), M_.params);
+        [U, T_order, T] = feval([M_.fname '.objective.sparse.static_resid'], ys, zeros(1,exo_nbr), M_.params);
+        [Uy, T_order, T] = feval([M_.fname '.objective.sparse.static_g1'], ys, zeros(1,exo_nbr), M_.params, M_.objective_g1_sparse_rowval, M_.objective_g1_sparse_colval, M_.objective_g1_sparse_colptr, T_order, T);
+        Uyy_v = feval([M_.fname '.objective.sparse.static_g2'], ys, zeros(1,exo_nbr), M_.params, T_order, T);
 
         Gy = dr.ghx(nstatic+(1:nspred),:);
         Gu = dr.ghu(nstatic+(1:nspred),:);
         gy(dr.order_var,:) = dr.ghx;
         gu(dr.order_var,:) = dr.ghu;
 
+        Uyy = build_two_dim_hessian(M_.objective_g2_sparse_indices, Uyy_v, 1, M_.endo_nbr);
         Uyy = full(Uyy);
 
         Uyygygy = A_times_B_kronecker_C(Uyy,gy,gy);
@@ -305,7 +312,7 @@ else
             dr.(['g_' num2str(i)]) = [dr.(['g_' num2str(i)]); W.(['W_' num2str(i)])];
         end
         % Amends the steady-state vector accordingly
-        [U] = feval([M_.fname '.objective.static'],ys,zeros(1,exo_nbr), M_.params);
+        U = feval([M_.fname '.objective.sparse.static_resid'], ys, zeros(1,exo_nbr), M_.params);
         ysteady = [ys(oo_.dr.order_var); U/(1-beta)];
 
         % Generates the sequence of shocks to compute unconditional welfare

matlab/optimization/solve1.m

@@ -123,7 +123,11 @@ for its = 1:maxit
         fjac2=fjac'*fjac;
         temp=max(sum(abs(fjac2)));
         if temp>0
-            p=-(fjac2+sqrt(nn*eps)*temp*eye(nn))\(fjac'*fvec);
+            if issparse(fjac)
+                p=-(fjac2+sqrt(nn*eps)*temp*speye(nn))\(fjac'*fvec);
+            else
+                p=-(fjac2+sqrt(nn*eps)*temp*eye(nn))\(fjac'*fvec);
+            end
         else
             errorflag = true;
             errorcode = 5;

matlab/partial_information/PCL_resol.m

@@ -25,7 +25,7 @@ function [dr,info]=PCL_resol(ys,check_flag)
 % SPECIAL REQUIREMENTS
 %    none
 
-% Copyright © 2001-2017 Dynare Team
+% Copyright © 2001-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -65,7 +65,13 @@ end
 dr.ys = ys;
 check1 = 0;
 % testing for steadystate file
-fh = str2func([M_.fname '.static']);
+static_resid = str2func(sprintf('%s.sparse.static_resid', M_.fname));
+static_g1 = str2func(sprintf('%s.sparse.static_g1', M_.fname));
+function [resid, g1] = static_resid_g1(y, x, params)
+    [resid, T_order, T] = static_resid(y, x, params);
+    g1 = static_g1(y, x, params, M_.static_g1_sparse_rowval, M_.static_g1_sparse_colval, M_.static_g1_sparse_colptr, T_order, T);
+end
+
 if options_.steadystate_flag
     [dr.ys,check1] = feval([M_.fname '_steadystate'],dr.ys,...
                            [oo_.exo_steady_state; ...
@@ -87,17 +93,17 @@ else
     if ~options_.ramsey_policy
         if options_.linear == 0
             % nonlinear models
-            if max(abs(feval(fh,dr.ys,[oo_.exo_steady_state; ...
-                                    oo_.exo_det_steady_state], M_.params))) > options_.solve_tolf
+            if max(abs(static_resid_g1(dr.ys, [oo_.exo_steady_state; ...
+                                               oo_.exo_det_steady_state], M_.params))) > options_.solve_tolf
                 opt = options_;
                 opt.jacobian_flag = false;
-                [dr.ys, check1] = dynare_solve(fh,dr.ys, options.steady_.maxit, options_.solve_tolf, options_.solve_tolx, ...
+                [dr.ys, check1] = dynare_solve(static_resid_g1, dr.ys, options.steady_.maxit, options_.solve_tolf, options_.solve_tolx, ...
                                                opt, [oo_.exo_steady_state; oo_.exo_det_steady_state], M_.params);
             end
         else
             % linear models
-            [fvec,jacob] = feval(fh,dr.ys,[oo_.exo_steady_state;...
-                                oo_.exo_det_steady_state], M_.params);
+            [fvec,jacob] = static_resid_g1(dr.ys, [oo_.exo_steady_state;...
+                                                   oo_.exo_det_steady_state], M_.params);
             if max(abs(fvec)) > 1e-12
                 dr.ys = dr.ys-jacob\fvec;
             end
@@ -111,7 +117,7 @@ if check1
         resid = check1 ;
     else
         info(1)= 20;
-        resid = feval(fh,ys,oo_.exo_steady_state, M_.params);
+        resid = static_resid(ys, oo_.exo_steady_state, M_.params);
     end
     info(2) = resid'*resid ;
     return
@@ -140,6 +146,8 @@ end
 oo_.exo_simul = tempex;
 tempex = [];
 
+end
+
 % 01/01/2003 MJ added dr_algo == 1
 % 08/24/2001 MJ uses Schmitt-Grohe and Uribe (2001) constant correction
 %               in dr.ghs2

matlab/partial_information/add_auxiliary_variables_to_steadystate.m

@@ -2,7 +2,7 @@ function ys1 = add_auxiliary_variables_to_steadystate(ys,aux_vars,fname, ...
                                                   exo_steady_state, exo_det_steady_state,params, byte_code)
 % Add auxiliary variables to the steady state vector
 
-% Copyright © 2009-2023 Dynare Team
+% Copyright © 2009-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -30,7 +30,7 @@ for i=1:n+1
                        [exo_steady_state; ...
                         exo_det_steady_state],params);
     else
-        res = feval([fname '.static'],ys1,...
+        res = feval([fname '.sparse.static_resid'], ys1,...
                     [exo_steady_state; ...
                      exo_det_steady_state],params);
     end

matlab/perfect-foresight-models/perfect_foresight_solver.m

@@ -23,7 +23,7 @@ function [oo_, ts]=perfect_foresight_solver(M_, options_, oo_, no_error_if_learn
 % SPECIAL REQUIREMENTS
 %   none
 
-% Copyright © 1996-2023 Dynare Team
+% Copyright © 1996-2024 Dynare Team
 %
 % This file is part of Dynare.
 %
@@ -55,7 +55,7 @@ end
 periods = options_.periods;
 
 if options_.debug
-    model_static = str2func([M_.fname,'.static']);
+    model_static = str2func([M_.fname,'.sparse.static_resid']);
     for ii=1:size(oo_.exo_simul,1)
         [residual(:,ii)] = model_static(oo_.steady_state, oo_.exo_simul(ii,:),M_.params);
     end

mex/sources/k_order_welfare/k_ord_objective.cc

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2021-2023 Dynare Team
+ * Copyright © 2021-2024 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -18,26 +18,23 @@
  */
 
 #include "k_ord_objective.hh"
-#include "objective_abstract_class.hh"
 
 #include <cassert>
 #include <utility>
 
-KordwDynare::KordwDynare(KordpDynare& m, ConstVector& NNZD_arg, Journal& jr, Vector& inParams,
-                         std::unique_ptr<ObjectiveAC> objectiveFile_arg,
+KordwDynare::KordwDynare(KordpDynare& m, Journal& jr, Vector& inParams,
+                         std::unique_ptr<ObjectiveMFile> objectiveFile_arg,
                          const std::vector<int>& dr_order) :
     model {m},
-    NNZD {NNZD_arg},
     journal {jr},
     params {inParams},
     resid(1),
     ud {1},
     objectiveFile {std::move(objectiveFile_arg)}
 {
-  dynppToDyn = dr_order;
   dynToDynpp.resize(model.ny());
   for (int i = 0; i < model.ny(); i++)
-    dynToDynpp[dynppToDyn[i]] = i;
+    dynToDynpp[dr_order[i]] = i;
 }
 
 void
@@ -46,71 +43,10 @@ KordwDynare::calcDerivativesAtSteady()
 
   assert(ud.begin() == ud.end());
 
-  std::vector<TwoDMatrix> dyn_ud;     // Planner's objective derivatives, in Dynare form
-  dyn_ud.emplace_back(1, model.ny()); // Allocate Jacobian
-  dyn_ud.back().zeros();
-
-  for (int i = 2; i <= model.order(); i++)
-    {
-      // Higher order derivatives, as sparse (3-column) matrices
-      dyn_ud.emplace_back(static_cast<int>(NNZD[i - 1]), 3);
-      dyn_ud.back().zeros();
-    }
-
   Vector xx(model.nexog());
   xx.zeros();
   resid.zeros();
-  objectiveFile->eval(model.getSteady(), xx, params, resid, dyn_ud);
-
-  for (int i = 1; i <= model.order(); i++)
-    populateDerivativesContainer(dyn_ud, i);
-}
-
-void
-KordwDynare::populateDerivativesContainer(const std::vector<TwoDMatrix>& dyn_ud, int ord)
-{
-  const TwoDMatrix& u = dyn_ud[ord - 1];
-
-  // utility derivatives FSSparseTensor instance
-  auto udTi = std::make_unique<FSSparseTensor>(ord, model.ny(), 1);
-
-  IntSequence s(ord, 0);
-
-  if (ord == 1)
-    for (int i = 0; i < u.ncols(); i++)
-      {
-        for (int j = 0; j < u.nrows(); j++)
-          {
-            double x = u.get(j, dynppToDyn[s[0]]);
-            if (x != 0.0)
-              udTi->insert(s, j, x);
-          }
-        s[0]++;
-      }
-  else // ord ≥ 2
-    for (int i = 0; i < u.nrows(); i++)
-      {
-        int j = static_cast<int>(u.get(i, 0)) - 1;
-        int i1 = static_cast<int>(u.get(i, 1)) - 1;
-        if (j < 0 || i1 < 0)
-          continue; // Discard empty entries (see comment in DynamicModelAC::unpackSparseMatrix())
-
-        for (int k = 0; k < ord; k++)
-          {
-            s[k] = dynToDynpp[i1 % model.ny()];
-            i1 /= model.ny();
-          }
-
-        if (ord == 2 && !s.isSorted())
-          continue; // Skip symmetric elements (only needed at order 2)
-        else if (ord > 2)
-          s.sort(); // For higher order, canonicalize the multi-index
-
-        double x = u.get(i, 2);
-        udTi->insert(s, j, x);
-      }
-
-  ud.insert(std::move(udTi));
+  objectiveFile->eval(model.getSteady(), xx, params, resid, dynToDynpp, ud);
 }
 
 template<>

mex/sources/k_order_welfare/k_ord_objective.hh

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2021-2023 Dynare Team
+ * Copyright © 2021-2024 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -21,7 +21,7 @@
 #define K_ORD_OBJECTIVE_HH
 
 #include "k_ord_dynare.hh"
-#include "objective_abstract_class.hh"
+#include "objective_m.hh"
 
 class KordwDynare;
 
@@ -29,22 +29,19 @@ class KordwDynare
 {
 public:
   KordpDynare& model;
-  const ConstVector& NNZD;
 
 private:
   Journal& journal;
   Vector& params;
   Vector resid;
   TensorContainer<FSSparseTensor> ud; // planner's objective derivatives, in Dynare++ form
-  std::vector<int> dynppToDyn;        // Maps Dynare++ jacobian variable indices to Dynare ones
   std::vector<int> dynToDynpp;        // Maps Dynare jacobian variable indices to Dynare++ ones
-  std::unique_ptr<ObjectiveAC> objectiveFile;
+  std::unique_ptr<ObjectiveMFile> objectiveFile;
 
 public:
-  KordwDynare(KordpDynare& m, ConstVector& NNZD_arg, Journal& jr, Vector& inParams,
-              std::unique_ptr<ObjectiveAC> objectiveFile_arg, const std::vector<int>& varOrder);
+  KordwDynare(KordpDynare& m, Journal& jr, Vector& inParams,
+              std::unique_ptr<ObjectiveMFile> objectiveFile_arg, const std::vector<int>& varOrder);
   void calcDerivativesAtSteady();
-  void populateDerivativesContainer(const std::vector<TwoDMatrix>& dyn_ud, int ord);
   [[nodiscard]] const TensorContainer<FSSparseTensor>&
   getPlannerObjDerivatives() const
   {

mex/sources/k_order_welfare/k_order_welfare.cc

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2021-2022 Dynare Team
+ * Copyright © 2021-2024 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -31,6 +31,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <string>
 
 #include "dynmex.h"
 
@@ -87,8 +88,8 @@ The routine proceeds in several steps:
    to the approxAtSteady method in the ApproximationWelfare class carries out the necessary
    operation
    - Importing the derivatives of the felicity function with the calcDerivativesAtSteady() method of
-     the KordwDynare class. It relies on the Matlab-generated files, which are handled by the
-     ObjectiveAC and ObjectiveMFile classes
+     the KordwDynare class. It relies on the MATLAB-generated files, which are handled by the
+     ObjectiveMFile class
    - Pinpointing the derivatives of the felicity and welfare functions. The performStep method of
      the KOrderWelfare class carries out the calculations,resorting to the FaaDiBruno class and its
      methods to get the needed intermediary results.
@@ -214,15 +215,6 @@ extern "C"
       mexErrMsgTxt("The derivatives were not computed for the required order. Make sure that you "
                    "used the right order option inside the `stoch_simul' command");
 
-    const mxArray* nnzderivatives_obj_mx = mxGetField(M_mx, 0, "NNZDerivatives_objective");
-    if (!(nnzderivatives_obj_mx && mxIsDouble(nnzderivatives_obj_mx)
-          && !mxIsComplex(nnzderivatives_obj_mx) && !mxIsSparse(nnzderivatives_obj_mx)))
-      mexErrMsgTxt("M_.NNZDerivatives should be a real dense array");
-    ConstVector NNZD_obj {nnzderivatives_obj_mx};
-    if (NNZD.length() < kOrder || NNZD_obj[kOrder - 1] == -1)
-      mexErrMsgTxt("The derivatives were not computed for the required order. Make sure that you "
-                   "used the right order option inside the `stoch_simul' command");
-
     const mxArray* endo_names_mx = mxGetField(M_mx, 0, "endo_names");
     if (!(endo_names_mx && mxIsCell(endo_names_mx)
           && mxGetNumberOfElements(endo_names_mx) == static_cast<size_t>(nEndo)))
@@ -261,6 +253,32 @@ extern "C"
     std::transform(mxGetPr(order_var_mx), mxGetPr(order_var_mx) + nEndo, dr_order.begin(),
                    [](double x) { return static_cast<int>(x) - 1; });
 
+    const mxArray* objective_g1_sparse_rowval_mx
+        = mxGetField(M_mx, 0, "objective_g1_sparse_rowval");
+    if (!(objective_g1_sparse_rowval_mx && mxIsInt32(objective_g1_sparse_rowval_mx)))
+      mexErrMsgTxt("M_.objective_g1_sparse_rowval should be an int32 array");
+
+    const mxArray* objective_g1_sparse_colval_mx
+        = mxGetField(M_mx, 0, "objective_g1_sparse_colval");
+    if (!(objective_g1_sparse_colval_mx && mxIsInt32(objective_g1_sparse_colval_mx)))
+      mexErrMsgTxt("M_.objective_g1_sparse_colval should be an int32 array");
+
+    const mxArray* objective_g1_sparse_colptr_mx
+        = mxGetField(M_mx, 0, "objective_g1_sparse_colptr");
+    if (!(objective_g1_sparse_colptr_mx && mxIsInt32(objective_g1_sparse_colptr_mx)))
+      mexErrMsgTxt("M_.objective_g1_sparse_colptr should be an int32 array");
+
+    std::vector<const mxArray*> objective_gN_sparse_indices;
+    for (int o {2}; o <= kOrder; o++)
+      {
+        using namespace std::string_literals;
+        auto fieldname {"objective_g"s + std::to_string(o) + "_sparse_indices"};
+        const mxArray* indices = mxGetField(M_mx, 0, fieldname.c_str());
+        if (!(indices && mxIsInt32(indices)))
+          mexErrMsgTxt(("M_."s + fieldname + " should be an int32 array").c_str());
+        objective_gN_sparse_indices.push_back(indices);
+      }
+
     const int nSteps
         = 0; // Dynare++ solving steps, for time being default to 0 = deterministic steady state
 
@@ -291,21 +309,14 @@ extern "C"
     // run stochastic steady
     app.walkStochSteady();
 
-    const mxArray* objective_tmp_nbr_mx = mxGetField(M_mx, 0, "objective_tmp_nbr");
-    if (!(objective_tmp_nbr_mx && mxIsDouble(objective_tmp_nbr_mx)
-          && !mxIsComplex(objective_tmp_nbr_mx) && !mxIsSparse(objective_tmp_nbr_mx)
-          && mxGetNumberOfElements(objective_tmp_nbr_mx) >= static_cast<size_t>(kOrder + 1)))
-      mexErrMsgTxt("M_.objective_tmp_nbr should be a real dense array with strictly more elements "
-                   "than the order of derivation");
-    int ntt_objective = std::accumulate(mxGetPr(objective_tmp_nbr_mx),
-                                        mxGetPr(objective_tmp_nbr_mx) + kOrder + 1, 0);
-
     // Getting derivatives of the planner's objective function
-    std::unique_ptr<ObjectiveAC> objectiveFile;
-    objectiveFile = std::make_unique<ObjectiveMFile>(fname, ntt_objective);
+    std::unique_ptr<ObjectiveMFile> objectiveFile;
+    objectiveFile = std::make_unique<ObjectiveMFile>(
+        fname, kOrder, objective_g1_sparse_rowval_mx, objective_g1_sparse_colval_mx,
+        objective_g1_sparse_colptr_mx, objective_gN_sparse_indices);
 
     // make KordwDynare object
-    KordwDynare welfare(dynare, NNZD_obj, journal, modParams, std::move(objectiveFile), dr_order);
+    KordwDynare welfare(dynare, journal, modParams, std::move(objectiveFile), dr_order);
 
     // construct main K-order approximation class of welfare
     ApproximationWelfare appwel(welfare, discount_factor, app.get_rule_ders(),

mex/sources/k_order_welfare/objective_abstract_class.hh

@@ -1,38 +0,0 @@
-/*
- * Copyright © 2021-2023 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 <https://www.gnu.org/licenses/>.
- */
-
-#ifndef OBJECTIVE_ABSTRACT_CLASS_HH
-#define OBJECTIVE_ABSTRACT_CLASS_HH
-
-#include <vector>
-
-#include "twod_matrix.hh"
-
-class ObjectiveAC
-{
-protected:
-  int ntt; // Size of vector of temporary terms
-public:
-  ObjectiveAC(int ntt_arg) : ntt {ntt_arg} {};
-  virtual ~ObjectiveAC() = default;
-  virtual void eval(const Vector& y, const Vector& x, const Vector& params, Vector& residual,
-                    std::vector<TwoDMatrix>& md)
-      = 0;
-};
-#endif

mex/sources/k_order_welfare/objective_m.cc

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2021-2023 Dynare Team
+ * Copyright © 2021-2024 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -26,88 +26,41 @@
 
 #include "objective_m.hh"
 
-ObjectiveMFile::ObjectiveMFile(const std::string& modName, int ntt_arg) :
-    ObjectiveAC(ntt_arg), ObjectiveMFilename {modName + ".objective.static"}
+ObjectiveMFile::ObjectiveMFile(const std::string& modName, int kOrder_arg,
+                               const mxArray* objective_g1_sparse_rowval_mx_arg,
+                               const mxArray* objective_g1_sparse_colval_mx_arg,
+                               const mxArray* objective_g1_sparse_colptr_mx_arg,
+                               const std::vector<const mxArray*> objective_gN_sparse_indices_arg) :
+    ObjectiveMFilename {modName + ".objective.sparse.static"},
+    kOrder {kOrder_arg},
+    objective_g1_sparse_rowval_mx {objective_g1_sparse_rowval_mx_arg},
+    objective_g1_sparse_colval_mx {objective_g1_sparse_colval_mx_arg},
+    objective_g1_sparse_colptr_mx {objective_g1_sparse_colptr_mx_arg},
+    objective_gN_sparse_indices {objective_gN_sparse_indices_arg}
 {
 }
 
-void
-ObjectiveMFile::unpackSparseMatrixAndCopyIntoTwoDMatData(mxArray* sparseMat, TwoDMatrix& tdm)
-{
-  int totalCols = mxGetN(sparseMat);
-  mwIndex* rowIdxVector = mxGetIr(sparseMat);
-  mwIndex* colIdxVector = mxGetJc(sparseMat);
-
-  assert(tdm.ncols() == 3);
-  /* Under MATLAB, the following check always holds at equality; under Octave,
-     there may be an inequality, because Octave diminishes nzmax if one gives
-     zeros in the values vector when calling sparse(). */
-  assert(tdm.nrows() >= static_cast<int>(mxGetNzmax(sparseMat)));
-
-  double* ptr = mxGetPr(sparseMat);
-
-  int rind = 0;
-  int output_row = 0;
-
-  for (int i = 0; i < totalCols; i++)
-    for (int j = 0; j < static_cast<int>((colIdxVector[i + 1] - colIdxVector[i])); j++, rind++)
-      {
-        tdm.get(output_row, 0) = rowIdxVector[rind] + 1;
-        tdm.get(output_row, 1) = i + 1;
-        tdm.get(output_row, 2) = ptr[rind];
-        output_row++;
-      }
-
-  /* If there are less elements than expected (that might happen if some
-     derivative is symbolically not zero but numerically zero at the evaluation
-     point), then fill in the matrix with empty entries, that will be
-     recognized as such by KordpDynare::populateDerivativesContainer() */
-  while (output_row < tdm.nrows())
-    {
-      tdm.get(output_row, 0) = 0;
-      tdm.get(output_row, 1) = 0;
-      tdm.get(output_row, 2) = 0;
-      output_row++;
-    }
-}
-
 void
 ObjectiveMFile::eval(const Vector& y, const Vector& x, const Vector& modParams, Vector& residual,
-                     std::vector<TwoDMatrix>& md) noexcept(false)
+                     const std::vector<int>& dynToDynpp,
+                     TensorContainer<FSSparseTensor>& derivatives) const
 {
-  mxArray* T_m = mxCreateDoubleMatrix(ntt, 1, mxREAL);
+  mxArray* y_mx = mxCreateDoubleMatrix(y.length(), 1, mxREAL);
+  std::copy_n(y.base(), y.length(), mxGetPr(y_mx));
 
-  mxArray* y_m = mxCreateDoubleMatrix(y.length(), 1, mxREAL);
-  std::copy_n(y.base(), y.length(), mxGetPr(y_m));
+  mxArray* x_mx = mxCreateDoubleMatrix(1, x.length(), mxREAL);
+  std::copy_n(x.base(), x.length(), mxGetPr(x_mx));
 
-  mxArray* x_m = mxCreateDoubleMatrix(1, x.length(), mxREAL);
-  std::copy_n(x.base(), x.length(), mxGetPr(x_m));
+  mxArray* params_mx = mxCreateDoubleMatrix(modParams.length(), 1, mxREAL);
+  std::copy_n(modParams.base(), modParams.length(), mxGetPr(params_mx));
 
-  mxArray* params_m = mxCreateDoubleMatrix(modParams.length(), 1, mxREAL);
-  std::copy_n(modParams.base(), modParams.length(), mxGetPr(params_m));
-
-  mxArray* T_flag_m = mxCreateLogicalScalar(false);
-
-  {
-    // Compute temporary terms (for all orders)
-    std::string funcname = ObjectiveMFilename + "_g" + std::to_string(md.size()) + "_tt";
-    std::array<mxArray*, 1> plhs;
-    std::array prhs {T_m, y_m, x_m, params_m};
-
-    int retVal
-        = mexCallMATLAB(plhs.size(), plhs.data(), prhs.size(), prhs.data(), funcname.c_str());
-    if (retVal != 0)
-      throw DynareException(__FILE__, __LINE__, "Trouble calling " + funcname);
-
-    mxDestroyArray(T_m);
-    T_m = plhs[0];
-  }
+  mxArray *T_order_mx, *T_mx;
 
   {
     // Compute residuals
     std::string funcname = ObjectiveMFilename + "_resid";
-    std::array<mxArray*, 1> plhs;
-    std::array prhs {T_m, y_m, x_m, params_m, T_flag_m};
+    std::array<mxArray*, 3> plhs;
+    std::array prhs {y_mx, x_mx, params_mx};
 
     int retVal
         = mexCallMATLAB(plhs.size(), plhs.data(), prhs.size(), prhs.data(), funcname.c_str());
@@ -116,35 +69,103 @@ ObjectiveMFile::eval(const Vector& y, const Vector& x, const Vector& modParams,
 
     residual = Vector {plhs[0]};
     mxDestroyArray(plhs[0]);
+
+    T_order_mx = plhs[1];
+    T_mx = plhs[2];
   }
 
-  for (size_t i = 1; i <= md.size(); i++)
+  {
+    // Compute Jacobian
+    std::string funcname = ObjectiveMFilename + "_g1";
+    std::array<mxArray*, 3> plhs;
+    std::array prhs {y_mx,
+                     x_mx,
+                     params_mx,
+                     const_cast<mxArray*>(objective_g1_sparse_rowval_mx),
+                     const_cast<mxArray*>(objective_g1_sparse_colval_mx),
+                     const_cast<mxArray*>(objective_g1_sparse_colptr_mx),
+                     T_order_mx,
+                     T_mx};
+
+    int retVal
+        = mexCallMATLAB(plhs.size(), plhs.data(), prhs.size(), prhs.data(), funcname.c_str());
+    if (retVal != 0)
+      throw DynareException(__FILE__, __LINE__, "Trouble calling " + funcname);
+
+    assert(static_cast<int>(mxGetN(plhs[0])) == y.length());
+    double* g1_v {mxGetPr(plhs[0])};
+    mwIndex* g1_ir {mxGetIr(plhs[0])};
+    mwIndex* g1_jc {mxGetJc(plhs[0])};
+
+    IntSequence s(1, 0);
+    auto tensor = std::make_unique<FSSparseTensor>(1, y.length(), 1);
+
+    for (int j {0}; j < y.length(); j++)
+      for (mwIndex k {g1_jc[j]}; k < g1_jc[j + 1]; k++)
+        {
+          s[0] = dynToDynpp[j];
+          tensor->insert(s, g1_ir[k], g1_v[k]);
+        }
+
+    mxDestroyArray(plhs[0]);
+
+    mxDestroyArray(T_order_mx);
+    T_order_mx = plhs[1];
+
+    mxDestroyArray(T_mx);
+    T_mx = plhs[2];
+
+    derivatives.insert(std::move(tensor));
+  }
+
+  for (int o {2}; o <= kOrder; o++)
     {
-      // Compute model derivatives
-      std::string funcname = ObjectiveMFilename + "_g" + std::to_string(i);
-      std::array<mxArray*, 1> plhs;
-      std::array prhs {T_m, y_m, x_m, params_m, T_flag_m};
+      // Compute higher derivatives
+      std::string funcname = ObjectiveMFilename + "_g" + std::to_string(o);
+      std::array<mxArray*, 3> plhs;
+      std::array prhs {y_mx, x_mx, params_mx, T_order_mx, T_mx};
 
       int retVal
           = mexCallMATLAB(plhs.size(), plhs.data(), prhs.size(), prhs.data(), funcname.c_str());
       if (retVal != 0)
         throw DynareException(__FILE__, __LINE__, "Trouble calling " + funcname);
 
-      if (i == 1)
+      const mxArray* sparse_indices_mx {objective_gN_sparse_indices[o - 2]};
+      size_t nnz {mxGetM(sparse_indices_mx)};
+#if MX_HAS_INTERLEAVED_COMPLEX
+      const int32_T* sparse_indices {mxGetInt32s(sparse_indices_mx)};
+#else
+      const int32_T* sparse_indices {static_cast<const int32_T*>(mxGetData(sparse_indices_mx))};
+#endif
+
+      assert(mxGetNumberOfElements(plhs[0]) == nnz);
+      double* gN_v {mxGetPr(plhs[0])};
+
+      IntSequence s(o, 0);
+      auto tensor = std::make_unique<FSSparseTensor>(o, y.length(), 1);
+
+      for (size_t k {0}; k < nnz; k++)
         {
-          assert(static_cast<int>(mxGetM(plhs[0])) == md[i - 1].nrows());
-          assert(static_cast<int>(mxGetN(plhs[0])) == md[i - 1].ncols());
-          std::copy_n(mxGetPr(plhs[0]), mxGetM(plhs[0]) * mxGetN(plhs[0]), md[i - 1].base());
+          for (int i {0}; i < o; i++)
+            s[i] = dynToDynpp[sparse_indices[k + (i + 1) * nnz] - 1];
+          assert(s.isSorted());
+          tensor->insert(s, sparse_indices[k] - 1, gN_v[k]);
         }
-      else
-        unpackSparseMatrixAndCopyIntoTwoDMatData(plhs[0], md[i - 1]);
 
       mxDestroyArray(plhs[0]);
+
+      mxDestroyArray(T_order_mx);
+      T_order_mx = plhs[1];
+
+      mxDestroyArray(T_mx);
+      T_mx = plhs[2];
+
+      derivatives.insert(std::move(tensor));
     }
 
-  mxDestroyArray(T_m);
-  mxDestroyArray(y_m);
-  mxDestroyArray(x_m);
-  mxDestroyArray(params_m);
-  mxDestroyArray(T_flag_m);
+  mxDestroyArray(y_mx);
+  mxDestroyArray(x_mx);
+  mxDestroyArray(params_mx);
+  mxDestroyArray(T_order_mx);
+  mxDestroyArray(T_mx);
 }

mex/sources/k_order_welfare/objective_m.hh

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2021-2023 Dynare Team
+ * Copyright © 2021-2024 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -20,24 +20,34 @@
 #ifndef OBJECTIVE_M_HH
 #define OBJECTIVE_M_HH
 
-#include "objective_abstract_class.hh"
+#include <vector>
 
-#include "mex.h"
-#include <dynmex.h>
+#include "dynmex.h"
 
-/**
- * handles calls to <model>/+objective/static.m
- *
- **/
-class ObjectiveMFile : public ObjectiveAC
+#include "Vector.hh"
+#include "sparse_tensor.hh"
+#include "t_container.hh"
+
+// Handles calls to <model>/+objective/+sparse/static*.m
+class ObjectiveMFile
 {
 private:
   const std::string ObjectiveMFilename;
-  static void unpackSparseMatrixAndCopyIntoTwoDMatData(mxArray* sparseMat, TwoDMatrix& tdm);
+  const int kOrder;
+  const mxArray *const objective_g1_sparse_rowval_mx, *const objective_g1_sparse_colval_mx,
+                                                          *const objective_g1_sparse_colptr_mx;
+  // Stores M_.objective_gN_sparse_indices, starting from N=2
+  const std::vector<const mxArray*> objective_gN_sparse_indices;
 
 public:
-  explicit ObjectiveMFile(const std::string& modName, int ntt_arg);
+  ObjectiveMFile(const std::string& modName, int kOrder_arg,
+                 const mxArray* objective_g1_sparse_rowval_mx_arg,
+                 const mxArray* objective_g1_sparse_colval_mx_arg,
+                 const mxArray* objective_g1_sparse_colptr_mx_arg,
+                 const std::vector<const mxArray*> objective_gN_sparse_indices_arg);
   void eval(const Vector& y, const Vector& x, const Vector& params, Vector& residual,
-            std::vector<TwoDMatrix>& md) override;
+            const std::vector<int>& dynToDynpp, TensorContainer<FSSparseTensor>& derivatives) const
+      noexcept(false);
 };
+
 #endif

preprocessor

@@ -1 +1 @@
-Subproject commit b134dba32c9bfc8e0ee25c4977e37558721d7737
+Subproject commit d8866fbec8a09df0d8fa1d2e7e60b2aae8685ea8

windows/deps/Makefile

@@ -49,30 +49,28 @@ clean-all: clean-lib clean-src clean-tar
 
 tarballs/slicot-$(SLICOT_VERSION).tar.gz:
 	mkdir -p tarballs
-	wget $(WGET_OPTIONS) -O $@ https://deb.debian.org/debian/pool/main/s/slicot/slicot_$(SLICOT_VERSION).orig.tar.gz
+	wget $(WGET_OPTIONS) -O $@ https://deb.debian.org/debian/pool/main/s/slicot/slicot_$(SLICOT_VERSION).orig.tar.xz
 
 sources64/slicot-$(SLICOT_VERSION)-with-64bit-integer: tarballs/slicot-$(SLICOT_VERSION).tar.gz
 	rm -rf sources64/slicot-*-with-64bit-integer
 	mkdir -p $@
 	tar xf $< --directory $@ --strip-components=1
-	patch -d $@ -p1 < slicot-build-system.patch
 	touch $@
 
 sources64/slicot-$(SLICOT_VERSION)-with-32bit-integer-and-underscore: tarballs/slicot-$(SLICOT_VERSION).tar.gz
 	rm -rf sources64/slicot-*-with-32bit-integer-and-underscore
 	mkdir -p $@
 	tar xf $< --directory $@ --strip-components=1
-	patch -d $@ -p1 < slicot-build-system.patch
 	touch $@
 
 lib64/Slicot/without-underscore/libslicot64_pic.a: sources64/slicot-$(SLICOT_VERSION)-with-64bit-integer
-	make -C $< -f makefile_Unix lib SLICOTLIB=../libslicot64_pic.a FFLAGS="$(FFLAGS) -fno-underscoring -fdefault-integer-8" FC=x86_64-w64-mingw32-gfortran LOADER=x86_64-w64-mingw32-gfortran ARCH=x86_64-w64-mingw32-ar
+	make -C $< -f makefile_Unix lib SLICOTLIB=../libslicot64_pic.a OPTS="$(FFLAGS) -fno-underscoring -fdefault-integer-8" FORTRAN=x86_64-w64-mingw32-gfortran LOADER=x86_64-w64-mingw32-gfortran ARCH=x86_64-w64-mingw32-ar
 	x86_64-w64-mingw32-strip --strip-debug $</libslicot64_pic.a
 	mkdir -p $(dir $@)
 	cp $</libslicot64_pic.a $@
 
 lib64/Slicot/with-underscore/libslicot_pic.a: sources64/slicot-$(SLICOT_VERSION)-with-32bit-integer-and-underscore
-	make -C $< -f makefile_Unix lib SLICOTLIB=../libslicot_pic.a FFLAGS="$(FFLAGS)" FC=x86_64-w64-mingw32-gfortran LOADER=x86_64-w64-mingw32-gfortran ARCH=x86_64-w64-mingw32-ar
+	make -C $< -f makefile_Unix lib SLICOTLIB=../libslicot_pic.a OPTS="$(FFLAGS)" FORTRAN=x86_64-w64-mingw32-gfortran LOADER=x86_64-w64-mingw32-gfortran ARCH=x86_64-w64-mingw32-ar
 	x86_64-w64-mingw32-strip --strip-debug $</libslicot_pic.a
 	mkdir -p $(dir $@)
 	cp $</libslicot_pic.a $@

windows/deps/slicot-build-system.patch

@@ -1,593 +0,0 @@
-Description: Various fixes to the build system
-Author: Sébastien Villemot <sebastien@debian.org>
-Forwarded: https://github.com/SLICOT/SLICOT-Reference/pull/14
-Last-Update: 2024-01-16
----
-This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
---- a/makefile_Unix
-+++ b/makefile_Unix
-@@ -43,15 +43,15 @@ all: lib example
- clean: cleanlib cleanexample
- 
- lib:
--	( cd src; $(MAKE) )
--	( cd src_aux; $(MAKE) )
-+	( cd src; $(MAKE) -f makefile_Unix )
-+	( cd src_aux; $(MAKE) -f makefile_Unix )
- 
- example:
--	( cd examples; $(MAKE) )
-+	( cd examples; $(MAKE) -f makefile_Unix )
- 
- cleanlib:
--	( cd src; $(MAKE) clean )
--	( cd src_aux; $(MAKE) clean )
-+	( cd src; $(MAKE) -f makefile_Unix clean )
-+	( cd src_aux; $(MAKE) -f makefile_Unix clean )
- 
- cleanexample:
--	( cd examples; $(MAKE) clean )
-+	( cd examples; $(MAKE) -f makefile_Unix clean )
---- a/src/makefile_Unix
-+++ b/src/makefile_Unix
-@@ -28,7 +28,7 @@
- #
- #######################################################################
-  
--include ../make.inc
-+include ../make_Unix.inc
- 
- SLSRC = \
-     AB01MD.o AB01ND.o AB01OD.o AB04MD.o AB05MD.o AB05ND.o AB05OD.o \
-@@ -78,8 +78,8 @@ SLSRC = \
-     MB04GD.o MB04HD.o MB04ID.o MB04IY.o MB04IZ.o MB04JD.o MB04KD.o \
-     MB04LD.o MB04MD.o MB04ND.o MB04NY.o MB04OD.o MB04OW.o MB04OX.o \
-     MB04OY.o MB04PA.o MB04PB.o MB04PU.o MB04PY.o MB04QB.o MB04QC.o \
--    MB04QF.o MB04QS.o MB04QU.o MB04RB.o MB04RD.o MB04RS.o MB04RT.o \
--    MB04RU.o MB04RV.o MB04RW.o MB04RZ.o MB04SU.o MB04TB.o MB04TS.o \
-+    MB04QF.o MB04QS.o MB04QU.o MB04RB.o \
-+    MB04RU.o MB04SU.o MB04TB.o MB04TS.o \
-     MB04TT.o MB04TU.o MB04TV.o MB04TW.o MB04TX.o MB04TY.o MB04UD.o \
-     MB04VD.o MB04VX.o MB04WD.o MB04WP.o MB04WR.o MB04WU.o MB04XD.o \
-     MB04XY.o MB04YD.o MB04YW.o MB04ZD.o MB05MD.o MB05MY.o MB05ND.o \
-@@ -121,8 +121,7 @@ SLSRC = \
-     TG01HD.o TG01HU.o TG01HX.o TG01HY.o TG01ID.o TG01JD.o TG01JY.o \
-     TG01KD.o TG01KZ.o TG01LD.o TG01LY.o TG01MD.o TG01ND.o TG01NX.o \
-     TG01OA.o TG01OB.o TG01OD.o TG01OZ.o TG01PD.o TG01QD.o TG01WD.o \
--    UD01BD.o UD01CD.o UD01DD.o UD01MD.o UD01MZ.o UD01ND.o UE01MD.o \
--    zelctg.o
-+    UD01BD.o UD01CD.o UD01DD.o UD01MD.o UD01MZ.o UD01ND.o UE01MD.o
-     
- all: 	$(SLSRC)
- 	$(ARCH) $(ARCHFLAGS) $(SLICOTLIB) $(SLSRC)
-@@ -136,4 +135,4 @@ clean:
- 	rm -f *.o
- 
- .f.o: 
--	$(FORTRAN) $(OPTS) -c $<
-+	$(FC) $(FFLAGS) -c $<
---- a/examples/makefile_Unix
-+++ b/examples/makefile_Unix
-@@ -850,248 +850,248 @@ cleanup:
-     TTG01ID TTG01JD TTG01JY TTG01LD TTG01MD TTG01ND TTG01PD TTG01QD \
-     TUD01BD TUD01CD TUD01DD TUD01MD TUD01ND 
- 
--TAB01MD.o: TAB01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB01ND.o: TAB01ND.f ; $(FORTRAN) $(OPTS) -c $<
--TAB01OD.o: TAB01OD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB04MD.o: TAB04MD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB05MD.o: TAB05MD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB05ND.o: TAB05ND.f ; $(FORTRAN) $(OPTS) -c $<
--TAB05OD.o: TAB05OD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB05PD.o: TAB05PD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB05QD.o: TAB05QD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB05RD.o: TAB05RD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB07MD.o: TAB07MD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB07ND.o: TAB07ND.f ; $(FORTRAN) $(OPTS) -c $<
--TAB08ND.o: TAB08ND.f ; $(FORTRAN) $(OPTS) -c $<
--TAB08NW.o: TAB08NW.f ; $(FORTRAN) $(OPTS) -c $<
--TAB08NZ.o: TAB08NZ.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09AD.o: TAB09AD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09BD.o: TAB09BD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09CD.o: TAB09CD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09DD.o: TAB09DD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09ED.o: TAB09ED.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09FD.o: TAB09FD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09GD.o: TAB09GD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09HD.o: TAB09HD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09ID.o: TAB09ID.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09JD.o: TAB09JD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09KD.o: TAB09KD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09MD.o: TAB09MD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB09ND.o: TAB09ND.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13AD.o: TAB13AD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13BD.o: TAB13BD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13CD.o: TAB13CD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13DD.o: TAB13DD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13ED.o: TAB13ED.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13FD.o: TAB13FD.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13ID.o: TAB13ID.f ; $(FORTRAN) $(OPTS) -c $<
--TAB13MD.o: TAB13MD.f ; $(FORTRAN) $(OPTS) -c $<
--TAG08BD.o: TAG08BD.f ; $(FORTRAN) $(OPTS) -c $<
--TAG08BZ.o: TAG08BZ.f ; $(FORTRAN) $(OPTS) -c $<
--TBB01AD.o: TBB01AD.f ; $(FORTRAN) $(OPTS) -c $<
--TBB02AD.o: TBB02AD.f ; $(FORTRAN) $(OPTS) -c $<
--TBB03AD.o: TBB03AD.f ; $(FORTRAN) $(OPTS) -c $<
--TBB04AD.o: TBB04AD.f ; $(FORTRAN) $(OPTS) -c $<
--TBD01AD.o: TBD01AD.f ; $(FORTRAN) $(OPTS) -c $<
--TBD02AD.o: TBD02AD.f ; $(FORTRAN) $(OPTS) -c $<
--TDE01OD.o: TDE01OD.f ; $(FORTRAN) $(OPTS) -c $<
--TDE01PD.o: TDE01PD.f ; $(FORTRAN) $(OPTS) -c $<
--TDF01MD.o: TDF01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TDG01MD.o: TDG01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TDG01ND.o: TDG01ND.f ; $(FORTRAN) $(OPTS) -c $<
--TDG01OD.o: TDG01OD.f ; $(FORTRAN) $(OPTS) -c $<
--TDK01MD.o: TDK01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TFB01QD.o: TFB01QD.f ; $(FORTRAN) $(OPTS) -c $<
--TFB01RD.o: TFB01RD.f ; $(FORTRAN) $(OPTS) -c $<
--TFB01SD.o: TFB01SD.f ; $(FORTRAN) $(OPTS) -c $<
--TFB01TD.o: TFB01TD.f ; $(FORTRAN) $(OPTS) -c $<
--TFB01VD.o: TFB01VD.f ; $(FORTRAN) $(OPTS) -c $<
--TFD01AD.o: TFD01AD.f ; $(FORTRAN) $(OPTS) -c $<
--TIB01AD.o: TIB01AD.f ; $(FORTRAN) $(OPTS) -c $<
--TIB01BD.o: TIB01BD.f ; $(FORTRAN) $(OPTS) -c $<
--TIB01CD.o: TIB01CD.f ; $(FORTRAN) $(OPTS) -c $<
--TIB03AD.o: TIB03AD.f ; $(FORTRAN) $(OPTS) -c $<
--TIB03BD.o: TIB03BD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB01TD.o: TMB01TD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02CD.o: TMB02CD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02DD.o: TMB02DD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02ED.o: TMB02ED.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02FD.o: TMB02FD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02GD.o: TMB02GD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02HD.o: TMB02HD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02ID.o: TMB02ID.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02JD.o: TMB02JD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02JX.o: TMB02JX.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02KD.o: TMB02KD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02MD.o: TMB02MD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02ND.o: TMB02ND.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02QD.o: TMB02QD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02SD.o: TMB02SD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB02VD.o: TMB02VD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03BD.o: TMB03BD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03BZ.o: TMB03BZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03FZ.o: TMB03FZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03KD.o: TMB03KD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03LD.o: TMB03LD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03LF.o: TMB03LF.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03LZ.o: TMB03LZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03MD.o: TMB03MD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03ND.o: TMB03ND.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03OD.o: TMB03OD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03PD.o: TMB03PD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03QD.o: TMB03QD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03QG.o: TMB03QG.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03RD.o: TMB03RD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03SD.o: TMB03SD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03TD.o: TMB03TD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03UD.o: TMB03UD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03VD.o: TMB03VD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03WD.o: TMB03WD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03XD.o: TMB03XD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03XP.o: TMB03XP.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03XZ.o: TMB03XZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB03ZD.o: TMB03ZD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04AD.o: TMB04AD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04AZ.o: TMB04AZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04BD.o: TMB04BD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04BZ.o: TMB04BZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04DD.o: TMB04DD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04DL.o: TMB04DL.f ; $(FORTRAN) $(OPTS) -c $<
--TMB4DLZ.o: TMB4DLZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04DP.o: TMB04DP.f ; $(FORTRAN) $(OPTS) -c $<
--TMB4DPZ.o: TMB4DPZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04DS.o: TMB04DS.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04DY.o: TMB04DY.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04DZ.o: TMB04DZ.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04ED.o: TMB04ED.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04FD.o: TMB04FD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04GD.o: TMB04GD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04MD.o: TMB04MD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04OD.o: TMB04OD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04PB.o: TMB04PB.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04PU.o: TMB04PU.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04TB.o: TMB04TB.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04TS.o: TMB04TS.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04UD.o: TMB04UD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04VD.o: TMB04VD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04XD.o: TMB04XD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04YD.o: TMB04YD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB04ZD.o: TMB04ZD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB05MD.o: TMB05MD.f ; $(FORTRAN) $(OPTS) -c $<
--TMB05ND.o: TMB05ND.f ; $(FORTRAN) $(OPTS) -c $<
--TMB05OD.o: TMB05OD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01MD.o: TMC01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01ND.o: TMC01ND.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01OD.o: TMC01OD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01PD.o: TMC01PD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01QD.o: TMC01QD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01RD.o: TMC01RD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01SD.o: TMC01SD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01TD.o: TMC01TD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01VD.o: TMC01VD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01WD.o: TMC01WD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC01XD.o: TMC01XD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC03MD.o: TMC03MD.f ; $(FORTRAN) $(OPTS) -c $<
--TMC03ND.o: TMC03ND.f ; $(FORTRAN) $(OPTS) -c $<
--TMD03AD.o: TMD03AD.f ; $(FORTRAN) $(OPTS) -c $<
--TMD03BD.o: TMD03BD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB01BD.o: TSB01BD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB01DD.o: TSB01DD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB01MD.o: TSB01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02MD.o: TSB02MD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02ND.o: TSB02ND.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02OD.o: TSB02OD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02PD.o: TSB02PD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02QD.o: TSB02QD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02RD.o: TSB02RD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB02SD.o: TSB02SD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB03MD.o: TSB03MD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB03OD.o: TSB03OD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB03QD.o: TSB03QD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB03SD.o: TSB03SD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB03TD.o: TSB03TD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB03UD.o: TSB03UD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB04MD.o: TSB04MD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB04ND.o: TSB04ND.f ; $(FORTRAN) $(OPTS) -c $<
--TSB04OD.o: TSB04OD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB04PD.o: TSB04PD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB04QD.o: TSB04QD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB04RD.o: TSB04RD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB06ND.o: TSB06ND.f ; $(FORTRAN) $(OPTS) -c $<
--TSB08CD.o: TSB08CD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB08DD.o: TSB08DD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB08ED.o: TSB08ED.f ; $(FORTRAN) $(OPTS) -c $<
--TSB08FD.o: TSB08FD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB08MD.o: TSB08MD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB08ND.o: TSB08ND.f ; $(FORTRAN) $(OPTS) -c $<
--TSB09MD.o: TSB09MD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10DD.o: TSB10DD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10ED.o: TSB10ED.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10FD.o: TSB10FD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10HD.o: TSB10HD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10ID.o: TSB10ID.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10KD.o: TSB10KD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB10ZD.o: TSB10ZD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB16AD.o: TSB16AD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB16BD.o: TSB16BD.f ; $(FORTRAN) $(OPTS) -c $<
--TSB16CD.o: TSB16CD.f ; $(FORTRAN) $(OPTS) -c $<
--TSG02AD.o: TSG02AD.f ; $(FORTRAN) $(OPTS) -c $<
--TSG02ND.o: TSG02ND.f ; $(FORTRAN) $(OPTS) -c $<
--TSG03AD.o: TSG03AD.f ; $(FORTRAN) $(OPTS) -c $<
--TSG03BD.o: TSG03BD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01ID.o: TTB01ID.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01IZ.o: TTB01IZ.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01KD.o: TTB01KD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01LD.o: TTB01LD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01MD.o: TTB01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01ND.o: TTB01ND.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01PD.o: TTB01PD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01PX.o: TTB01PX.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01TD.o: TTB01TD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01UD.o: TTB01UD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01UY.o: TTB01UY.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01WD.o: TTB01WD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01WX.o: TTB01WX.f ; $(FORTRAN) $(OPTS) -c $<
--TTB01ZD.o: TTB01ZD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB03AD.o: TTB03AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB04AD.o: TTB04AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB04BD.o: TTB04BD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB04CD.o: TTB04CD.f ; $(FORTRAN) $(OPTS) -c $<
--TTB05AD.o: TTB05AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTC01OD.o: TTC01OD.f ; $(FORTRAN) $(OPTS) -c $<
--TTC04AD.o: TTC04AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTC05AD.o: TTC05AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTD03AD.o: TTD03AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTD04AD.o: TTD04AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTD05AD.o: TTD05AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTF01MD.o: TTF01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TTF01ND.o: TTF01ND.f ; $(FORTRAN) $(OPTS) -c $<
--TTF01OD.o: TTF01OD.f ; $(FORTRAN) $(OPTS) -c $<
--TTF01PD.o: TTF01PD.f ; $(FORTRAN) $(OPTS) -c $<
--TTF01QD.o: TTF01QD.f ; $(FORTRAN) $(OPTS) -c $<
--TTF01RD.o: TTF01RD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01AD.o: TTG01AD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01AZ.o: TTG01AZ.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01CD.o: TTG01CD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01DD.o: TTG01DD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01ED.o: TTG01ED.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01FD.o: TTG01FD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01FZ.o: TTG01FZ.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01GD.o: TTG01GD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01HD.o: TTG01HD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01ID.o: TTG01ID.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01JD.o: TTG01JD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01JY.o: TTG01JY.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01LD.o: TTG01LD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01MD.o: TTG01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01ND.o: TTG01ND.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01PD.o: TTG01PD.f ; $(FORTRAN) $(OPTS) -c $<
--TTG01QD.o: TTG01QD.f ; $(FORTRAN) $(OPTS) -c $<
--TUD01BD.o: TUD01BD.f ; $(FORTRAN) $(OPTS) -c $<
--TUD01CD.o: TUD01CD.f ; $(FORTRAN) $(OPTS) -c $<
--TUD01DD.o: TUD01DD.f ; $(FORTRAN) $(OPTS) -c $<
--TUD01MD.o: TUD01MD.f ; $(FORTRAN) $(OPTS) -c $<
--TUD01ND.o: TUD01ND.f ; $(FORTRAN) $(OPTS) -c $<
-+TAB01MD.o: TAB01MD.f ; $(FC) $(FFLAGS) -c $<
-+TAB01ND.o: TAB01ND.f ; $(FC) $(FFLAGS) -c $<
-+TAB01OD.o: TAB01OD.f ; $(FC) $(FFLAGS) -c $<
-+TAB04MD.o: TAB04MD.f ; $(FC) $(FFLAGS) -c $<
-+TAB05MD.o: TAB05MD.f ; $(FC) $(FFLAGS) -c $<
-+TAB05ND.o: TAB05ND.f ; $(FC) $(FFLAGS) -c $<
-+TAB05OD.o: TAB05OD.f ; $(FC) $(FFLAGS) -c $<
-+TAB05PD.o: TAB05PD.f ; $(FC) $(FFLAGS) -c $<
-+TAB05QD.o: TAB05QD.f ; $(FC) $(FFLAGS) -c $<
-+TAB05RD.o: TAB05RD.f ; $(FC) $(FFLAGS) -c $<
-+TAB07MD.o: TAB07MD.f ; $(FC) $(FFLAGS) -c $<
-+TAB07ND.o: TAB07ND.f ; $(FC) $(FFLAGS) -c $<
-+TAB08ND.o: TAB08ND.f ; $(FC) $(FFLAGS) -c $<
-+TAB08NW.o: TAB08NW.f ; $(FC) $(FFLAGS) -c $<
-+TAB08NZ.o: TAB08NZ.f ; $(FC) $(FFLAGS) -c $<
-+TAB09AD.o: TAB09AD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09BD.o: TAB09BD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09CD.o: TAB09CD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09DD.o: TAB09DD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09ED.o: TAB09ED.f ; $(FC) $(FFLAGS) -c $<
-+TAB09FD.o: TAB09FD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09GD.o: TAB09GD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09HD.o: TAB09HD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09ID.o: TAB09ID.f ; $(FC) $(FFLAGS) -c $<
-+TAB09JD.o: TAB09JD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09KD.o: TAB09KD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09MD.o: TAB09MD.f ; $(FC) $(FFLAGS) -c $<
-+TAB09ND.o: TAB09ND.f ; $(FC) $(FFLAGS) -c $<
-+TAB13AD.o: TAB13AD.f ; $(FC) $(FFLAGS) -c $<
-+TAB13BD.o: TAB13BD.f ; $(FC) $(FFLAGS) -c $<
-+TAB13CD.o: TAB13CD.f ; $(FC) $(FFLAGS) -c $<
-+TAB13DD.o: TAB13DD.f ; $(FC) $(FFLAGS) -c $<
-+TAB13ED.o: TAB13ED.f ; $(FC) $(FFLAGS) -c $<
-+TAB13FD.o: TAB13FD.f ; $(FC) $(FFLAGS) -c $<
-+TAB13ID.o: TAB13ID.f ; $(FC) $(FFLAGS) -c $<
-+TAB13MD.o: TAB13MD.f ; $(FC) $(FFLAGS) -c $<
-+TAG08BD.o: TAG08BD.f ; $(FC) $(FFLAGS) -c $<
-+TAG08BZ.o: TAG08BZ.f ; $(FC) $(FFLAGS) -c $<
-+TBB01AD.o: TBB01AD.f ; $(FC) $(FFLAGS) -c $<
-+TBB02AD.o: TBB02AD.f ; $(FC) $(FFLAGS) -c $<
-+TBB03AD.o: TBB03AD.f ; $(FC) $(FFLAGS) -c $<
-+TBB04AD.o: TBB04AD.f ; $(FC) $(FFLAGS) -c $<
-+TBD01AD.o: TBD01AD.f ; $(FC) $(FFLAGS) -c $<
-+TBD02AD.o: TBD02AD.f ; $(FC) $(FFLAGS) -c $<
-+TDE01OD.o: TDE01OD.f ; $(FC) $(FFLAGS) -c $<
-+TDE01PD.o: TDE01PD.f ; $(FC) $(FFLAGS) -c $<
-+TDF01MD.o: TDF01MD.f ; $(FC) $(FFLAGS) -c $<
-+TDG01MD.o: TDG01MD.f ; $(FC) $(FFLAGS) -c $<
-+TDG01ND.o: TDG01ND.f ; $(FC) $(FFLAGS) -c $<
-+TDG01OD.o: TDG01OD.f ; $(FC) $(FFLAGS) -c $<
-+TDK01MD.o: TDK01MD.f ; $(FC) $(FFLAGS) -c $<
-+TFB01QD.o: TFB01QD.f ; $(FC) $(FFLAGS) -c $<
-+TFB01RD.o: TFB01RD.f ; $(FC) $(FFLAGS) -c $<
-+TFB01SD.o: TFB01SD.f ; $(FC) $(FFLAGS) -c $<
-+TFB01TD.o: TFB01TD.f ; $(FC) $(FFLAGS) -c $<
-+TFB01VD.o: TFB01VD.f ; $(FC) $(FFLAGS) -c $<
-+TFD01AD.o: TFD01AD.f ; $(FC) $(FFLAGS) -c $<
-+TIB01AD.o: TIB01AD.f ; $(FC) $(FFLAGS) -c $<
-+TIB01BD.o: TIB01BD.f ; $(FC) $(FFLAGS) -c $<
-+TIB01CD.o: TIB01CD.f ; $(FC) $(FFLAGS) -c $<
-+TIB03AD.o: TIB03AD.f ; $(FC) $(FFLAGS) -c $<
-+TIB03BD.o: TIB03BD.f ; $(FC) $(FFLAGS) -c $<
-+TMB01TD.o: TMB01TD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02CD.o: TMB02CD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02DD.o: TMB02DD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02ED.o: TMB02ED.f ; $(FC) $(FFLAGS) -c $<
-+TMB02FD.o: TMB02FD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02GD.o: TMB02GD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02HD.o: TMB02HD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02ID.o: TMB02ID.f ; $(FC) $(FFLAGS) -c $<
-+TMB02JD.o: TMB02JD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02JX.o: TMB02JX.f ; $(FC) $(FFLAGS) -c $<
-+TMB02KD.o: TMB02KD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02MD.o: TMB02MD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02ND.o: TMB02ND.f ; $(FC) $(FFLAGS) -c $<
-+TMB02QD.o: TMB02QD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02SD.o: TMB02SD.f ; $(FC) $(FFLAGS) -c $<
-+TMB02VD.o: TMB02VD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03BD.o: TMB03BD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03BZ.o: TMB03BZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB03FZ.o: TMB03FZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB03KD.o: TMB03KD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03LD.o: TMB03LD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03LF.o: TMB03LF.f ; $(FC) $(FFLAGS) -c $<
-+TMB03LZ.o: TMB03LZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB03MD.o: TMB03MD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03ND.o: TMB03ND.f ; $(FC) $(FFLAGS) -c $<
-+TMB03OD.o: TMB03OD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03PD.o: TMB03PD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03QD.o: TMB03QD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03QG.o: TMB03QG.f ; $(FC) $(FFLAGS) -c $<
-+TMB03RD.o: TMB03RD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03SD.o: TMB03SD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03TD.o: TMB03TD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03UD.o: TMB03UD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03VD.o: TMB03VD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03WD.o: TMB03WD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03XD.o: TMB03XD.f ; $(FC) $(FFLAGS) -c $<
-+TMB03XP.o: TMB03XP.f ; $(FC) $(FFLAGS) -c $<
-+TMB03XZ.o: TMB03XZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB03ZD.o: TMB03ZD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04AD.o: TMB04AD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04AZ.o: TMB04AZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB04BD.o: TMB04BD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04BZ.o: TMB04BZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB04DD.o: TMB04DD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04DL.o: TMB04DL.f ; $(FC) $(FFLAGS) -c $<
-+TMB4DLZ.o: TMB4DLZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB04DP.o: TMB04DP.f ; $(FC) $(FFLAGS) -c $<
-+TMB4DPZ.o: TMB4DPZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB04DS.o: TMB04DS.f ; $(FC) $(FFLAGS) -c $<
-+TMB04DY.o: TMB04DY.f ; $(FC) $(FFLAGS) -c $<
-+TMB04DZ.o: TMB04DZ.f ; $(FC) $(FFLAGS) -c $<
-+TMB04ED.o: TMB04ED.f ; $(FC) $(FFLAGS) -c $<
-+TMB04FD.o: TMB04FD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04GD.o: TMB04GD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04MD.o: TMB04MD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04OD.o: TMB04OD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04PB.o: TMB04PB.f ; $(FC) $(FFLAGS) -c $<
-+TMB04PU.o: TMB04PU.f ; $(FC) $(FFLAGS) -c $<
-+TMB04TB.o: TMB04TB.f ; $(FC) $(FFLAGS) -c $<
-+TMB04TS.o: TMB04TS.f ; $(FC) $(FFLAGS) -c $<
-+TMB04UD.o: TMB04UD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04VD.o: TMB04VD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04XD.o: TMB04XD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04YD.o: TMB04YD.f ; $(FC) $(FFLAGS) -c $<
-+TMB04ZD.o: TMB04ZD.f ; $(FC) $(FFLAGS) -c $<
-+TMB05MD.o: TMB05MD.f ; $(FC) $(FFLAGS) -c $<
-+TMB05ND.o: TMB05ND.f ; $(FC) $(FFLAGS) -c $<
-+TMB05OD.o: TMB05OD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01MD.o: TMC01MD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01ND.o: TMC01ND.f ; $(FC) $(FFLAGS) -c $<
-+TMC01OD.o: TMC01OD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01PD.o: TMC01PD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01QD.o: TMC01QD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01RD.o: TMC01RD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01SD.o: TMC01SD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01TD.o: TMC01TD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01VD.o: TMC01VD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01WD.o: TMC01WD.f ; $(FC) $(FFLAGS) -c $<
-+TMC01XD.o: TMC01XD.f ; $(FC) $(FFLAGS) -c $<
-+TMC03MD.o: TMC03MD.f ; $(FC) $(FFLAGS) -c $<
-+TMC03ND.o: TMC03ND.f ; $(FC) $(FFLAGS) -c $<
-+TMD03AD.o: TMD03AD.f ; $(FC) $(FFLAGS) -c $<
-+TMD03BD.o: TMD03BD.f ; $(FC) $(FFLAGS) -c $<
-+TSB01BD.o: TSB01BD.f ; $(FC) $(FFLAGS) -c $<
-+TSB01DD.o: TSB01DD.f ; $(FC) $(FFLAGS) -c $<
-+TSB01MD.o: TSB01MD.f ; $(FC) $(FFLAGS) -c $<
-+TSB02MD.o: TSB02MD.f ; $(FC) $(FFLAGS) -c $<
-+TSB02ND.o: TSB02ND.f ; $(FC) $(FFLAGS) -c $<
-+TSB02OD.o: TSB02OD.f ; $(FC) $(FFLAGS) -c $<
-+TSB02PD.o: TSB02PD.f ; $(FC) $(FFLAGS) -c $<
-+TSB02QD.o: TSB02QD.f ; $(FC) $(FFLAGS) -c $<
-+TSB02RD.o: TSB02RD.f ; $(FC) $(FFLAGS) -c $<
-+TSB02SD.o: TSB02SD.f ; $(FC) $(FFLAGS) -c $<
-+TSB03MD.o: TSB03MD.f ; $(FC) $(FFLAGS) -c $<
-+TSB03OD.o: TSB03OD.f ; $(FC) $(FFLAGS) -c $<
-+TSB03QD.o: TSB03QD.f ; $(FC) $(FFLAGS) -c $<
-+TSB03SD.o: TSB03SD.f ; $(FC) $(FFLAGS) -c $<
-+TSB03TD.o: TSB03TD.f ; $(FC) $(FFLAGS) -c $<
-+TSB03UD.o: TSB03UD.f ; $(FC) $(FFLAGS) -c $<
-+TSB04MD.o: TSB04MD.f ; $(FC) $(FFLAGS) -c $<
-+TSB04ND.o: TSB04ND.f ; $(FC) $(FFLAGS) -c $<
-+TSB04OD.o: TSB04OD.f ; $(FC) $(FFLAGS) -c $<
-+TSB04PD.o: TSB04PD.f ; $(FC) $(FFLAGS) -c $<
-+TSB04QD.o: TSB04QD.f ; $(FC) $(FFLAGS) -c $<
-+TSB04RD.o: TSB04RD.f ; $(FC) $(FFLAGS) -c $<
-+TSB06ND.o: TSB06ND.f ; $(FC) $(FFLAGS) -c $<
-+TSB08CD.o: TSB08CD.f ; $(FC) $(FFLAGS) -c $<
-+TSB08DD.o: TSB08DD.f ; $(FC) $(FFLAGS) -c $<
-+TSB08ED.o: TSB08ED.f ; $(FC) $(FFLAGS) -c $<
-+TSB08FD.o: TSB08FD.f ; $(FC) $(FFLAGS) -c $<
-+TSB08MD.o: TSB08MD.f ; $(FC) $(FFLAGS) -c $<
-+TSB08ND.o: TSB08ND.f ; $(FC) $(FFLAGS) -c $<
-+TSB09MD.o: TSB09MD.f ; $(FC) $(FFLAGS) -c $<
-+TSB10DD.o: TSB10DD.f ; $(FC) $(FFLAGS) -c $<
-+TSB10ED.o: TSB10ED.f ; $(FC) $(FFLAGS) -c $<
-+TSB10FD.o: TSB10FD.f ; $(FC) $(FFLAGS) -c $<
-+TSB10HD.o: TSB10HD.f ; $(FC) $(FFLAGS) -c $<
-+TSB10ID.o: TSB10ID.f ; $(FC) $(FFLAGS) -c $<
-+TSB10KD.o: TSB10KD.f ; $(FC) $(FFLAGS) -c $<
-+TSB10ZD.o: TSB10ZD.f ; $(FC) $(FFLAGS) -c $<
-+TSB16AD.o: TSB16AD.f ; $(FC) $(FFLAGS) -c $<
-+TSB16BD.o: TSB16BD.f ; $(FC) $(FFLAGS) -c $<
-+TSB16CD.o: TSB16CD.f ; $(FC) $(FFLAGS) -c $<
-+TSG02AD.o: TSG02AD.f ; $(FC) $(FFLAGS) -c $<
-+TSG02ND.o: TSG02ND.f ; $(FC) $(FFLAGS) -c $<
-+TSG03AD.o: TSG03AD.f ; $(FC) $(FFLAGS) -c $<
-+TSG03BD.o: TSG03BD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01ID.o: TTB01ID.f ; $(FC) $(FFLAGS) -c $<
-+TTB01IZ.o: TTB01IZ.f ; $(FC) $(FFLAGS) -c $<
-+TTB01KD.o: TTB01KD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01LD.o: TTB01LD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01MD.o: TTB01MD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01ND.o: TTB01ND.f ; $(FC) $(FFLAGS) -c $<
-+TTB01PD.o: TTB01PD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01PX.o: TTB01PX.f ; $(FC) $(FFLAGS) -c $<
-+TTB01TD.o: TTB01TD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01UD.o: TTB01UD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01UY.o: TTB01UY.f ; $(FC) $(FFLAGS) -c $<
-+TTB01WD.o: TTB01WD.f ; $(FC) $(FFLAGS) -c $<
-+TTB01WX.o: TTB01WX.f ; $(FC) $(FFLAGS) -c $<
-+TTB01ZD.o: TTB01ZD.f ; $(FC) $(FFLAGS) -c $<
-+TTB03AD.o: TTB03AD.f ; $(FC) $(FFLAGS) -c $<
-+TTB04AD.o: TTB04AD.f ; $(FC) $(FFLAGS) -c $<
-+TTB04BD.o: TTB04BD.f ; $(FC) $(FFLAGS) -c $<
-+TTB04CD.o: TTB04CD.f ; $(FC) $(FFLAGS) -c $<
-+TTB05AD.o: TTB05AD.f ; $(FC) $(FFLAGS) -c $<
-+TTC01OD.o: TTC01OD.f ; $(FC) $(FFLAGS) -c $<
-+TTC04AD.o: TTC04AD.f ; $(FC) $(FFLAGS) -c $<
-+TTC05AD.o: TTC05AD.f ; $(FC) $(FFLAGS) -c $<
-+TTD03AD.o: TTD03AD.f ; $(FC) $(FFLAGS) -c $<
-+TTD04AD.o: TTD04AD.f ; $(FC) $(FFLAGS) -c $<
-+TTD05AD.o: TTD05AD.f ; $(FC) $(FFLAGS) -c $<
-+TTF01MD.o: TTF01MD.f ; $(FC) $(FFLAGS) -c $<
-+TTF01ND.o: TTF01ND.f ; $(FC) $(FFLAGS) -c $<
-+TTF01OD.o: TTF01OD.f ; $(FC) $(FFLAGS) -c $<
-+TTF01PD.o: TTF01PD.f ; $(FC) $(FFLAGS) -c $<
-+TTF01QD.o: TTF01QD.f ; $(FC) $(FFLAGS) -c $<
-+TTF01RD.o: TTF01RD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01AD.o: TTG01AD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01AZ.o: TTG01AZ.f ; $(FC) $(FFLAGS) -c $<
-+TTG01CD.o: TTG01CD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01DD.o: TTG01DD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01ED.o: TTG01ED.f ; $(FC) $(FFLAGS) -c $<
-+TTG01FD.o: TTG01FD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01FZ.o: TTG01FZ.f ; $(FC) $(FFLAGS) -c $<
-+TTG01GD.o: TTG01GD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01HD.o: TTG01HD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01ID.o: TTG01ID.f ; $(FC) $(FFLAGS) -c $<
-+TTG01JD.o: TTG01JD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01JY.o: TTG01JY.f ; $(FC) $(FFLAGS) -c $<
-+TTG01LD.o: TTG01LD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01MD.o: TTG01MD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01ND.o: TTG01ND.f ; $(FC) $(FFLAGS) -c $<
-+TTG01PD.o: TTG01PD.f ; $(FC) $(FFLAGS) -c $<
-+TTG01QD.o: TTG01QD.f ; $(FC) $(FFLAGS) -c $<
-+TUD01BD.o: TUD01BD.f ; $(FC) $(FFLAGS) -c $<
-+TUD01CD.o: TUD01CD.f ; $(FC) $(FFLAGS) -c $<
-+TUD01DD.o: TUD01DD.f ; $(FC) $(FFLAGS) -c $<
-+TUD01MD.o: TUD01MD.f ; $(FC) $(FFLAGS) -c $<
-+TUD01ND.o: TUD01ND.f ; $(FC) $(FFLAGS) -c $<
- 
--.f.o: ; $(FORTRAN) $(OPTS) -c $<
-+.f.o: ; $(FC) $(FFLAGS) -c $<
- 
---- a/make_Unix.inc
-+++ b/make_Unix.inc
-@@ -14,7 +14,6 @@ SHELL = /bin/sh
- #
- FC = gfortran
- FFLAGS = -O2 -fPIC -fdefault-integer-8
--FFLAGS_NOOPT = -O0
- 
- #  Define LDFLAGS to the desired linker options for your machine.
- #
-@@ -24,10 +23,11 @@ LDFLAGS =
- #  (library).  If your system has no ranlib, set RANLIB = echo.
- #
- ARCH = ar
--ARFLAGS = cr
-+ARCHFLAGS = cr
- # ARCHFLAGS= r
- # RANLIB   = ranlib
- 
-+LOADER   = $(FC)
- LOADOPTS = $(SLICOTLIB) $(LPKAUXLIB) $(LAPACKLIB) $(BLASLIB)
- #
- #  The location of the libraries to which you will link.  (The
---- a/src_aux/makefile_Unix
-+++ b/src_aux/makefile_Unix
-@@ -47,4 +47,4 @@ clean:
- 	rm -f *.o
- 
- .f.o: 
--	$(FORTRAN) $(OPTS) -c $<
-+	$(FC) $(FFLAGS) -c $<

windows/deps/versions.mk

@@ -1,4 +1,4 @@
-SLICOT_VERSION = 5.8+20230223.git401037e
+SLICOT_VERSION = 5.9~20240205.gita037f7e
 X13AS_VERSION = 1-1-b60
 
 OCTAVE_VERSION = 8.4.0