enum ModelDataType

typedef enum {
    MODEL_DATA_NONE,
    MODEL_DATA_INT,
    MODEL_DATA_LIST,
    MODEL_DATA_DOUBLE,
    MODEL_DATA_INT_ARRAY,
    MODEL_DATA_DOUBLE_ARRAY,
    MODEL_DATA_STRING,
    MODEL_DATA_CHAR_ARRAY,
    MODEL_DATA_CMPLX_ARRAY,
    MODEL_DATA_STRUCT
} ModelDataType;

enum ArmaFlags

typedef enum {
    ARMA_SEAS  = 1 << 0, /* includes seasonal component */
    ARMA_DSPEC = 1 << 1, /* input list includes differences */
    ARMA_X12A  = 1 << 2, /* using X-12-ARIMA to generate estimates */
    ARMA_EXACT = 1 << 3, /* using exact ML */
    ARMA_VECH  = 1 << 4  /* using vech representation when computing
			    variance matrix of state for Kalman filter
			 */
} ArmaFlags;

CoeffIntervals

typedef struct CoeffIntervals_ CoeffIntervals;

struct CoeffIntervals_

struct CoeffIntervals_ {
    int asy;
    int ncoeff;
    double t;
    char **names;
    double *coeff;
    double *maxerr;
    int df;
    int ifc;
};

AR_MODEL()

#define     AR_MODEL(c)

AR1_MODEL()

#define     AR1_MODEL(c)

SIMPLE_AR_MODEL()

#define     SIMPLE_AR_MODEL(c)

ML_ESTIMATOR()

#define     ML_ESTIMATOR(c)

LIMDEP()

#define     LIMDEP(c)

LSQ_MODEL()

#define     LSQ_MODEL(c)

ASYMPTOTIC_MODEL()

#define     ASYMPTOTIC_MODEL(c)

is_model_ref_cmd()

#define     is_model_ref_cmd(c)

enum ModelTestType

typedef enum {
    GRETL_TEST_ADD,
    GRETL_TEST_ARCH,
    GRETL_TEST_AUTOCORR,
    GRETL_TEST_CHOW,
    GRETL_TEST_CUSUM,
    GRETL_TEST_QLR,
    GRETL_TEST_GROUPWISE,
    GRETL_TEST_LOGS,
    GRETL_TEST_NORMAL,
    GRETL_TEST_OMIT,
    GRETL_TEST_RESET,
    GRETL_TEST_SQUARES,
    GRETL_TEST_WHITES,
    GRETL_TEST_SARGAN,
    GRETL_TEST_TSLS_HAUSMAN,
    GRETL_TEST_PANEL_HAUSMAN,
    GRETL_TEST_PANEL_F,
    GRETL_TEST_PANEL_BP,
    GRETL_TEST_PANEL_TIMEDUM,
    GRETL_TEST_MAX
} ModelTestType;

attach_model_tests_from_xml ()

int         attach_model_tests_from_xml     (MODEL *pmod,
                                             xmlNodePtr node);

gretl_model_new ()

MODEL*      gretl_model_new                 (void);

Allocates memory for a gretl MODEL struct and initializes the struct, using gretl_model_init().

gretl_model_init ()

void        gretl_model_init                (MODEL *pmod);

Initializes a gretl MODEL, including setting its pointer members to NULL. This initialization should be done if the caller has declared a MODEL struct directly, rather than obtaining a pointer to MODEL using gretl_model_new() (in which case the initialization is done automatically).

gretl_model_allocate_storage ()

int         gretl_model_allocate_storage    (MODEL *pmod);

Allocates space for coefficients and standard errors, residuals and fitted values in pmod. The sizes of the arrays are based on the ncoeff and full_n members of pmod, which must be set first. The residuals and fitted values are initialized to gretl's missing value.

gretl_model_array_new ()

MODEL**     gretl_model_array_new           (int n);

Allocates memory for an array of n gretl MODEL structs and initializes each model using gretl_model_init().

allocate_working_models ()

MODEL**     allocate_working_models         (int n);

Allocates memory for an array of n gretl MODEL structs and initializes each model using gretl_model_init(). The models are "protected" against deletion.

