Skip to content
Snippets Groups Projects
Select Git revision
  • 1a058fea4f1a08c060a9571fd33b2f71dc365766
  • master default protected
  • nlf-fixes
  • DSMH
  • OneStep2
  • SMC
  • online-filter-as-a-sampler
  • nonlinear-filter-fixes
  • SMCsamplers
  • smc-sampler
  • 4.5
  • dynamic-striated
  • occbin
  • exo_steady_state
  • filter_initial_state
  • declare_vars_in_model_block
  • exceptions
  • rmExtraExo
  • julia
  • error_msg_undeclared_model_vars
  • static_aux_vars
  • 4.5.6
  • 4.5.5
  • 4.5.4
  • 4.5.3
  • 4.5.2
  • 4.5.1
  • 4.5.0
  • 4.4.3
  • 4.4.2
  • 4.4.1
  • 4.4.0
  • 4.4-beta1
  • 4.3.3
  • 4.3.2
  • 4.3.1
  • 4.3.0
  • 4.2.5
  • 4.2.4
  • 4.2.3
  • 4.2.2
41 results

CodeInterpreter.hh

Blame
  • Forked from Dynare / dynare
    Source project has a limited visibility.
    BlockTriangular.hh 5.91 KiB
    /*
     * 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"
    
    typedef struct List_IM
    {
      List_IM* pNext;
      int lead_lag;
      bool* IM;
    };
    
    
    typedef struct vari
    {
      int Size;
      int* arc;
      int used_arc;
      int available;
    };
    
    
    typedef map<pair<int ,int >,double> jacob_map;
    
    class BlockTriangular
    {
    public:
      BlockTriangular(const SymbolTable &symbol_table_arg);
      ~BlockTriangular();
      /*! 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);
      bool* bGet_IM(int lead_lag) const;
      void fill_IM(int equation, int variable_endo, int lead_lag);
      void unfill_IM(int equation, int variable_endo, int lead_lag);
      void incidence_matrix() const;
      void init_incidence_matrix(int nb_endo);
      void Print_IM(int n) const;
      void Free_IM(List_IM* First_IM);
      void Print_SIM(bool* IM, int n) const;
      void Normalize_and_BlockDecompose_Static_Model();
      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 );
      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);
      void Normalize_and_BlockDecompose_0();
      void Normalize_and_BlockDecompose_Inside_Earth();
      void Prologue_Epilogue(bool* IM, int* prologue, int* epilogue, int n, simple* Index_Var_IM, simple* Index_Equ_IM);
      void Sort_By_Cols(bool* IM, int d, int f);
      void getMax_Lead_Lag(int var, int equ, int *lead, int *lag);
      void getMax_Lead_Lag_B(int size, int* Equation, int *Variable, int *lead, int *lag);
      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);
      void Free_Block(Model_Block* ModelBlock);
      string getnamebyID(Type type, int id);
      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;
          }
      };
      inline static std::string BlockSim_d(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