.. index:: bvar_dsge .. _bvar_dsge: .. _bvar_dsge_properties_methods: The properties =============== .. index:: bvar_dsge.nlags .. _bvar_dsge.nlags: nlags ------ bvar_dsge/nlags is a property. .. index:: bvar_dsge.constant .. _bvar_dsge.constant: constant --------- bvar_dsge/constant is a property. .. index:: bvar_dsge.endogenous .. _bvar_dsge.endogenous: endogenous ----------- bvar_dsge/endogenous is a property. .. index:: bvar_dsge.options .. _bvar_dsge.options: options -------- bvar_dsge/options is a property. .. index:: bvar_dsge.shocks .. _bvar_dsge.shocks: shocks ------- bvar_dsge/shocks is a property. .. index:: bvar_dsge.parameters .. _bvar_dsge.parameters: parameters ----------- information on parameters (names, number, types, etc.) Help for bvar_dsge/parameters is inherited from superclass estimable .. index:: bvar_dsge.markov_chains .. _bvar_dsge.markov_chains: markov_chains -------------- information on markov chains, regimes and related items Help for bvar_dsge/markov_chains is inherited from superclass estimable .. index:: bvar_dsge.estimation .. _bvar_dsge.estimation: estimation ----------- information on estimation: posterior maximization and simulation Help for bvar_dsge/estimation is inherited from superclass estimable The methods ============ .. index:: bvar_dsge.autocov .. _bvar_dsge.autocov: autocov -------- Compute the autocovariances (and the auto-correlation) of endogenous variables given the parameter values :: [C,R,retcode] = autocov(self); [C,R,retcode] = autocov(self, params); [C,R,retcode] = autocov(self, params, max_periods); Args: self (var object): var object params (cell of struct): struct containing var model related parameters (default: []) max_periods (integer): maximum number of period to calculate auto-covariance (default: 5) Returns: : - **C** [4-dimensional array]: auto-covariance where dimensions correspond to - 1,2: covariance - 3: time lags - 4: Number of parameters - **R** [4-dimensional array]: auto-correlation with same dimensions .. index:: bvar_dsge.bvar_dsge .. _bvar_dsge.bvar_dsge: bvar_dsge ---------- bvar_dsge Construct an instance of the bvar_dsge class obj = bvar_dsge(dsgemodel) obj = bvar_dsge(dsgemodel,nlags) obj = bvar_dsge(dsgemodel,nlags,const) obj = bvar_dsge(dsgemodel,nlags,const,shock_list) INPUTS - dsgemodel [dsge\|rise\|char\|cell array] \* dsge or rise : well understood \* char : rise file name \* cell array a. multiple rise files {'file1','file2',...,'filen'} b. one file and arguments {'file1','arg1',argval1,...,'argn',argvaln} c. multiple rise files and arguments {{'file1','file2',...,'filen'},'arg1',argval1,...,'argn',argvaln} - nlags [numeric\|{4}] : number of lags - const [false\|{true}] : constant in the VAR - shock_list [empty\|cell array] : list of selected shocks in the DSGE in case the DSGE model has more shocks than the number of observables. OUTPUTS - obj [bvar_dsge] TODO (if there is a demand for it) - add exogenous variables as in a normal VAR - Turn on the possibility of drawing from a Normal-inverse-Wishart prior when running impulse responses. At the moment the feature is turned of because for every parameter draw, only one single IRF is computed and not a distribution. .. index:: bvar_dsge.draw_parameter .. _bvar_dsge.draw_parameter: draw_parameter --------------- Random parameter draws for RISE model objects. :: [draw,obj] = draw_parameter(obj,simulation_folder); Args: - obj (rise \| dsge \| rfvar \| svar): RISE model object - simulation_folder (char \| struct): - char(1): simulation folder : the stored elements should be structures with fields: - **x** : parameter vectors - **f** : value of minus(log posterior kernel) - char(2): ['mode'\|'prior']: draw from the prior distribution or from a multivariate normal distribution around the mode. Returns: - **draw** [cell]: the first entry is the names of the estimated parameters and the second is a vector of drawn parameters. The whole cell can be pushed in to a model as obj=set(obj,'parameters',draw). - **obj** [rise\|dsge\|rfvar\|svar]: RISE model object in which the drawn parameter has been pushed. Help for bvar_dsge/draw_parameter is inherited from superclass estimable .. index:: bvar_dsge.estimate .. _bvar_dsge.estimate: estimate --------- Estimate the parameters of a RISE model :: obj=estimate(obj) obj=estimate(obj,varargin) [obj,filtration]=estimate(...) Args: - obj (bvar_dsge): model object - varargin : additional optional inputs among which the most relevant for estimation. See ESTIMABLE/ESTIMATE .. index:: bvar_dsge.fisher .. _bvar_dsge.fisher: fisher ------- INTERNAL FUNCTION Help for bvar_dsge/fisher is inherited from superclass estimable .. index:: bvar_dsge.forecast .. _bvar_dsge.forecast: forecast --------- FORECAST Generate forecasts for a model object. Syntax: [fkst, retcode] = forecast(self) [fkst, retcode] = forecast(self, histdb) [fkst, retcode] = forecast(self, histdb, date_start) [fkst, retcode] = forecast(self, histdb, date_start, params) [fkst, retcode] = forecast(self, histdb, date_start, params, nsteps) [fkst, retcode] = forecast(self, histdb, date_start, params, nsteps, ... shock_uncertainty) [fkst, retcode] = forecast(self, histdb, date_start, params, nsteps, ... shock_uncertainty, Rfunc) [fkst, retcode] = forecast(self, histdb, date_start, params, nsteps, ... shock_uncertainty, Rfunc, conditions) Inputs: - self: Model object (VAR\|SVAR\|BVAR-DSGE\|Proxy-SVAR\|Panel VAR). - histdb: (Database\|empty) Database of historical data. If empty, the estimation data used in the model object is used. - date_start: (rise date\|empty) Start date of the forecasts. If empty, the forecasts start right after the end of the sample given in histdb. - params: Matrix of parameter values to update the model object with for every forecast. If empty, the parameterized model is used. - nsteps: (numeric\|{12}) Number of forecasting steps. - shock_uncertainty: Flag indicating whether to consider shock uncertainty. - Rfunc: (function handle\|empty) Identification function for shocks. If empty, a cholesky identification is assumed. - conditions: Conditions for conditional forecasting (can be empty). The conditions can include endogenous variables, shocks, and "regime". Outputs: - fkst: Structure with forecasted variables. - retcode: Return code indicating if there was any issue during forecasting. 0 indicates no issues. Notes: - If no arguments are provided, default values are assumed for each parameter. - For conditional forecasting, specify conditions including endogenous variables, shocks, and "regime". Example: % Simple unconditional forecast [fkst, retcode] = forecast(myModel, historicalData, rq(2024,1), params, 12); .. seealso:: vartools.forecast, vartools.conditional_forecast .. index:: bvar_dsge.get .. _bvar_dsge.get: get ---- get - Query graphics object properties This MATLAB function displays the properties and property values for the specified graphics object h in the Command Window. Syntax get(h) s = get(h) v = get(h,propertyNames) s = get(h,"default") s = get(groot,"factory") v = get(h,defaultTypeProperty) v = get(groot,factoryTypeProperty) Input Arguments h - Graphics objects single object \| vector of objects propertyNames - Property names string scalar \| character vector \| cell array defaultTypeProperty - Default property name string scalar \| character vector factoryTypeProperty - Factory property name string scalar \| character vector Output Arguments s - Property names and values structure v - Property values any value \| cell array Examples openExample('graphics/ListAllPropertyValuesForSpecificObjectExample') openExample('graphics/QuerySpecificPropertyOfSpecificObjectExample') openExample('graphics/GetSetOfPropertiesForSpecificObjectExample') openExample('graphics/GetDefaultPropertyValueOnRootExample') openExample('graphics/GetDefaultPropertyValueForObjectExample') openExample('graphics/GetDefaultPropertyValuesOnRootExample') See also findobj, set, gcf, gca, gco .. index:: bvar_dsge.hessian .. _bvar_dsge.hessian: hessian -------- Computes the hessian of the model at a specific point :: [obj,H,issue] = hessian(obj) [obj,H,issue] = hessian(obj,x) [obj,H,issue] = hessian(obj,x,varargin) Args: - obj (rise \| dsge \| rfvar \| svar): model object - x ([] \| vector): vector at which one wants to compute the hessian - varargin: additional optional inputs among which the most relevant for estimation is: - **hessian_type** [{'fd'}\|'opg']: The hessian is either computed by finite differences (fd) or by outer-product-gradient (opg) Returns: : - **obj** [rise\|dsge\|rfvar\|svar]: model object containing the new hessian in case the model was previously estimated. - **H** [d x d matrix]: hessian matrix - **issue** [char\|'']: any issue encountered during the computation of the hessian Help for bvar_dsge/hessian is inherited from superclass estimable .. index:: bvar_dsge.historical_decomposition .. _bvar_dsge.historical_decomposition: historical_decomposition ------------------------- HISTORICAL_DECOMPOSITION Performs historical decomposition of shocks in a time series model. This function computes the contributions of various shocks to the historical movements of the variables in a model, using the specified model parameters and shock identification function. Inputs:: self - The model object containing all necessary model structures and data. params - The parameters of the model used for the decomposition. Rfunc - A function handle to identify the shocks. varargin - Additional options, including the date range for analysis. Outputs:: hd - The historical decomposition of each variable in the model, with details on the contributions of each shock and other components. retcode - Return code that indicates the status of the computation (0 = success). .. index:: bvar_dsge.irf .. _bvar_dsge.irf: irf ---- Compute impulse response function from the given parameter values :: myirfs = irf(self) myirfs = irf(self, shock_names) myirfs = irf(self, shock_names, irf_periods) myirfs = irf(self, shock_names, irf_periods, params) myirfs = irf(self, shock_names, irf_periods, params, Rfunc) myirfs = irf(self, shock_names, irf_periods, params, Rfunc,girf_setup) Args: - **self** (var object): var object - **shock_names** (cellstr): shocks for which to compute IRFs (has to be consistent with the identification scheme :ref:`identification `) - **irf_periods** (int): number of periods to compute IRFs (default: 40) - **params** (vector): parameter values of the model. If empty MLE/posterior-mode values are used. - **Rfunc** (function handle): identification function. This is an output of ``identification``. (default: choleski identification) - **girf_setup** (struct\|{empty}): structure containing information relevant for the computation of generalized impulse response functions. If empty, simple regime-specific impulse responses are computed, else girfs are computed. In that case the relevant information to provide in girf_setup is: - **nsims** : (default=300) number of simulations for the integration. Note that even setting girf_setup=struct() will trigger the computation of girfs. But in that case only the default options will apply. Returns: - **myirfs** : (struct) structure containing the IRFs .. note:: Only successful IRFs are returned. If the structure does not return some IRFs make sure that IRFs properly identified. .. index:: bvar_dsge.load_parameters .. _bvar_dsge.load_parameters: load_parameters ---------------- load_parameters loads the parameters. This allows the user to quickly load the parameters from a file, which may be the output of estimation, and get going with irfs, simulations, etc. :: model=load_parameters(model,the_mode_file) Args: - **model** (estimable object): model object - **the_mode_file** (m-file): file containing the parameters and their values Returns: - **model** (estimable object): reparameterized model object Help for bvar_dsge/load_parameters is inherited from superclass estimable .. index:: bvar_dsge.log_posterior_kernel .. _bvar_dsge.log_posterior_kernel: log_posterior_kernel --------------------- Computes the log posterior of the dsge model :: [log_post,log_lik,log_prior,Incr,retcode,obj]=log_posterior_kernel(obj, param) Args: - obj (estimable object): model object - param (column vector): parameter values Returns: - **log_post** (double): log posterior - **log_lik** (double): log likelihood - **log_prior** (double): log prior - **Incr** (double): - **retcode** : return code - obj (estimable object): model passed through .. seealso:: - :ref:`log_prior_density ` .. note:: In effort to make RISE modular, this function is available so that one can use a different sampler if needed, but most likely, one should just use available stock samplers. Help for bvar_dsge/log_posterior_kernel is inherited from superclass estimable .. index:: bvar_dsge.log_prior_density .. _bvar_dsge.log_prior_density: log_prior_density ------------------ Computes the probability density function of the prior corresponding to the parameter values :: [lnprior, retcode] = log_prior_density(model) [lnprior, retcode] = log_prior_density(model, param) [lnprior, retcode] = log_prior_density(model, param,filtration) Args: - **model** (estimable object): model object - **param** (column vector): parameter values - **filtration** (empty\|struct): results from model filtration that can potentially be used for endogenizing priors. Returns: - **lnprior** (double): log of prior density function - **retcode**: return code .. seealso:: - :ref:`log_posterior_kernel ` .. note:: In effort to make RISE modular, this function is available so that one can use a different sampler if needed, but most likely, one should just use available stock samplers. Help for bvar_dsge/log_prior_density is inherited from superclass estimable .. index:: bvar_dsge.mode_curvature .. _bvar_dsge.mode_curvature: mode_curvature --------------- Checks the curvature at the posterior mode :: db = mode_curvature(obj) db = mode_curvature(obj,varlist) db = mode_curvature(obj,varlist,N) db = mode_curvature(obj,varlist,N,type) Args: - **obj** (rise \| dsge \| rfvar \| svar): model object - **varlist** (char \| cellstr \| empty): list of parameters for which we want to check the curvature - **N** ({20} \| integer): Number of grid points - **type** ({'max'} \| 'min' \| 'range'): normalization of the log-posterior and the log-likelihood. - **dbin** (struct\|empty): structure containing the information to plot the curvature. Each field is the name of a particular parameter. This is to avoid a costly recomputation of db Returns: - **db** [struct\|cell array\|vector]: structure containing the information to plot the curvature. Each field is the name of a particular parameter. Alternatively, when dbin is not empty, db is a handle to the plots. Note: - when no output is requested, plots are made but not saved. - one way to plot the curvatures from the output is to use the function utils.plot.curvature .. seealso:: - utils.plot.curvature Help for bvar_dsge/mode_curvature is inherited from superclass estimable .. index:: bvar_dsge.posterior_sample .. _bvar_dsge.posterior_sample: posterior_sample ----------------- Computes a sample of any quantity of interest using parameter draws from a population e.g. a posterior simulation :: [result]=posterior_sample(m,pop,dowhat) [result]=posterior_sample(m,pop,dowhat,howmany) [result]=posterior_sample(m,pop,dowhat,howmany,ouf) [result]=posterior_sample(m,pop,dowhat,howmany,ouf,varargin) [result,is_failed,time_it_took]=posterior_sample(...) Args: - **m** [rise\|dsge\|svar\|rfvar\|valid rise object]: model object - **pop** [m x n struct]: parameter draws, with "m" the number of chains and "n" the number of draws in each chain. Each element of "pop" is a structure with fields "f" (not used), the value of the posterior and "x" the parameter vector - **dowhat** [fhandle]: function (handle) to apply to each parameterized model object. e.g. dowhat=@irf, dowhat=@simulate, dowhat=@forecast, etc. "dowhat" need not be a method of "m": it represents the quantity of interest. - **howmany** [integer\|{m x n}]: number of draws to use in the calculation - **ouf** [fhandle\|{[]}]: output update function. Function that updates the output before storing it. e.g. if dowhat=@filter, one may be interested in the filters only and in that case ouf=@(x)x.filtering. - **varargin** [pairwise args]: valid pairwise arguments for the model object Returns: - **result** [1 x howmany cell]: container of the various applications of the "dowhat" handle - **time_it_took** [numeric]: number of seconds needed to run all the simulations. .. seealso:: :ref:`draw_parameter ` .. note:: - the function will exploit parallel computation if there are workers idle. - Because the solving of the model is sometimes iterative, a change of solver or of the settings of the solver can result in the model not being solved or more generally simulations failures. The algorithm will loop until the requested number of simulations is obtained. But it will not point to the parameter vectors that fail. Help for bvar_dsge/posterior_sample is inherited from superclass estimable .. index:: bvar_dsge.print_estimation_results .. _bvar_dsge.print_estimation_results: print_estimation_results ------------------------- `PRINT_ESTIMATION_RESULTS`: Display the results of estimation. retcode = print_estimation_results(obj) retcode = print_estimation_results(obj, detail) **Args**: - `obj` (estimable): Model object. - `detail` (true\|{false}): If true, the description of parameters is given alongside the code name. If they are the same, i.e., the description has not been provided, then the code name is given only once. **Returns**: - `retcode` (numeric): 0 if there is no problem. **Notes**: - If there are multiple objects in the array, each object's results will be displayed. - The function displays information such as log-posterior, log-likelihood, log-prior, etc. - The displayed results include information about the estimation sample, solution algorithm, estimation algorithm, number of estimated parameters, number of function evaluations, and the time taken for estimation. - If there are any issues, a list of issues is displayed. **Example**: print_estimation_results(obj) print_estimation_results(obj, true) **See also**: `TABLE_DISPLAYER` Help for bvar_dsge/print_estimation_results is inherited from superclass estimable .. index:: bvar_dsge.pull_objective .. _bvar_dsge.pull_objective: pull_objective --------------- Pulls the objective function to optimize :: [ff,lb,ub]=pull_objective(obj) [ff,lb,ub]=pull_objective(obj,varargin) [ff,lb,ub,x0]=pull_objective(obj,varargin) [ff,lb,ub,x0,vcov]=pull_objective(obj,varargin) [ff,lb,ub,x0,vcov,obj]=pull_objective(obj,varargin) [ff,lb,ub,x0,vcov,obj,constraints]=pull_objective(obj,varargin) Args: - obj (rise \| dsge \| svar \| rfvar): initial model object - varargin (pairwise addional inputs): usual RISE arguments Returns: - **ff** [function handle]: for computing "minus log posterior kernel" - **lb** [d x 1 vector]: lower bound of the parameters to optimize - **ub** [d x 1 vector]: upper bound of the parameters to optimize - **x0** [d x 1 vector]: posterior mode if available - **vcov** [d x d matrix]: covariance matrix at the posterior mode if available. - **obj** [rise\|dsge\|svar\|rfvar]: updated model object - **constraints** [rise\|dsge\|svar\|rfvar]: Matrix where each row is [index1, index2], corresponding to a constraint that index1 <= index2 after normalization. Note: - The function can be used for : - optimization, - gradient computation, - hessian computation, - posterior simulation - The updated object should be used for doing various exercises (irfs, simulations, etc.) if the posterior mode is not computed. - Using this function is potentially costly. One could alternatively simply use log_posterior_kernel. However, if there are restrictions, they will not be enforced. Nevertheless it is an interesting proposition that should be investigated further. Help for bvar_dsge/pull_objective is inherited from superclass estimable .. index:: bvar_dsge.residuals .. _bvar_dsge.residuals: residuals ---------- Computes the residuals given the parameters .. index:: bvar_dsge.set .. _bvar_dsge.set: set ---- METHOD1 Summary of this method goes here Detailed explanation goes here .. index:: bvar_dsge.solve .. _bvar_dsge.solve: solve ------ INTERNAL FUNCTION: intermediary file for computing key elements for dsge-var :: [sol,retcode,self] = solve(self) [sol,retcode,self] = solve(self,params) [sol,retcode,self] = solve(self,params,whichVar) Args: - **self** (bvar_dsge): model object - **params** - **whichVar** ['var'\|'var_approx'\|{'var_dsge'}]: choose which VAR you want to solve. Where : - **var** : is the classical VAR without priors - **var_approx** : is the VAR approximation of the DSGE - **var_dsge** : is the Bayesian VAR with the (VAR approximation of the) DSGE as prior Returns: - **self** [bvar_dsge]: model object .. index:: bvar_dsge.variance_decomposition .. _bvar_dsge.variance_decomposition: variance_decomposition ----------------------- Compute the variance decompsition of the VAR :: [vd,retcode] = variance_decomposition(self) [vd,retcode] = variance_decomposition(self,params) [vd,retcode] = variance_decomposition(self,params,Rfunc) [vd,retcode] = variance_decomposition(self,params,Rfunc,nperiods) Args: - self (var object): - params :(optional) parameter values - Rfunc (function handle): (optional) transform parameters into dynamics - nperiods :(optional) periods for decomposition Returns: - **vd** (struct): a struct containing the variance decomposition: - **infinity** (struct): - **conditional** (struct): - **retcode** (integer): This passes through the retcode given by Rfunc. Currently (2018/07/19), this output always returns 0.