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
/*
 * 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/>.
 */

20
21
#ifndef _BLOCKTRIANGULAR_HH
#define _BLOCKTRIANGULAR_HH
22
23
24
25
26
27
28
29
30

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

#include "ExprNode.hh"

sebastien's avatar
sebastien committed
31
//! List of incidence matrix (one matrix per lead/lag)
32
struct List_IM
33
34
35
36
37
38
{
  List_IM* pNext;
  int lead_lag;
  bool* IM;
};

sebastien's avatar
sebastien committed
39
//! Matrix of doubles for representing jacobian
40
41
typedef map<pair<int ,int >,double> jacob_map;

sebastien's avatar
sebastien committed
42
//! Create the incidence matrix, computes prologue & epilogue, normalizes the model and computes the block decomposition
43
44
45
46
47
48
49
50
51
52
class BlockTriangular
{
public:
  BlockTriangular(const SymbolTable &symbol_table_arg);
  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;
53
  void fill_IM(int equation, int variable_endo, int lead_lag);
54
55
56
  void unfill_IM(int equation, int variable_endo, int lead_lag);
  void init_incidence_matrix(int nb_endo);
  void Print_IM(int n) const;
57
  void Free_IM(List_IM* First_IM) const;
58
59
60
  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);
61
  void Prologue_Epilogue(bool* IM, int* prologue, int* epilogue, int n, simple* Index_Var_IM, simple* Index_Equ_IM, bool* IM0);
62
  void swap_IM_c(bool *SIM, int pos1, int pos2, int pos3, simple* Index_Var_IM, simple* Index_Equ_IM, int n);
sebastien's avatar
sebastien committed
63
  void Allocate_Block(int size, int *count_Equ, int *count_Block, BlockType type, Model_Block * ModelBlock);
64
  void Free_Block(Model_Block* ModelBlock) const;
65
66
67
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
  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