default_lag_order ()

int
default_lag_order (const DATASET *dset);

standard_lag_of ()

int
standard_lag_of (int v,
                 int parent,
                 const DATASET *dset);

is_standard_diff ()

int
is_standard_diff (int v,
                  const DATASET *dset,
                  int *parent);

diffgenr ()

int
diffgenr (int v,
          int ci,
          DATASET *dset);

Creates the first difference (or log- or seasonal difference, depending on the value of ci ) of variable v , if the differenced variable does not already exist.

laggenr ()

int
laggenr (int v,
         int lag,
         DATASET *dset);

Creates the specified lag of variable v if this variable does not already exist.

loggenr ()

int
loggenr (int v,
         DATASET *dset);

Creates the natural log of variable v if this variable does not already exist.

invgenr ()

int
invgenr (int v,
         DATASET *dset);

Creates the reciprocal of variable v if this variable does not already exist.

xpxgenr ()

int
xpxgenr (int vi,
         int vj,
         DATASET *dset);

Creates the cross product of variables vi and vj if this variable does not already exist.

list_diffgenr ()

int
list_diffgenr (int *list,
               int ci,
               DATASET *dset);

Generate differences of the variables in list , and add them to the data set. If ci is DIFF these are ordinary first differences; if ci is LDIFF they are log differences; and if ci is SDIFF they are seasonal differences.

list_orthdev ()

int
list_orthdev (int *list,
              DATASET *dset);

Generate orthogonal deviations of the variables in list , and add them to the data set.

list_resample ()

int
list_resample (int *list,
               DATASET *dset);

list_dropcoll ()

int
list_dropcoll (int *list,
               double eps,
               DATASET *dset);

Drop collinear variables from list .

list_laggenr ()

int
list_laggenr (int **plist,
              int lmin,
              int lmax,
              const gretl_matrix *lvec,
              DATASET *dset,
              int compfac,
              gretlopt opt);

Generates and adds to the data set lagged values of the variables given in the list pointed to by plist .

laggenr_from_to ()

int *
laggenr_from_to (int v,
                 int fromlag,
                 int tolag,
                 DATASET *dset,
                 int *err);

Creates the specified lags of variable v if they do not already exist.

list_loggenr ()

int
list_loggenr (int *list,
              DATASET *dset);

Generates and adds to the data set the natural logs of the variables given in list .

list_stdgenr ()

int
list_stdgenr (int *list,
              DATASET *dset,
              gretlopt opt);

Generates and adds to the dataset standardized versions of the series given in list .

list_xpxgenr ()

int
list_xpxgenr (int **plist,
              DATASET *dset,
              gretlopt opt);

Generates and adds to the data set squares and (if opt is OPT_O) cross-products of the variables given in the list pointed to by plist .

list_dumgenr ()

int
list_dumgenr (int **plist,
              DATASET *dset,
              gretlopt opt);

For each of the variables given in the list to which plist points, generates and adds to the data set k dummy variables coding for the k distinct values of the variable in question. All these variables must have already been marked as discrete. If the OPT_F or OPT_L option is given, either the first or the last value of each variable is taken as the "base" and is not given a dummy encoding (that is, only k - 1 dummies are added for each variable).

dumgenr_with_oddval ()

int
dumgenr_with_oddval (int **plist,
                     DATASET *dset,
                     double oddval);

For each of the variables given in the list to which plist points, generates and adds to the data set k dummy variables coding for the k distinct values of the variable in question. All these variables must have already been marked as discrete. if oddval is not NADBL, it is treated as the omitted category and only k - 1 dummies are added for each variable).

auto_dummify_list ()

int
auto_dummify_list (int **plist,
                   DATASET *dset);

Produces a list in which any coded series in the original list are replaced by a set of dummy variables. If the original list contains no such series it is not altered. In generating dummy series, the omitted category is the minimum value of the coding variable.

list_makediscrete ()

int
list_makediscrete (const int *list,
                   DATASET *dset,
                   gretlopt opt);

Sets the variables given in list as discrete, unless opt is OPT_R, in which case the variables are set as continuous.

hf_list_diffgenr ()

int
hf_list_diffgenr (int *list,
                  int ci,
                  double parm,
                  DATASET *dset);

Generate high-frequency differences of the variables in list and add them to the data set. If ci is DIFF these are ordinary first differences; if ci is LDIFF they are log differences. If parm is not NA then the new series are all multiplied by the specified value (as in multiplication of log-differences by 100).

gretl_transforms_cleanup ()

void
gretl_transforms_cleanup (void);

Called by libgretl_cleanup(). Frees any memory allocated as workspace for the creation of transformed variables.