- Correction of several bugs

- normalize an equation linear in its endogenous variable
- Chained rule derivatives (necessary to reduce a block to the feedback equations and variables)

git-svn-id: https://www.dynare.org/svn/dynare/trunk@2726 ac1d8469-bf42-47a9-8791-bf33cf982152

BlockTriangular.hh

@@ -24,21 +24,23 @@
 #include "CodeInterpreter.hh"
 #include "ExprNode.hh"
 #include "SymbolTable.hh"
-#include "ModelNormalization.hh"
-#include "ModelBlocks.hh"
+//#include "ModelNormalization.hh"
+//#include "ModelBlocks.hh"
 #include "IncidenceMatrix.hh"
 #include "ModelTree.hh"
 
 
 
-
-
 //! Sparse matrix of double to store the values of the Jacobian
 typedef map<pair<int ,int >,double> jacob_map;
 
 typedef vector<pair<BlockSimulationType, pair<int, int> > > t_type;
 
-typedef vector<pair<EquationType, int> > t_etype;
+//! Vector describing equations: BlockSimulationType, if BlockSimulationType == EVALUATE_s then a NodeID on the new normalized equation
+typedef vector<pair<EquationType, NodeID > > t_etype;
+
+//! Vector describing variables: max_lag in the block, max_lead in the block
+typedef vector<pair< int, int> > t_vtype;
 
 //! Creates the incidence matrix, computes prologue & epilogue, normalizes the model and computes the block decomposition
 class BlockTriangular
@@ -52,27 +54,32 @@ private:
   bool Compute_Normalization(bool *IM, int equation_number, int prologue, int epilogue, bool verbose, bool *IM0, vector<int> &Index_Var_IM) const;
   //! Decomposes into recurive blocks the non purely recursive equations and determines for each block the minimum feedback variables
   void Compute_Block_Decomposition_and_Feedback_Variables_For_Each_Block(bool *IM, int nb_var, int prologue, int epilogue, vector<int> &Index_Equ_IM, vector<int> &Index_Var_IM, vector<pair<int, int> > &blocks, t_etype &Equation_Type, bool verbose_) const;
-  //! determine the type of each equation of the model (couble evaluated or need to be solved)
+  //! determines the type of each equation of the model (could be evaluated or need to be solved)
   t_etype Equation_Type_determination(vector<BinaryOpNode *> &equations, map<pair<int, int >, NodeID> &first_cur_endo_derivatives, vector<int> &Index_Var_IM, vector<int> &Index_Equ_IM);
   //! Tries to merge the consecutive blocks in a single block and determine the type of each block: recursive, simultaneous, ...
   t_type Reduce_Blocks_and_type_determination(int prologue, int epilogue, vector<pair<int, int> > &blocks, vector<BinaryOpNode *> &equations, t_etype &Equation_Type);
+  //! Compute for each variable its maximum lead and lag in its block
+  t_vtype Get_Variable_LeadLag_By_Block(vector<int > &components_set, int nb_blck_sim, int prologue, int epilogue) const;
 public:
-  const SymbolTable &symbol_table;
-  BlockTriangular(const SymbolTable &symbol_table_arg);
+  SymbolTable &symbol_table;
+  /*Blocks blocks;
+  Normalization normalization;*/
+  IncidenceMatrix incidencematrix;
+  NumericalConstants &num_const;
+  DataTree *Normalized_Equation;
+  BlockTriangular(SymbolTable &symbol_table_arg, NumericalConstants &num_const_arg);
+  ~BlockTriangular();
   //! Frees the Model structure describing the content of each block
   void Free_Block(Model_Block* ModelBlock) const;
-  //BlockTriangular(const IncidenceMatrix &incidence_matrix_arg);
-  //const SymbolTable &symbol_table;
-  Blocks blocks;
-  Normalization normalization;
-  IncidenceMatrix incidencematrix;
+
+
+
   void Normalize_and_BlockDecompose_Static_0_Model(jacob_map &j_m, vector<BinaryOpNode *> &equations, t_etype &V_Equation_Type, map<pair<int, int >, NodeID> &first_cur_endo_derivatives);
   void Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock, int n, int &prologue, int &epilogue, vector<int> &Index_Var_IM, vector<int> &Index_Equ_IM, bool* IM_0 , jacob_map &j_m, vector<BinaryOpNode *> &equations, t_etype &equation_simulation_type, map<pair<int, int >, NodeID> &first_cur_endo_derivatives);
   vector<int> Index_Equ_IM;
   vector<int> Index_Var_IM;
   int prologue, epilogue;
   bool bt_verbose;