gretl_model_array_destroy ()

void        gretl_model_array_destroy       (MODEL **models,
                                             int n);

Frees all resources associated with an array of models, which should have been obtained via gretl_model_array_new().

destroy_working_models ()

void        destroy_working_models          (MODEL **models,
                                             int n);

gretl_model_smpl_init ()

void        gretl_model_smpl_init           (MODEL *pmod,
                                             const DATAINFO *pdinfo);

Records the start and end of the current sample range in the model pmod, which may be necessary for future reference if a hypothesis test is to be performed. Note that this sample range may not be the same as the data range over which the model is actually estimated (for example, in the case of autoregressive models where observations have to be dropped to allow for lags).

impose_model_smpl ()

void        impose_model_smpl               (const MODEL *pmod,
                                             DATAINFO *pdinfo);

Sets on pdinfo the sample range (starting and ending observations) that was in effect when pmod was estimated. This is not always the same as the data range over which pmod was actually estimated (e.g. in case of autoregressive models, where observations are dropped to allow for lags).

gretl_model_set_auxiliary ()

void        gretl_model_set_auxiliary       (MODEL *pmod,
                                             ModelAuxCode aux);

Sets an auxiliary code on pmod, which may be relevant for how the model is printed.

clear_model ()

void        clear_model                     (MODEL *pmod);

Clears a gretl MODEL, freeing all allocated storage and setting pointer members to NULL. Also frees any data pointers attached via gretl_model_set_data(). The model pointer itself is not freed, so this function may be called on a MODEL which has been declared directly by the caller (by passing the address of the MODEL).

gretl_model_free ()

void        gretl_model_free                (MODEL *pmod);

Free allocated content of pmod then the pointer itself.

gretl_model_free_on_exit ()

void        gretl_model_free_on_exit        (MODEL *pmod);

Free allocated content of pmod then the pointer itself, without regard to the model's reference count.

gretl_model_set_data_with_destructor ()

int         gretl_model_set_data_with_destructor
                                            (MODEL *pmod,
                                             const char *key,
                                             void *ptr,
                                             ModelDataType type,
                                             size_t size,
                                             void (*destructor) (void *));

Attaches data to pmod: the data can be retrieved later using gretl_model_get_data(). Note that the data are not "physically" copied to the model; simply, ptr is recorded on the model. This means that the data referenced by the pointer now in effect belong to pmod. When pmod is cleared with clear_model(), destructor will be invoked with ptr as its single argument. If a simple "free" is OK for freeing the data, you can use gretl_model_set_data() instead.

The size is needed in case the model is copied with copy_model(), in which case the target of the copying operation receives a newly allocated copy of the data in question.

gretl_model_set_data ()

int         gretl_model_set_data            (MODEL *pmod,
                                             const char *key,
                                             void *ptr,
                                             ModelDataType type,
                                             size_t size);

Attaches data to pmod: the data can be retrieved later using gretl_model_get_data(). Note that the data are not "physically" copied to the model; simply, ptr is recorded on the model. This means that the data referenced by the pointer now in effect belong to pmod. The data pointer will be freed when pmod is cleared with clear_model(). If the data has deep structure that requires special treatment on freeing, use gretl_model_set_data_with_destructor() instead.

The size is needed in case the model is copied with copy_model(), in which case the target of the copying operation receives a newly allocated copy of the data in question.

gretl_model_set_list_as_data ()

int         gretl_model_set_list_as_data    (MODEL *pmod,
                                             const char *key,
                                             int *list);

Attaches list to pmod as data, recoverable via the key key using gretl_model_get_data().

gretl_model_set_string_as_data ()

int         gretl_model_set_string_as_data  (MODEL *pmod,
                                             const char *key,
                                             char *str);

Attaches str to pmod as data, recoverable via the key key using gretl_model_get_data().

gretl_model_destroy_data_item ()

int         gretl_model_destroy_data_item   (MODEL *pmod,
                                             const char *key);

Looks up the data pointer, attached to pmod, that is identified by key, and if a pointer is found, frees it (or applies the destructor function that was set for the item, if any) and removes it from the model's list of data items. If you want to remove the item from the model's list without freeing the underlying data pointer, use gretl_model_detach_data_item().

