eval_ytest ()

int
eval_ytest (double y,
            GretlOp op,
            double test);

gretl_minmax ()

int
gretl_minmax (int t1,
              int t2,
              const double *x,
              double *min,
              double *max);

Puts the minimum and maximum values of the series x , from obs t1 to obs t2 , into the variables min and max .

gretl_min ()

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

gretl_max ()

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

gretl_sum ()

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

gretl_mean ()

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

gretl_restricted_mean ()

double
gretl_restricted_mean (int t1,
                       int t2,
                       const double *x,
                       const double *y,
                       GretlOp yop,
                       double yval);

gretl_quantile ()

double
gretl_quantile (int t1,
                int t2,
                const double *x,
                double p,
                gretlopt opt,
                int *err);

gretl_array_quantiles ()

int
gretl_array_quantiles (double *a,
                       int n,
                       double *p,
                       int k);

Computes k quantiles (given by the elements of p ) for the first n elements of the array a , which is re-ordered in the process. On successful exit, p contains the quantiles.

gretl_array_quantile ()

double
gretl_array_quantile (double *a,
                      int n,
                      double p);

gretl_median ()

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

gretl_sst ()

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

gretl_variance ()

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

gretl_restricted_variance ()

double
gretl_restricted_variance (int t1,
                           int t2,
                           const double *x,
                           const double *y,
                           GretlOp yop,
                           double yval);

gretl_stddev ()

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

gretl_restricted_stddev ()

double
gretl_restricted_stddev (int t1,
                         int t2,
                         const double *x,
                         const double *y,
                         GretlOp yop,
                         double yval);

gretl_long_run_variance ()

double
gretl_long_run_variance (int t1,
                         int t2,
                         const double *x,
                         int m,
                         double mu);

gretl_covar ()

double
gretl_covar (int t1,
             int t2,
             const double *x,
             const double *y,
             int *missing);

gretl_corr ()

double
gretl_corr (int t1,
            int t2,
            const double *x,
            const double *y,
            int *missing);

gretl_corr_rsq ()

double
gretl_corr_rsq (int t1,
                int t2,
                const double *x,
                const double *y);

gretl_skewness ()

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

gretl_kurtosis ()

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

gretl_moments ()

int
gretl_moments (int t1,
               int t2,
               const double *x,
               const double *wts,
               double *xbar,
               double *sd,
               double *skew,
               double *kurt,
               int k);

Calculates sample moments for series x from obs t1 to obs t2 .

gretl_sorted_series ()

double *
gretl_sorted_series (int v,
                     const DATASET *dset,
                     gretlopt opt,
                     int *n,
                     int *err);

free_freq ()

void
free_freq (FreqDist *freq);

Frees all resources associated with freq , and the pointer itself.

freq_setup ()

int
freq_setup (int v,
            const DATASET *dset,
            int *pn,
            double *pxmax,
            double *pxmin,
            int *nbins,
            double *binwidth);

get_freq ()

FreqDist *
get_freq (int varno,
          const DATASET *dset,
          double fmin,
          double fwid,
          int nbins,
          int params,
          gretlopt opt,
          int *err);

Calculates the frequency distribution for the specified variable.

get_discrete_freq ()

FreqDist *
get_discrete_freq (int v,
                   const DATASET *dset,
                   gretlopt opt,
                   int *err);

freqdist ()

int
freqdist (int varno,
          const DATASET *dset,
          gretlopt opt,
          PRN *prn);

freqdist_matrix ()

gretl_matrix *
freqdist_matrix (const double *x,
                 int t1,
                 int t2,
                 int *err);

get_last_result_data ()

void *
get_last_result_data (GretlType *type,
                      int *err);

set_last_result_data ()

void
set_last_result_data (void *ptr,
                      GretlType type);

last_result_cleanup ()

void
last_result_cleanup (void);

crosstab ()

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

crosstab_from_matrix ()

int
crosstab_from_matrix (gretlopt opt,
                      PRN *prn);

compare_xtab_rows ()

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

single_crosstab ()

Xtab *
single_crosstab (const int *list,
                 const DATASET *dset,
                 gretlopt opt,
                 PRN *prn,
                 int *err);

xtab_to_matrix ()

gretl_matrix *
xtab_to_matrix (const Xtab *tab);

free_xtab ()

void
free_xtab (Xtab *tab);

Frees all resources associated with tab , and the pointer itself.

model_error_dist ()

int
model_error_dist (const MODEL *pmod,
                  DATASET *dset,
                  gretlopt opt,
                  PRN *prn);

