The vector of lower and upper bounds is now provided by
{static,dynamic}_complementarity_conditions.m (which accepts parameters as an
argument, in preparation for the possibility of having parameters in
complementarity conditions).

The index that denotes the reordering of equation residuals (so that the
residual of an equation appears at the index of the endogenous appearing in the
complementarity condition) is now in “M_.{static,dynamic}_mcp_equations_reordering”.

Constraints declared through the ramsey_constraints block are also incorporated
in this new interface (and therefore “M_.ramsey_model_constraints” has been
removed).

Automatically detected by clang-tidy using
performance-inefficient-string-concatenation check.

Several of the detected cases are left unattended, because the syntax is more
elegant as it is, and they are not performance-critical.

Automatically detected by clang-tidy with performance-move-const-arg check.

Do not make the modification for Tokenizer::location type, since we have no
guarantee that the type will remain trivially-copyable in the future.

Automatically detected by clang-tidy using the performance-faster-string-find
check.

Automatically detected by clang-tidy using performance-for-range-copy check.

Automatically detected by clang-tidy using performance-unnecessary-value-param
check.

Also add some annotations to remove some false positives.

There remain some boost-related false positives, it’s unclear how to suppress
them.

Incidentally, makes tag names case-insensitive in “model_replace” and
“model_remove”, which is consistent with tag declarations.

This is a restoration of the behaviour that was present in 5.x.

It is already available as a class member.

Willi Mutschler authored 1 year ago and Sébastien Villemot committed 1 year ago

Related to Dynare/dynare#1893 and Dynare/dynare#1894

Initialization with initalizer list is nicer. And, more importantly,
initialization with parentheses is not supported by Clang < 16.

If the model is purely backward, determine whether all original equations have
a single contemporaneous endogenous on the LHS. If this is the case, then first
try a normalization by enforcing that each original equation is matched with
the endogenous on the LHS.

This helps with the simulation of purely backward models, where equations are
renormalized with mfs=3, since it produces a simpler system to be recursively
evaluated/solved.

It would previously return a boolean. The exception is more convenient for
producing a different error message in the case of the specialized algorithm
introduced in the next commit.

Improve performance on very large models (⩾ 5000 equations).

Note that std::unordered_set cannot be used for the temporary_terms_t type,
because ordering is needed there (for writing the output files).

The first argument to ExprNode::computeTemporaryTerms() is supposed to be a
pair (endo derivation order, param derivation order). The two elements were
interverted in the call. This would not affect the result, because parameter
derivatives are not computed there and what matters is the lexical ordering
which remains the same. But fixing the order is better, for consistency with
the method description.

By the way, remove a redundant Cluster{} constructor call.

Previously, the MinGW location was appended multiple times to the PATH
variable, which in some cases would make the variable too long and thus
dysfunctional.

The variable is now initialized once when the worker threads are created.

By the way, move the macOS+Octave environment variable initializations to the
same place, for consistency.

Note that DynamicModel::determineBlockDerivativesType(), it’s legitimate to
replace max_{lead,lag} by max_endo_{lead,lag}, because for exogenous
lag=lead=0, and we no longer compute derivatives w.r.t. to endogenous that do
not belong to the block (so-called “other” endogenous).

Bytecode w/ block decomposition: no longer output derivatives w.r.t. exogenous and endogenous outside the block

— No longer call std::exit() from threads when compilation fails, that function
  is marked as not thread-safe under GNU/Linux; and it leads to deadlocks under
  Windows. Rather store the list of failed objects, and exit with a message and
  an error code from the main thread when that list is not empty at the end of
  preprocessing.
– Fix the condition used for waiting until all compilation threads finish;
  checking that the queue is empty is not enough, since a compilation may be
  ongoing. So also track objects whose compilation is ongoing.

Such a decomposition has to be simulated with periods as the outer loop and
blocks as the inner loop.

It is enabled by default for purely backward/forward/static models, as long as
the “block” option is not given. In that case, “mfs” is also set to 3 by
default (until that value becomes the global default).

M_.time_recursive_block_decomposition is set to “true” when that decomposition
has been performed, “false” otherwise for the traditional decomposition (the
latter has to be simulated with blocks as the outer loop and periods as the
inner loop).

Block decomposition: when falling back to symbolic normalization, use contemporaneous symbolic Jacobian

Previously, it would use a symbolic Jacobian where leads and lags were also
taken into account.

By the way, ensure that temporary terms associated to external functions are
not removed, since they are not optional.

Within a block, if mfs>0, the recursive variables would not appear in recursive
order. This could lead to wrong results in case of dependency relationships
between recursive variables.

The stochastic mode in currently unsupported.

This commit adds new fields in M_.

This is a preliminary step for dynare#1859.

The new representation is only supported for MATLAB/Octave, C and Julia output
for the time being. Bytecode and JSON are unsupported.

This commit adds new fields in M_.

This is a preliminary step for dynare#1859.

– print the information only for the final matching (and not the intermediary
  ones that may have failed);
– print the equation name next to its number.

In an “evaluate” block, the LHS of a renormalized equation (such as “log(x)=…”)
could be associated to a temporary term that would then be incorrectly
computed: that temporary term would be evaluated *before* (and not after) the
evaluation of the associated variable (“x” in the example).