-  //int endo_nbr, exo_nbr;
   Model_Block* ModelBlock;
   int periods;
   inline static std::string BlockType0(int type)
@@ -101,11 +108,11 @@ public:
     switch (type)
       {
       case EVALUATE_FORWARD:
-      case EVALUATE_FORWARD_R:
+      //case EVALUATE_FORWARD_R:
         return ("EVALUATE FORWARD             ");
         break;
       case EVALUATE_BACKWARD:
-      case EVALUATE_BACKWARD_R:
+      //case EVALUATE_BACKWARD_R:
         return ("EVALUATE BACKWARD            ");
         break;
       case SOLVE_FORWARD_SIMPLE:
@@ -137,7 +144,7 @@ public:
     {
     "E_UNKNOWN   ",
     "E_EVALUATE  ",
-    "E_EVALUATE_R",
+    //"E_EVALUATE_R",
     "E_EVALUATE_S",
     "E_SOLVE     "
     };

CodeInterpreter.hh

@@ -53,8 +53,8 @@ enum EquationType
   {
     E_UNKNOWN,              //!< Unknown equation type
     E_EVALUATE,             //!< Simple evaluation, normalized variable on left-hand side
-    E_EVALUATE_R,           //!< Simple evaluation, normalized variable on right-hand side
-    E_EVALUATE_S,           //!< Simple evaluation, normalize using the first order derivative which does not involve the normalized variable
+    //E_EVALUATE_R,           //!< Simple evaluation, normalized variable on right-hand side
+    E_EVALUATE_S,           //!< Simple evaluation, normalize using the first order derivative
     E_SOLVE                 //!< No simple evaluation of the equation, it has to be solved
   };
 
@@ -71,8 +71,8 @@ enum BlockSimulationType
     SOLVE_FORWARD_COMPLETE,       //!< Block of several equations, newton solver needed, forward
     SOLVE_BACKWARD_COMPLETE,       //!< Block of several equations, newton solver needed, backward
     SOLVE_TWO_BOUNDARIES_COMPLETE, //!< Block of several equations, newton solver needed, forward and backwar
-    EVALUATE_FORWARD_R,           //!< Simple evaluation, normalized variable on right-hand side, forward
-    EVALUATE_BACKWARD_R            //!< Simple evaluation, normalized variable on right-hand side, backward
+    //EVALUATE_FORWARD_R,           //!< Simple evaluation, normalized variable on right-hand side, forward
+    //EVALUATE_BACKWARD_R            //!< Simple evaluation, normalized variable on right-hand side, backward
   };
 
 //! Enumeration of possible symbol types

ExprNode.hh

@@ -109,6 +109,10 @@ private:
   //! Computes derivative w.r. to a derivation ID (but doesn't store it in derivatives map)
   /*! You shoud use getDerivative() to get the benefit of symbolic a priori and of caching */
   virtual NodeID computeDerivative(int deriv_id) = 0;
+  //! Computes derivative w.r. to a derivation ID and use chaine rule derivatives (but doesn't store it in derivatives map)
+  /*! You shoud use getDerivative() to get the benefit of symbolic a priori and of caching */
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_) = 0;
+
 
 protected:
   //! Reference to the enclosing DataTree
@@ -136,6 +140,10 @@ public:
     For an equal node, returns the derivative of lhs minus rhs */
   NodeID getDerivative(int deriv_id);
 
+  //! Returns derivative w.r. to derivation ID and use if it possible chaine rule derivatives
+  NodeID getChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
+
+
   //! Returns precedence of node
   /*! Equals 100 for constants, variables, unary ops, and temporary terms */
   virtual int precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
@@ -145,7 +153,7 @@ public:
   virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
 
   //! Writes output of node, using a Txxx notation for nodes in temporary_terms
-  virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const = 0;
+  virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const /*= 0*/;
 
   //! Writes output of node (with no temporary terms and with "outside model" output type)
   void writeOutput(ostream &output);
@@ -174,6 +182,7 @@ public:
                                      map_idx_type &map_idx) const;
 
   class EvalException
+
   {
   };
 
@@ -185,6 +194,8 @@ public:
     adds the result in the static_datatree argument (and not in the original datatree), and returns it.
   */
   virtual NodeID toStatic(DataTree &static_datatree) const = 0;
