var_n_lags()

#define var_n_lags(v) ((v->lags != NULL)? v->lags[0] : v->order)

var_max_lag()

#define var_max_lag(v) ((v->lags != NULL)? v->lags[v->lags[0]] : v->order)

levels_order()

#define levels_order(v) (v->order+(v->ci==VECM))

var_max_order ()

int
var_max_order (const int *list,
               const DATASET *dset);

gretl_VAR ()

GRETL_VAR *
gretl_VAR (int order,
           int *laglist,
           int *list,
           const DATASET *dset,
           gretlopt opt,
           PRN *prn,
           int *err);

Estimate a vector auto-regression (VAR), print and save the results.

gretl_VECM ()

GRETL_VAR *
gretl_VECM (int order,
            int rank,
            int *list,
            const DATASET *dset,
            gretlopt opt,
            PRN *prn,
            int *err);

gui_VAR_lagsel ()

int
gui_VAR_lagsel (int order,
                int *list,
                const DATASET *dset,
                gretlopt opt,
                PRN *prn,
                gretl_matrix **pm);

gretl_VAR_get_forecast_matrix ()

const gretl_matrix *
gretl_VAR_get_forecast_matrix (GRETL_VAR *var,
                               int t1,
                               int t2,
                               DATASET *dset,
                               gretlopt opt,
                               int *err);

gretl_VAR_get_residual_matrix ()

const gretl_matrix *
gretl_VAR_get_residual_matrix (const GRETL_VAR *var);

gretl_VAR_get_fcast_decomp ()

gretl_matrix *
gretl_VAR_get_fcast_decomp (const GRETL_VAR *var,
                            int targ,
                            int periods,
                            int *errp);

gretl_VAR_get_vma_matrix ()

gretl_matrix *
gretl_VAR_get_vma_matrix (const GRETL_VAR *var,
                          const DATASET *dset,
                          int *err);

gretl_VAR_get_FEVD_matrix ()

gretl_matrix *
gretl_VAR_get_FEVD_matrix (const GRETL_VAR *var,
                           int targ,
                           int shock,
                           int horizon,
                           const DATASET *dset,
                           int *err);

gretl_VAR_get_full_FEVD_matrix ()

gretl_matrix *
gretl_VAR_get_full_FEVD_matrix (const GRETL_VAR *var,
                                const DATASET *dset,
                                int *err);

gretl_FEVD_from_bundle ()

gretl_matrix *
gretl_FEVD_from_bundle (gretl_bundle *b,
                        int targ,
                        int shock,
                        const DATASET *dset,
                        int *err);

gretl_IRF_from_bundle ()

gretl_matrix *
gretl_IRF_from_bundle (gretl_bundle *b,
                       int targ,
                       int shock,
                       double alpha,
                       const DATASET *dset,
                       int *err);

VECM_get_EC_matrix ()

gretl_matrix *
VECM_get_EC_matrix (const GRETL_VAR *v,
                    const DATASET *dset,
                    int *err);

gretl_VAR_do_error_decomp ()

int
gretl_VAR_do_error_decomp (const gretl_matrix *S,
                           gretl_matrix *C,
                           const gretl_matrix *ord);

gretl_VAR_get_roots ()

const gretl_matrix *
gretl_VAR_get_roots (GRETL_VAR *var,
                     int *err);

gretl_VAR_autocorrelation_test ()

int
gretl_VAR_autocorrelation_test (GRETL_VAR *var,
                                int order,
                                DATASET *dset,
                                gretlopt opt,
                                PRN *prn);

gretl_VAR_arch_test ()

int
gretl_VAR_arch_test (GRETL_VAR *var,
                     int order,
                     DATASET *dset,
                     gretlopt opt,
                     PRN *prn);

gretl_VAR_normality_test ()

int
gretl_VAR_normality_test (const GRETL_VAR *var,
                          gretlopt opt,
                          PRN *prn);

set_VAR_model_stats ()

int
set_VAR_model_stats (GRETL_VAR *var,
                     int i);

gretl_VAR_get_exo_list ()

const int *
gretl_VAR_get_exo_list (const GRETL_VAR *var);

gretl_VAR_get_endo_list ()

const int *
gretl_VAR_get_endo_list (const GRETL_VAR *var);

gretl_VAR_omit_test ()

GRETL_VAR *
gretl_VAR_omit_test (GRETL_VAR *var,
                     const int *omitlist,
                     DATASET *dset,
                     gretlopt opt,
                     PRN *prn,
                     int *err);

Re-estimates a given VAR after removing the variables specified in omitlist , and reports per-equation F-tests and system-wide LR tests for the null hypothesis that the omitted variables have zero parameters.

