StaticModel.hh 15.1 KB
Newer Older
sebastien's avatar
sebastien committed
1
/*
2
 * Copyright (C) 2003-2010 Dynare Team
sebastien's avatar
sebastien committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * 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/>.
 */

20 21 22 23 24 25
#ifndef _STATIC_MODEL_HH
#define _STATIC_MODEL_HH

using namespace std;

#include <fstream>
sebastien's avatar
sebastien committed
26 27 28

#include "ModelTree.hh"

29
//! Stores a static model, as derived from the "model" block when leads and lags have been removed
sebastien's avatar
sebastien committed
30 31 32
class StaticModel : public ModelTree
{
private:
33 34 35 36 37
  typedef map<pair<int, int>, int> deriv_id_table_t;
  //! Maps a pair (symbol_id, lag) to a deriv ID
  deriv_id_table_t deriv_id_table;
  //! Maps a deriv ID to a pair (symbol_id, lag)
  vector<pair<int, int> > inv_deriv_id_table;
38

39
  //! Temporary terms for the file containing parameters dervicatives
40
  temporary_terms_t params_derivs_temporary_terms;
41

42
  //! Temporary terms for block decomposed models
43
  vector<vector<temporary_terms_t> > v_temporary_terms;
44

45
  vector<temporary_terms_inuse_t> v_temporary_terms_inuse;
46

47
  typedef map< pair< int, pair< int, int> >, expr_t> first_chain_rule_derivatives_t;
48
  first_chain_rule_derivatives_t first_chain_rule_derivatives;
49

50
  //! Writes static model file (standard Matlab version)
51 52 53 54
  void writeStaticMFile(const string &static_basename) const;

  //! Writes the static function calling the block to solve (Matlab version)
  void writeStaticBlockMFSFile(const string &basename) const;
sebastien's avatar
sebastien committed
55

56 57 58
  //! Writes static model file (C version)
  /*! \todo add third derivatives handling */
  void writeStaticCFile(const string &static_basename) const;
59

60 61
  //! Writes the Block reordred structure of the model in M output
  void writeModelEquationsOrdered_M(const string &dynamic_basename) const;
62

63
  //! Writes the code of the Block reordred structure of the model in virtual machine bytecode
64
  void writeModelEquationsCode_Block(const string file_name, const string bin_basename, map_idx_t map_idx) const;
65 66

  //! Writes the code of the model in virtual machine bytecode
67
  void writeModelEquationsCode(const string file_name, const string bin_basename, map_idx_t map_idx) const;
68

69

70 71 72 73 74
  //! 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)
  */
75
  void evaluateJacobian(const eval_context_t &eval_context, jacob_map_t *j_m, bool dynamic);
76

77
  map_idx_t map_idx;
sebastien's avatar
sebastien committed
78

79
  //! sorts the temporary terms in the blocks order
80
  void computeTemporaryTermsOrdered();
81 82 83
  //! creates a mapping from the index of temporary terms to a natural index
  void computeTemporaryTermsMapping();

84
  //! Write derivative code of an equation w.r. to a variable
85
  void compileDerivative(ofstream &code_file, unsigned int &instruction_number, int eq, int symb_id, map_idx_t &map_idx) const;
86
  //! Write chain rule derivative code of an equation w.r. to a variable
87
  void compileChainRuleDerivative(ofstream &code_file, unsigned int &instruction_number, int eq, int var, int lag, map_idx_t &map_idx) const;
88

89 90 91 92 93 94 95 96 97 98 99
  //! Get the type corresponding to a derivation ID
  virtual SymbolType getTypeByDerivID(int deriv_id) const throw (UnknownDerivIDException);
  //! Get the lag corresponding to a derivation ID
  virtual int getLagByDerivID(int deriv_id) const throw (UnknownDerivIDException);
  //! Get the symbol ID corresponding to a derivation ID
  virtual int getSymbIDByDerivID(int deriv_id) const throw (UnknownDerivIDException);
  //! Compute the column indices of the static Jacobian
  void computeStatJacobianCols();
  //! 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
100
  void computeChainRuleJacobian(blocks_derivatives_t &blocks_derivatives);
101
  //! Collect only the first derivatives
102
  map<pair<int, pair<int, int> >, expr_t> collect_first_order_derivatives_endogenous();
103 104 105 106 107 108 109 110 111 112

  //! Helper for writing the Jacobian elements in MATLAB and C
  /*! Writes either (i+1,j+1) or [i+j*no_eq] */
  void jacobianHelper(ostream &output, int eq_nb, int col_nb, ExprNodeOutputType output_type) const;

