.clang-format

@@ -11,9 +11,12 @@ BreakInheritanceList: AfterColon
 Cpp11BracedListStyle: true
 DeriveLineEnding: false
 IndentPPDirectives: AfterHash
+InsertNewlineAtEOF: true
 PackConstructorInitializers: NextLine
 PPIndentWidth: 1
 PointerAlignment: Left
+# RemoveParentheses: ReturnStatement
+# RemoveSemicolon: true
 SpaceAfterTemplateKeyword: false
 SpaceBeforeParens: ControlStatements
 SpaceBeforeCpp11BracedList: true

.gitlab-ci.yml

 variables:
   TERM: linux
-  MINGW64_BOOST_VERSION: 1.85.0-2
+  MINGW64_BOOST_VERSION: 1.86.0-7
   WGET_OPTIONS: '--no-verbose --no-use-server-timestamps --retry-connrefused --retry-on-host-error'
   # To ensure that "false && true" fails, see https://gitlab.com/gitlab-org/gitlab-runner/-/issues/25394#note_412609647
   FF_ENABLE_BASH_EXIT_CODE_CHECK: 'true'
@@ -77,3 +77,16 @@ test_clang_format:
     - meson setup build-clang-format
     - ninja -C build-clang-format clang-format-check
   needs: []
+
+test_clang_tidy:
+  stage: test
+  script:
+    # Hack needed for meson < 1.6.0 which only looks for unversioned clang-tidy
+    - mkdir -p ~/.local/bin && ln -s /usr/bin/clang-tidy-19 ~/.local/bin/clang-tidy
+    - export PATH="$HOME/.local/bin:$PATH"
+    - meson setup build-clang-tidy
+    # Generate Flex and Bison files
+    - meson compile -C build-clang-tidy
+    - ninja -C build-clang-tidy clang-tidy
+  needs: []
+  when: manual

src/ComputingTasks.cc

@@ -283,7 +283,9 @@ PerfectForesightWithExpectationErrorsSolverStatement::writeOutput(
     [[maybe_unused]] bool minimal_workspace) const
 {
   options_list.writeOutput(output);
-  output << "oo_ = perfect_foresight_with_expectation_errors_solver(M_, options_, oo_);" << endl;
+  output << "[oo_, Simulated_time_series] = perfect_foresight_with_expectation_errors_solver(M_, "
+            "options_, oo_);"
+         << endl;
 }
 
 void
@@ -3713,8 +3715,7 @@ SvarGlobalIdentificationCheckStatement::writeJsonOutput(ostream& output) const
   output << R"({"statementName": "svar_global_identification"})";
 }
 
-SetTimeStatement::SetTimeStatement(OptionsList options_list_arg) :
-    options_list {move(options_list_arg)}
+SetTimeStatement::SetTimeStatement(string period_arg) : period {move(period_arg)}
 {
 }
 
@@ -3722,19 +3723,13 @@ void
 SetTimeStatement::writeOutput(ostream& output, [[maybe_unused]] const string& basename,
                               [[maybe_unused]] bool minimal_workspace) const
 {
-  options_list.writeOutput(output);
+  output << "options_.initial_period = " << period << endl;
 }
 
 void
 SetTimeStatement::writeJsonOutput(ostream& output) const
 {
-  output << R"({"statementName": "set_time")";
-  if (!options_list.empty())
-    {
-      output << ", ";
-      options_list.writeJsonOutput(output);
-    }
-  output << "}";
+  output << R"({"statementName": "set_time", "period": ")" << period << R"("})";
 }
 
 EstimationDataStatement::EstimationDataStatement(OptionsList options_list_arg) :
@@ -5347,8 +5342,8 @@ void
 ResidStatement::writeOutput(ostream& output, [[maybe_unused]] const string& basename,
                             [[maybe_unused]] bool minimal_workspace) const
 {
-  options_list.writeOutput(output, "options_resid_");
-  output << "display_static_residuals(M_, options_, oo_, options_resid_);" << endl;
+  options_list.writeOutput(output);
+  output << "display_static_residuals(M_, options_, oo_);" << endl;
 }
 
 void

src/ComputingTasks.hh

@@ -524,7 +524,7 @@ public:
   blockName() const override
   {
     return "estimated_params";
-  };
+  }
   void checkPass(ModFileStructure& mod_file_struct, WarningConsolidation& warnings) override;
   void writeOutput(ostream& output, const string& basename, bool minimal_workspace) const override;
   void writeJsonOutput(ostream& output) const override;
@@ -542,7 +542,7 @@ public:
   blockName() const override
   {
     return "estimated_params_init";
-  };
+  }
   void checkPass(ModFileStructure& mod_file_struct, WarningConsolidation& warnings) override;
   void writeOutput(ostream& output, const string& basename, bool minimal_workspace) const override;
   void writeJsonOutput(ostream& output) const override;
@@ -557,7 +557,7 @@ public:
   blockName() const override
   {
     return "estimated_params_bounds";
-  };
+  }
   void checkPass(ModFileStructure& mod_file_struct, WarningConsolidation& warnings) override;
   void writeOutput(ostream& output, const string& basename, bool minimal_workspace) const override;
   void writeJsonOutput(ostream& output) const override;
@@ -1007,10 +1007,10 @@ public:
 class SetTimeStatement : public Statement
 {
 private:
-  const OptionsList options_list;
+  const string period;
 
 public:
-  explicit SetTimeStatement(OptionsList options_list_arg);
+  explicit SetTimeStatement(string period_arg);
   void writeOutput(ostream& output, const string& basename, bool minimal_workspace) const override;
   void writeJsonOutput(ostream& output) const override;
 };

src/Configuration.hh

@@ -47,7 +47,7 @@ private:
     get_paths() const
     {
       return paths;
-    };
+    }
 
   private:
     map<string, vector<string>> paths;

src/DataTree.cc

@@ -24,6 +24,7 @@
 #include <fstream>
 #include <iostream>
 #include <iterator>
+#include <ranges>
 
 #include "DataTree.hh"
 
@@ -69,13 +70,14 @@ DataTree::DataTree(const DataTree& d) :
   // Constants must be initialized first because they are used in some Add* methods
   initConstants();
 
+  // See commment in DataTree::operator=() for the rationale
+  for (int symb_id : d.local_variables_vector)
+    local_variables_table[symb_id] = d.local_variables_table.at(symb_id)->clone(*this);
+
   for (const auto& it : d.node_list)
     it->clone(*this);
 
   assert(node_list.size() == d.node_list.size());
-
-  for (const auto& [symb_id, value] : d.local_variables_table)
-    local_variables_table[symb_id] = value->clone(*this);
 }
 
 DataTree&
