preprocessor + bytecode DLL: various enhancements to block and bytecode options (changes by Ferhat)

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

BlockTriangular.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 _BLOCKTRIANGULAR_HH
-#define _BLOCKTRIANGULAR_HH
-
-#include <string>
-#include "CodeInterpreter.hh"
-#include "ExprNode.hh"
-#include "SymbolTable.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;
-
-//! 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;
-
-typedef set<int> temporary_terms_inuse_type;
-
-typedef vector<pair< pair<int, pair<int, int> >, pair<int, int> > > chain_rule_derivatives_type;
-
-//! For one lead/lag of one block, stores mapping of information between original model and block-decomposed model
-struct IM_compact
-{
-  int size, u_init, u_finish, nb_endo, nb_other_endo, size_exo, size_other_endo;
-  int *u, *us, *Var, *Equ, *Var_Index, *Equ_Index, *Exogenous, *Exogenous_Index, *Equ_X, *Equ_X_Index;
-  int *u_other_endo, *Var_other_endo, *Equ_other_endo, *Var_Index_other_endo, *Equ_Index_other_endo;
-};
-
-//! One block of the model
-struct Block
-{
-  int Size, Sized, nb_exo, nb_exo_det, nb_other_endo, Nb_Recursives;
-  BlockType Type;
-  BlockSimulationType Simulation_Type;
-  int Max_Lead, Max_Lag, Nb_Lead_Lag_Endo;
-  int Max_Lag_Endo, Max_Lead_Endo;
-  int Max_Lag_Other_Endo, Max_Lead_Other_Endo;
-  int Max_Lag_Exo, Max_Lead_Exo;
-  bool is_linear;
-  int *Equation, *Own_Derivative;
-  EquationType *Equation_Type;
-  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;
-  IM_compact *IM_lead_lag;
-	chain_rule_derivatives_type *Chain_Rule_Derivatives;
-  int Code_Start, Code_Length;
-};
-
-
-
-//! The set of all blocks of the model
-struct Model_Block
-{
-  int Size, Periods;
-  Block* Block_List;
-  //int *in_Block_Equ, *in_Block_Var, *in_Equ_of_Block, *in_Var_of_Block;
-};
-
-
-//! Creates the incidence matrix, computes prologue & epilogue, normalizes the model and computes the block decomposition
-class BlockTriangular
-{
-private:
-  //! Find equations and endogenous variables belonging to the prologue and epilogue of the model
-  void Prologue_Epilogue(bool* IM, int &prologue, int &epilogue, int n, vector<int> &Index_Var_IM, vector<int> &Index_Equ_IM, bool* IM0);
-  //! Allocates and fills the Model structure describing the content of each block
-  void Allocate_Block(int size, int *count_Equ, int count_Block, BlockType type, BlockSimulationType SimType, Model_Block *ModelBlock, t_etype &Equation_Type, int recurs_Size, vector<int> &Index_Var_IM, vector<int> &Index_Equ_IM);
-  //! Finds a matching between equations and endogenous variables
-  bool Compute_Normalization(bool *IM, int equation_number, int prologue, int epilogue, int 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_, bool select_feedback_variable, int mfs) const;
-  //! 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, pair<int, int> >, NodeID> &first_order_endo_derivatives, vector<int> &Index_Var_IM, vector<int> &Index_Equ_IM, int mfs);
-  //! 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, vector<int> &Index_Var_IM, vector<int> &Index_Equ_IM);
-  //! 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, t_vtype &equation_lead_lag) const;
-public:
-  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;
-
-  map<pair<pair<int, pair<int, int> >, pair<int, int> >, int> get_Derivatives(Model_Block *ModelBlock, int Blck);
-
-
-  void Normalize_and_BlockDecompose_Static_0_Model(jacob_map &j_m, vector<BinaryOpNode *> &equations, t_etype &V_Equation_Type, map<pair<int, pair<int, int> >, NodeID> &first_order_endo_derivatives, int mfs, double cutoff);
-  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, pair<int, int> >, NodeID> &first_order_endo_derivatives, bool dynamic, int mfs, double cutoff);
-  vector<int> Index_Equ_IM;
-  vector<int> Index_Var_IM;
-  int prologue, epilogue;
-  bool bt_verbose;
-  Model_Block* ModelBlock;
-  int periods;
-  inline static std::string BlockType0(int type)
-  {
-    switch (type)
-      {
-      case 0:
-        return ("SIMULTANEOUS TIME SEPARABLE  ");
-        break;
-      case 1:
-        return ("PROLOGUE                     ");
-        break;
-      case 2:
-        return ("EPILOGUE                     ");
-        break;
-      case 3:
-        return ("SIMULTANEOUS TIME UNSEPARABLE");
-        break;
-      default:
-        return ("UNKNOWN                      ");
-        break;
-      }
-  };
-  inline static std::string BlockSim(int type)
-  {
-    switch (type)
-      {
-      case EVALUATE_FORWARD:
-      //case EVALUATE_FORWARD_R:
-        return ("EVALUATE FORWARD             ");
-        break;
-      case EVALUATE_BACKWARD:
-      //case EVALUATE_BACKWARD_R:
-        return ("EVALUATE BACKWARD            ");
-        break;
-      case SOLVE_FORWARD_SIMPLE:
-        return ("SOLVE FORWARD SIMPLE         ");
-        break;
-      case SOLVE_BACKWARD_SIMPLE:
-        return ("SOLVE BACKWARD SIMPLE        ");
-        break;
-      case SOLVE_TWO_BOUNDARIES_SIMPLE:
-        return ("SOLVE TWO BOUNDARIES SIMPLE  ");
-        break;
-      case SOLVE_FORWARD_COMPLETE:
-        return ("SOLVE FORWARD COMPLETE       ");
-        break;
-      case SOLVE_BACKWARD_COMPLETE:
-        return ("SOLVE BACKWARD COMPLETE      ");
-        break;
-      case SOLVE_TWO_BOUNDARIES_COMPLETE:
-        return ("SOLVE TWO BOUNDARIES COMPLETE");
-        break;
-      default:
-        return ("UNKNOWN                      ");
-        break;
-      }
-  };
-  inline static std::string c_Equation_Type(int type)
-  {
-    char c_Equation_Type[4][13]=
-    {
-    "E_UNKNOWN   ",
-    "E_EVALUATE  ",
-    "E_EVALUATE_S",
-    "E_SOLVE     "
-    };
-    return(c_Equation_Type[type]);
-  };
-};
-#endif