auto_acf_order ()

int
auto_acf_order (int T);

auto_spectrum_order ()

int
auto_spectrum_order (int T,
                     gretlopt opt);

corrgram ()

int
corrgram (int varno,
          int order,
          int nparam,
          DATASET *dset,
          gretlopt opt,
          PRN *prn);

Computes the autocorrelation function and plots the correlogram for the variable specified by varno .

xcorrgram ()

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

Computes the cross-correlation function and plots the cross-correlogram for the specified variables.

periodogram ()

int
periodogram (int varno,
             int width,
             const DATASET *dset,
             gretlopt opt,
             PRN *prn);

Computes and displays the periodogram for the series specified by varno .

residual_periodogram ()

int
residual_periodogram (const double *x,
                      int width,
                      const DATASET *dset,
                      gretlopt opt,
                      PRN *prn);

Computes and displays the periodogram for x , which is presumed to be a model residual series.

periodogram_matrix ()

gretl_matrix *
periodogram_matrix (const double *x,
                    int t1,
                    int t2,
                    int width,
                    int *err);

Implements the userspace gretl pergm function, which can be used on either a series from the dataset or a gretl vector.

fractint ()

int
fractint (int varno,
          int order,
          const DATASET *dset,
          gretlopt opt,
          PRN *prn);

Computes and prints a test for fractional integration of the series specified by varno . By default the test uses the Local Whittle Estimator but if opt includes OPT_G then the Geweke and Porter-Hudak test is done instead, or if OPT_A then both tests are shown. If OPT_Q is given the test results are not printed, just recorded (with preference given to the LWE in case of OPT_A).

get_summary ()

Summary *
get_summary (const int *list,
             const DATASET *dset,
             gretlopt opt,
             PRN *prn,
             int *err);

Calculates descriptive summary statistics for the specified variables.

get_summary_weighted ()

Summary *
get_summary_weighted (const int *list,
                      const DATASET *dset,
                      int var,
                      gretlopt opt,
                      PRN *prn,
                      int *err);

Calculates descriptive summary statistics for the specified variables, weighting the observations by rv . The series rv must be of full length (dset->n).

get_summary_restricted ()

Summary *
get_summary_restricted (const int *list,
                        const DATASET *dset,
                        const double *rv,
                        gretlopt opt,
                        PRN *prn,
                        int *err);

Calculates descriptive summary statistics for the specified variables, with the observations restricted to those for which rv has a non-zero (and non-missing) value. The series rv must be of full length (dset->n).

list_summary ()

int
list_summary (const int *list,
              int wgtvar,
              const DATASET *dset,
              gretlopt opt,
              PRN *prn);

Prints descriptive statistics for the listed variables.

print_summary ()

void
print_summary (const Summary *summ,
               const DATASET *dset,
               PRN *prn);

Prints the summary statistics for a given variable.

print_summary_single ()

void
print_summary_single (const Summary *s,
                      int digits,
                      int places,
                      const DATASET *dset,
                      PRN *prn);

summary_has_missing_values ()

int
summary_has_missing_values (const Summary *summ);

free_summary ()

void
free_summary (Summary *summ);

Frees all resources associated with summ , and the pointer itself.

corrlist ()

VMatrix *
corrlist (int ci,
          int *list,
          const DATASET *dset,
          gretlopt opt,
          int *err);

Computes pairwise correlation coefficients for the variables specified in list , skipping any constants. If the option flags contain OPT_N, a uniform sample is ensured: only those observations for which all the listed variables have valid values are used. If OPT_C is included, we actually calculate covariances rather than correlations.

vmatrix_new ()

VMatrix *
vmatrix_new (void);

free_vmatrix ()

void
free_vmatrix (VMatrix *vmat);

Frees all resources associated with vmat , and the pointer itself.

gretl_corrmx ()

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

Computes and prints the correlation matrix for the specified list of variables.

satterthwaite_df ()

int
satterthwaite_df (double v1,
                  int n1,
                  double v2,
                  int n2);

means_test ()

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

Carries out test of the null hypothesis that the means of two variables are equal.

vars_test ()

int
vars_test (const int *list,
           const DATASET *dset,
           PRN *prn);

Carries out test of the null hypothesis that the variances of two variables are equal.

print_corrmat ()

void
print_corrmat (VMatrix *corr,
               const DATASET *dset,
               PRN *prn);

Prints a gretl correlation matrix to prn .

doornik_chisq ()