@@ -804,9 +806,9 @@ DataTree::AddSum(expr_t arg)
 bool
 DataTree::isSymbolUsed(int symb_id) const
 {
-  for (const auto& [symb_lag, expr] : variable_node_map)
-    if (symb_lag.first == symb_id)
-      return true;
+  if (ranges::any_of(views::keys(variable_node_map),
+                     [=](const auto& symb_lag) { return symb_lag.first == symb_id; }))
+    return true;
 
   if (local_variables_table.contains(symb_id))
     return true;
@@ -852,8 +854,8 @@ DataTree::addAllParamDerivId([[maybe_unused]] set<int>& deriv_id_set)
 bool
 DataTree::isUnaryOpUsed(UnaryOpcode opcode) const
 {
-  return ranges::any_of(unary_op_node_map,
-                        [=](const auto& it) { return get<1>(it.first) == opcode; });
+  return ranges::any_of(views::keys(unary_op_node_map),
+                        [=](const auto& key) { return get<1>(key) == opcode; });
 }
 
 bool
@@ -873,8 +875,8 @@ DataTree::isUnaryOpUsedOnType(SymbolType type, UnaryOpcode opcode) const
 bool
 DataTree::isBinaryOpUsed(BinaryOpcode opcode) const
 {
-  return ranges::any_of(binary_op_node_map,
-                        [=](const auto& it) { return get<2>(it.first) == opcode; });
+  return ranges::any_of(views::keys(binary_op_node_map),
+                        [=](const auto& key) { return get<2>(key) == opcode; });
 }
 
 bool

src/DataTree.hh

@@ -367,7 +367,13 @@ public:
     if (it == local_variables_table.end())
       throw UnknownLocalVariableException {symb_id};
 
-    return it->second->decreaseLeadsLags(-lead_lag);
+    /* In the following, the case without lead/lag is optimized. It makes a difference on models
+       with many nested model-local variables, see e.g.
+       https://forum.dynare.org/t/pre-processing-takes-very-long/26865 */
+    if (lead_lag == 0)
+      return it->second;
+    else
+      return it->second->decreaseLeadsLags(-lead_lag);
   }
 
   static void
@@ -396,7 +402,7 @@ DataTree::AddPossiblyNegativeConstant(double v)
   if (isnan(v))
     return NaN;
   if (isinf(v))
-    return (v < 0 ? MinusInfinity : Infinity);
+    return v < 0 ? MinusInfinity : Infinity;
 
   bool neg = false;
   if (v < 0)

src/DynamicModel.cc

 /*
- * Copyright © 2003-2024 Dynare Team
+ * Copyright © 2003-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -1043,14 +1043,8 @@ DynamicModel::writeDriverOutput(ostream& output, bool compute_xrefs) const
          << (static_only_equations.size() > 0) << ";" << endl;
 
   // Say if model contains an external function call
-  bool has_external_function = false;
-  for (auto equation : equations)
-    if (equation->containsExternalFunction())
-      {
-        has_external_function = true;
-        break;
-      }
-  output << "M_.has_external_function = " << boolalpha << has_external_function << ';' << endl;
+  output << "M_.has_external_function = " << boolalpha
+         << ranges::any_of(equations, &ExprNode::containsExternalFunction) << ';' << endl;
 
   // Compute list of state variables, ordered in block-order
   vector<int> state_var;
@@ -1822,7 +1816,7 @@ DynamicModel::analyzePacEquationStructure(const string& name, map<string, string
   for (auto& equation : equations)
     if (equation->containsPacExpectation(name))
       {
-        if (!pac_eq_name[name].empty())
+        if (pac_eq_name.contains(name))
           {
             cerr << "It is not possible to use 'pac_expectation(" << name
                  << ")' in several equations." << endl;
@@ -1921,6 +1915,13 @@ DynamicModel::analyzePacEquationStructure(const string& name, map<string, string
                                    move(additive_vars_params_and_constants),
                                    move(optim_additive_vars_params_and_constants)};
       }
+
+  if (!pac_eq_name.contains(name))
+    {
+      cerr << "ERROR: the model does not contain the 'pac_expectation(" << name << ")' operator."
+           << endl;
+      exit(EXIT_FAILURE);
+    }
 }
 
 int

src/DynamicModel.hh

@@ -73,7 +73,8 @@ public:
     void checkAllRegimesPresent() const noexcept(false);
 
   private:
-    pair<vector<string>, vector<string>> convertBitVectorToRegimes(const vector<bool>& r) const;
+    [[nodiscard]] pair<vector<string>, vector<string>>
+    convertBitVectorToRegimes(const vector<bool>& r) const;
   };
 
 private:
@@ -713,7 +714,7 @@ public:
   {
     return tuple {static_only_equations, static_only_equations_lineno,
                   static_only_complementarity_conditions, static_only_equations_equation_tags};
-  };
+  }
 
   //! Returns true if a parameter was used in the model block with a lead or lag
   bool ParamUsedWithLeadLag() const;

src/DynareFlex.ll

 /* -*- C++ -*- */
 /*
- * Copyright © 2003-2024 Dynare Team
+ * Copyright © 2003-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -20,7 +20,6 @@
 
 
 %{
-#include <cstring>
 #include "ParsingDriver.hh"
 
 using namespace std;
@@ -60,7 +59,6 @@ string eofbuff;
 %x VERBATIM_BLOCK
 %x NATIVE
 %x NATIVE_COMMENT
-%x DATES_STATEMENT
 %x LINE1
 %x LINE2
 %x LINE3
@@ -70,7 +68,9 @@ string eofbuff;
 #define YY_USER_ACTION location_increment(yylloc, yytext);
 %}
 
-DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
+NAME [a-z_][a-z0-9_]*
+FLOAT_NUMBER ((([0-9]*\.[0-9]+)|([0-9]+\.))([ed][-+]?[0-9]+)?)|([0-9]+[ed][-+]?[0-9]+)
+DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4]|[sh][12])
 
 %%
  /* Code put at the beginning of yylex() */
@@ -92,12 +92,12 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
                 }
 
  /* spaces, tabs and carriage returns are ignored */
-<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,COMMENT,DATES_STATEMENT,LINE1,LINE2,LINE3>[[:space:]]+  { yylloc->step(); }
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,COMMENT,LINE1,LINE2,LINE3>[[:space:]]+  { yylloc->step(); }
 
  /* Comments */