CodeInterpreter.hh

@@ -100,10 +100,10 @@ enum Tags
 
 enum BlockType
   {
-    SIMULTANS = 0, //!< Simultaneous time separable block
-    PROLOGUE = 1,  //!< Prologue block (one equation at the beginning, later merged)
-    EPILOGUE = 2,  //!< Epilogue block (one equation at the beginning, later merged)
-    SIMULTAN = 3   //!< Simultaneous time unseparable block
+    SIMULTANS,  //!< Simultaneous time separable block
+    PROLOGUE,   //!< Prologue block (one equation at the beginning, later merged)
+    EPILOGUE,   //!< Epilogue block (one equation at the beginning, later merged)
+    SIMULTAN    //!< Simultaneous time unseparable block
   };
 
 enum EquationType
@@ -126,7 +126,7 @@ enum BlockSimulationType
     SOLVE_TWO_BOUNDARIES_SIMPLE,  //!< Block of one equation, newton solver needed, forward & ackward
     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
+    SOLVE_TWO_BOUNDARIES_COMPLETE //!< Block of several equations, newton solver needed, forward and backwar
   };
 
 //! Enumeration of possible symbol types
@@ -475,9 +475,8 @@ private:
   uint8_t op_code;
   int size;
   uint8_t type;
-  int *variable;
-  int *equation;
-  int *own_derivatives;
+  vector<int> variable;
+  vector<int> equation;
   bool is_linear;
   vector<Block_contain_type> Block_Contain_;
   int endo_nbr;
@@ -485,11 +484,14 @@ private:
   int Max_Lead;
   int u_count_int;
 public:
-  inline FBEGINBLOCK_(){ op_code = FBEGINBLOCK; size = 0; type = UNKNOWN; variable = NULL; equation = NULL; own_derivatives = NULL;
+  inline FBEGINBLOCK_(){ op_code = FBEGINBLOCK; size = 0; type = UNKNOWN; /*variable = NULL; equation = NULL;*/
            is_linear = false; endo_nbr = 0; Max_Lag = 0; Max_Lead = 0; u_count_int = 0;};
-  inline FBEGINBLOCK_(const int size_arg, const BlockSimulationType type_arg, int *variable_arg, int *equation_arg, int *own_derivatives_arg,
-                      bool is_linear_arg, int endo_nbr_arg, int Max_Lag_arg, int Max_Lead_arg, int u_count_int_arg)
-         { op_code = FBEGINBLOCK; size = size_arg; type = type_arg; variable = variable_arg; equation = equation_arg; own_derivatives = own_derivatives_arg;
+  inline FBEGINBLOCK_(unsigned int &size_arg, BlockSimulationType &type_arg, int unsigned first_element, int unsigned &block_size,
+                      const vector<int> &variable_arg, const vector<int> &equation_arg,
+                      bool is_linear_arg, int endo_nbr_arg, int Max_Lag_arg, int Max_Lead_arg, int &u_count_int_arg)
+         { op_code = FBEGINBLOCK; size = size_arg; type = type_arg;
+           variable = vector<int>(variable_arg.begin()+first_element, variable_arg.begin()+(first_element+block_size));
+           equation = vector<int>(equation_arg.begin()+first_element, equation_arg.begin()+(first_element+block_size));
            is_linear = is_linear_arg; endo_nbr = endo_nbr_arg; Max_Lag = Max_Lag_arg; Max_Lead = Max_Lead_arg; u_count_int = u_count_int_arg;/*Block_Contain.clear();*/};
   inline unsigned int get_size() { return size;};
   inline uint8_t get_type() { return type;};
@@ -508,7 +510,6 @@ public:
        {
          CompileCode.write(reinterpret_cast<char *>(&variable[i]), sizeof(variable[0]));
          CompileCode.write(reinterpret_cast<char *>(&equation[i]), sizeof(equation[0]));
-         CompileCode.write(reinterpret_cast<char *>(&own_derivatives[i]), sizeof(own_derivatives[0]));
        }
      if (type==SOLVE_TWO_BOUNDARIES_SIMPLE || type==SOLVE_TWO_BOUNDARIES_COMPLETE ||
          type==SOLVE_BACKWARD_COMPLETE || type==SOLVE_FORWARD_COMPLETE)
@@ -532,7 +533,6 @@ public:
           Block_contain_type bc;
           memcpy(&bc.Variable, code, sizeof(bc.Variable)); code += sizeof(bc.Variable);
           memcpy(&bc.Equation, code, sizeof(bc.Equation)); code += sizeof(bc.Equation);
-          memcpy(&bc.Own_Derivative, code, sizeof(bc.Own_Derivative)); code += sizeof(bc.Own_Derivative);
           Block_Contain_.push_back(bc);
         }
        if (type==SOLVE_TWO_BOUNDARIES_SIMPLE || type==SOLVE_TWO_BOUNDARIES_COMPLETE ||

ComputingTasks.cc

@@ -876,13 +876,13 @@ PlannerObjectiveStatement::checkPass(ModFileStructure &mod_file_struct)
 void
 PlannerObjectiveStatement::computingPass()
 {
-  model_tree->computingPass(false, true, false);
+  model_tree->computingPass(eval_context_type(), false, true, false);
 }
 
 void
 PlannerObjectiveStatement::writeOutput(ostream &output, const string &basename) const
 {
-  model_tree->writeStaticFile(basename + "_objective", false);
+  model_tree->writeStaticFile(basename + "_objective", false, false);
 }
 
 BVARDensityStatement::BVARDensityStatement(int maxnlags_arg, const OptionsList &options_list_arg) :

DynamicModel.hh

@@ -25,8 +25,6 @@ using namespace std;
 #include <fstream>
 
 #include "StaticModel.hh"
-#include "StaticDllModel.hh"
-#include "BlockTriangular.hh"
 
 //! Stores a dynamic model
 class DynamicModel : public ModelTree
@@ -76,10 +74,15 @@ private:
   //! Temporary terms for the file containing parameters dervicatives
   temporary_terms_type params_derivs_temporary_terms;
 
+  //! Temporary terms for block decomposed models
+  vector< vector<temporary_terms_type> > v_temporary_terms;
+
+  vector<temporary_terms_inuse_type> v_temporary_terms_inuse;
+
+  //! Store the derivatives or the chainrule derivatives:map<pair< equation, pair< variable, lead_lag >, NodeID>
   typedef map< pair< int, pair< int, int> >, NodeID> first_chain_rule_derivatives_type;
   first_chain_rule_derivatives_type first_chain_rule_derivatives;
 
-
   //! Writes dynamic model file (Matlab version)
   void writeDynamicMFile(const string &dynamic_basename) const;
   //! Writes dynamic model file (C version)
@@ -91,37 +94,38 @@ private:
   /*! \todo add third derivatives handling in C output */
   void writeDynamicModel(ostream &DynamicOutput, bool use_dll) const;
   //! Writes the Block reordred structure of the model in M output
-  void writeModelEquationsOrdered_M(Model_Block *ModelBlock, const string &dynamic_basename) const;
+  void writeModelEquationsOrdered_M(const string &dynamic_basename) const;
   //! Writes the code of the Block reordred structure of the model in virtual machine bytecode
-  void writeModelEquationsCodeOrdered(const string file_name, const Model_Block *ModelBlock, const string bin_basename, map_idx_type map_idx) const;
+  void writeModelEquationsCodeOrdered(const string file_name, const string bin_basename, map_idx_type map_idx) const;
   //! Computes jacobian and prepares for equation normalization
   /*! Using values from initval/endval blocks and parameter initializations:
     - computes the jacobian for the model w.r. to contemporaneous variables
     - removes edges of the incidence matrix when derivative w.r. to the corresponding variable is too close to zero (below the cutoff)
   */
-  void evaluateJacobian(const eval_context_type &eval_context, jacob_map *j_m, bool dynamic);
-  void BlockLinear(Model_Block *ModelBlock);
+  //void evaluateJacobian(const eval_context_type &eval_context, jacob_map *j_m, bool dynamic);
+
+  //! return a map on the block jacobian
+  map<pair<pair<int, pair<int, int> >, pair<int, int> >, int> get_Derivatives(int block);
+  //! Computes chain rule derivatives of the Jacobian w.r. to endogenous variables
+  void computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives);
+
   string reform(string name) const;
   map_idx_type map_idx;
-  //! Build The incidence matrix form the modeltree
-  void BuildIncidenceMatrix();
 
-  void computeTemporaryTermsOrdered(Model_Block *ModelBlock);
+  void computeTemporaryTermsOrdered();
   //! Write derivative code of an equation w.r. to a variable
   void compileDerivative(ofstream &code_file, int eq, int symb_id, int lag, map_idx_type &map_idx) const;
   //! Write chain rule derivative code of an equation w.r. to a variable
   void compileChainRuleDerivative(ofstream &code_file, int eq, int var, int lag, map_idx_type &map_idx) const;
 
   //! Get the type corresponding to a derivation ID
-  SymbolType getTypeByDerivID(int deriv_id) const throw (UnknownDerivIDException);
+  virtual SymbolType getTypeByDerivID(int deriv_id) const throw (UnknownDerivIDException);
   //! Get the lag corresponding to a derivation ID
-  int getLagByDerivID(int deriv_id) const throw (UnknownDerivIDException);
+  virtual int getLagByDerivID(int deriv_id) const throw (UnknownDerivIDException);
   //! Get the symbol ID corresponding to a derivation ID
-  int getSymbIDByDerivID(int deriv_id) const throw (UnknownDerivIDException);
+  virtual int getSymbIDByDerivID(int deriv_id) const throw (UnknownDerivIDException);
   //! Compute the column indices of the dynamic Jacobian
   void computeDynJacobianCols(bool jacobianExo);
-  //! Computes chain rule derivatives of the Jacobian w.r. to endogenous variables
-  void computeChainRuleJacobian(Model_Block *ModelBlock);
   //! Computes derivatives of the Jacobian w.r. to parameters
   void computeParamsDerivatives();
   //! Computes temporary terms for the file containing parameters derivatives
@@ -145,10 +149,50 @@ private:
   //! Write chain rule derivative of a recursive equation w.r. to a variable
   void writeChainRuleDerivative(ostream &output, int eq, int var, int lag, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
 
+  //! Collecte the derivatives w.r. to endogenous of the block, to endogenous of previouys blocks and to exogenous
+  void collect_block_first_order_derivatives();
+
+
   //! Factorized code for substitutions of leads/lags
   /*! \param[in] type determines which type of variables is concerned */
   void substituteLeadLagInternal(aux_var_t type);
 
+
+private:
+  //! Indicate if the temporary terms are computed for the overall model (true) or not (false). Default value true
+  bool global_temporary_terms;
+
+  //! vector of block reordered variables and equations
+  vector<int> equation_reordered, variable_reordered, inv_equation_reordered, inv_variable_reordered;
+
+  //! Vector describing equations: BlockSimulationType, if BlockSimulationType == EVALUATE_s then a NodeID on the new normalized equation
+  t_equation_type_and_normalized_equation equation_type_and_normalized_equation;
+
+  //! for each block contains pair< Simulation_Type, pair < Block_Size, Recursive_part_Size > >
+  t_block_type_firstequation_size_mfs block_type_firstequation_size_mfs;
+
+  //! for all blocks derivatives description
+  t_blocks_derivatives blocks_derivatives;
+
+  //! The jacobian without the elements below the cutoff
+  dynamic_jacob_map dynamic_jacobian;
+
+  //! Vector indicating if the block is linear in endogenous variable (true) or not (false)
+  vector<bool> blocks_linear;
+
+  //! Map the derivatives for a block pair<lag, make_pair(make_pair(eq, var)), NodeID>
+  typedef map<pair< int, pair<int, int> >, NodeID> t_derivative;
+  //! Vector of derivative for each blocks
+  vector<t_derivative> derivative_endo, derivative_other_endo, derivative_exo, derivative_exo_det;
+
+  //!List for each block and for each lag-leag all the other endogenous variables and exogenous variables
+  typedef set<int> t_var;
+  typedef map<int, t_var> t_lag_var;
+  vector<t_lag_var> other_endo_block, exo_block, exo_det_block;
+
+  //!Maximum lead and lag for each block on endogenous of the block, endogenous of the previous blocks, exogenous and deterministic exogenous
+  vector<pair<int, int> > endo_max_leadlag_block, other_endo_max_leadlag_block, exo_max_leadlag_block, exo_det_max_leadlag_block, max_leadlag_block;
+
 public:
   DynamicModel(SymbolTable &symbol_table_arg, NumericalConstants &num_constants);
   //! Adds a variable node
@@ -179,8 +223,6 @@ public:
   //! Writes model initialization and lead/lag incidence matrix to output
   void writeOutput(ostream &output, const string &basename, bool block, bool byte_code, bool use_dll) const;
 
-  //! Complete set to block decompose the model
-  BlockTriangular block_triangular;
   //! Adds informations for simulation in a binary file
   void Write_Inf_To_Bin_File(const string &dynamic_basename, const string &bin_basename,
                              const int &num, int &u_count_int, bool &file_open, bool is_two_boundaries) const;
@@ -192,14 +234,12 @@ public:
   /*! It assumes that the static model given in argument has just been allocated */
   void toStatic(StaticModel &static_model) const;
 
-  void toStaticDll(StaticDllModel &static_model) const;
-
   //! Writes LaTeX file with the equations of the dynamic model
   void writeLatexFile(const string &basename) const;
 
   virtual int getDerivID(int symb_id, int lag) const throw (UnknownDerivIDException);
   virtual int getDynJacobianCol(int deriv_id) const throw (UnknownDerivIDException);
-	
+
   //! Returns true indicating that this is a dynamic model
   virtual bool isDynamic() const { return true; };
 
@@ -225,6 +265,40 @@ public:
 
   //! Fills eval context with values of model local variables and auxiliary variables
   void fillEvalContext(eval_context_type &eval_context) const;
+
+
+  //! Return the number of blocks
+  virtual unsigned int getNbBlocks() const {return(block_type_firstequation_size_mfs.size());};
+  //! Determine the simulation type of each block
+  virtual BlockSimulationType getBlockSimulationType(int block_number) const {return(block_type_firstequation_size_mfs[block_number].first.first);};
+  //! Return the first equation number of a block
+  virtual unsigned int getBlockFirstEquation(int block_number) const {return(block_type_firstequation_size_mfs[block_number].first.second);};
+  //! Return the size of the block block_number
+  virtual unsigned int getBlockSize(int block_number) const {return(block_type_firstequation_size_mfs[block_number].second.first);};
+  //! Return the number of feedback variable of the block block_number
+  virtual unsigned int getBlockMfs(int block_number) const {return(block_type_firstequation_size_mfs[block_number].second.second);};
+  //! Return the maximum lag in a block
+  virtual unsigned int getBlockMaxLag(int block_number) const {return(block_lag_lead[block_number].first);};
+  //! Return the maximum lead in a block
+  virtual unsigned int getBlockMaxLead(int block_number) const {return(block_lag_lead[block_number].second);};
+  //! Return the type of equation (equation_number) belonging to the block block_number
+  virtual EquationType getBlockEquationType(int block_number, int equation_number) const {return( equation_type_and_normalized_equation[equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]].first);};
+  //! Return true if the equation has been normalized
+  virtual bool isBlockEquationRenormalized(int block_number, int equation_number) const {return( equation_type_and_normalized_equation[equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]].first == E_EVALUATE_S);};
+  //! Return the NodeID of the equation equation_number belonging to the block block_number
+  virtual NodeID getBlockEquationNodeID(int block_number, int equation_number) const {return( equations[equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]]);};
+  //! Return the NodeID of the renormalized equation equation_number belonging to the block block_number
+  virtual NodeID getBlockEquationRenormalizedNodeID(int block_number, int equation_number) const {return( equation_type_and_normalized_equation[equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]].second);};
+  //! Return the original number of equation equation_number belonging to the block block_number
+  virtual int getBlockEquationID(int block_number, int equation_number) const {return( equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]);};
+  //! Return the original number of variable variable_number belonging to the block block_number
+  virtual int getBlockVariableID(int block_number, int variable_number) const {return( variable_reordered[block_type_firstequation_size_mfs[block_number].first.second+variable_number]);};
+  //! Return the position of equation_number in the block number belonging to the block block_number
+  virtual int getBlockInitialEquationID(int block_number, int equation_number) const {return((int)inv_equation_reordered[equation_number] - (int)block_type_firstequation_size_mfs[block_number].first.second);};
+  //! Return the position of variable_number in the block number belonging to the block block_number
+  virtual int getBlockInitialVariableID(int block_number, int variable_number) const {return((int)inv_variable_reordered[variable_number] - (int)block_type_firstequation_size_mfs[block_number].first.second);};
+
+
 };
 
 #endif