+  //! Try to normalize an equation linear in its endogenous variable
+  virtual pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! Object used to compare two nodes (using their indexes)
@@ -204,6 +215,7 @@ private:
   //! Id from numerical constants table
   const int id;
   virtual NodeID computeDerivative(int deriv_id);
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
 public:
   NumConstNode(DataTree &datatree_arg, int id_arg);
   virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
@@ -213,6 +225,7 @@ public:
   virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
   virtual void compile(ofstream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, map_idx_type &map_idx) const;
   virtual NodeID toStatic(DataTree &static_datatree) const;
+  virtual pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! Symbol or variable node
@@ -226,6 +239,7 @@ private:
   //! Derivation ID
   const int deriv_id;
   virtual NodeID computeDerivative(int deriv_id_arg);
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
 public:
   VariableNode(DataTree &datatree_arg, int symb_id_arg, int lag_arg, int deriv_id_arg);
   virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms = temporary_terms_type()) const;
@@ -243,6 +257,7 @@ public:
   virtual void compile(ofstream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, map_idx_type &map_idx) const;
   virtual NodeID toStatic(DataTree &static_datatree) const;
   int get_symb_id() const { return symb_id; };
+  virtual pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! Unary operator node
@@ -252,6 +267,7 @@ private:
   const NodeID arg;
   const UnaryOpcode op_code;
   virtual NodeID computeDerivative(int deriv_id);
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
 
   virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
 public:
@@ -276,6 +292,7 @@ public:
   //! Returns op code
   UnaryOpcode get_op_code() const { return(op_code); };
   virtual NodeID toStatic(DataTree &static_datatree) const;
+  virtual pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! Binary operator node
@@ -285,6 +302,8 @@ private:
   const NodeID arg1, arg2;
   const BinaryOpcode op_code;
   virtual NodeID computeDerivative(int deriv_id);
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
+
   virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
 public:
   BinaryOpNode(DataTree &datatree_arg, const NodeID arg1_arg,
@@ -312,6 +331,7 @@ public:
   //! Returns op code
   BinaryOpcode get_op_code() const { return(op_code); };
   virtual NodeID toStatic(DataTree &static_datatree) const;
+  pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! Trinary operator node
@@ -322,6 +342,8 @@ private:
   const NodeID arg1, arg2, arg3;
   const TrinaryOpcode op_code;
   virtual NodeID computeDerivative(int deriv_id);
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
+
   virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
 public:
   TrinaryOpNode(DataTree &datatree_arg, const NodeID arg1_arg,
@@ -343,6 +365,7 @@ public:
   virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
   virtual void compile(ofstream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, map_idx_type &map_idx) const;
   virtual NodeID toStatic(DataTree &static_datatree) const;
+  virtual pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! Unknown function node
@@ -352,6 +375,7 @@ private:
   const int symb_id;
   const vector<NodeID> arguments;
   virtual NodeID computeDerivative(int deriv_id);
+  virtual NodeID computeChaineRuleDerivative(int deriv_id, map<int, NodeID> &recursive_variables, int var, int lag_);
 public:
   UnknownFunctionNode(DataTree &datatree_arg, int symb_id_arg,
                       const vector<NodeID> &arguments_arg);
@@ -370,6 +394,7 @@ public:
   virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
   virtual void compile(ofstream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, map_idx_type &map_idx) const;
   virtual NodeID toStatic(DataTree &static_datatree) const;
+  virtual pair<bool, NodeID> normalizeLinearInEndoEquation(int symb_id_endo, NodeID Derivative) const;
 };
 
 //! For one lead/lag of one block, stores mapping of information between original model and block-decomposed model
@@ -393,7 +418,8 @@ struct Block
   bool is_linear;
   int *Equation, *Own_Derivative;
   EquationType *Equation_Type;
-  int *Variable, *Other_Endogenous, *Exogenous, *Equation_Type_Var;
+  NodeID *Equation_Normalized;
+  int *Variable, *Other_Endogenous, *Exogenous;
   temporary_terms_type **Temporary_Terms_in_Equation;
   //temporary_terms_type *Temporary_terms;
   temporary_terms_inuse_type *Temporary_InUse;

MinimumFeedbackSet.cc

@@ -186,7 +186,6 @@ namespace MFS
     GraphvizDigraph_2_AdjacencyList(GraphvizDigraph& G1, set<int> select_index)
     {
       unsigned int n = select_index.size();
-      //cout << "n=" << n << "\n";
       AdjacencyList_type G(n);
       property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
       property_map<AdjacencyList_type, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
@@ -208,13 +207,7 @@ namespace MFS
             {
               int ii = target(*it_out, G1);
               if (select_index.find(ii) != select_index.end())
-                {
-                  /*cout << "*it=" << *it << " i = " << i << " ii=" << ii << " n=" << n << " *it_out=" << *it_out << "\n";
-                  cout << "source(*it_out, G1) = " << source(*it_out, G1) << " target(*it_out, G1) = " << target(*it_out, G1) << "\n";
-                  cout << "vertex(source(*it_out, G1), G) = " << vertex(source(*it_out, G1), G) << " vertex(target(*it_out, G1), G) = " << vertex(target(*it_out, G1), G) << "\n";*/
-                  add_edge( vertex(reverse_index[source(*it_out, G1)],G), vertex(reverse_index[target(*it_out, G1)], G), G);
-                  //add_edge(vertex(source(*it_out, G1), G) , vertex(target(*it_out, G1), G), G);
-                }
+                add_edge( vertex(reverse_index[source(*it_out, G1)],G), vertex(reverse_index[target(*it_out, G1)], G), G);
             }
         }
       return G;
@@ -367,109 +360,7 @@ namespace MFS
       return something_has_been_done;
     }
 