-<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,DATES_STATEMENT>%.*
-<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,DATES_STATEMENT>"//".*
-<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,DATES_STATEMENT>"/*"   {comment_caller = YY_START; BEGIN COMMENT;}
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK>%.*
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK>"//".*
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK>"/*"   {comment_caller = YY_START; BEGIN COMMENT;}
 
 <COMMENT>"*/"        {BEGIN comment_caller;}
 <COMMENT>.
@@ -236,6 +236,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <INITIAL>pac_target_info {BEGIN DYNARE_BLOCK; return token::PAC_TARGET_INFO;}
 <INITIAL>matched_irfs {BEGIN DYNARE_BLOCK; return token::MATCHED_IRFS;}
 <INITIAL>matched_irfs_weights {BEGIN DYNARE_BLOCK; return token::MATCHED_IRFS_WEIGHTS;}
+<INITIAL>perfect_foresight_controlled_paths {BEGIN DYNARE_BLOCK; return token::PERFECT_FORESIGHT_CONTROLLED_PATHS;}
 
  /* For the semicolon after an "end" keyword */
 <INITIAL>; {return Dynare::parser::token_type (yytext[0]);}
@@ -246,7 +247,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>subsamples {return token::SUBSAMPLES;}
 <DYNARE_STATEMENT>options {return token::OPTIONS;}
 <DYNARE_STATEMENT>prior {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::PRIOR;
 }
 <INITIAL>std {BEGIN DYNARE_STATEMENT; return token::STD;}
@@ -256,27 +257,12 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <INITIAL>prior_function {BEGIN DYNARE_STATEMENT; return token::PRIOR_FUNCTION;}
 <INITIAL>posterior_function {BEGIN DYNARE_STATEMENT; return token::POSTERIOR_FUNCTION;}
 
- /* Inside  of a Dynare statement */
-<DYNARE_STATEMENT>{DATE} {
-                           /* If a date is found within a statement, substitute it with a call to
-                              the dates() constructor in the input character stream. Then it will
-                              be handled by the rule that follows the present one. */
-                           char* yycopy = strdup(yytext);
-                           char* uput = yycopy + yyleng;
-                           unput(')');
-                           unput('\'');
-                           while (uput > yycopy)
-                             unput(*--uput);
-                           unput('\'');
-                           unput('(');
-                           unput('s');
-                           unput('e');
-                           unput('t');
-                           unput('a');
-                           unput('d');
-                           free( yycopy );
-                         }
-<DYNARE_STATEMENT>dates  {dates_parens_nb=0; BEGIN DATES_STATEMENT; yylval->build<string>("dates");}
+<DYNARE_STATEMENT,DYNARE_BLOCK>{DATE} {
+  yylval->emplace<string>(yytext);
+  return token::DATE;
+}
+
+ /* Inside a Dynare statement */
 <DYNARE_STATEMENT>file                  {return token::FILE;}
 <DYNARE_STATEMENT>datafile 		{return token::DATAFILE;}
 <DYNARE_STATEMENT>dirname       {return token::DIRNAME;}
@@ -309,10 +295,10 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>posterior_nograph   		{return token::POSTERIOR_NOGRAPH;}
 <DYNARE_STATEMENT>nodisplay     {return token::NODISPLAY;}
 <DYNARE_STATEMENT>graph_format  {return token::GRAPH_FORMAT;}
-<DYNARE_STATEMENT>eps  {yylval->build<string>(yytext); return token::EPS;}
-<DYNARE_STATEMENT>pdf  {yylval->build<string>(yytext); return token::PDF;}
-<DYNARE_STATEMENT>fig  {yylval->build<string>(yytext); return token::FIG;}
-<DYNARE_STATEMENT>none  {yylval->build<string>(yytext); return token::NONE;}
+<DYNARE_STATEMENT>eps  {yylval->emplace<string>(yytext); return token::EPS;}
+<DYNARE_STATEMENT>pdf  {yylval->emplace<string>(yytext); return token::PDF;}
+<DYNARE_STATEMENT>fig  {yylval->emplace<string>(yytext); return token::FIG;}
+<DYNARE_STATEMENT>none  {yylval->emplace<string>(yytext); return token::NONE;}
 <DYNARE_STATEMENT>print   		{return token::PRINT;}
 <DYNARE_STATEMENT>noprint   		{return token::NOPRINT;}
 <DYNARE_STATEMENT>conf_sig  		{return token::CONF_SIG;}
@@ -420,6 +406,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>logarithmic_reduction {return token::LOGARITHMIC_REDUCTION;}
 <DYNARE_STATEMENT>use_univariate_filters_if_singularity_is_detected {return token::USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED;}
 <DYNARE_STATEMENT>hybrid {return token::HYBRID;}
+<DYNARE_STATEMENT>use_first_order_solution {return token::USE_FIRST_ORDER_SOLUTION;}
 <DYNARE_STATEMENT>default {return token::DEFAULT;}
 <DYNARE_STATEMENT>init2shocks {return token::INIT2SHOCKS;}
 
@@ -432,6 +419,10 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>kitagawa {return token::KITAGAWA;}
 <DYNARE_STATEMENT>smooth {return token::SMOOTH;}
 <DYNARE_STATEMENT>stratified {return token::STRATIFIED;}
+<DYNARE_STATEMENT>residual {
+  yylval->emplace<string>(yytext);
+  return token::RESIDUAL;
+}
 <DYNARE_STATEMENT>cpf_weights {return token::CPF_WEIGHTS;}
 <DYNARE_STATEMENT>amisanotristani {return token::AMISANOTRISTANI;}
 <DYNARE_STATEMENT>murrayjonesparslow {return token::MURRAYJONESPARSLOW;}
@@ -453,43 +444,40 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>fsolve_options {return token::FSOLVE_OPTIONS;}
 
 <DYNARE_STATEMENT>alpha {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::ALPHA;
 }
 <DYNARE_STATEMENT>beta {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::BETA;
 }
 <DYNARE_STATEMENT>gamma {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::GAMMA;
 }
 <DYNARE_STATEMENT>inv_gamma {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::INV_GAMMA;
 }
 <DYNARE_STATEMENT>inv_gamma1 {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::INV_GAMMA1;
 }
 <DYNARE_STATEMENT>inv_gamma2 {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::INV_GAMMA2;
 }
 <DYNARE_STATEMENT>dirichlet {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::DIRICHLET;
 }
-<DYNARE_STATEMENT>weibull {
-  yylval->build<string>(yytext);
-  return token::WEIBULL;
-}
+<DYNARE_STATEMENT>weibull {return token::WEIBULL;}
 <DYNARE_STATEMENT>normal {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::NORMAL;
 }
 <DYNARE_STATEMENT>uniform {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::UNIFORM;
 }
 <DYNARE_STATEMENT>gsig2_lmdm {return token::GSIG2_LMDM;}
