enum gretl_system_methods

typedef enum {
    SYS_SUR = 0,
    SYS_3SLS,
    SYS_FIML,
    SYS_LIML,
    SYS_OLS,
    SYS_TSLS,
    SYS_WLS,
    SYS_MAX
} gretl_system_methods;

id_atom

typedef struct id_atom_ id_atom;

identity

typedef struct identity_ identity;

struct gretl_equation_system_

struct gretl_equation_system_ {
    char *name;                 /* user-specified name for system, or NULL */
    int refcount;               /* for saving/deleting */
    int t1;                     /* starting observation number */
    int t2;                     /* ending observation number */
    int method;                 /* estimation method */
    int n_equations;            /* number of stochastic equations */
    int n_identities;           /* number of identities */
    int n_obs;                  /* number of observations per equation */
    int iters;                  /* number of iterations taken */
    char flags;                 /* to record options (e.g. save residuals) */
    double ll;                  /* log-likelihood (restricted) */
    double llu;                 /* unrestricted log-likelihood */
    double X2;                  /* chi-square test value */
    double ess;                 /* total error sum of squares */
    double diag;                /* test stat for diagonal covariance matrix */
    double bdiff;               /* summary stat for change in coefficients */
    int **lists;                /* regression lists for stochastic equations */
    int *endog_vars;            /* list of endogenous variables */
    int *instr_vars;            /* list of instruments (exogenous vars) */
    identity **idents;          /* set of identities */
    gretl_matrix *b;            /* coefficient estimates */
    gretl_matrix *vcv;          /* covariance matrix of coefficients */
    gretl_matrix *sigma;        /* cross-equation covariance matrix */
    gretl_matrix *R;            /* LHS of any linear restrictions */
    gretl_matrix *q;            /* RHS of any linear restrictions */  
    gretl_matrix *uhat;         /* residuals, all equations */
    MODEL **models;             /* set of pointers to per-equation models: just
				   convenience pointers -- these should NOT be
				   freed as part of sys cleanup
				*/
};

make_system_data_info ()

void        make_system_data_info           (gretl_equation_system *sys,
                                             int eqn,
                                             DATAINFO *pdinfo,
                                             int v,
                                             int code);

system_start ()

gretl_equation_system* system_start         (const char *line,
                                             gretlopt opt);

Start compiling an equation system: line must specify a "method" (estimation method) and/or a name for the system. If a method is given, the system will be estimated as soon as its definition is complete. If a name is given, the system definition is saved on a stack, and it can subsequently be estimated via various methods If both a name and an estimation method are given, the system is both estimated and saved.

get_system_name_from_line ()

char*       get_system_name_from_line       (const char *s);

gretl_equation_system_append ()

int         gretl_equation_system_append    (gretl_equation_system *sys,
                                             const int *list);

Adds an equation (as represented by list) to sys.

system_parse_line ()

int         system_parse_line               (gretl_equation_system *sys,
                                             const char *line,
                                             const DATAINFO *pdinfo);

