default_lag_order ()

int                 default_lag_order                   (const DATAINFO *pdinfo);

is_standard_lag ()

int                 is_standard_lag                     (int v,
                                                         const DATAINFO *pdinfo,
                                                         int *parent);

is_standard_diff ()

int                 is_standard_diff                    (int v,
                                                         const DATAINFO *pdinfo,
                                                         int *parent);

is_dummy_child ()

int                 is_dummy_child                      (int v,
                                                         const DATAINFO *pdinfo,
                                                         int *parent);

diffgenr ()

int                 diffgenr                            (int v,
                                                         int ci,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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

loggenr ()

int                 loggenr                             (int v,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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

invgenr ()

int                 invgenr                             (int v,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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

xpxgenr ()

int                 xpxgenr                             (int vi,
                                                         int vj,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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

list_laggenr ()

int                 list_laggenr                        (int **plist,
                                                         int order,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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

laggenr_from_to ()

int *               laggenr_from_to                     (int v,
                                                         int minlag,
                                                         int maxlag,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo,
                                                         int *err);

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

list_loggenr ()

int                 list_loggenr                        (int *list,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo);

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

list_xpxgenr ()

int                 list_xpxgenr                        (int **plist,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo,
                                                         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,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo,
                                                         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,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo,
                                                         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).

list_makediscrete ()

int                 list_makediscrete                   (const int *list,
                                                         DATAINFO *pdinfo,
                                                         gretlopt opt);

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

gettrend ()

int                 gettrend                            (double ***pZ,
                                                         DATAINFO *pdinfo,
                                                         int square);

gretl_transforms_cleanup ()

void                gretl_transforms_cleanup            (void);