@@ -500,13 +488,13 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>ncsk {return token::NCSK;}
 <DYNARE_STATEMENT>nstd {return token::NSTD;}
 <DYNARE_STATEMENT>ninv {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::NINV;
 }
 <DYNARE_STATEMENT>indxparr {return token::INDXPARR;}
 <DYNARE_STATEMENT>indxovr {return token::INDXOVR;}
 <DYNARE_STATEMENT>aband {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::ABAND;
 }
 <DYNARE_STATEMENT>write_equation_tags {return token::WRITE_EQUATION_TAGS;}
@@ -523,18 +511,18 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>indxgdls {return token::INDXGDLS;}
 <DYNARE_STATEMENT>eq_ms {return token::EQ_MS;}
 <DYNARE_STATEMENT>cms {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::CMS;
 }
 <DYNARE_STATEMENT>ncms {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::NCMS;
 }
 <DYNARE_STATEMENT>eq_cms {return token::EQ_CMS;}
 <DYNARE_STATEMENT>tlindx {return token::TLINDX;}
 <DYNARE_STATEMENT>tlnumber {return token::TLNUMBER;}
 <DYNARE_STATEMENT>cnum {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::CNUM;
 }
 <DYNARE_STATEMENT>nodecomposition {return token::NODECOMPOSITION;};
@@ -616,18 +604,9 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>substitute_libs {return token::SUBSTITUTE_LIBS;}
 <DYNARE_STATEMENT>compiler {return token::COMPILER;}
 <DYNARE_STATEMENT>instruments {return token::INSTRUMENTS;}
-<DYNARE_STATEMENT>hessian  {
-  yylval->build<string>(yytext);
-  return token::HESSIAN;
-}
-<DYNARE_STATEMENT>prior_variance  {
-  yylval->build<string>(yytext);
-  return token::PRIOR_VARIANCE;
-}
-<DYNARE_STATEMENT>identity_matrix  {
-  yylval->build<string>(yytext);
-  return token::IDENTITY_MATRIX;
-}
+<DYNARE_STATEMENT>hessian  {return token::HESSIAN;}
+<DYNARE_STATEMENT>prior_variance  {return token::PRIOR_VARIANCE;}
+<DYNARE_STATEMENT>identity_matrix  {return token::IDENTITY_MATRIX;}
 <DYNARE_STATEMENT>mcmc_jumping_covariance {return token::MCMC_JUMPING_COVARIANCE;}
 
  /* These four (var, varexo, varexo_det, parameters) are for change_type */
@@ -727,14 +706,6 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>lmmcp {return token::LMMCP;}
 <DYNARE_STATEMENT>additional_optimizer_steps	{return token::ADDITIONAL_OPTIMIZER_STEPS;}
 <DYNARE_STATEMENT>bartlett_kernel_lag {return token::BARTLETT_KERNEL_LAG; }
-<DYNARE_STATEMENT>optimal {
-  yylval->build<string>(yytext);
-  return token::OPTIMAL;
-}
-<DYNARE_STATEMENT>diagonal  {
-  yylval->build<string>(yytext);
-  return token::DIAGONAL;
-}
 <DYNARE_STATEMENT>gmm {return token::GMM;}
 <DYNARE_STATEMENT>smm {return token::SMM;}
 <DYNARE_STATEMENT>irf_matching {return token::IRF_MATCHING;}
@@ -780,8 +751,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>non_zero {return token::NON_ZERO;}
 
 <DYNARE_STATEMENT>\$[^$]*\$ {
-  strtok(yytext + 1, "$");
-  yylval->build<string>(yytext + 1);
+  yylval->emplace<string>(yytext + 1).pop_back();
   return token::TEX_NAME;
 }
 
@@ -794,16 +764,16 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_BLOCK>periods {return token::PERIODS;}
 <DYNARE_BLOCK>scales {return token::SCALES;}
 <DYNARE_BLOCK>add {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::ADD;
 }
 <DYNARE_BLOCK>multiply {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::MULTIPLY;
 }
 <DYNARE_STATEMENT,DYNARE_BLOCK>cutoff {return token::CUTOFF;}
 <DYNARE_STATEMENT,DYNARE_BLOCK>mfs {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::MFS;
 }
 <DYNARE_STATEMENT,DYNARE_BLOCK>static_mfs {return token::STATIC_MFS;}
@@ -820,19 +790,19 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_BLOCK>dsge_prior_weight {return token::DSGE_PRIOR_WEIGHT;}
 <DYNARE_BLOCK>surprise {return token::SURPRISE;}
 <DYNARE_BLOCK>bind {
-    yylval->build<string>(yytext);
+    yylval->emplace<string>(yytext);
     return token::BIND;
 }
 <DYNARE_BLOCK>relax {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::RELAX;
 }
 <DYNARE_BLOCK>error_bind {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::ERROR_BIND;
 }
 <DYNARE_BLOCK>error_relax {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::ERROR_RELAX;
 }
 <DYNARE_BLOCK>relative_to_initval {return token::RELATIVE_TO_INITVAL;}
@@ -846,22 +816,24 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_BLOCK,DYNARE_STATEMENT>auxname {return token::AUXNAME;}
 <DYNARE_BLOCK>auxname_target_nonstationary {return token::AUXNAME_TARGET_NONSTATIONARY;}
 <DYNARE_BLOCK,DYNARE_STATEMENT>kind {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::KIND;
 }
 <DYNARE_BLOCK,DYNARE_STATEMENT>ll {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::LL;
 }
 <DYNARE_BLOCK,DYNARE_STATEMENT>dl {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::DL;
 }
 <DYNARE_BLOCK,DYNARE_STATEMENT>dd {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::DD;
 }
 <DYNARE_BLOCK>weights {return token::WEIGHTS;}
+<DYNARE_BLOCK>exogenize {return token::EXOGENIZE;}
+<DYNARE_BLOCK>endogenize {return token::ENDOGENIZE;}
 
  /* Inside Dynare statement */
 <DYNARE_STATEMENT>solve_algo {return token::SOLVE_ALGO;}
@@ -873,7 +845,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>order {return token::ORDER;}
 <DYNARE_STATEMENT>lyapunov {return token::LYAPUNOV;}
 <DYNARE_STATEMENT>dr {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::DR;
  }
 <DYNARE_STATEMENT>lyapunov_complex_threshold {return token::LYAPUNOV_COMPLEX_THRESHOLD;}