-    bool
-    Suppression_of_Edge_i_j_if_not_a_loop_and_if_for_all_i_k_edge_we_have_a_k_j_edge_Step(AdjacencyList_type& G)  //Suppression
-    {
-      bool something_has_been_done = false;
-      AdjacencyList_type::vertex_iterator  it, it_end;
-      int i = 0;
-      bool agree;
-      for (tie(it, it_end) = vertices(G);it != it_end; ++it, i++)
-        {
-          AdjacencyList_type::in_edge_iterator it_in, in_end;
-          AdjacencyList_type::out_edge_iterator it_out, out_end, it_out1, ita_out;
-          int j = 0;
-          for (tie(ita_out = it_out, out_end) = out_edges(*it, G); it_out != out_end; ++it_out, j++)
-            {
-              AdjacencyList_type::edge_descriptor ed;
-              bool exist;
-              tie(ed, exist) = edge(target(*it_out, G), source(*it_out, G) , G);
-              if (!exist)
-                {
-                  agree = true;
-                  for (tie(it_out1, out_end) = out_edges(*it, G); it_out1 != out_end; ++it_out1)
-                    {
-                      bool exist;
-                      tie(ed, exist) = edge(target(*it_out1, G), target(*it_out, G) , G);
-                      if (target(*it_out1, G) != target(*it_out, G) and !exist)
-                        agree = false;
-                    }
-                  if (agree)
-                    {
-                      something_has_been_done = true;
-                      remove_edge(*it_out, G);
-                      if (out_degree(*it, G) == 0)
-                        break;
-                      if (j > 0)
-                        {
-                          it_out = ita_out;
-                          tie(it_out1, out_end) = out_edges(*it, G);
-                        }
-                      else
-                        {
-                          tie(it_out, out_end) = out_edges(*it, G);
-                          j--;
-                        }
-                    }
-                }
-              ita_out = it_out;
-            }
-        }
-      return something_has_been_done;
-    }
-
 
-    bool
-    Suppression_of_all_in_Edge_in_i_if_not_a_loop_and_if_all_doublet_i_eq_Min_inDegree_outDegree_Step(AdjacencyList_type& G)
-    {
-      bool something_has_been_done = false;
-      AdjacencyList_type::vertex_iterator  it, it_end;
-      int i = 0;
-      for (tie(it, it_end) = vertices(G);it != it_end; ++it, i++)
-        {
-          AdjacencyList_type::in_edge_iterator it_in, in_end, it_in1, ita_in;
-          vector<AdjacencyList_type::vertex_descriptor> doublet = Collect_Doublet(*it, G);
-          if (doublet.size() == (unsigned int) min(in_degree(*it, G), out_degree(*it, G)))
-            {
-              int j = 0;
-              if (in_degree(*it, G))
-                for (tie(ita_in = it_in, in_end) = in_edges(*it, G); it_in != in_end; ++it_in, j++)
-                  {
-                    vector<AdjacencyList_type::vertex_descriptor>::iterator  it1 = doublet.begin();
-                    bool not_a_doublet = true;
-                    while (it1 != doublet.end() and not_a_doublet)
-                      {
-                        if (target(*it_in, G) == *it1)
-                          not_a_doublet = false;
-                        it1++;
-                      }
-                    if (not_a_doublet and source(*it_in, G) != target(*it_in, G))
-                      {
-#ifdef verbose
-                        property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
-                        cout << "remove_edge(" << v_index[source(*it_in, G)] << ", " << v_index[target(*it_in, G)] << ", G) j=" << j << " it_in == in_end : " << (it_in == in_end) << " in_degree(*it, G)=" << in_degree(*it, G) << ";\n";
-#endif
-                        something_has_been_done = true;
-                        remove_edge(source(*it_in, G), target(*it_in, G), G);
-                        cout << " in_degree(*it, G)=" << in_degree(*it, G) << ";\n";
-                        if (in_degree(*it, G) == 0)
-                          break;
-                        if (j > 0)
-                          {
-                            it_in = ita_in;
-                          }
-                        else
-                          {
-                            tie(it_in, in_end) = in_edges(*it, G);
-                            j--;
-                          }
-                      }
-                    ita_in = it_in;
-                  }
-            }
-        }
-      return something_has_been_done;
-    }
 
 
     bool
