Solving the Model

solve(m::AbstractDSGEModel)

Driver to compute the model solution and augment transition matrices.

Inputs

• m: the model object

Keyword Arguments

• regime_switching::Bool: true if the state space system features regime switching
• regimes::Union{Int, Vector{Int}, UnitRange{Int}}: specifies the specific regime to solve for.

Outputs

• TTT, RRR, and CCC matrices of the state transition equation:

S_t = TTT*S_{t-1} + RRR*ϵ_t + CCC

solve(m::PoolModel) ```

Driver to compute the model solution when using the PoolModel type

Inputs

• m: the PoolModel object

Outputs

• Φ: transition function
• F_ϵ: distribution of structural shock
• Fλ: prior on the initial λ0

solvect(m::AbstractCTModel; reduction_settings_check::Bool = false)

Driver to compute the model solution and augment transition matrices.

Inputs

• m: the model object

Outputs

• TTT, RRR, and CCC matrices of the state transition equation: S_t = TTT*S_{t-1} + RRR*ϵ_t + CCC

System{T <: Real}

A mutable struct containing the transition and measurement equations for a state-space model. The matrices may be directly indexed: sys[:TTT] returns sys.transition.TTT, sys[:ZZ] returns sys.measurement.ZZ, etc.

Transition{T<:Real}

The transition equation of the state-space model takes the form

`s_t = TTT*s_{t-1} + RRR*ϵ_t + CCC`

The Transition type stores the coefficient Matrix{T}s (TTT, RRR) and constant Vector{T} CCC.

Measurement{T<:Real}

The measurement equation of the state-space model takes the form

y_t = ZZ*s_t + DD + u_t

where the error u_t is the measurement error, which is uncorrelated with the shocks in the transition equation ϵ_t.

Fields

If Ns is the number of states s_t, Ny is the number of observables y_t, and Ne is the number of shocks ϵ_t:

• ZZ: the Ny x Ns measurement matrix
• DD: the Ny x 1 constant vector
• QQ: the Ne x Ne covariance matrix for the shocks ϵ_t
• EE: the Ny x Ny covariance matrix for the measurement error η_t

PseudoMeasurement{T<:Real}

The pseudo-measurement equation of the state-space model takes the form

x_t = ZZ_pseudo*s_t + DD_pseudo

Fields

Let Ns be the number of states s_t and Nx be the number of pseudo-observables x_t:

• ZZ_pseudo: the Nx x Ns pseudo-measurement matrix
• DD_pseudo: the Nx x 1 constant vector

compute_system(m; tvis::Bool = false, verbose = :high)
compute_system_helper(m; tvis::Bool = false, verbose = :high)

Given the current model parameters, compute the state-space system corresponding to model m. Returns a System or RegimeSwitchingSystem object. The keyword apply_altpolicy indicates whether the state-space system should reflect an alternative policy, and the keyword tvis indicates whether the state-space system involves time-varying information sets. To use tvis = true, at least the setting :tvis_information_set must exist. See ?DSGE.compute_tvis_system for more information about computing state-space systems with time-varying information sets.

computesystem just runs computesystem_helper (which actually computes the system) and then in the case of imperfect but positive credibility, adjusts the anticipated observables and pseudo-observables' measurement equations.

compute_system(m::PoolModel{T})

Given the current model parameters, compute the state-space system corresponding to the PoolModel model m.

Outputs

``` Φ: state transition function Ψ: likelihood function, given weights on underlying models (the states) and predictive densities Fϵ: structural shock distribution Fu: likelihood function measurement error distribution F_λ: initial distribution of λ for state transition function

compute_system(m; apply_altpolicy = false,
            check_system = false, get_system = false,
            get_population_moments = false, use_intercept = false,
            tvis::Bool = false, verbose = :high)
            compute_system(m, data; apply_altpolicy = false,
            check_system = false, get_system = false,
            get_population_moments = false,
            tvis::Bool = false, verbose = :high)

Given the current model parameters, compute the DSGE-VAR or DSGE-VECM system corresponding to model m. If a matrix data is also passed, then the VAR is estimated on data using the DSGE m as a prior with weight λ.

Keyword Arguments

• check_system::Bool: see ?compute_system that takes the input m::AbstractDSGEModel and system::System.
• get_system::Bool: see Outputs
• get_population_moments::Bool: see Outputs
• use_intercept::Bool: use an intercept term when computing the OLS estimate of the VAR system.
• tvis::Bool indicates whether the state-space system involves time-varying information sets.

Outputs

• If get_system = true: Returns the updated system whose measurement matrices ZZ, DD, and QQ correspond to the VAR or VECM specified by m. If m is an AbstractDSGEVECMModel, then the system and the vector implied by additional cointegrating relationships are returned as a 2-element tuple.
• If get_population_moments = true: Returns the limit cross product matrices that describe the DSGE implied population moments between the observables and their lags. If data is also passed as an input, then the sample population moments are also returned.
• Otherwise:

Returns β and Σ, the coefficients and observables covariance matrix of the VAR or VECM. If data is passed in, then β and Σ are estimated from the data using m as a prior with weight λ. Otherwise, β and Σ comprise the VECM approximation of the DSGE m.

compute_system(m::AbstractDSGEModel, system::System;
observables::Vector{Symbol} = collect(keys(m.observables)),
pseudo_observables::Vector{Symbol} = collect(keys(m.pseudo_observables)),
states::Vector{Symbol} = vcat(collect(keys(m.endogenou_states)),
collect(keys(m.endogenous_states_augmented)))
shocks::Vector{Symbol} = collect(keys(m.exogenous_shocks)),
zero_DD = false, zero_DD_pseudo = false)
compute_system(m::AbstractDSGEVECMModel, system::System;
observables::Vector{Symbol} = collect(keys(m.observables)),
pseudo_observables::Vector{Symbol} = collect(keys(m.pseudo_observables)),
cointegrating::Vector{Symbol} = collect(keys(m.cointegrating)),
states::Vector{Symbol} = vcat(collect(keys(m.endogenou_states)),
collect(keys(m.endogenous_states_augmented)))
shocks::Vector{Symbol} = collect(keys(m.exogenous_shocks)),
zero_DD = false, zero_DD_pseudo = false)

computes the corresponding transition and measurement equations specified by the keywords (e.g. states, pseudo_observables) using the existing ZZ, ZZ_pseudo, and TTT matrices in system.

Note that this function does not update the EE matrix, which is set to all zeros. To incorporate measurement errors, the user must specify the EE matrix after applying compute_system.

Keywords

• observables: variables that should be

entered into the new ZZ and DD matrices. The observables can be both Observables and PseudoObservables, but they must be an element of the system already.

• pseudo_observables: variables that should be

entered into the new ZZ_pseudo and DD_pseudo matrices. The observables can be both Observables and PseudoObservables, but they must be an element of the system already.

• cointegrating: variables that should be

entered into the new ZZ and DD matrices as cointegrating relationships. The observables can be both Observables and PseudoObservables, but they must be an element of the system already.

• states: variables that should be

entered into the new TTT and RRR matrices as states. They must be existing states.

• shocks: variables that should be

entered into the new RRR and QQ matrices as shocks. They must be existing exogenous shocks.

RegimeSwitchingSystem{T <: Real}

A mutable struct containing the transition and measurement equations for a state-space model with regime-switching. The matrices may be directly indexed: sys[1, :TTT] returns sys.regime[1].transition.TTT, etc.