ExprNode.cc

@@ -32,7 +32,6 @@ using namespace __gnu_cxx;
 
 #include "ExprNode.hh"
 #include "DataTree.hh"
-#include "BlockTriangular.hh"
 #include "ModFile.hh"
 
 ExprNode::ExprNode(DataTree &datatree_arg) : datatree(datatree_arg), preparedForDerivation(false)
@@ -127,9 +126,8 @@ ExprNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
                                 temporary_terms_type &temporary_terms,
                                 map<NodeID, pair<int, int> > &first_occurence,
                                 int Curr_block,
-                                Model_Block *ModelBlock,
-                                int equation,
-                                map_idx_type &map_idx) const
+                                vector<vector<temporary_terms_type> > &v_temporary_terms,
+                                int equation) const
   {
     // Nothing to do for a terminal node
   }
@@ -242,18 +240,17 @@ NumConstNode::computeDerivative(int deriv_id)
 }
 
 void
-NumConstNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, Model_Block *ModelBlock, int Curr_Block) const
+NumConstNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
   {
     temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<NumConstNode *>(this));
     if (it != temporary_terms.end())
-      ModelBlock->Block_List[Curr_Block].Temporary_InUse->insert(idx);
+      temporary_terms_inuse.insert(idx);
   }
 
 void
 NumConstNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
                           const temporary_terms_type &temporary_terms) const
   {
-    //cout << "writeOutput constante\n";
     temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<NumConstNode *>(this));
     if (it != temporary_terms.end())
       if (output_type == oMatlabDynamicModelSparse)