@@ -937,11 +909,11 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>time_shift {return token::TIME_SHIFT;}
 <DYNARE_STATEMENT>structural {return token::STRUCTURAL;}
 <DYNARE_STATEMENT>true {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::TRUE;
 }
 <DYNARE_STATEMENT>false {
-    yylval->build<string>(yytext);
+    yylval->emplace<string>(yytext);
     return token::FALSE;
 }
 
@@ -1065,38 +1037,27 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <DYNARE_STATEMENT>use_shock_groups {return token::USE_SHOCK_GROUPS;}
 <DYNARE_STATEMENT>colormap {return token::COLORMAP;}
 
-<DYNARE_STATEMENT,DYNARE_BLOCK>[a-z_][a-z0-9_]* {
-  yylval->build<string>(yytext);
+<DYNARE_STATEMENT,DYNARE_BLOCK>{NAME} {
+  yylval->emplace<string>(yytext);
   return token::NAME;
 }
 
-<DYNARE_STATEMENT,DYNARE_BLOCK>((([0-9]*\.[0-9]+)|([0-9]+\.))([ed][-+]?[0-9]+)?)|([0-9]+[ed][-+]?[0-9]+) {
-  yylval->build<string>(yytext);
+<DYNARE_STATEMENT,DYNARE_BLOCK>{FLOAT_NUMBER} {
+  yylval->emplace<string>(yytext);
   return token::FLOAT_NUMBER;
 }
 
 <DYNARE_STATEMENT,DYNARE_BLOCK>[0-9]+ {
-  yylval->build<string>(yytext);
+  yylval->emplace<string>(yytext);
   return token::INT_NUMBER;
 }
 
-<DATES_STATEMENT>\( { yylval->as<string>().append(yytext); dates_parens_nb++; }
-<DATES_STATEMENT>\) {
-                      yylval->as<string>().append(yytext);
-                      if (--dates_parens_nb == 0)
-                      {
-                        BEGIN DYNARE_STATEMENT;
-                        return token::DATES;
-                      }
-                    }
-<DATES_STATEMENT>.  { yylval->as<string>().append(yytext); }
-
 <DYNARE_BLOCK>\|e { return token::PIPE_E; }
 <DYNARE_BLOCK>\|x { return token::PIPE_X; }
 <DYNARE_BLOCK>\|p { return token::PIPE_P; }
 
 <DYNARE_STATEMENT,DYNARE_BLOCK>\'[^\']*\' {
-  yylval->build<string>(yytext + 1).pop_back();
+  yylval->emplace<string>(yytext + 1).pop_back();
   return token::QUOTED_STRING;
 }
 
@@ -1128,11 +1089,11 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
     element in initval (in which case Dynare recognizes the matrix name as an external
     function symbol), and may want to modify the matrix later with Matlab statements.
  */
-<INITIAL>[a-z_][a-z0-9_]* {
+<INITIAL>{NAME} {
   if (driver.symbol_exists_and_is_not_modfile_local_or_external_function(yytext))
     {
       BEGIN DYNARE_STATEMENT;
-      yylval->build<string>(yytext);
+      yylval->emplace<string>(yytext);
       return token::NAME;
     }
   else
@@ -1153,7 +1114,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
     be able to back out of the statement if we realize it's a native statement
     and move to the NATIVE context
  */
-<INITIAL>\[([[:space:]]*[a-z_][a-z0-9_]*[[:space:]]*,{1}[[:space:]]*)*([[:space:]]*[a-z_][a-z0-9_]*[[:space:]]*){1}\] {
+<INITIAL>\[([[:space:]]*{NAME}[[:space:]]*,{1}[[:space:]]*)*([[:space:]]*{NAME}[[:space:]]*){1}\] {
   string yytextcpy{yytext};
   yytextcpy.erase(remove(yytextcpy.begin(), yytextcpy.end(), '['), yytextcpy.end());
   yytextcpy.erase(remove(yytextcpy.begin(), yytextcpy.end(), ']'), yytextcpy.end());
@@ -1177,7 +1138,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
   if (dynare_statement)
     {
       BEGIN DYNARE_STATEMENT;
-      yylval->build<vector<string>>(val);
+      yylval->emplace<vector<string>>(val);
       return token::SYMBOL_VEC;
     }
 }
@@ -1222,7 +1183,7 @@ DATE -?[0-9]+([ya]|m([1-9]|1[0-2])|q[1-4])
 <NATIVE_COMMENT>"*/"[[:space:]]*\n   { BEGIN NATIVE; }
 <NATIVE_COMMENT>.
 
-<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,COMMENT,DATES_STATEMENT,LINE1,LINE2,LINE3,NATIVE_COMMENT><<EOF>> { yyterminate(); }
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK,COMMENT,LINE1,LINE2,LINE3,NATIVE_COMMENT><<EOF>> { yyterminate(); }
 
 <*>.      { driver.error(*yylloc, "character unrecognized by lexer"); }
 %%

src/ExprNode.cc

 /*
- * Copyright © 2007-2024 Dynare Team
+ * Copyright © 2007-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -2978,10 +2978,8 @@ UnaryOpNode::writeJsonOutput(ostream& output, const temporary_terms_t& temporary
       output << "])";
       return;
     case UnaryOpcode::steadyState:
-      output << "(";
-      arg->writeJsonOutput(output, temporary_terms, tef_terms, isdynamic);
-      output << ")";
-      return;
+      output << "STEADY_STATE";
+      break;
     case UnaryOpcode::steadyStateParamDeriv:
       {
         auto varg = dynamic_cast<VariableNode*>(arg);
@@ -6458,9 +6456,9 @@ TrinaryOpNode::eval_opcode(double v1, TrinaryOpcode op_code, double v2, double v
   switch (op_code)
     {
     case TrinaryOpcode::normcdf:
-      return (0.5 * (1 + erf((v1 - v2) / v3 / numbers::sqrt2)));
+      return 0.5 * (1 + erf((v1 - v2) / v3 / numbers::sqrt2));
     case TrinaryOpcode::normpdf:
-      return (1 / (v3 * sqrt(2 * numbers::pi) * exp(pow((v1 - v2) / v3, 2) / 2)));
+      return 1 / (v3 * sqrt(2 * numbers::pi) * exp(pow((v1 - v2) / v3, 2) / 2));
     }
   __builtin_unreachable(); // Silence GCC warning
 }
@@ -6989,9 +6987,9 @@ TrinaryOpNode::isVariableNodeEqualTo([[maybe_unused]] SymbolType type_arg,
 bool
 TrinaryOpNode::containsPacExpectation(const string& pac_model_name) const
 {
-  return (arg1->containsPacExpectation(pac_model_name)
-          || arg2->containsPacExpectation(pac_model_name)
-          || arg3->containsPacExpectation(pac_model_name));
+  return arg1->containsPacExpectation(pac_model_name)
+         || arg2->containsPacExpectation(pac_model_name)
+         || arg3->containsPacExpectation(pac_model_name);
 }
 
 bool
@@ -7907,7 +7905,7 @@ ExternalFunctionNode::sameTefTermPredicate() const
 {
   return [this](expr_t e) {
     auto e2 = dynamic_cast<ExternalFunctionNode*>(e);
-    return (e2 != nullptr && e2->symb_id == symb_id && e2->arguments == arguments);
+    return e2 != nullptr && e2->symb_id == symb_id && e2->arguments == arguments;
   };
 }
 
@@ -8245,12 +8243,12 @@ FirstDerivExternalFunctionNode::sameTefTermPredicate() const
   if (first_deriv_symb_id == symb_id)
     return [this](expr_t e) {
       auto e2 = dynamic_cast<ExternalFunctionNode*>(e);
-      return (e2 && e2->symb_id == symb_id && e2->arguments == arguments);
+      return e2 && e2->symb_id == symb_id && e2->arguments == arguments;
     };
   else
     return [this](expr_t e) {
       auto e2 = dynamic_cast<FirstDerivExternalFunctionNode*>(e);
-      return (e2 && e2->symb_id == symb_id && e2->arguments == arguments);
+      return e2 && e2->symb_id == symb_id && e2->arguments == arguments;
     };
 }
 
@@ -8600,12 +8598,12 @@ SecondDerivExternalFunctionNode::sameTefTermPredicate() const
   if (second_deriv_symb_id == symb_id)
     return [this](expr_t e) {
       auto e2 = dynamic_cast<ExternalFunctionNode*>(e);
-      return (e2 && e2->symb_id == symb_id && e2->arguments == arguments);
+      return e2 && e2->symb_id == symb_id && e2->arguments == arguments;
     };
   else
     return [this](expr_t e) {
       auto e2 = dynamic_cast<SecondDerivExternalFunctionNode*>(e);
-      return (e2 && e2->symb_id == symb_id && e2->arguments == arguments);
+      return e2 && e2->symb_id == symb_id && e2->arguments == arguments;
     };
 }
 
@@ -9491,9 +9489,9 @@ ExprNode::matchParamTimesTargetMinusVariable(int symb_id) const
         auto& avi = datatree.symbol_table.getAuxVarInfo(target->symb_id);
         if (avi.type == AuxVarType::pacTargetNonstationary && target->lag == -1)
           return true;
-        return (avi.type == AuxVarType::unaryOp && avi.unary_op == "log" && avi.orig_symb_id
-                && !datatree.symbol_table.isAuxiliaryVariable(*avi.orig_symb_id)
-                && target->lag + avi.orig_lead_lag.value() == -1);
+        return avi.type == AuxVarType::unaryOp && avi.unary_op == "log" && avi.orig_symb_id
+               && !datatree.symbol_table.isAuxiliaryVariable(*avi.orig_symb_id)
+               && target->lag + avi.orig_lead_lag.value() == -1;
       }
     else
       return target->lag == -1;
@@ -9572,13 +9570,14 @@ ExprNode::toString() const
 }
 
 tuple<int, expr_t, expr_t>
-ExprNode::matchComplementarityCondition() const
+ExprNode::matchComplementarityCondition(
+    [[maybe_unused]] const optional<int>& heterogeneity_dimension) const
 {
   throw MatchFailureException {"This expression is not an inequality"};
 }
 
 tuple<int, expr_t, expr_t>
-BinaryOpNode::matchComplementarityCondition() const
+BinaryOpNode::matchComplementarityCondition(const optional<int>& heterogeneity_dimension) const
 {
   bool is_greater {[&] {
     switch (op_code)
@@ -9596,7 +9595,13 @@ BinaryOpNode::matchComplementarityCondition() const
 
   auto match_contemporaneous_endogenous = [&](expr_t e) -> optional<int> {
     auto* ve = dynamic_cast<VariableNode*>(e);
-    if (ve && ve->lag == 0 && datatree.symbol_table.getType(ve->symb_id) == SymbolType::endogenous)
+    if (ve && ve->lag == 0
+        && ((!heterogeneity_dimension
+             && datatree.symbol_table.getType(ve->symb_id) == SymbolType::endogenous)
+            || (heterogeneity_dimension
+                && datatree.symbol_table.getType(ve->symb_id) == SymbolType::heterogeneousEndogenous
+                && datatree.symbol_table.getHeterogeneityDimension(ve->symb_id)
+                       == *heterogeneity_dimension)))
       return ve->symb_id;
     else
       return nullopt;
@@ -9633,11 +9638,11 @@ BinaryOpNode::matchComplementarityCondition() const
             || (!is_greater
                 && (barg1->op_code == BinaryOpcode::less
                     || barg1->op_code == BinaryOpcode::lessEqual)))))
-    throw MatchFailureException {"Complementarity condition does not have the right form"};
+    throw MatchFailureException {};
 
   auto id = match_contemporaneous_endogenous(barg1->arg2);
   if (!id)
-    throw MatchFailureException {"Complementarity condition does not have the right form"};
+    throw MatchFailureException {};
   check_bound_constant(barg1->arg1);
   check_bound_constant(arg2);
 

src/ExprNode.hh

 /*
- * Copyright © 2007-2024 Dynare Team
+ * Copyright © 2007-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -283,7 +283,7 @@ protected:
   min_cost(bool is_matlab)
   {
     return is_matlab ? min_cost_matlab : min_cost_c;
-  };
+  }
 
   //! Initializes data member non_null_derivatives
   virtual void prepareForDerivation() = 0;
@@ -943,7 +943,8 @@ public:
   /* Matches an expression that constitutes a complementarity condition.
      If successful, returns a triplet (endo_symb_id, lower_bound, upper_bound).
      Otherwise, throws a MatchFailureException. */
-  [[nodiscard]] virtual tuple<int, expr_t, expr_t> matchComplementarityCondition() const;
+  [[nodiscard]] virtual tuple<int, expr_t, expr_t>
+  matchComplementarityCondition(const optional<int>& heterogeneity_dimension = nullopt) const;
 
   /* Replaces aggregation operators (e.g. SUM()) by new auxiliary variables.
      Also declares those aggregation operators in the HeterogeneityTable, so as to
@@ -1519,7 +1520,9 @@ public:
   [[nodiscard]] expr_t substituteLogTransform(int orig_symb_id, int aux_symb_id) const override;
   [[nodiscard]] expr_t substituteAggregationOperators(subst_table_t& subst_table,
                                                       vector<BinaryOpNode*>& neweqs) const override;
-  [[nodiscard]] tuple<int, expr_t, expr_t> matchComplementarityCondition() const override;
+  [[nodiscard]] tuple<int, expr_t, expr_t>
+  matchComplementarityCondition(const optional<int>& heterogeneity_dimension
+                                = nullopt) const override;
 };
 
 //! Trinary operator node

src/HeterogeneityTable.hh

@@ -90,7 +90,7 @@ public:
   };
 
   void addSummedHeterogeneousEndogenous(int symb_id);
-  int getSummedHeterogenousEndogenousIndex(int symb_id) const;
+  [[nodiscard]] int getSummedHeterogenousEndogenousIndex(int symb_id) const;
   [[nodiscard]] int aggregateEndoSize() const;
 
   void writeOutput(ostream& output) const;

src/HeterogeneousModel.cc

 /*
- * Copyright © 2024 Dynare Team
+ * Copyright © 2024-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -33,14 +33,6 @@ HeterogeneousModel::HeterogeneousModel(SymbolTable& symbol_table_arg,
 {
 }
 
-HeterogeneousModel::HeterogeneousModel(const HeterogeneousModel& m) :
-    ModelTree {m},
-    heterogeneity_dimension {m.heterogeneity_dimension},
-    deriv_id_table {m.deriv_id_table},
-    inv_deriv_id_table {m.inv_deriv_id_table}
-{
-}
-
 HeterogeneousModel&
 HeterogeneousModel::operator=(const HeterogeneousModel& m)
 {
@@ -123,14 +115,7 @@ HeterogeneousModel::computingPass(int derivsOrder, bool no_tmp_terms, bool use_d
 
   computeTemporaryTerms(!use_dll, no_tmp_terms);
 
-  if (ranges::any_of(complementarity_conditions, [](const auto& x) { return x.has_value(); }))
-    {
-      // Implementing it requires modifications in ModelTree::computeMCPEquationsReordering()
-      cerr << "ERROR: Complementarity conditions are not yet implemented in "
-              "model(heterogeneity=...) blocks"
-           << endl;
-      exit(EXIT_FAILURE);
-    }
+  computeMCPEquationsReordering(heterogeneity_dimension);
 }
 
 void
@@ -138,6 +123,7 @@ HeterogeneousModel::writeModelFiles(const string& basename, bool julia) const
 {
   assert(!julia); // Not yet implemented
   writeSparseModelMFiles<true>(basename, heterogeneity_dimension);
+  writeComplementarityConditionsFile<true>(basename, heterogeneity_dimension);
 }
 
 int
@@ -245,4 +231,9 @@ HeterogeneousModel::writeDriverOutput(ostream& output) const
   output << "];" << endl;
   writeDriverSparseIndicesHelper(
       "heterogeneity("s + to_string(heterogeneity_dimension + 1) + ").dynamic", output);
+  output << "M_.heterogeneity(" << heterogeneity_dimension + 1
+         << ").dynamic_mcp_equations_reordering = [";
+  for (auto i : mcp_equations_reordering)
+    output << i + 1 << "; ";
+  output << "];" << endl;
 }

src/HeterogeneousModel.hh

@@ -35,7 +35,7 @@ public:
                      ExternalFunctionsTable& external_functions_table_arg,
                      HeterogeneityTable& heterogeneity_table_arg, int heterogeneity_dimension_arg);
 
-  HeterogeneousModel(const HeterogeneousModel& m);
+  HeterogeneousModel(const HeterogeneousModel& m) = default;
   HeterogeneousModel& operator=(const HeterogeneousModel& m);
 
   void computingPass(int derivsOrder, bool no_tmp_terms, bool use_dll);

src/ModFile.cc

 /*
- * Copyright © 2006-2024 Dynare Team
+ * Copyright © 2006-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -1137,7 +1137,8 @@ ModFile::writeMOutput(const string& basename, bool clear_all, bool clear_global,
               << "M_.heteroskedastic_shocks.Qvalue_orig = [];" << endl
               << "M_.heteroskedastic_shocks.Qscale_orig = [];" << endl
               << "M_.matched_irfs = {};" << endl
-              << "M_.matched_irfs_weights = {};" << endl;
+              << "M_.matched_irfs_weights = {};" << endl
+              << "M_.perfect_foresight_controlled_paths = [];" << endl;
 
   // NB: options_.{ramsey,discretionary}_policy should rather be fields of M_
   mOutputFile << boolalpha << "options_.linear = " << linear << ";" << endl
@@ -1311,8 +1312,8 @@ ModFile::writeMOutput(const string& basename, bool clear_all, bool clear_global,
 
       if (!no_warn)
         {
-          if (warnings.countWarnings() > 0)
-            mOutputFile << "disp('Note: " << warnings.countWarnings()
+          if (int num_warnings {warnings.numWarnings()}; num_warnings > 0)
+            mOutputFile << "disp('Note: " << num_warnings
                         << " warning(s) encountered in the preprocessor')" << endl;
 
           mOutputFile << "if ~isempty(lastwarn)" << endl

src/ModelEquationBlock.hh

 /*
- * Copyright © 2010-2024 Dynare Team
+ * Copyright © 2010-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -62,6 +62,17 @@ protected:
   {
     return "original Ramsey model";
   }
+  int
+  getJacobianCol(int deriv_id, [[maybe_unused]] bool sparse) const override
+  {
+    /* Override the DynamicModel method by returning a dummy Jacobian column number.
+       The override is necessary because the method from DynamicModel fails with
+       endos with lag/lead greater than 1 or exos with a lag/lead, while substitutions
+       are by definition not done for an original model.
+       In particular, this fixes dynare#1960 (equation derivatives are computed for models declared
+       as linear, to check whether they are truly linear). */
+    return deriv_id;
+  }
 };
 
 class SteadyStateModel : public DataTree

src/ModelTree.cc

 /*
- * Copyright © 2003-2024 Dynare Team
+ * Copyright © 2003-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -895,7 +895,7 @@ ModelTree::determineLinearBlocks()
 int
 ModelTree::equation_number() const
 {
-  return (equations.size());
+  return equations.size();
 }
 
 void
@@ -1398,8 +1398,7 @@ ModelTree::writeLatexModelFile(const string& mod_basename, const string& latex_b
       content_output << endl << R"(\end{dmath})" << endl;
     }
 
-  output << R"(\include{)" << latex_basename + "_content"
-         << "}" << endl
+  output << R"(\include{)" << latex_basename + "_content" << "}" << endl
          << R"(\end{document})" << endl;
 
   output.close();
@@ -2119,11 +2118,13 @@ ModelTree::writeAuxVarRecursiveDefinitions(ostream& output, ExprNodeOutputType o
 }
 
 void
-ModelTree::computeMCPEquationsReordering()
+ModelTree::computeMCPEquationsReordering(const optional<int>& heterogeneous_dimension)
 {
   /* Optimal policy models (discretionary, or Ramsey before computing FOCs) do not have as many
      equations as variables. Do not even try to compute the reordering. */
-  if (static_cast<int>(equations.size()) != symbol_table.endo_nbr())
+  if (static_cast<int>(equations.size())
+      != (heterogeneous_dimension ? symbol_table.het_endo_nbr(*heterogeneous_dimension)
+                                  : symbol_table.endo_nbr()))
     return;
 
   assert(equations.size() == complementarity_conditions.size());

src/ModelTree.hh

 /*
- * Copyright © 2003-2024 Dynare Team
+ * Copyright © 2003-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -211,7 +211,7 @@ protected:
     getRecursiveSize() const
     {
       return size - mfs_size;
-    };
+    }
   };
 
   // Whether block decomposition has been successfully computed
@@ -296,7 +296,7 @@ protected:
 
   /* Computes the mcp_equations_reordering vector.
      Also checks that a variable does not appear as constrained in two different equations. */
-  void computeMCPEquationsReordering();
+  void computeMCPEquationsReordering(const optional<int>& heterogeneous_dimension = nullopt);
 
   //! Writes temporary terms
   template<ExprNodeOutputType output_type>
@@ -439,7 +439,9 @@ protected:
   void writeSetAuxiliaryVariablesFile(const string& basename, bool julia) const;
 
   template<bool dynamic>
-  void writeComplementarityConditionsFile(const string& basename) const;
+  void writeComplementarityConditionsFile(const string& basename,
+                                          const optional<int>& heterogeneous_dimension
+                                          = nullopt) const;
 
 private:
   //! Sparse matrix of double to store the values of the static Jacobian
@@ -559,7 +561,7 @@ protected:
   {
     return equation_type_and_normalized_equation[eq_idx_block2orig[blocks[blk].first_equation + eq]]
         .first;
-  };
+  }
   //! Return true if the equation has been normalized
   bool
   isBlockEquationRenormalized(int blk, int eq) const
@@ -567,44 +569,44 @@ protected:
     return equation_type_and_normalized_equation[eq_idx_block2orig[blocks[blk].first_equation + eq]]
                .first
            == EquationType::evaluateRenormalized;
-  };
+  }
   //! Return the expr_t of equation belonging to the block
   BinaryOpNode*
   getBlockEquationExpr(int blk, int eq) const
   {
     return equations[eq_idx_block2orig[blocks[blk].first_equation + eq]];
-  };
+  }
   //! Return the expr_t of renormalized equation belonging to the block
   BinaryOpNode*
   getBlockEquationRenormalizedExpr(int blk, int eq) const
   {
     return equation_type_and_normalized_equation[eq_idx_block2orig[blocks[blk].first_equation + eq]]
         .second;
-  };
+  }
   //! Return the original number of equation belonging to the block
   int
   getBlockEquationID(int blk, int eq) const
   {
     return eq_idx_block2orig[blocks[blk].first_equation + eq];
-  };
+  }
   //! Return the original number of variable belonging to the block
   int
   getBlockVariableID(int blk, int var) const
   {
     return endo_idx_block2orig[blocks[blk].first_equation + var];
-  };
+  }
   //! Return the position of an equation (given by its original index) inside its block
   int
   getBlockInitialEquationID(int blk, int eq) const
   {
     return eq_idx_orig2block[eq] - blocks[blk].first_equation;
-  };
+  }
   //! Return the position of a variable (given by its original index) inside its block
   int
   getBlockInitialVariableID(int blk, int var) const
   {
     return endo_idx_orig2block[var] - blocks[blk].first_equation;
-  };
+  }
   //! Initialize equation_reordered & variable_reordered
   void initializeVariablesAndEquations();
 
