– enable new options InsertNewlineAtEOF and RemoveSemicolon
– reformat the code accordingly

– New “heterogeneity_dimension” statement
– New option “heterogeneity” to “var”, “varexo”, “parameters”, “model” and
  “shocks” statements
– New “SUM()” operator in “model” block

[skip ci]

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 using clang-tidy with bugprone-reserved-identifier
check.

By the way, homogeneize the define identifiers in relation to camel case
convention.

Automatically detected using clang-tidy with modernize-use-nodiscard check.

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

Improves performance on very very large models (tens of thousands of equations).

This is effectively a revert of commits 1b4f68f9,
32fb90d5 and f6f4ea70.

This transformation had been introduced in order to fix the computation of the
Ramsey steady state in the case where Lagrange multipliers appeared with a lead
or lag ⩾ 2 (and where thus part of the definition of an auxiliary variable).

But this transformation had introduced bugs in the handling of external
functions which were difficult to tackle.

Moreover, it seems preferable to keep the strict correspondence between the
dynamic and static model, in order to make reasoning about the preprocessor
internals easier (in particular, for this reason this transformation was not
implemented in ModFile::transformPass() but in ModFile::computingPass(), which
was a bit confusing).

A better solution for the Ramsey steady state issue will is implemented in the
descendent of the present commit.

Ref. dynare#633, dynare#1119, dynare#1133

The argument had the same name as the data member “datatree”, so this could
lead to confusion (though there was no bug, since the argument was masking
the data member).

Commit 23b0c12d introduced caching in chain
rule derivation (used by block decomposition), which increased speed for mfs >
0, but actually decreased it for mfs=0.

This patch introduces the pre-computation of derivatives which are known to be
zero using symbolic a priori (similarly to what is done in the non-chain rule
context). The algorithms are now identical between the two contexts (both
symbolic a priori + caching), the difference being that in the chain rule
context, the symbolic a priori and the cache are not stored within the ExprNode
class, since they depend on the list of recursive variables.

This patch brings a significant performant improvement for all values of the
“mfs” option (the improvement is greater for small values of “mfs”).

Useful for mfs > 0 on large models.

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.

Should have no impact though, since diff nodes are already substituted out at
that point. But it’s better to implement it properly, in case we change the
substitution rules later.

By the way, make the computeSubExprContainingVariable method protected.

By the way, turn those classes into structs since all their members are public.

Also improve the naming of the enum class used for identifying the type of
external function call.

By the way, add assertions to ensure that assignment LHS output type is only
used on VariableNode(s) and AbstractExternalFunctionNode(s).

When the same complex expression appears outside and inside a steady_state()
operator, the same temporary term would be used for both cases, which was
obviously wrong.

The fix consists in never substituting temporary terms for expressions inside
the steady_state operator().

Incidentally, this implies that external functions can no longer be used inside
steady_state operators (since their computed values are stored inside temporary
terms).

This probably brings no benefit since those functions are currently not used at
compile time, but it’s nice…

– a generic one: CommonEnums.hh
– and a bytecode-specific one: Bytecode.hh

By the way, rename global constant “near_zero” into “power_deriv_near_zero”,
for clarity.

We follow the advice given by Josuttis in his book about move semantics.

Deleting those member fuctions can be a bug if we want to allow copy semantics,
because overload resolution will no longer fallback to the copy
constructor/assignment operator when given an rvalue.

In particular, this explain why it was not possible to delete the move
assignment operator of the StaticModel class.