  //! Helper for writing the sparse Hessian elements in MATLAB and C
  /*! Writes either (i+1,j+1) or [i+j*NNZDerivatives[1]] */
  void hessianHelper(ostream &output, int row_nb, int col_nb, ExprNodeOutputType output_type) const;

  //! Write chain rule derivative of a recursive equation w.r. to a variable
113
  void writeChainRuleDerivative(ostream &output, int eq, int var, int lag, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
114 115 116 117 118 119 120 121 122 123 124

  //! Collecte the derivatives w.r. to endogenous of the block, to endogenous of previouys blocks and to exogenous
  void collect_block_first_order_derivatives();

protected:
  //! 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;

125
  //! Vector describing equations: BlockSimulationType, if BlockSimulationType == EVALUATE_s then a expr_t on the new normalized equation
126
  equation_type_and_normalized_equation_t equation_type_and_normalized_equation;
127 128

  //! for each block contains pair< Simulation_Type, pair < Block_Size, Recursive_part_Size > >
129
  block_type_firstequation_size_mfs_t block_type_firstequation_size_mfs;
130 131

  //! for all blocks derivatives description
132
  blocks_derivatives_t blocks_derivatives;
133 134

  //! The jacobian without the elements below the cutoff
135
  dynamic_jacob_map_t dynamic_jacobian;
136 137 138 139

  //! Vector indicating if the block is linear in endogenous variable (true) or not (false)
  vector<bool> blocks_linear;

140 141
  //! Map the derivatives for a block pair<lag, make_pair(make_pair(eq, var)), expr_t>
  typedef map<pair< int, pair<int, int> >, expr_t> derivative_t;
142
  //! Vector of derivative for each blocks
143
  vector<derivative_t> derivative_endo, derivative_other_endo, derivative_exo, derivative_exo_det;
144 145

  //!List for each block and for each lag-leag all the other endogenous variables and exogenous variables
146 147 148
  typedef set<int> var_t;
  typedef map<int, var_t> lag_var_t;
  vector<lag_var_t> other_endo_block, exo_block, exo_det_block;
149

150 151 152 153 154 155 156 157 158 159
  //! for each block described the number of static, forward, backward and mixed variables in the block
  /*! pair< pair<static, forward>, pair<backward,mixed> > */
  vector<pair< pair<int, int>, pair<int,int> > > block_col_type;

  //! List for each variable its block number and its maximum lag and lead inside the block
  vector<pair<int, pair<int, int> > > variable_block_lead_lag;
  //! List for each equation its block number
  vector<int> equation_block;


160 161
  //!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;
162

sebastien's avatar
sebastien committed
163
public:
164
  StaticModel(SymbolTable &symbol_table_arg, NumericalConstants &num_constants, ExternalFunctionsTable &external_functions_table_arg);
165 166

  //! Writes information on block decomposition when relevant
167
  void writeOutput(ostream &output, bool block) const;
168

169 170 171 172
  //! Absolute value under which a number is considered to be zero
  double cutoff;
  //! Compute the minimum feedback set in the static model:
  /*!   0 : all endogenous variables are considered as feedback variables
173 174 175
    1 : the variables belonging to a non linear equation are considered as feedback variables
    2 : the variables belonging to a non normalizable non linear equation are considered as feedback variables
    default value = 0 */
176 177 178 179 180 181 182 183 184 185 186 187
  int mfs;
  //! the file containing the model and the derivatives code
  ofstream code_file;
  //! Execute computations (variable sorting + derivation)
  /*!
    \param jacobianExo whether derivatives w.r. to exo and exo_det should be in the Jacobian (derivatives w.r. to endo are always computed)
    \param hessian whether 2nd derivatives w.r. to exo, exo_det and endo should be computed (implies jacobianExo = true)
    \param thirdDerivatives whether 3rd derivatives w.r. to endo/exo/exo_det should be computed (implies jacobianExo = true)
    \param paramsDerivatives whether 2nd derivatives w.r. to a pair (endo/exo/exo_det, parameter) should be computed (implies jacobianExo = true)
    \param eval_context evaluation context for normalization
    \param no_tmp_terms if true, no temporary terms will be computed in the static files
  */
188
  void computingPass(const eval_context_t &eval_context, bool no_tmp_terms, bool hessian, bool block, bool bytecode);
189

190 191
  //! Adds informations for simulation in a binary file for a block decomposed model
  void Write_Inf_To_Bin_File_Block(const string &static_basename, const string &bin_basename, const int &num,
192 193
                             int &u_count_int, bool &file_open) const;

sebastien's avatar
sebastien committed
194
  //! Writes static model file
195
  void writeStaticFile(const string &basename, bool block, bool bytecode) const;
196

197 198 199
  //! Writes LaTeX file with the equations of the static model
  void writeLatexFile(const string &basename) const;

200 201
  //! Writes initializations in oo_.steady_state or steady state file for the auxiliary variables
  void writeAuxVarInitval(ostream &output, ExprNodeOutputType output_type) const;
sebastien's avatar
sebastien committed
202

203 204 205
  //! Initialize equation_reordered & variable_reordered
  void initializeVariablesAndEquations();

206
  virtual int getDerivID(int symb_id, int lag) const throw (UnknownDerivIDException);
207 208

  //! Return the number of blocks
209 210 211 212 213
  virtual unsigned int
  getNbBlocks() const
  {
    return (block_type_firstequation_size_mfs.size());
  };
214
  //! Determine the simulation type of each block
215 216 217 218 219
  virtual BlockSimulationType
  getBlockSimulationType(int block_number) const
  {
    return (block_type_firstequation_size_mfs[block_number].first.first);
  };
220
  //! Return the first equation number of a block
221 222 223 224 225
  virtual unsigned int
  getBlockFirstEquation(int block_number) const
  {
    return (block_type_firstequation_size_mfs[block_number].first.second);
  };
226
  //! Return the size of the block block_number
227 228 229 230 231
  virtual unsigned int
  getBlockSize(int block_number) const
  {
    return (block_type_firstequation_size_mfs[block_number].second.first);
  };
232 233 234 235 236 237 238 239 240 241
  //! Return the number of exogenous variable in the block block_number
  virtual unsigned int getBlockExoSize(int block_number) const
  {
    return 0;
  };
  //! Return the number of colums in the jacobian matrix for exogenous variable in the block block_number
  virtual unsigned int getBlockExoColSize(int block_number) const
  {
    return 0;
  }
242
  //! Return the number of feedback variable of the block block_number
243 244 245 246 247
  virtual unsigned int
  getBlockMfs(int block_number) const
  {
    return (block_type_firstequation_size_mfs[block_number].second.second);
  };
248
  //! Return the maximum lag in a block
249 250 251 252 253
  virtual unsigned int
  getBlockMaxLag(int block_number) const
  {
    return (block_lag_lead[block_number].first);
  };
254
  //! Return the maximum lead in a block
255 256 257 258 259
  virtual unsigned int
  getBlockMaxLead(int block_number) const
  {
    return (block_lag_lead[block_number].second);
  };
260
  //! Return the type of equation (equation_number) belonging to the block block_number
261 262 263 264 265
  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);
  };
