BlockTriangular.hh 4.17 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
 * 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_H
#define BLOCKTRIANGULAR_H

#include <string>
#include "ExprNode.hh"
#include "SymbolTable.hh"
#include "ModelNormalization.hh"
#include "ModelBlocks.hh"

/*!
  \class  BlockTriangular
  \brief  Creat the incidence matrice and reorder the model's equations.
*/

#include "ExprNode.hh"

36
struct List_IM
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
{
  List_IM* pNext;
  int lead_lag;
  bool* IM;
};

typedef map<pair<int ,int >,double> jacob_map;

class BlockTriangular
{
public:
  BlockTriangular(const SymbolTable &symbol_table_arg);
  /*! The incidence matrix for each lead and lags */
  const SymbolTable &symbol_table;
  Blocks blocks;
  Normalization normalization;
  List_IM* Build_IM(int lead_lag);
  List_IM* Get_IM(int lead_lag);
  bool* bGet_IM(int lead_lag) const;
56
  void fill_IM(int equation, int variable_endo, int lead_lag);
57
58
59
  void unfill_IM(int equation, int variable_endo, int lead_lag);
  void init_incidence_matrix(int nb_endo);
  void Print_IM(int n) const;
60
  void Free_IM(List_IM* First_IM) const;
61
62
63
  void Print_SIM(bool* IM, int n) const;
  void Normalize_and_BlockDecompose_Static_0_Model(const jacob_map &j_m);
  bool Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock, int n, int* prologue, int* epilogue, simple* Index_Var_IM, simple* Index_Equ_IM, bool Do_Normalization, bool mixing, bool* IM_0 , jacob_map j_m);
64
  void Prologue_Epilogue(bool* IM, int* prologue, int* epilogue, int n, simple* Index_Var_IM, simple* Index_Equ_IM, bool* IM0);
65
66
  void swap_IM_c(bool *SIM, int pos1, int pos2, int pos3, simple* Index_Var_IM, simple* Index_Equ_IM, int n);
  void Allocate_Block(int size, int *count_Equ, int *count_Block, int type, Model_Block * ModelBlock);
67
  void Free_Block(Model_Block* ModelBlock) const;
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
  List_IM *First_IM ;
  List_IM *Last_IM ;
  simple *Index_Equ_IM;
  simple *Index_Var_IM;
  int prologue, epilogue;
  int Model_Max_Lead, Model_Max_Lag, periods;
  bool bt_verbose;
  int endo_nbr;
  Model_Block* ModelBlock;
  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_FOREWARD:
      case EVALUATE_FOREWARD_R:
        return ("EVALUATE FOREWARD            ");
        break;
      case EVALUATE_BACKWARD:
      case EVALUATE_BACKWARD_R:
        return ("EVALUATE BACKWARD            ");
        break;
      case SOLVE_FOREWARD_SIMPLE:
        return ("SOLVE FOREWARD SIMPLE        ");
        break;
      case SOLVE_BACKWARD_SIMPLE:
        return ("SOLVE BACKWARD SIMPLE        ");
        break;
      case SOLVE_TWO_BOUNDARIES_SIMPLE:
        return ("SOLVE TWO BOUNDARIES SIMPLE  ");
        break;
      case SOLVE_FOREWARD_COMPLETE:
        return ("SOLVE FOREWARD 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;
      }
  };
};
//------------------------------------------------------------------------------
#endif