@@ -427,13 +424,13 @@ VariableNode::computeDerivative(int deriv_id)
 }
 
 void
-VariableNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, Model_Block *ModelBlock, int Curr_Block) const
+VariableNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
   {
     temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<VariableNode *>(this));
     if (it != temporary_terms.end())
-      ModelBlock->Block_List[Curr_Block].Temporary_InUse->insert(idx);
+      temporary_terms_inuse.insert(idx);
     if (type== eModelLocalVariable)
-      datatree.local_variables_table[symb_id]->collectTemporary_terms(temporary_terms, ModelBlock, Curr_Block);
+      datatree.local_variables_table[symb_id]->collectTemporary_terms(temporary_terms, temporary_terms_inuse, Curr_Block);
   }
 
 void
@@ -486,7 +483,7 @@ VariableNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
 
       case eModelLocalVariable:
       case eModFileLocalVariable:
-        if (output_type==oMatlabDynamicModelSparse || output_type==oMatlabStaticModelSparse)
+        if (output_type==oMatlabDynamicModelSparse || output_type==oMatlabStaticModelSparse || output_type == oMatlabDynamicModelSparseLocalTemporaryTerms)
           {
             output << "(";
             datatree.local_variables_table[symb_id]->writeOutput(output, output_type,temporary_terms);
@@ -510,6 +507,7 @@ VariableNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
             output <<  "y" << LEFT_ARRAY_SUBSCRIPT(output_type) << i << RIGHT_ARRAY_SUBSCRIPT(output_type);
             break;
           case oMatlabDynamicModelSparse:
+          case oMatlabDynamicModelSparseLocalTemporaryTerms:
             i = tsid + ARRAY_SUBSCRIPT_OFFSET(output_type);
             if (lag > 0)
               output << "y" << LEFT_ARRAY_SUBSCRIPT(output_type) << "it_+" << lag << ", " << i << RIGHT_ARRAY_SUBSCRIPT(output_type);
@@ -535,6 +533,7 @@ VariableNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
           {
           case oMatlabDynamicModel:
           case oMatlabDynamicModelSparse:
+          case oMatlabDynamicModelSparseLocalTemporaryTerms:
             if (lag > 0)
               output <<  "x(it_+" << lag << ", " << i << ")";
             else if (lag < 0)
@@ -572,6 +571,7 @@ VariableNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
           {
           case oMatlabDynamicModel:
           case oMatlabDynamicModelSparse:
+          case oMatlabDynamicModelSparseLocalTemporaryTerms:
             if (lag > 0)
               output <<  "x(it_+" << lag << ", " << i << ")";
             else if (lag < 0)
@@ -695,12 +695,11 @@ VariableNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
                                     temporary_terms_type &temporary_terms,
                                     map<NodeID, pair<int, int> > &first_occurence,
                                     int Curr_block,
-                                    Model_Block *ModelBlock,
-                                    int equation,
-                                    map_idx_type &map_idx) const
+                                    vector<vector<temporary_terms_type> > &v_temporary_terms,
+                                    int equation) const
   {
     if (type== eModelLocalVariable)
-      datatree.local_variables_table[symb_id]->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, Curr_block, ModelBlock, equation, map_idx);
+      datatree.local_variables_table[symb_id]->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, Curr_block, v_temporary_terms, equation);
   }
 
 void
@@ -1204,9 +1203,8 @@ UnaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
                                    temporary_terms_type &temporary_terms,
                                    map<NodeID, pair<int, int> > &first_occurence,
                                    int Curr_block,
-                                   Model_Block *ModelBlock,
-                                   int equation,
-                                   map_idx_type &map_idx) const
+                                   vector< vector<temporary_terms_type> > &v_temporary_terms,
+                                   int equation) const
   {
     NodeID this2 = const_cast<UnaryOpNode *>(this);
     map<NodeID, int>::iterator it = reference_count.find(this2);
@@ -1214,7 +1212,7 @@ UnaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
       {
         reference_count[this2] = 1;
         first_occurence[this2] = make_pair(Curr_block,equation);
-        arg->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, Curr_block, ModelBlock, equation, map_idx);