gretl_model_detach_data_item ()

int         gretl_model_detach_data_item    (MODEL *pmod,
                                             const char *key);

Looks up the data item, attached to pmod, that is identified by key, and if an item is found, removes it from the model's list of such items. The data pointer associated with key is not touched. If you want the underlying resources associated with key to be freed, use gretl_model_destroy_data_item().

gretl_model_set_int ()

int         gretl_model_set_int             (MODEL *pmod,
                                             const char *key,
                                             int val);

Records an integer value on a model: the value can be retrieved later using gretl_model_get_int(), using the appropriate key.

gretl_model_set_double ()

int         gretl_model_set_double          (MODEL *pmod,
                                             const char *key,
                                             double val);

Records a floating-point value on pmod: the value can be retrieved later using gretl_model_get_double() with the appropriate key.

gretl_model_get_data ()

void*       gretl_model_get_data            (const MODEL *pmod,
                                             const char *key);

gretl_model_get_data_and_size ()

void*       gretl_model_get_data_and_size   (const MODEL *pmod,
                                             const char *key,
                                             size_t *sz);

gretl_model_get_int ()

int         gretl_model_get_int             (const MODEL *pmod,
                                             const char *key);

gretl_model_get_double ()

double      gretl_model_get_double          (const MODEL *pmod,
                                             const char *key);

gretl_model_get_list ()

int*        gretl_model_get_list            (const MODEL *pmod,
                                             const char *key);

gretl_model_get_param_name ()

char*       gretl_model_get_param_name      (const MODEL *pmod,
                                             const DATAINFO *pdinfo,
                                             int i,
                                             char *targ);

Writes the appropriate parameter name into targ, which should be at least VNAMELEN bytes long. Usually this is the name of a variable in the dataset, but sometimes it is a special string (e.g. for nonlinear models).

gretl_model_get_param_number ()

int         gretl_model_get_param_number    (const MODEL *pmod,
                                             const DATAINFO *pdinfo,
                                             const char *s);

free_coeff_intervals ()

void        free_coeff_intervals            (CoeffIntervals *cf);

gretl_model_get_coeff_intervals ()

CoeffIntervals* gretl_model_get_coeff_intervals
                                            (const MODEL *pmod,
                                             const DATAINFO *pdinfo);

Save the 95 percent confidence intervals for the parameter estimates in pmod.

gretl_model_get_depvar ()

int         gretl_model_get_depvar          (const MODEL *pmod);

gretl_model_get_x_list ()

int*        gretl_model_get_x_list          (const MODEL *pmod);

arma_model_nonseasonal_AR_order ()

int         arma_model_nonseasonal_AR_order (const MODEL *pmod);

arma_model_nonseasonal_MA_order ()

int         arma_model_nonseasonal_MA_order (const MODEL *pmod);

arma_model_max_AR_lag ()

int         arma_model_max_AR_lag           (const MODEL *pmod);

arma_model_max_MA_lag ()

int         arma_model_max_MA_lag           (const MODEL *pmod);

arma_model_integrated_AR_MA_coeffs ()

int         arma_model_integrated_AR_MA_coeffs
                                            (const MODEL *pmod,
                                             double **phi_star,
                                             double **theta_star);

Creates consolidated versions of the AR and MA coefficient vectors from pmod. If pmod includes seasonal ARMA terms, the vectors are suitably expanded to include the interactions between seasonal and non-seasonal terms. If the dependent variable has been differenced, the AR coefficients are integrated to account for the differencing. These are the \Phi^* and \Theta^* as used by Box and Jenkins for forecasting.

The length of these vectors can be determined using gretl_arma_model_get_max_AR_lag() and gretl_arma_model_get_max_MA_lag() respectively.

regarma_model_AR_coeffs ()

int         regarma_model_AR_coeffs         (const MODEL *pmod,
                                             double **phi0,
                                             int *pp);

Creates a consolidated version of the AR coefficients from pmod. If pmod includes seasonal AR terms the vector is suitably expanded to include the interactions between seasonal and non-seasonal terms, but it is not integrated with respect to any differencing of the dependent variable.

arma_model_get_x_coeffs ()

