src/ExprNode.hh

 /*
- * Copyright © 2007-2024 Dynare Team
+ * Copyright © 2007-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -219,13 +219,13 @@ RIGHT_ARRAY_SUBSCRIPT(ExprNodeOutputType output_type)
 }
 
 // Left and right parentheses
-inline string
+constexpr string
 LEFT_PAR(ExprNodeOutputType output_type)
 {
   return isLatexOutput(output_type) ? "\\left(" : "(";
 }
 
-inline string
+constexpr string
 RIGHT_PAR(ExprNodeOutputType output_type)
 {
   return isLatexOutput(output_type) ? "\\right)" : ")";
@@ -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;
@@ -572,38 +572,35 @@ public:
   {
   };
 
-  //! Returns the maximum lead of endogenous in this expression
+  //! Returns the maximum lead of endogenous in this expression (not incl. heterogeneous endo)
   /*! Always returns a non-negative value */
   [[nodiscard]] virtual int maxEndoLead() const = 0;
 
-  //! Returns the maximum lead of exogenous in this expression
+  //! Returns the maximum lead of exogenous in this expression (not incl. heterogeneous exo)
   /*! Always returns a non-negative value */
   [[nodiscard]] virtual int maxExoLead() const = 0;
 
-  //! Returns the maximum lag of endogenous in this expression
+  //! Returns the maximum lag of endogenous in this expression (not incl. heterogeneous endo)
   /*! Always returns a non-negative value */
   [[nodiscard]] virtual int maxEndoLag() const = 0;
 
-  //! Returns the maximum lag of exogenous in this expression
+  //! Returns the maximum lag of exogenous in this expression (not incl. heterogeneous exo)
   /*! Always returns a non-negative value */
   [[nodiscard]] virtual int maxExoLag() const = 0;
 
-  //! Returns the maximum lead of endo/exo/exodet in this expression
-  /*! A negative value means that the expression contains only lagged
-    variables. A value of numeric_limits<int>::min() means that there is
-    no variable. */
+  /* Returns the maximum lead of endo/exo/exodet in this expression (including heterogeneous
+     endo/exo). A negative value means that the expression contains only lagged variables. A value
+     of numeric_limits<int>::min() means that there is no variable. */
   [[nodiscard]] virtual int maxLead() const = 0;
 
-  //! Returns the maximum lag of endo/exo/exodet in this expression
-  /*! A negative value means that the expression contains only leaded
-    variables. A value of numeric_limits<int>::min() means that there is
-    no variable. */
+  /* Returns the maximum lag of endo/exo/exodet in this expression (including heterogeneous
+     endo/exo). A negative value means that the expression contains only leaded variables. A value
+     of numeric_limits<int>::min() means that there is no variable. */
   [[nodiscard]] virtual int maxLag() const = 0;
 
-  //! Returns the maximum lag of endo/exo/exodet, as if diffs were expanded
-  /*! This function behaves as maxLag(), except that it treats diff()
-    differently. For e.g., on diff(diff(x(-1))), maxLag() returns 1 while
-    maxLagWithDiffsExpanded() returns 3. */
+  /* Returns the maximum lag of endo/exo/exodet (including heterogeneous endo/exo), as if diffs were
+     expanded. This function behaves as maxLag(), except that it treats diff() differently. For
+     e.g., on diff(diff(x(-1))), maxLag() returns 1 while maxLagWithDiffsExpanded() returns 3. */
   [[nodiscard]] virtual int maxLagWithDiffsExpanded() const = 0;
 
   [[nodiscard]] virtual expr_t undiff() const = 0;
@@ -942,6 +939,19 @@ public:
 
   // Substitutes orig_symb_id(±l) with exp(aux_symb_id(±l)) (used for “var(log)”)
   [[nodiscard]] virtual expr_t substituteLogTransform(int orig_symb_id, int aux_symb_id) const = 0;
+
+  /* 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 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
+     compute their index in the dedicated vector in argument of the dynamic/static files. */
+  [[nodiscard]] virtual expr_t substituteAggregationOperators(subst_table_t& subst_table,
+                                                              vector<BinaryOpNode*>& neweqs) const
+      = 0;
 };
 
 //! Object used to compare two nodes (using their indexes)
