floateq()

#define floateq(x, y)  (fabs((x) - (y)) < DBL_EPSILON)

floatneq()

#define floatneq(x, y) (fabs((x) - (y)) > DBL_EPSILON)

floatgt()

#define floatgt(x, y)  ((x) - (y) > DBL_EPSILON)

floatlt()

#define floatlt(x, y)  ((y) - (x) > DBL_EPSILON)

ok_int()

#define ok_int(x) (x <= (double) INT_MAX && x >= (double) INT_MIN)

libgretl_init ()

void        libgretl_init                   (void);

libgretl_session_cleanup ()

void        libgretl_session_cleanup        (void);

libgretl_cleanup ()

void        libgretl_cleanup                (void);

date ()

double      date                            (int nt,
                                             int pd,
                                             const double sd0);

gretl_isdummy ()

int         gretl_isdummy                   (int t1,
                                             int t2,
                                             const double *x);

Check whether variable x has only 0 or 1 values over the given sample range (or possibly missing values).

gretl_iszero ()

int         gretl_iszero                    (int t1,
                                             int t2,
                                             const double *x);

Check whether variable x has only zero values over the given sample range (or possibly missing values).

gretl_isconst ()

int         gretl_isconst                   (int t1,
                                             int t2,
                                             const double *x);

Check whether variable x is constant over the given sample range (aside from any missing values).

gretl_isunits ()

int         gretl_isunits                   (int t1,
                                             int t2,
                                             const double *x);

Check whether variable x equals 1 over the given sample range (aside from any missing values).

gretl_isdiscrete ()

int         gretl_isdiscrete                (int t1,
                                             int t2,
                                             const double *x);

Checks the variable x over the range t1 to t2 for discreteness. This is a heuristic whose components are (a) whether the values are "fairly round" (multiples of 0.25) or not, and, if test (a) is passed, (b) whether the variable takes on only "few" distinct values.

true_const ()

int         true_const                      (int v,
                                             const double **Z,
                                             const DATAINFO *pdinfo);

Check whether variable Z[v] equals 1 over the sample range given in pdinfo, (aside from any missing values).

format_obs ()

char*       format_obs                      (char *obs,
                                             int maj,
                                             int min,
                                             int pd);

Prints to obs the gretl-type date string representing the observation given by maj, min and pd.

set_obs ()

int         set_obs                         (const char *line,
                                             double **Z,
                                             DATAINFO *pdinfo,
                                             gretlopt opt);

Set the frequency and initial observation for a dataset.

gretl_compare_doubles ()

int         gretl_compare_doubles           (const void *a,
                                             const void *b);

Comparison function for use with qsort. Sorts doubles in ascending order.

gretl_inverse_compare_doubles ()

int         gretl_inverse_compare_doubles   (const void *a,
                                             const void *b);

Comparison function for use with qsort. Sorts doubles in descending order.

count_distinct_values ()

int         count_distinct_values           (const double *x,
                                             int n);

count_distinct_int_values ()

int         count_distinct_int_values       (const int *x,
                                             int n);

rearrange_id_array ()

int         rearrange_id_array              (double *x,
                                             int m,
                                             int n);

Rearranges the sorted array x such that the first m elements contain the m distinct values in sorted order.

gretl_compare_ints ()

int         gretl_compare_ints              (const void *a,
                                             const void *b);

Comparison function for use with qsort. Sorts integers in ascending order.

printlist ()

void        printlist                       (const int *list,
                                             const char *msg);

Prints to stderr the given list of integers along with a message.

gretl_int_from_string ()

int         gretl_int_from_string           (const char *s,
                                             const double **Z,
                                             const DATAINFO *pdinfo,
                                             int *err);

If s is a valid string representation of an integer, return that integer, otherwise if s is the name of a scalar variable, return the value of that variable, otherwise set the content of err to a non-zero value.

positive_int_from_string ()

int         positive_int_from_string        (const char *s);

If s is a valid string representation of a positive integer, return that integer, otherwise return -1.

varnum_from_string ()

int         varnum_from_string              (const char *str,
                                             DATAINFO *pdinfo);

rename_var_by_id ()

int         rename_var_by_id                (const char *idstr,
                                             const char *vname,
                                             DATAINFO *pdinfo);

re_estimate ()

int         re_estimate                     (char *model_spec,
                                             MODEL *tmpmod,
                                             double ***pZ,
                                             DATAINFO *pdinfo);

copyvec ()

double*     copyvec                         (const double *src,
                                             int n);

doubles_array_free ()

void        doubles_array_free              (double **X,
                                             int m);

Frees a 2-dimensional array of doubles, first freeing each sub-array.

doubles_array_new ()

double**    doubles_array_new               (int m,
                                             int n);

Allocates a 2-dimensional array of doubles, that is, m arrays each containing n elements.

data_array_from_model ()

double**    data_array_from_model           (const MODEL *pmod,
                                             double **Z,
                                             int missv);

Constructs a dataset containing all the variables referenced in pmod. The arrays start at the correct sample offset for pmod, and are contiguous. If missvals equals 0, this is done by creating a set of pointers into the main dataset, but if there are missing values to be handled, the sub-arrays are newly allocated and purged of NAs.

ijton ()

int         ijton                           (int i,
                                             int j,
                                             int nrows);

Given a (row, column) reference into a symmetric 2-dimensional matrix A, finds the index into a 1-dimensional array x composed of the non-redundant (lower) elements of A.

E.g. for the 3 x 3 case with 6 non-redundant elements, 0 to 5,

A(0,0) = x[0] A(0,1) = x[1] A(0,2) = x[2] A(1,0) = x[1] A(1,1) = x[3] A(1,2) = x[4] A(2,0) = x[2] A(2,1) = x[4] A(2,1) = x[5]

ztox ()

int         ztox                            (int i,
                                             double *px,
                                             const double **Z,
                                             const DATAINFO *pdinfo);

Pull one series from data matrix and put it into px.

get_xvalue ()

double      get_xvalue                      (int i,
                                             const double **Z,
                                             const DATAINFO *pdinfo);

gretl_copy_file ()

int         gretl_copy_file                 (const char *src,
                                             const char *dest);

gretl_spawn ()

int         gretl_spawn                     (char *cmdline);

gretl_calculate_criteria ()

int         gretl_calculate_criteria        (double ess,
                                             int n,
                                             int k,
                                             double *ll,
                                             double *aic,
                                             double *bic,
                                             double *hqc);

Calculates model selection criteria based on ess, nobs and k, for a model estimated via least squares.

gretl_print_criteria ()

int         gretl_print_criteria            (double ess,
                                             int nobs,
                                             int ncoeff,
                                             PRN *prn);

Prints the values of the model selection criteria AIC, BIC and HQC for the given parameters.

ls_criteria ()

int         ls_criteria                     (MODEL *pmod);

Fills out the model selection criteria members of pmod, using gretl_calculate_criteria().

record_test_result ()

void        record_test_result              (double teststat,
                                             double pval,
                                             char *blurb);

get_last_test_statistic ()

double      get_last_test_statistic         (char *blurb);

get_last_pvalue ()

double      get_last_pvalue                 (char *blurb);

gretl_stopwatch ()

double      gretl_stopwatch                 (void);