const double* arma_model_get_x_coeffs       (const MODEL *pmod);

regarima_model_get_AR_coeffs ()

int         regarima_model_get_AR_coeffs    (const MODEL *pmod,
                                             double **phi0,
                                             int *pp);

gretl_model_new_vcv ()

int         gretl_model_new_vcv             (MODEL *pmod,
                                             int *nelem);

Allocates space for a packed coefficient covariance matrix in pmod (if such space is not already allocated). Sets all entries in the array to zero.

gretl_model_get_vcv ()

VMatrix*    gretl_model_get_vcv             (MODEL *pmod,
                                             const DATAINFO *pdinfo);

Supplies the caller with a copy of the variance-covariance matrix for the parameter estimates in pmod, in a format suitable for printing. See also free_vcv(). To get the covariance matrix as a gretl_matrix, see gretl_vcv_matrix_from_model().

gretl_model_add_arinfo ()

int         gretl_model_add_arinfo          (MODEL *pmod,
                                             int nterms);

Performs initial setup for structure to hold info on autoregressive coefficients.

gretl_model_copy ()

MODEL*      gretl_model_copy                (const MODEL *pmod);

Does a deep copy of pmod: allocates a new MODEL pointer which has its own allocated copies of all the pointer members of pmod. The only feature of pmod that is not duplicated is the reference count, which is set to zero in the copy.

swap_models ()

void        swap_models                     (MODEL *targ,
                                             MODEL *src);

Swaps the content of the two model pointers.

is_model_cmd ()

int         is_model_cmd                    (const char *line);

is_quiet_model_test ()

int         is_quiet_model_test             (int ci,
                                             gretlopt opt);

command_ok_for_model ()

int         command_ok_for_model            (int test_ci,
                                             gretlopt opt,
                                             int model_ci);

model_test_ok ()

int         model_test_ok                   (int ci,
                                             gretlopt opt,
                                             const MODEL *pmod,
                                             const DATAINFO *pdinfo);

A more rigorous version of command_ok_for_model(). Use this function if the extra information is available.

gretl_is_arima_model ()

int         gretl_is_arima_model            (const MODEL *pmod);

get_first_model_stat ()

int         get_first_model_stat            (const char **word,
                                             const char **desc);

get_next_model_stat ()

int         get_next_model_stat             (const char **word,
                                             const char **desc);

get_model_count ()

int         get_model_count                 (void);

reset_model_count ()

void        reset_model_count               (void);

model_count_plus ()

int         model_count_plus                (void);

model_count_minus ()

void        model_count_minus               (void);

set_model_id ()

void        set_model_id                    (MODEL *pmod);

model_test_new ()

ModelTest*  model_test_new                  (ModelTestType ttype);

model_test_free ()

void        model_test_free                 (ModelTest *test);

maybe_add_test_to_model ()

int         maybe_add_test_to_model         (MODEL *pmod,
                                             ModelTest *test);

Adds a ModelTest to pmod, if the test in question has not already been performed and recorded. Note that this function takes care of freeing test.

model_test_set_teststat ()

void        model_test_set_teststat         (ModelTest *test,
                                             unsigned char ts);

model_test_set_order ()

void        model_test_set_order            (ModelTest *test,
                                             int order);

model_test_set_dfn ()

void        model_test_set_dfn              (ModelTest *test,
                                             int df);

model_test_set_dfd ()

void        model_test_set_dfd              (ModelTest *test,
                                             int df);

model_test_set_value ()

void        model_test_set_value            (ModelTest *test,
                                             double val);

model_test_set_pvalue ()

void        model_test_set_pvalue           (ModelTest *test,
                                             double pval);

model_test_set_param ()

void        model_test_set_param            (ModelTest *test,
                                             const char *s);

model_test_set_allocated_param ()

void        model_test_set_allocated_param  (ModelTest *test,
                                             char *s);

model_test_set_crit_and_alpha ()

void        model_test_set_crit_and_alpha   (ModelTest *test,
                                             double crit,
                                             double alpha);

gretl_model_test_print ()

void        gretl_model_test_print          (const MODEL *pmod,
                                             int i,
                                             PRN *prn);