gretl_VAR_wald_omit_test ()

int
gretl_VAR_wald_omit_test (GRETL_VAR *var,
                          const int *omitlist,
                          DATASET *dset,
                          gretlopt opt,
                          PRN *prn);

Runs a Wald test for the joint omission of the exogenous variables specified in omitlist .

gretl_VECM_get_EC ()

double *
gretl_VECM_get_EC (GRETL_VAR *vecm,
                   int j,
                   const DATASET *dset,
                   int *err);

gretl_VAR_free ()

void
gretl_VAR_free (GRETL_VAR *var);

default_VAR_horizon ()

int
default_VAR_horizon (const DATASET *dset);

gretl_VAR_get_impulse_response ()

gretl_matrix *
gretl_VAR_get_impulse_response (GRETL_VAR *var,
                                int targ,
                                int shock,
                                int periods,
                                double alpha,
                                const DATASET *dset,
                                int *err);

Computes the response of targ to a perturbation of shock in the context of var : targ and shock are zero-based indices relative to the structure of var . For example if targ = 0 and shock = 1, we compute the response of the dependent variable in the first VAR equation to a perturbation of the variable that appears as dependent in the second VAR equation.

If alpha is zero, the response matrix returned is a column vector of length periods , giving the point estimate of the response function. Otherwise, the response matrix returned has three columns, containing the point estimate, the alpha / 2 quantile and the 1 - alpha / 2 quantile, where the quantiles are based on bootstrap replication, with resampling of the original residuals with replacement.

gretl_VAR_set_name ()

void
gretl_VAR_set_name (GRETL_VAR *var,
                    const char *name);

gretl_VAR_get_name ()

const char *
gretl_VAR_get_name (const GRETL_VAR *var);

gretl_VAR_get_variable_number ()

int
gretl_VAR_get_variable_number (const GRETL_VAR *var,
                               int k);

gretl_VAR_get_n_equations ()

int
gretl_VAR_get_n_equations (const GRETL_VAR *var);

gretl_VAR_get_t1 ()

int
gretl_VAR_get_t1 (const GRETL_VAR *var);

gretl_VAR_get_t2 ()

int
gretl_VAR_get_t2 (const GRETL_VAR *var);

gretl_var_get_sample ()

int
gretl_var_get_sample (const GRETL_VAR *var,
                      int *t1,
                      int *t2);

gretl_VAR_get_model ()

const MODEL *
gretl_VAR_get_model (const GRETL_VAR *var,
                     int i);

gretl_VAR_get_resid_series ()

double *
gretl_VAR_get_resid_series (GRETL_VAR *var,
                            int eqnum,
                            int *err);

gretl_VAR_set_ordering ()

int
gretl_VAR_set_ordering (GRETL_VAR *var,
                        gretl_matrix *ord);

gretl_VAR_do_irf ()

int
gretl_VAR_do_irf (GRETL_VAR *var,
                  const char *line,
                  const DATASET *dset);

gretl_VAR_get_highest_variable ()

int
gretl_VAR_get_highest_variable (const GRETL_VAR *var);

johansen_test ()

GRETL_VAR *
johansen_test (int order,
               const int *list,
               const DATASET *dset,
               gretlopt opt,
               PRN *prn);

Carries out the Johansen test for cointegration.

johansen_test_simple ()

int
johansen_test_simple (int order,
                      const int *list,
                      const DATASET *dset,
                      gretlopt opt,
                      PRN *prn);

Carries out the Johansen test for cointegration and prints the results (but unlike johansen_test(), does not return the allocated results in VAR form).

gretl_VECM_n_beta ()

int
gretl_VECM_n_beta (const GRETL_VAR *vecm);

gretl_VECM_n_alpha ()

int
gretl_VECM_n_alpha (const GRETL_VAR *vecm);

gretl_VECM_test ()

int
gretl_VECM_test (GRETL_VAR *vecm,
                 gretl_restriction *rset,
                 const DATASET *dset,
                 gretlopt opt,
                 PRN *prn);

gretl_VAR_test ()

int
gretl_VAR_test (GRETL_VAR *var,
                gretl_restriction *rset,
                const DATASET *dset,
                gretlopt opt,
                PRN *prn);

real_gretl_restricted_vecm ()

GRETL_VAR *
real_gretl_restricted_vecm (GRETL_VAR *orig,
                            gretl_restriction *rset,
                            const DATASET *dset,
                            PRN *prn,
                            int *err);

gretl_VECM_rank ()

int
gretl_VECM_rank (const GRETL_VAR *vecm);

beta_restricted_VECM ()

int
beta_restricted_VECM (const GRETL_VAR *vecm);