Modifies sys according to the command supplied in line, which must start with "identity" (and supply an identity to be added to the system, or "endog" (and supply a list of endogenous variables), or "instr" (and supply a list of instrumental variables).

gretl_equation_system_finalize ()

int         gretl_equation_system_finalize  (gretl_equation_system *sys,
                                             double ***pZ,
                                             DATAINFO *pdinfo,
                                             PRN *prn);

Finalize an equation system, e.g. in response to "end system". If the system has a specified name, we save it on a stack of defined systems. If it has a specified estimation method, we go ahead and estimate it. If it has both, we do both.

gretl_equation_system_estimate ()

int         gretl_equation_system_estimate  (gretl_equation_system *sys,
                                             double ***pZ,
                                             DATAINFO *pdinfo,
                                             gretlopt opt,
                                             PRN *prn);

Estimate a pre-defined equation system and print the results to prn.

estimate_named_system ()

int         estimate_named_system           (const char *line,
                                             double ***pZ,
                                             DATAINFO *pdinfo,
                                             gretlopt opt,
                                             PRN *prn);

gretl_equation_system_destroy ()

void        gretl_equation_system_destroy   (gretl_equation_system *sys);

system_get_full_string ()

const char* system_get_full_string          (const gretl_equation_system *sys);

system_save_uhat ()

int         system_save_uhat                (const gretl_equation_system *sys);

system_save_yhat ()

int         system_save_yhat                (const gretl_equation_system *sys);

system_save_vcv ()

int         system_save_vcv                 (const gretl_equation_system *sys);

system_want_df_corr ()

int         system_want_df_corr             (const gretl_equation_system *sys);

system_n_restrictions ()

int         system_n_restrictions           (const gretl_equation_system *sys);

system_max_indep_vars ()

int         system_max_indep_vars           (const gretl_equation_system *sys);

system_n_indep_vars ()

int         system_n_indep_vars             (const gretl_equation_system *sys);

system_adjust_t1t2 ()

int         system_adjust_t1t2              (gretl_equation_system *sys,
                                             int *t1,
                                             int *t2,
                                             const double **Z);

system_get_list ()

int*        system_get_list                 (const gretl_equation_system *sys,
                                             int i);

compose_tsls_list ()

int*        compose_tsls_list               (gretl_equation_system *sys,
                                             int i);

system_get_depvar ()

int         system_get_depvar               (const gretl_equation_system *sys,
                                             int i);

gretl_system_short_string ()

const char* gretl_system_short_string       (const MODEL *pmod);

gretl_system_set_name ()

void        gretl_system_set_name           (gretl_equation_system *sys,
                                             const char *name);

gretl_system_method_from_string ()

int         gretl_system_method_from_string (const char *s);

system_method_full_string ()

const char* system_method_full_string       (int method);

system_method_short_string ()

const char* system_method_short_string      (int method);

system_get_endog_vars ()

int*        system_get_endog_vars           (const gretl_equation_system *sys);

system_get_instr_vars ()

int*        system_get_instr_vars           (const gretl_equation_system *sys);

system_attach_uhat ()

void        system_attach_uhat              (gretl_equation_system *sys,
                                             gretl_matrix *uhat);

system_attach_sigma ()

void        system_attach_sigma             (gretl_equation_system *sys,
                                             gretl_matrix *sigma);

system_attach_coeffs ()

void        system_attach_coeffs            (gretl_equation_system *sys,
                                             gretl_matrix *b);

system_attach_vcv ()

void        system_attach_vcv               (gretl_equation_system *sys,
                                             gretl_matrix *vcv);

system_get_model ()

MODEL*      system_get_model                (const gretl_equation_system *sys,
                                             int i);

system_get_overid_df ()

int         system_get_overid_df            (const gretl_equation_system *sys);

system_vcv_geomean ()

int         system_vcv_geomean              (const gretl_equation_system *sys);

system_vcv_denom ()

double      system_vcv_denom                (const gretl_equation_system *sys,
                                             int i,
                                             int j);

rhs_var_in_identity ()

int         rhs_var_in_identity             (const gretl_equation_system *sys,
                                             int lhsvar,
                                             int rhsvar);

print_equation_system_info ()

void        print_equation_system_info      (const gretl_equation_system *sys,
                                             const DATAINFO *pdinfo,
                                             gretlopt opt,
                                             PRN *prn);

Prints details of an equation system to prn.

system_set_restriction_matrices ()

void        system_set_restriction_matrices (gretl_equation_system *sys,
                                             gretl_matrix *R,
                                             gretl_matrix *q);

system_normality_test ()

int         system_normality_test           (const gretl_equation_system *sys,
                                             PRN *prn);

gretl_system_add_resids_to_dataset ()

int         gretl_system_add_resids_to_dataset
                                            (gretl_equation_system *sys,
                                             int eqnum,
                                             double ***pZ,
                                             DATAINFO *pdinfo);

gretl_equation_system_get_series ()

double*     gretl_equation_system_get_series
                                            (const gretl_equation_system *sys,
                                             const DATAINFO *pdinfo,
                                             int idx,
                                             const char *key,
                                             int *err);

gretl_equation_system_get_matrix ()

gretl_matrix* gretl_equation_system_get_matrix
                                            (const gretl_equation_system *sys,
                                             int idx,
                                             int *err);

highest_numbered_var_in_system ()

int         highest_numbered_var_in_system  (const gretl_equation_system *sys,
                                             const DATAINFO *pdinfo);

gretl_system_serialize ()

int         gretl_system_serialize          (gretl_equation_system *sys,
                                             SavedObjectFlags flags,
                                             FILE *fp);

gretl_system_set_save_flag ()

void        gretl_system_set_save_flag      (gretl_equation_system *sys);

gretl_system_unset_save_flag ()

void        gretl_system_unset_save_flag    (gretl_equation_system *sys);

gretl_system_save_flag_set ()

int         gretl_system_save_flag_set      (gretl_equation_system *sys);

gretl_system_from_XML ()

gretl_equation_system* gretl_system_from_XML
                                            (xmlNodePtr node,
                                             xmlDocPtr doc,
                                             int *err);