@@ -537,21 +428,9 @@ namespace MFS
 #endif
 
               //Rule 3
-              //something_has_been_done=(Suppression_of_Edge_i_j_if_not_a_loop_and_if_for_all_i_k_edge_we_have_a_k_j_edge_Step(G) or something_has_been_done);
-#ifdef verbose
-              cout << "3 something_has_been_done=" << something_has_been_done << "\n";
-#endif
-
-              //Rule 4
-              //something_has_been_done=(Suppression_of_all_in_Edge_in_i_if_not_a_loop_and_if_all_doublet_i_eq_Min_inDegree_outDegree_Step(G) or something_has_been_done);
-#ifdef verbose
-              cout << "4 something_has_been_done=" << something_has_been_done << "\n";
-#endif
-
-              //Rule 5
               something_has_been_done = (Suppression_of_Vertex_X_if_it_loops_store_in_set_of_feedback_vertex_Step(feed_back_vertices, G) or something_has_been_done);
 #ifdef verbose
-              cout << "5 something_has_been_done=" << something_has_been_done << "\n";
+              cout << "3 something_has_been_done=" << something_has_been_done << "\n";
 #endif
             }
           vector<int> circuit;

MinimumFeedbackSet.hh

@@ -25,8 +25,6 @@
 #include <vector>
 #include <boost/graph/graphviz.hpp>
 #include <boost/graph/adjacency_list.hpp>
-#include <stdio.h>
-#include <stdlib.h>
 
 using namespace std;
 using namespace boost;