alpha_restricted_VECM ()

int
alpha_restricted_VECM (const GRETL_VAR *vecm);

restricted_VECM ()

int
restricted_VECM (const GRETL_VAR *vecm);

gretl_VECM_R_matrix ()

const gretl_matrix *
gretl_VECM_R_matrix (const GRETL_VAR *vecm);

gretl_VECM_q_matrix ()

const gretl_matrix *
gretl_VECM_q_matrix (const GRETL_VAR *vecm);

gretl_VECM_Ra_matrix ()

const gretl_matrix *
gretl_VECM_Ra_matrix (const GRETL_VAR *vecm);

gretl_VECM_qa_matrix ()

const gretl_matrix *
gretl_VECM_qa_matrix (const GRETL_VAR *vecm);

gretl_VAR_get_series ()

double *
gretl_VAR_get_series (const GRETL_VAR *var,
                      const DATASET *dset,
                      int idx,
                      const char *key,
                      int *err);

gretl_VAR_get_matrix ()

gretl_matrix *
gretl_VAR_get_matrix (const GRETL_VAR *var,
                      int idx,
                      int *err);

gretl_VAR_param_names ()

void
gretl_VAR_param_names (GRETL_VAR *v,
                       char **params,
                       const DATASET *dset);

gretl_VAR_serialize ()

int
gretl_VAR_serialize (const GRETL_VAR *var,
                     SavedObjectFlags flags,
                     PRN *prn);

gretl_VAR_bundlize ()

int
gretl_VAR_bundlize (const GRETL_VAR *var,
                    DATASET *dset,
                    gretl_bundle *b);

transcribe_VAR_models ()

int
transcribe_VAR_models (GRETL_VAR *var,
                       const DATASET *dset,
                       const gretl_matrix *XTX);

gretl_VAR_from_XML ()

GRETL_VAR *
gretl_VAR_from_XML (xmlNodePtr node,
                    xmlDocPtr doc,
                    const DATASET *dset,
                    int *err);

vma_rep ()

gretl_matrix *
vma_rep (gretl_matrix *A,
         gretl_matrix *C,
         int horizon,
         int *err);

enum Detflags

enum VAR_robust

JohansenInfo

typedef struct JohansenInfo_ JohansenInfo;

struct GRETL_VAR_

struct GRETL_VAR_ {
    int ci;              /* command index (VAR or VECM) */
    int refcount;        /* for saving/deleting */
    int err;             /* error code */
    int neqns;           /* number of equations in system */
    int order;           /* maximum lag order */
    int t1;              /* starting observation */
    int t2;              /* ending observation */
    int T;               /* number of observations */
    int df;              /* T - average coeffs per equation */
    int ifc;             /* equations include a constant (1) or not (0) */
    int ncoeff;          /* total coefficients per equation */
    int *lags;           /* list of specific lags */
    int *ylist;          /* list of stochastic vars */
    int *xlist;          /* list of exogenous variables */
    int *rlist;          /* restricted exogenous variables (VECM only) */
    int detflags;        /* record of automatic deterministic vars added */
    int robust;          /* computing robust std errors? */
    int xcols;           /* full column size of X matrix (VECM special) */
    gretl_matrix *Y;     /* matrix of dependent variables */
    gretl_matrix *X;     /* matrix of independent variables */
    gretl_matrix *B;     /* basic coefficient matrix */
    gretl_matrix *XTX;   /* X'X inverse */
    gretl_matrix *A;     /* augmented coefficient matrix (companion form) */
    gretl_matrix *L;     /* lambda: inverse roots of A(L) polynomial */
    gretl_matrix *E;     /* residuals matrix */
    gretl_matrix *C;     /* Cholesky-decomposed covariance matrix */
    gretl_matrix *S;     /* cross-equation variance matrix */
    gretl_matrix *F;     /* optional forecast matrix */
    gretl_matrix *V;     /* full parameter covariance matrix */
    gretl_matrix *ord;   /* optional Cholesky-ordering vector */
    MODEL **models;      /* pointers to individual equation estimates */
    double *Fvals;       /* hold results of F-tests */
    double *Ivals;       /* hold results of info criteria comparisons */
    double ldet;         /* log-determinant of S */
    double ll;           /* log-likelihood */
    double AIC;          /* Akaike criterion */
    double BIC;          /* Bayesian criterion */
    double HQC;          /* Hannan-Quinn criterion */
    double LR;           /* for likelihood-ratio testing */
    double LB;           /* Ljung-Box (Portmanteau) test statistic */
    int LBs;             /* order for Portmanteau test */
    JohansenInfo *jinfo; /* extra information for VECMs */
    char *name;          /* for use in session management */
};