enum MMissingCode

typedef enum {
    M_MISSING_OK,
    M_MISSING_ERROR,
    M_MISSING_SKIP,
    M_MISSING_TRIM
} MMissingCode;

gretl_vector_from_array ()

gretl_vector *      gretl_vector_from_array             (const double *x,
                                                         int n,
                                                         GretlMatrixMod mod);

gretl_vector_from_series ()

gretl_vector *      gretl_vector_from_series            (const double *x,
                                                         int t1,
                                                         int t2);

gretl_matrix_from_2d_array ()

gretl_matrix *      gretl_matrix_from_2d_array          (const double **X,
                                                         int rows,
                                                         int cols);

gretl_matrix_from_scalar ()

gretl_matrix *      gretl_matrix_from_scalar            (double x);

gretl_vcv_matrix_from_model ()

gretl_matrix *      gretl_vcv_matrix_from_model         (MODEL *pmod,
                                                         const char *select,
                                                         int *err);

Produces all or part of the covariance matrix for pmod in the form of a gretl_matrix. Storage is allocated, to be freed by the caller. If select is not NULL, it should be an array with non-zero elements in positions corresponding to the desired rows (and columns), and zero elements otherwise.

gretl_coeff_vector_from_model ()

gretl_vector *      gretl_coeff_vector_from_model       (const MODEL *pmod,
                                                         const char *select,
                                                         int *err);

Produces all or part of the coefficient vector for pmod in the form of a gretl column vector. Storage is allocated, to be freed by the caller. If select is non-NULL, it should be an array with non-zero elements in positions corresponding to the desired rows and zero elements otherwise.

gretl_covariance_matrix_from_varlist ()

gretl_matrix *      gretl_covariance_matrix_from_varlist
                                                        (const int *list,
                                                         const double **Z,
                                                         const DATAINFO *pdinfo,
                                                         gretl_matrix **means,
                                                         int *errp);

gretl_matrix_row_to_array ()

int                 gretl_matrix_row_to_array           (const gretl_matrix *m,
                                                         int i,
                                                         double *x);

Copies the values from row i of matrix m into the array x, which should already be allocated to the correct size.

gretl_matrix_data_subset_masked ()

gretl_matrix *      gretl_matrix_data_subset_masked     (const int *list,
                                                         const double **Z,
                                                         int t1,
                                                         int t2,
                                                         const char *mask,
                                                         int *err);

Creates a gretl matrix holding the subset of variables from Z specified by list, over the sample range t1 to t2, inclusive. Variables are in columns. mask should be an array of char of length (t2 - t1 + 1) with 1s in the positions of observations to exclude from the subset and zeros elsewhere. This apparatus can be used to exclude missing observations.

gretl_matrix_data_subset ()

gretl_matrix *      gretl_matrix_data_subset            (const int *list,
                                                         const double **Z,
                                                         int t1,
                                                         int t2,
                                                         int missop,
                                                         int *err);

Creates a gretl matrix holding the subset of variables from Z specified by list, over the sample range t1 to t2, inclusive. Variables are in columns. The missop flag can be M_MISSING_OK to indicate that it's OK to include missing values in the matrix (these become NaNs), M_MISSING_ERROR (it's an error of any missing values are found), or M_MISSING_SKIP (observations with any missing values are omitted from the matrix).

gretl_dataset_from_matrix ()

DATAINFO *          gretl_dataset_from_matrix           (gretl_matrix *m,
                                                         const int *list,
                                                         double ***pZ,
                                                         int *err);

Creates a gretl dataset from matrix m, either using the columns specified in list or using all columns if list is NULL.

gretl_plotfit_matrices ()

int                 gretl_plotfit_matrices              (const double *yvar,
                                                         const double *xvar,
                                                         FitType fit,
                                                         int t1,
                                                         int t2,
                                                         gretl_matrix **py,
                                                         gretl_matrix **pX);

Creates a vector y and matrix X based on the input yvar, xvar and fit, using the given sample range. An observation is skipped if either yvar or xvar is missing at that observation.

gretl_matrix_delete_columns ()

int                 gretl_matrix_delete_columns         (gretl_matrix *X,
                                                         int *list);

gretl_matrix_read_from_text ()

gretl_matrix *      gretl_matrix_read_from_text         (const char *fname,
                                                         int *err);

Reads a matrix from a text file by the name fname; the column separator must be space or tab. It is assumed that the dimensions of the matrix (number of rows and columns) are found on the first line of the csv file, so no heuristics are necessary. In case of error, an empty matrix is returned and err is filled appropriately.

gretl_matrix_write_as_text ()

int                 gretl_matrix_write_as_text          (gretl_matrix *A,
                                                         const char *fname);

gretl_matrix_print_to_prn ()

void                gretl_matrix_print_to_prn           (const gretl_matrix *m,
                                                         const char *msg,
                                                         PRN *prn);

Prints the matrix m to prn.

gretl_packed_matrix_print ()

void                gretl_packed_matrix_print           (const gretl_matrix *m,
                                                         const char *msg);

Prints the symmetric matrix m (packed as lower triangle) to stderr.

debug_print_matrix ()

void                debug_print_matrix                  (const gretl_matrix *m,
                                                         const char *msg);

Prints the matrix m to stderr, as with gretl_matrix_print(), but appends the address of the matrix struct.

gretl_matrix_print_with_col_heads ()

void                gretl_matrix_print_with_col_heads   (const gretl_matrix *m,
                                                         const char *title,
                                                         const char **heads,
                                                         PRN *prn);

Prints the matrix m to prn, with column headings given by heads.

gretl_matrix_print_with_format ()

void                gretl_matrix_print_with_format      (const gretl_matrix *m,
                                                         const char *fmt,
                                                         int wid,
                                                         int prec,
                                                         PRN *prn);

gretl_matrix_cut_rows ()

int                 gretl_matrix_cut_rows               (gretl_matrix *m,
                                                         const char *mask);

In-place reduction of m based on mask: the masked rows are cut out of m.

gretl_matrix_cut_rows_cols ()

int                 gretl_matrix_cut_rows_cols          (gretl_matrix *m,
                                                         const char *mask);

In-place reduction of m based on mask: the masked rows and columns are cut out of m.

gretl_matrix_zero_row_mask ()

char *              gretl_matrix_zero_row_mask          (const gretl_matrix *m,
                                                         int *err);

Checks matrix m for rows that are all zero. If there are any such rows, constructs a mask of length equal to the number of rows in m, with 1s indicating zero rows, 0s elsewhere. If there are no such rows, returns NULL.

E_ALLOC is written to err in case a mask should have been constructed but allocation failed.

gretl_matrix_rank_mask ()

char *              gretl_matrix_rank_mask              (const gretl_matrix *m,
                                                         int *err);

Performs a QR decomposition of matrix m and uses this to assess the rank of m. If m is not of full rank, constructs a mask of length equal to the numbers of columns in m, with 1s in positions corresponding to diagonal elements of R that are effectively 0, and 0s elsewhere. If m is of full column rank, NULL is returned.

E_ALLOC is written to err in case a mask should have been constructed but allocation failed.

gretl_matrix_mp_ols ()

int                 gretl_matrix_mp_ols                 (const gretl_vector *y,
                                                         const gretl_matrix *X,
                                                         gretl_vector *b,
                                                         gretl_matrix *vcv,
                                                         gretl_vector *uhat,
                                                         double *s2);

Computes OLS estimates using Cholesky factorization, via the GMP multiple-precision library, and puts the coefficient estimates in b. Optionally, calculates the covariance matrix in vcv and the residuals in uhat.