@@ -44,25 +42,42 @@ using namespace boost;
 
 namespace MFS
 {
+  //! Eliminate a vertex i:
+  //! For a vertex i replace all edges e_k_i and e_i_j by a shorcut e_k_j and then Suppress the vertex i
   void Eliminate(AdjacencyList_type::vertex_descriptor vertex_to_eliminate, AdjacencyList_type& G);
+  //!collect all doublet (for each edge e_i_k there is an edge e_k_i with k!=i) in the graph
+  //!      and return the vector of doublet
   vector_vertex_descriptor Collect_Doublet(AdjacencyList_type::vertex_descriptor vertex, AdjacencyList_type& G);
+  //! Detect all the clique (all vertex in a clique are related to each other) in the graph
   bool Vertex_Belong_to_a_Clique(AdjacencyList_type::vertex_descriptor vertex, AdjacencyList_type& G);
-  bool Elimination_of_Vertex_With_One_or_Less_Indegree_or_Outdegree_Step(AdjacencyList_type& G);  //Graph reduction: eliminating purely intermediate variables or variables outside of any circuit
-  bool Elimination_of_Vertex_belonging_to_a_clique_Step(AdjacencyList_type& G);                   //Graphe reduction: eliminaion of Cliques
-  bool Suppression_of_Edge_i_j_if_not_a_loop_and_if_for_all_i_k_edge_we_have_a_k_j_edge_Step(AdjacencyList_type& G);  //Suppression
-  bool Suppression_of_all_in_Edge_in_i_if_not_a_loop_and_if_all_doublet_i_eq_Min_inDegree_outDegree_Step(AdjacencyList_type& G);
+  //! Graph reduction: eliminating purely intermediate variables or variables outside of any circuit
+  bool Elimination_of_Vertex_With_One_or_Less_Indegree_or_Outdegree_Step(AdjacencyList_type& G);
+  //! Graphe reduction: elimination of a vertex inside a clique
+  bool Elimination_of_Vertex_belonging_to_a_clique_Step(AdjacencyList_type& G);
+  //! A vertex belong to the feedback vertex set if the vertex loop on itself.
+  //! We have to suppress this vertex and store it into the feedback set.
   bool Suppression_of_Vertex_X_if_it_loops_store_in_set_of_feedback_vertex_Step(vector<pair<int, AdjacencyList_type::vertex_descriptor> > &looping_variable, AdjacencyList_type& G);
-  void Print(AdjacencyList_type& G);
-  AdjacencyList_type AM_2_AdjacencyList(bool* AMp,unsigned int n);
+  //! Print the Graph
   void Print(GraphvizDigraph& G);
+  void Print(AdjacencyList_type& G);
+  //! Create a GraphvizDigraph from a Adjacency Matrix (an incidence Matrix without the diagonal terms)
   GraphvizDigraph AM_2_GraphvizDigraph(bool* AM, unsigned int n);
+  //! Create an adjacency graph from a Adjacency Matrix (an incidence Matrix without the diagonal terms)
+  AdjacencyList_type AM_2_AdjacencyList(bool* AMp,unsigned int n);
+  //! Create an adjacency graph from a GraphvizDigraph
   AdjacencyList_type GraphvizDigraph_2_AdjacencyList(GraphvizDigraph& G1, set<int> select_index);
+  //! Check if the graph contains any cycle (true if the model contains at least one cycle, false otherwise)
   bool has_cycle_dfs(AdjacencyList_type& g, AdjacencyList_type::vertex_descriptor u, color_type& color, vector<int> &circuit_stack);
   bool has_cylce(AdjacencyList_type& g, vector<int> &circuit_stack, int size);
   bool has_cycle(vector<int> &circuit_stack, AdjacencyList_type& G);
+  //! Return the feedback set
   AdjacencyList_type Minimal_set_of_feedback_vertex(set<int> &feed_back_vertices, const AdjacencyList_type& G);
+  //! clear all in and out edges of vertex_to_eliminate
+  //!    and remove vertex_to_eliminate from the graph
   void Suppress(AdjacencyList_type::vertex_descriptor vertex_to_eliminate, AdjacencyList_type& G);
   void Suppress(int vertex_num, AdjacencyList_type& G);
+  //! reorder the recursive variable:
+  //! They appear first in a quasi triangular form and they are followed by the feedback variables
   vector<int> Reorder_the_recursive_variables(const AdjacencyList_type& G1, set<int> &feed_back_vertices);
 };
 

ModFile.cc

@@ -147,7 +147,7 @@ ModFile::computingPass(bool no_tmp_terms)
       static_model.computingPass(false, no_tmp_terms);
 
       // Set things to compute for dynamic model
-      
+
       if (mod_file_struct.simul_present)
         dynamic_model.computingPass(false, false, false, false, global_eval_context, no_tmp_terms);
       else

ModelGraph.hh

-/*
- * Copyright (C) 2007-2008 Dynare Team
- *
- * This file is part of Dynare.
- *
- * Dynare is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Dynare is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MODEL_GRAPH
-#define MODEL_GRAPH
-#define DIRECT_COMPUTE
-#define SORTED
-#define SIMPLIFY
-#define SIMPLIFYS
-#define SAVE
-#define COMPUTE
-//#define PRINT_OUT_OUT
-//#define PRINT_OUT_1
-#define DIRECT_SAVE
-#include "ModelTree.hh"
-#include "BlockTriangular.hh"
-
-struct t_edge
-{
-  int index, u_count;
-};
-
-struct t_vertex
-{
-  t_edge *out_degree_edge, *in_degree_edge;
-  int nb_out_degree_edges, nb_in_degree_edges;
-  int max_nb_out_degree_edges, max_nb_in_degree_edges;
-  int index, lag_lead;
-};
-
-struct t_model_graph
-{
-  int nb_vertices;
-  t_vertex* vertex;
-};
-
-void free_model_graph(t_model_graph* model_graph);
-void print_Graph(t_model_graph* model_graph);
-void Check_Graph(t_model_graph* model_graph);
-int ModelBlock_Graph(Model_Block *ModelBlock, int Blck_num,bool dynamic, t_model_graph* model_graph, int nb_endo, int *block_u_count, int *starting_vertex, int* periods, int *nb_table_y, int *mean_var_in_equ);
-#endif