266
  //! Return true if the equation has been normalized
267 268 269 270 271
  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);
  };
272 273 274
  //! Return the expr_t of the equation equation_number belonging to the block block_number
  virtual expr_t
  getBlockEquationExpr(int block_number, int equation_number) const
275 276 277
  {
    return (equations[equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]]);
  };
278 279 280
  //! Return the expr_t of the renormalized equation equation_number belonging to the block block_number
  virtual expr_t
  getBlockEquationRenormalizedExpr(int block_number, int equation_number) const
281 282 283
  {
    return (equation_type_and_normalized_equation[equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]].second);
  };
284
  //! Return the original number of equation equation_number belonging to the block block_number
285 286 287 288 289
  virtual int
  getBlockEquationID(int block_number, int equation_number) const
  {
    return (equation_reordered[block_type_firstequation_size_mfs[block_number].first.second+equation_number]);
  };
290
  //! Return the original number of variable variable_number belonging to the block block_number
291 292 293 294 295
  virtual int
  getBlockVariableID(int block_number, int variable_number) const
  {
    return (variable_reordered[block_type_firstequation_size_mfs[block_number].first.second+variable_number]);
  };
296 297 298 299 300 301
  //! Return the original number of the exogenous variable varexo_number belonging to the block block_number
  virtual int
  getBlockVariableExoID(int block_number, int variable_number) const
  {
    return 0;
  };
302
  //! Return the position of equation_number in the block number belonging to the block block_number
303 304 305 306 307
  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);
  };
308
  //! Return the position of variable_number in the block number belonging to the block block_number
309 310 311 312 313
  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);
  };
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
  //! Return the position of variable_number in the block number belonging to the block block_number
  virtual int
  getBlockInitialExogenousID(int block_number, int variable_number) const
  {
    return -1;
  };
  //! Return the position of the deterministic exogenous variable_number in the block number belonging to the block block_number
  virtual int
  getBlockInitialDetExogenousID(int block_number, int variable_number) const
  {
    return -1;
  };
  //! Return the position of the other endogenous variable_number in the block number belonging to the block block_number
  virtual int
  getBlockInitialOtherEndogenousID(int block_number, int variable_number) const
  {
    return -1;
  };
sebastien's avatar
sebastien committed
332 333 334
};

#endif