@@ -1053,6 +1063,8 @@ public:
                                                     = "") const override;
   [[nodiscard]] bool isParamTimesEndogExpr() const override;
   [[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;
 };
 
 //! Symbol or variable node
@@ -1085,6 +1097,10 @@ protected:
 
 public:
   VariableNode(DataTree& datatree_arg, int idx_arg, int symb_id_arg, int lag_arg);
+  [[nodiscard]] SymbolType get_type() const;
+  [[nodiscard]] string getName() const;
+  [[nodiscard]] int getDerivID() const;
+  [[nodiscard]] int getTypeSpecificID() const;
   void writeOutput(ostream& output, ExprNodeOutputType output_type,
                    const temporary_terms_t& temporary_terms,
                    const temporary_terms_idxs_t& temporary_terms_idxs,
@@ -1102,7 +1118,6 @@ public:
                            const deriv_node_temp_terms_t& tef_terms) const override;
   expr_t toStatic(DataTree& static_datatree) const override;
   void computeXrefs(EquationInfo& ei) const override;
-  [[nodiscard]] SymbolType get_type() const;
   BinaryOpNode* normalizeEquationHelper(const set<expr_t>& contain_var, expr_t rhs) const override;
   [[nodiscard]] int maxEndoLead() const override;
   [[nodiscard]] int maxExoLead() const override;
@@ -1157,6 +1172,8 @@ public:
                           vector<int>& powers) const override;
   [[nodiscard]] pair<int, expr_t> matchEndogenousTimesConstant() const override;
   [[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;
 };
 
 //! Unary operator node
@@ -1304,6 +1321,8 @@ public:
   [[nodiscard]] bool isParamTimesEndogExpr() const override;
   void decomposeAdditiveTerms(vector<pair<expr_t, int>>& terms, int current_sign) const override;
   [[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;
 };
 
 //! Binary operator node
@@ -1454,7 +1473,7 @@ public:
   [[nodiscard]] expr_t unpackPowerDeriv() const;
   //! Returns MULT_i*(lhs-rhs) = 0, creating multiplier MULT_i
   expr_t addMultipliersToConstraints(int i);
-  //! Returns the non-zero hand-side of an equation (that must have a hand side equal to zero)
+  //! Returns the non-zero hand side of an equation (that must have a hand side equal to zero)
   [[nodiscard]] expr_t getNonZeroPartofEquation() const;
   [[nodiscard]] bool isInStaticForm() const override;
   void fillAutoregressiveRow(int eqn, const vector<int>& lhs,
@@ -1499,6 +1518,11 @@ public:
                           vector<int>& powers) const override;
   [[nodiscard]] pair<int, expr_t> matchEndogenousTimesConstant() const override;
   [[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 optional<int>& heterogeneity_dimension
+                                = nullopt) const override;
 };
 
 //! Trinary operator node
@@ -1642,6 +1666,8 @@ public:
   [[nodiscard]] bool containsPacTargetNonstationary(const string& pac_model_name
                                                     = "") const override;
   [[nodiscard]] bool isParamTimesEndogExpr() const override;
+  [[nodiscard]] expr_t substituteAggregationOperators(subst_table_t& subst_table,
+                                                      vector<BinaryOpNode*>& neweqs) const override;
   [[nodiscard]] expr_t substituteLogTransform(int orig_symb_id, int aux_symb_id) const override;
 };
 
@@ -1714,6 +1740,7 @@ protected:
 public:
   AbstractExternalFunctionNode(DataTree& datatree_arg, int idx_arg, int symb_id_arg,
                                vector<expr_t> arguments_arg);
+  [[nodiscard]] string getName() const;
   void computeTemporaryTerms(const pair<int, int>& derivOrder,
                              map<pair<int, int>, unordered_set<expr_t>>& temp_terms_map,
                              unordered_map<expr_t, pair<int, pair<int, int>>>& reference_count,
@@ -1816,6 +1843,8 @@ public:
                                                     = "") const override;
   [[nodiscard]] bool isParamTimesEndogExpr() const override;
   [[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;
 };
 
 class ExternalFunctionNode : public AbstractExternalFunctionNode
@@ -2018,6 +2047,8 @@ public:
   expr_t detrend(int symb_id, bool log_trend, expr_t trend) const override;
   [[nodiscard]] expr_t removeTrendLeadLag(const map<int, expr_t>& trend_symbols_map) const override;
   [[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;
 
 protected:
   void prepareForDerivation() override;

src/ExtendedPreprocessorTypes.hh

@@ -24,6 +24,7 @@
 enum class OutputType
 {
   standard, // Default value, infer the derivation order from .mod file only
+  first,    // Output only 1st dynamic derivatives with no other computations
   second,   // Output at least 2nd dynamic derivatives
   third,    // Output at least 3rd dynamic derivatives
 };

src/MacroExpandModFile.cc

 /*
- * Copyright © 2015-2023 Dynare Team
+ * Copyright © 2015-2025 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -41,7 +41,7 @@ macroExpandModFile(const filesystem::path& filename, const istream& modfile, boo
   if (save_macro)
     {
       if (save_macro_file.empty())
-        save_macro_file = filename.stem().string() + "-macroexp.mod";
+        save_macro_file = filename.stem().string() + "_macroexp.mod";
       ofstream macro_output_file {save_macro_file};
       if (macro_output_file.fail())
         {
@@ -52,15 +52,8 @@ macroExpandModFile(const filesystem::path& filename, const istream& modfile, boo
       string str(macro_output.str());
       if (!line_macro)
         {
-          /* Remove the @#line directives.
-             Unfortunately GCC 11 does not yet support std::regex::multiline
-             (despite it being in the C++17 standard), so we are forced to use
-             a trick to emulate the “usual” behaviour of the caret ^;
-             here, the latter only matches the beginning of file.
-             This also means that we are forced to remove the EOL before the
-             @#line, and not the one after it (matching the EOL before and the
-             EOL after in the same regexp does not work). */
-          str = regex_replace(str, regex(R"((^|\r?\n)@#line.*)"), "");
+          // Remove the @#line directives.
+          str = regex_replace(str, regex(R"(^@#line.*$)", std::regex::multiline), "");
           /* Remove the EOLs at the beginning of the output, the first one
              being a remnant of the first @#line directive. */
           str = regex_replace(str, regex(R"(^(\r?\n)+)"), "");

src/ModFile.hh

 /*
- * Copyright © 2006-2023 Dynare Team
+ * Copyright © 2006-2024 Dynare Team
  *
  * This file is part of Dynare.
  *
@@ -30,6 +30,8 @@
 #include "DynamicModel.hh"
 #include "ExtendedPreprocessorTypes.hh"
 #include "ExternalFunctionsTable.hh"
+#include "HeterogeneityTable.hh"
+#include "HeterogeneousModel.hh"
 #include "ModelEquationBlock.hh"
 #include "NumericalConstants.hh"
 #include "NumericalInitialization.hh"
@@ -46,6 +48,8 @@ class ModFile
 {
 public:
   explicit ModFile(WarningConsolidation& warnings_arg);
+  // For heterogeneity dimensions
+  HeterogeneityTable heterogeneity_table;
   //! Symbol table
   SymbolTable symbol_table;
   //! External Functions table
@@ -76,6 +80,8 @@ public:
   StaticModel static_model;
   //! Static model, as declared in the "steady_state_model" block if present
   SteadyStateModel steady_state_model;
+  // Heterogeneous model blocks, ordered per heterogeneity dimension ID
+  vector<HeterogeneousModel> heterogeneous_models;
 
   //! Option linear
   bool linear {false};
@@ -117,6 +123,11 @@ public:
   /*! (i.e. option parallel_local_files of model block) */
   vector<string> parallel_local_files;
 
+  /* Contents of the ramsey_constraints block.
+     Maps symb_id → (lower_bound, upper_bound).
+     NB: The two expr_t live in dynamic_model */
+  map<int, pair<expr_t, expr_t>> ramsey_constraints;
+
 private:
   //! List of statements
   vector<unique_ptr<Statement>> statements;