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

By the way, also improve the terminology used in variable and method names: a
“constraint” is something like “ZLB” or “INEG”, a regime is a state in which
constraints are either binding or relaxed.

Really closes: #103

In particular, emit more explicit error messages in the presence of
inconsistencies.

Closes: #103

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 using clang-tidy with modernize-loop-convert check.

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

NB: does not (yet) works with Occbin regime-specific equations.

Ref. dynare#1890

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

It maps column indices in the Jacobian returned by bytecode MEX in evaluate
mode (which only contains nonzero columns, but also incorporate recursive
variables), into column indices in the sparse representation (which has 3×n
columns for two-boundaries blocks and n columns for one-boundary blocks).
Columns unused in the sparse representation are indicated by a zero.

When parsing the FSTPG{2,3} opcodes, the bytecode MEX internally constructs a
Jacobian with as many lines as feedback variables. But the preprocessor would
also output instructions for filling derivatives of equations corresponding to
recursive variables in the “evaluate” mode, thus leading to memory corruption
in the bytecode MEX.

Currently defaults to 0.

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

Those models do not have as many variables as equations, and this case is not
supported by bytecode.

The present commit is an improvement over commit
a8ea57dd, which had already removed bytecode
for the planner objective model.

The preprocessor would try to write bytecode for the planner objective. But
bytecode only works when there are as many endogenous as equations, which is
not the case for the PlannerObjective object derived from StaticModel.

Temporary terms computed in previous blocks were not used in the bytecode
output of a given block. This was inefficient (because this means that
expressions already computed and store in the temporary terms vector would be
recomputed), and incidentally it would break the external functions
output (because it would trigger a lookup in the “TEF terms”, which would thus
fail).

Closes: #115

Adapt the code accordingly.

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

The computing of the Ramsey steady state relies on the fact that Lagrange
multipliers appear linearly in the system to be solved. Instead of directly
solving for the Lagrange multipliers along with the other variables,
dyn_ramsey_static.m reduces the size of the problem by always computing the
value of the multipliers that minimizes the residuals, given the other
variables (using a minimum norm solution, easy to compute because of the
linearity property). That function thus needs the derivatives of the optimality
FOCs with respect to the multipliers. The problem is that, when multipliers
appear in an auxiliary variable related to a lead/lag, then those derivatives
need to be retrieved by a chain rule derivation, which cannot be easily done
with the regular static file.

This commit implements the creation of a new file,
ramsey_multipliers_static_g1.{m,mex}, that provides exactly the needed
derivatives w.r.t. Lagrange multipliers through chain rule derivation.

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

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.

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

NB: mfs=3 is nevertheless used when “block” option has not been used, and the
model is purely backward/forward or static, for solve_algo={12,14}.

Closes: #113

No longer needed since perfect_foresight_problem MEX has moved to the sparse
representation.

Fix size of dynamic derivatives (legacy representation) when there are unused exogenous and “nostrict” option is given