@@ -1004,9 +1006,8 @@ ModelTree::writeModelCFile(const string& basename, const string& mexext,
 
   const filesystem::path model_src_dir {filesystem::path {basename} / "model" / "src"};
 
-  auto [d_output, tt_output] = writeModelFileHelper < dynamic
-                                   ? ExprNodeOutputType::CDynamicModel
-                                   : ExprNodeOutputType::CStaticModel > ();
+  auto [d_output, tt_output] = writeModelFileHelper<dynamic ? ExprNodeOutputType::CDynamicModel
+                                                            : ExprNodeOutputType::CStaticModel>();
   vector<filesystem::path> header_files, object_files;
 
   // TODO: when C++20 support is complete, mark the following strings constexpr
@@ -2376,9 +2377,9 @@ ModelTree::writeSparseModelJuliaFiles(const string& basename) const
 {
   assert(heterogeneity_table.empty());
 
-  auto [d_sparse_output, tt_sparse_output] = writeModelFileHelper < dynamic
-                                                 ? ExprNodeOutputType::juliaSparseDynamicModel
-                                                 : ExprNodeOutputType::juliaSparseStaticModel > ();
+  auto [d_sparse_output, tt_sparse_output]
+      = writeModelFileHelper<dynamic ? ExprNodeOutputType::juliaSparseDynamicModel
+                                     : ExprNodeOutputType::juliaSparseStaticModel>();
 
   filesystem::path julia_dir {filesystem::path {basename} / "model" / "julia"};
   // TODO: when C++20 support is complete, mark the following strings constexpr
@@ -3154,10 +3155,13 @@ ModelTree::writeSetAuxiliaryVariablesFile(const string& basename, bool julia) co
 
 template<bool dynamic>
 void
-ModelTree::writeComplementarityConditionsFile(const string& basename) const
+ModelTree::writeComplementarityConditionsFile(const string& basename,
+                                              const optional<int>& heterogeneous_dimension) const
 {
-  // TODO: when C++20 support is complete, mark the following string constexpr
-  const string funcname {(dynamic ? "dynamic"s : "static"s) + "_complementarity_conditions"};
+  const string funcname {
+      (dynamic ? "dynamic"s : "static"s)
+      + (heterogeneous_dimension ? "_het"s + to_string(*heterogeneous_dimension + 1) : ""s)
+      + "_complementarity_conditions"};
   const filesystem::path filename {packageDir(basename) / (funcname + ".m")};
   /* Can’t use matlabOutsideModel for output type, since it uses M_.
      Static is ok even for the dynamic model, since there are no leads/lags. */