Skip to content
Snippets Groups Projects
Select Git revision
  • e672d88d7aaf69e806d0ec494f50b1e945b00dba
  • 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

disp_dr.m

Blame
  • Forked from Dynare / dynare
    11809 commits behind the upstream repository.
    Sébastien Villemot's avatar
    Sébastien Villemot authored
    Replace them by equivalents in M_ (and an extra one: M_.dynamic).
    
    IMPORTANT POINT: oo_.dr.npred used to count both purely backward and mixed/both
    variables. This was the cause of lots of confusion. The new M_.npred only
    counts purely backward variables.
    
    We now have the following indentities:
    
    M_.npred + M_.nboth + M_.nfwrd + M_.nstatic = M_.endo_nbr
    M_.nspred = M_.npred + M_.nboth
    M_.nsfwrd = M_.nfwrd + M_.nboth
    M_.ndynamic = M_.npred + M_.nboth + M_.nfwrd
    c121aa14
    History
    disp_dr.m 6.56 KiB
    
    function disp_dr(dr,order,var_list)
    % Display the decision rules
    %
    % INPUTS
    %    dr [struct]:            decision rules
    %    order [int]:            order of approximation
    %    var_list [char array]:  list of endogenous variables for which the
    %                            decision rules should be printed
    
    % Copyright (C) 2001-2012 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/>.
    
    global M_ options_
    
    nx =size(dr.ghx,2);
    nu =size(dr.ghu,2);
    if options_.block
        k = M_.nspred;
        k1 = 1:M_.endo_nbr;
    else
        k = find(dr.kstate(:,2) <= M_.maximum_lag+1);
        klag = dr.kstate(k,[1 2]);
        k1 = dr.order_var;
    end;
    
    if size(var_list,1) == 0
        var_list = M_.endo_names(1:M_.orig_endo_nbr, :);
    end
    
    nvar = size(var_list,1);
    
    ivar=zeros(nvar,1);
    for i=1:nvar
        i_tmp = strmatch(var_list(i,:),M_.endo_names(k1,:),'exact');
        if isempty(i_tmp)
            disp(var_list(i,:));
            error (['One of the variable specified does not exist']) ;
        else
            ivar(i) = i_tmp;
        end
    end
    
    disp('POLICY AND TRANSITION FUNCTIONS')
    % variable names
    str = '                        ';
    for i=1:nvar
        str = [str sprintf('%16s',M_.endo_names(k1(ivar(i)),:))];
    end
    disp(str);
    %
    % constant
    %
    str = 'Constant            ';
    flag = 0;
    for i=1:nvar
        x = dr.ys(k1(ivar(i)));
        if order > 1
            x = x + dr.ghs2(ivar(i))/2;
        end
        if abs(x) > 1e-6
            flag = 1;
            str = [str sprintf('%16.6f',x)];
        else
            str = [str '               0'];
        end
    end
    if flag
        disp(str)
    end
    if order > 1
        str = '(correction)        ';
        flag = 0;
        for i=1:nvar
            x = dr.ghs2(ivar(i))/2;
            if abs(x) > 1e-6
                flag = 1;
                str = [str sprintf('%16.6f',x)];
            else
                str = [str '               0'];
            end
        end
        if flag
            disp(str)
        end
    end
    %
    % ghx
    %
    for k=1:nx
        flag = 0;
        if isfield(dr,'state_var')
            str1 = subst_auxvar(dr.state_var(k),-1);
        else
            str1 = subst_auxvar(k1(klag(k,1)),klag(k,2)-M_.maximum_lag-2);
        end
        str = sprintf('%-20s',str1);
        for i=1:nvar
            x = dr.ghx(ivar(i),k);
            if abs(x) > 1e-6
                flag = 1;
                str = [str sprintf('%16.6f',x)];
            else
                str = [str '               0'];
            end
        end
        if flag
            disp(str)
        end
    end
    %
    % ghu
    %
    for k=1:nu
        flag = 0;
        str = sprintf('%-20s',M_.exo_names(k,:));
        for i=1:nvar
            x = dr.ghu(ivar(i),k);
            if abs(x) > 1e-6
                flag = 1;
                str = [str sprintf('%16.6f',x)];
            else
                str = [str '               0'];
            end
        end
        if flag
            disp(str)
        end
    end
    
    if order > 1
        % ghxx
        for k = 1:nx
            for j = 1:k
                flag = 0;
                str1 = sprintf('%s,%s',subst_auxvar(k1(klag(k,1)),klag(k,2)-M_.maximum_lag-2), ...
                               subst_auxvar(k1(klag(j,1)),klag(j,2)-M_.maximum_lag-2));
                str = sprintf('%-20s',str1);
                for i=1:nvar
                    if k == j
                        x = dr.ghxx(ivar(i),(k-1)*nx+j)/2;
                    else
                        x = dr.ghxx(ivar(i),(k-1)*nx+j);
                    end
                    if abs(x) > 1e-6
                        flag = 1;
                        str = [str sprintf('%16.6f',x)];
                    else
                        str = [str '               0'];
                    end
                end
                if flag
                    disp(str)
                end
            end
        end
        %
        % ghuu
        %
        for k = 1:nu
            for j = 1:k
                flag = 0;
                str = sprintf('%-20s',[M_.exo_names(k,:) ',' M_.exo_names(j,:)] );
                for i=1:nvar
                    if k == j
                        x = dr.ghuu(ivar(i),(k-1)*nu+j)/2;
                    else
                        x = dr.ghuu(ivar(i),(k-1)*nu+j);
                    end
                    if abs(x) > 1e-6
                        flag = 1;
                        str = [str sprintf('%16.6f',x)];
                    else
                        str = [str '               0'];
                    end
                end
                if flag
                    disp(str)
                end
            end
        end
        %
        % ghxu
        %
        for k = 1:nx
            for j = 1:nu
                flag = 0;
                str1 = sprintf('%s,%s',subst_auxvar(k1(klag(k,1)),klag(k,2)-M_.maximum_lag-2), ...
                               M_.exo_names(j,:));
                str = sprintf('%-20s',str1);
                for i=1:nvar
                    x = dr.ghxu(ivar(i),(k-1)*nu+j);
                    if abs(x) > 1e-6
                        flag = 1;
                        str = [str sprintf('%16.6f',x)];
                    else
                        str = [str '               0'];
                    end
                end
                if flag
                    disp(str)
                end
            end
        end
    end
    end
    
    % Given the index of an endogenous (possibly an auxiliary var), and a
    % lead/lag, creates a string of the form "x(lag)".
    % In the case of auxiliary vars for lags, replace by the original variable
    % name, and compute the lead/lag accordingly.
    function str = subst_auxvar(aux_index, aux_lead_lag)
    global M_
    
    if aux_index <= M_.orig_endo_nbr
        str = sprintf('%s(%d)', deblank(M_.endo_names(aux_index,:)), aux_lead_lag);
        return
    end
    for i = 1:length(M_.aux_vars)
        if M_.aux_vars(i).endo_index == aux_index
            switch M_.aux_vars(i).type
              case 1
                orig_name = deblank(M_.endo_names(M_.aux_vars(i).orig_index, :));
              case 3
                orig_name = deblank(M_.exo_names(M_.aux_vars(i).orig_index, :));
              case 4
                str = sprintf('EXPECTATION(%d)(...)', aux_lead_lag);
                return
              case 6
                str = sprintf('%s(%d)', ...
                              deblank(M_.endo_names(M_.aux_vars(i).endo_index, :)),aux_lead_lag);
                return
              otherwise
                error(sprintf('Invalid auxiliary type: %s', M_.endo_names(aux_index, :)))
            end
            str = sprintf('%s(%d)', orig_name, M_.aux_vars(i).orig_lead_lag+aux_lead_lag);
            return
        end
    end
    error(sprintf('Could not find aux var: %s', M_.endo_names(aux_index, :)))
    end