gretl_model_print_last_test ()

void        gretl_model_print_last_test     (const MODEL *pmod,
                                             PRN *prn);

gretl_model_test_print_direct ()

void        gretl_model_test_print_direct   (const ModelTest *test,
                                             int heading,
                                             PRN *prn);

gretl_model_destroy_tests ()

void        gretl_model_destroy_tests       (MODEL *pmod);

Clears any hypothesis test structs that have been attached to pmod.

model_list_to_string ()

void        model_list_to_string            (int *list,
                                             char *buf);

highest_numbered_var_in_model ()

int         highest_numbered_var_in_model   (const MODEL *pmod,
                                             const DATAINFO *pdinfo);

mle_criteria ()

int         mle_criteria                    (MODEL *pmod,
                                             int addk);

coeff_pval ()

double      coeff_pval                      (int ci,
                                             double x,
                                             int df);

gretl_model_allocate_params ()

int         gretl_model_allocate_params     (MODEL *pmod,
                                             int k);

Allocate an array of k strings to hold the names given to the associated coefficients, in a model where these strings are not simply given by the names of the independent variables.

gretl_model_add_arma_varnames ()

int         gretl_model_add_arma_varnames   (MODEL *pmod,
                                             const DATAINFO *pdinfo,
                                             int yno,
                                             int p,
                                             int q,
                                             int P,
                                             int Q,
                                             int r);

Composes a set of names to be given to the regressors in an ARMA model.

gretl_model_add_panel_varnames ()

int         gretl_model_add_panel_varnames  (MODEL *pmod,
                                             const DATAINFO *pdinfo,
                                             const int *ulist);

Composes a set of names to be given to the regressors in an panel model.

gretl_model_add_allocated_varnames ()

void        gretl_model_add_allocated_varnames
                                            (MODEL *pmod,
                                             char **vnames);

Attaches an allocated set of variable names to be used when printing model results, for use in special cases where we can't just reference names from the list of regressors attached to the model. The number of strings must match the number of coefficients, given by the ncoeff member of pmod.

Note that pmod "takes charge" of the array vnames: this will be freed when the model is destroyed.

gretl_model_get_fitted_formula ()

char*       gretl_model_get_fitted_formula  (const MODEL *pmod,
                                             int xvar,
                                             const double **Z,
                                             const DATAINFO *pdinfo);

If pmod is a simple linear, quadratic or logistic model, and if xvar is in fact the "x" variable from the model, returns a string representing the formula for generating the fitted values as a function of x. This formula may be used in the context of a fitted versus actual plot.

gretl_model_set_name ()

void        gretl_model_set_name            (MODEL *pmod,
                                             const char *name);

gretl_model_get_name ()

const char* gretl_model_get_name            (const MODEL *pmod);

gretl_model_get_scalar ()

double      gretl_model_get_scalar          (const MODEL *pmod,
                                             ModelDataIndex idx,
                                             int *err);

Retrieves a specified scalar statistic from pmod: idx must be less than M_SCALAR_MAX.

gretl_model_get_series ()

double*     gretl_model_get_series          (const MODEL *pmod,
                                             const DATAINFO *pdinfo,
                                             ModelDataIndex idx,
                                             int *err);

Retrieves from pmod a copy of a specified series (for example, regression residuals); idx must be greater than M_ELEM_MAX and less than M_SERIES_MAX.

gretl_model_get_matrix ()

gretl_matrix* gretl_model_get_matrix        (MODEL *pmod,
                                             ModelDataIndex idx,
                                             int *err);

Retrieves from pmod a copy of a specified matrix (for example, regression residuals); idx must be greater than M_ELEM_MAX and less than M_MAX.

gretl_model_get_data_element ()

double      gretl_model_get_data_element    (MODEL *pmod,
                                             int idx,
                                             const char *s,
                                             const DATAINFO *pdinfo,
                                             int *err);

gretl_model_serialize ()

int         gretl_model_serialize           (const MODEL *pmod,
                                             SavedObjectFlags flags,
                                             FILE *fp);

gretl_model_from_XML ()

MODEL*      gretl_model_from_XML            (xmlNodePtr node,
                                             xmlDocPtr doc,