double
doornik_chisq (double skew,
               double xkurt,
               int n);

Calculates the Chi-square test for normality as set out by Doornik and Hansen, "An Omnibus Test for Normality", 1994. This is a modified version of the test proposed by Bowman and Shenton (Biometrika, 1975).

multivariate_normality_test ()

int
multivariate_normality_test (const gretl_matrix *E,
                             const gretl_matrix *Sigma,
                             gretlopt opt,
                             PRN *prn);

mahalanobis_distance ()

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

get_mahal_distances ()

MahalDist *
get_mahal_distances (const int *list,
                     DATASET *dset,
                     gretlopt opt,
                     PRN *prn,
                     int *err);

free_mahal_dist ()

void
free_mahal_dist (MahalDist *md);

mahal_dist_get_distances ()

const double *
mahal_dist_get_distances (const MahalDist *md);

mahal_dist_get_n ()

int
mahal_dist_get_n (const MahalDist *md);

mahal_dist_get_varlist ()

const int *
mahal_dist_get_varlist (const MahalDist *md);

distance ()

gretl_matrix *
distance (const gretl_matrix *X,
          const gretl_matrix *Y,
          const char *type,
          int *err);

gretl_gini ()

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

gini ()

int
gini (int varno,
      DATASET *dset,
      gretlopt opt,
      PRN *prn);

Graphs the Lorenz curve for variable vnum and prints the Gini coefficient.

shapiro_wilk ()

int
shapiro_wilk (const double *x,
              int t1,
              int t2,
              double *W,
              double *pval);

Computes the Shapiro-Wilk W statistic as a test for normality of the data x , and also the p-value for the test. These are written into the pointer arguments W and pval .

gretl_normality_test ()

int
gretl_normality_test (int varno,
                      const DATASET *dset,
                      gretlopt opt,
                      PRN *prn);

Performs, and prints the results of, the specified test(s) randomness for the variable specified by v .

gretl_normtest_matrix ()

gretl_matrix *
gretl_normtest_matrix (const double *y,
                       int t1,
                       int t2,
                       gretlopt opt,
                       int *err);

acf_matrix ()

gretl_matrix *
acf_matrix (const double *x,
            int order,
            const DATASET *dset,
            int n,
            int *err);

Computes the autocorrelation function for series x with maximum lag order .

xcf_vec ()

gretl_matrix *
xcf_vec (const double *x,
         const double *y,
         int p,
         const DATASET *dset,
         int n,
         int *err);

Computes the cross-correlation function for series x with series y up to maximum lag order .

ljung_box ()

double
ljung_box (int m,
           int t1,
           int t2,
           const double *y,
           int *err);

MahalDist

typedef struct MahalDist_ MahalDist;

Summary

typedef struct {
    gretlopt opt;
    int n;
    int weight_var;
    int *misscount;
    int *list;
    double *stats;
    double *mean;
    double *median;
    double *sd;
    double *skew;

    double *xkurt;
    double *low;
    double *high;
    double *cv;
    double *perc05;
    double *perc95;
    double *iqr;
    double sw;
    double sb;
} Summary;

FreqDist

typedef struct {
    char varname[VNAMELEN];  /* for ID purposes */
    int discrete;            /* 1 if series contains integers */
    int strvals;             /* 1 if series is string-valued */
    int dist;                /* code for theoretical distribution */
    int numbins;             /* number of bins or intervals */
    double xbar, sdx;        /* mean and std dev of variable */
    double *midpt;           /* array of midpoints of intervals */
    double *endpt;           /* array of endpoints of intervals */
    char **S;                /* array of string values */
    int *f;                  /* frequencies */
    double test;             /* Chi-squared statistic for testing for a
                                Gaussian distribution, or z statistic
			        for testing for Gamma dist. */
    int n;                   /* included observation */
    int t1, t2;              /* sample limits */
} FreqDist;

Xtab

typedef struct {
    char rvarname[VNAMELEN]; /* name of rows series */
    char cvarname[VNAMELEN]; /* name of cols series */
    char **Sr;               /* array of row string values */
    char **Sc;               /* array of column string values */
    int rows, cols;          /* dimensions of table */
    double *rval, *cval;     /* row and column numeric values */
    int *rtotal, *ctotal;    /* marginal totals */
    int **f;                 /* array of frequencies */
    int n, missing;          /* observation counts */
    int t1, t2;              /* sample limits */
    int rstrs;               /* row string-valued flag */
    int cstrs;               /* col string-valued flag */
} Xtab;