gretl_list_new ()

int *               gretl_list_new                      (int nterms);

Creates a newly allocated list with space for nterms elements, besides the leading element, which in a gretl list always holds a count of the number of elements that follow. This leading element is initialized appropriately. For example, if nterms = 4, space for 5 integers is allocated and the first element of the array is set to 4. The other elements of the list are initialized to 0.

gretl_list_resize ()

int *               gretl_list_resize                   (int **oldlist,
                                                         int nterms);

Resizes the content of oldlist to hold nterms, and adjusts the first element to reflect the new size. If the new list is longer than the old, the extra elements are initialized to zero.

gretl_list_append_term ()

int *               gretl_list_append_term              (int **plist,
                                                         int v);

Resizes (or allocates from scratch) the content of plist, so that it can hold one extra element, and sets the last element to v.

gretl_list_sort ()

int *               gretl_list_sort                     (int *list);

Sorts the elements from position 1 to the end of list in ascending order.

gretl_list_cmp ()

int                 gretl_list_cmp                      (const int *list1,
                                                         const int *list2);

gretl_null_list ()

int *               gretl_null_list                     (void);

Creates a newly allocated "list" with only one member, which is set to zero.

gretl_consecutive_list_new ()

int *               gretl_consecutive_list_new          (int lmin,
                                                         int lmax);

Creates a newly allocated list whose elements run from lmin to lmax consecutively.

gretl_list_copy ()

int *               gretl_list_copy                     (const int *src);

gretl_list_copy_from_pos ()

int *               gretl_list_copy_from_pos            (const int *src,
                                                         int pos);

gretl_list_from_string ()

int *               gretl_list_from_string              (const char *str,
                                                         int *err);

Reads a string containing a list of integers, separated by spaces and/or commas and possibly wrapped in parentheses, and constructs an array of these integers. The first element is the number of integers that follow. This function supports an abbreviation for consecutive (increasing) integers in the list, using the notation, e.g., "1-4" as shorthand for "1 2 3 4".

gretl_list_to_string ()

char *              gretl_list_to_string                (const int *list);

Prints the given list of integers into a newly allocated string, separated by single spaces and with one leading space. This function is designed to handle positive integers in a range that is sensible for ID numbers of variables, typically with three digits or less, and will fail if the list contains any numbers greater than 9998.

gretl_list_to_lags_string ()

char *              gretl_list_to_lags_string           (const int *list,
                                                         int *err);

Prints the given list of integers into a newly allocated string, separated by commas. Will fail if the list contains any numbers greater than 998.

in_gretl_list ()

int                 in_gretl_list                       (const int *list,
                                                         int k);

Checks whether k is present among the members of list, in position 1 or higher.

gretl_list_delete_at_pos ()

int                 gretl_list_delete_at_pos            (int *list,
                                                         int pos);

Deletes the element at position pos from list and moves any remaining elements forward. Decrements the value of the first, counter, element of list.

gretl_list_purge_const ()

int                 gretl_list_purge_const              (int *list,
                                                         const double **Z,
                                                         const DATAINFO *pdinfo);

Checks list from position 1 onward for the presence of a variable whose valid values in sample all equal 1.0. If such a variable is found, it is deleted from list (that is, any following elements are moved forward by one and list[0] is decremented by 1).

gretl_list_add ()

int *               gretl_list_add                      (const int *orig,
                                                         const int *add,
                                                         int *err);

Creates a list containing the union of elements of orig and the elements of add. If one or more elements of add were already present in orig, the error code is E_ADDDUP.

gretl_list_union ()

int *               gretl_list_union                    (const int *l1,
                                                         const int *l2,
                                                         int *err);

Creates a list holding the union of l1 and l2.

gretl_list_intersection ()

int *               gretl_list_intersection             (const int *l1,
                                                         const int *l2,
                                                         int *err);

Creates a list holding the intersection of l1 and l2.

gretl_list_omit ()

int *               gretl_list_omit                     (const int *orig,
                                                         const int *omit,
                                                         int minpos,
                                                         int *err);

Creates a list containing the elements of orig that are not present in omit. It is an error if the omit list contains members that are not present in orig.

gretl_list_omit_last ()

int *               gretl_list_omit_last                (const int *orig,
                                                         int *err);

Creates a list containing all but the last element of orig.

gretl_list_drop ()

int *               gretl_list_drop                     (const int *orig,
                                                         const int *drop,
                                                         int *err);

Creates a list containing the elements of orig that are not present in drop. Unlike gretl_list_omit(), processing always starts from position 1 in orig, and it is not an error if some members of drop are not present in orig.

gretl_list_diff ()

int                 gretl_list_diff                     (int *targ,
                                                         const int *biglist,
                                                         const int *sublist);

Fills out targ with the elements of biglist, from position 2 onwards, that are not present in sublist. It is assumed that the variable ID number in position 1 (dependent variable) is the same in both lists. It is an error if, from position 2 on, sublist is not a proper subset of biglist. See also gretl_list_diff_new.

gretl_list_diff_new ()

int *               gretl_list_diff_new                 (const int *biglist,
                                                         const int *sublist,
                                                         int minpos);

gretl_list_build ()

int *               gretl_list_build                    (const char *s,
                                                         const DATAINFO *pdinfo,
                                                         int *err);

Builds a list based on the specification in s, which may include the ID numbers of variables, the names of variables, and/or the names of previously defined lists (all separated by spaces).

gretl_list_add_list ()

int                 gretl_list_add_list                 (int **targ,
                                                         const int *src);

Adds src onto the end of targ. The length of targ becomes the sum of the lengths of the two original lists.

gretl_list_insert_list ()

int                 gretl_list_insert_list              (int **targ,
                                                         const int *src,
                                                         int pos);

Inserts src into targ at pos. The length of targ becomes the sum of the lengths of the two original lists.

gretl_list_insert_list_minus ()

int                 gretl_list_insert_list_minus        (int **targ,
                                                         const int *src,
                                                         int pos);

Inserts src into targ at pos. The length of targ becomes the sum of the lengths of the two original lists minus one. This can be useful if we were expecting to insert a single variable but found we had to insert a list instead. Insertion of src overwrites any entries in targ beyond pos (the expectation is that this function will be called in the process of assembling targ, in left-to-right mode).

reglist_check_for_const ()

int                 reglist_check_for_const             (int *list,
                                                         const double **Z,
                                                         const DATAINFO *pdinfo);

Checks list for an intercept term (a variable all of whose valid values in sample are 1). If such a variable is present, it is moved to position 2 in the list.

gretl_list_const_pos ()

int                 gretl_list_const_pos                (const int *list,
                                                         int minpos,
                                                         const double **Z,
                                                         const DATAINFO *pdinfo);

Checks list for the presence, in position minpos or higher, of a variable whose valid values in sample all equal 1. This usually amounts to checking whether a list of regressors includes an intercept term.

list_members_replaced ()

int                 list_members_replaced               (const int *list,
                                                         const DATAINFO *pdinfo,
                                                         int ref_id);

Checks whether any variable in list has been redefined via gretl's genr command since a previous model (identified by ref_id) was estimated.

gretl_list_position ()

int                 gretl_list_position                 (int v,
                                                         const int *list);

Scans list, from position 1 onward, for variable v. In case the list contains a list separator, LISTSEP, only the portion prior to the separator is considered.

gretl_list_separator_position ()

int                 gretl_list_separator_position       (const int *list);

gretl_list_has_separator ()

int                 gretl_list_has_separator            (const int *list);

gretl_list_is_consecutive ()

int                 gretl_list_is_consecutive           (const int *list);

gretl_list_split_on_separator ()

int                 gretl_list_split_on_separator       (const int *list,
                                                         int **plist1,
                                                         int **plist2);

If list contains the list separator, LISTSEP, creates two sub-lists, one containing the elements of list preceding the separator and one containing the elements following the separator. The sub-lists are newly allocated, and assigned as the content of plist1 and plist2 respectively.

gretl_lists_join_with_separator ()

int *               gretl_lists_join_with_separator     (const int *list1,
                                                         const int *list2);

Concatenates the content of list2 onto list1, after first appending the list separator. It is acceptable that list1 be NULL, in which case the returned list is just list2 with the separator prepended. But it is not acceptable that list2 be null; in that this function returns NULL.

gretl_list_duplicates ()

int                 gretl_list_duplicates               (const int *list,
                                                         GretlCmdIndex ci);

Checks whether or not a gretl list contains duplicated elements. Exactly what counts as duplication depends on the context of the command in which list will be used, which is given by ci.

gretl_lists_share_members ()

int                 gretl_lists_share_members           (const int *list1,
                                                         const int *list2);

full_var_list ()

int *               full_var_list                       (const DATAINFO *pdinfo,
                                                         int *nvars);

Creates a newly allocated list including all variables in the dataset that are not scalars, are not hidden variables, and are accessible at the current level of function execution. The return value is NULL in case either (a) allocation of memory failed, or (b) the resulting list would be empty. The caller can distinguish between these possibilities by examining the value returned in nvars, which will be zero if and only if the resulting list would be empty. If this is not of interest to the caller, nvars may be given as NULL.

n_saved_lists ()

int                 n_saved_lists                       (void);

max_varno_in_saved_lists ()

int                 max_varno_in_saved_lists            (void);

get_list_name_by_index ()

const char *        get_list_name_by_index              (int idx);

get_list_by_name ()

int *               get_list_by_name                    (const char *name);

Looks up name in the stack of saved lists, at the current level of function execution, and retrieves the associated list.

append_to_list_by_name ()

int                 append_to_list_by_name              (const char *targ,
                                                         const int *add);

If targ is the name of a saved list, append the list add to it.

subtract_from_list_by_name ()

int                 subtract_from_list_by_name          (const char *targ,
                                                         const int *sub);

If targ is the name of a saved list, remove from targ any elements of sub that it contains.

replace_list_by_name ()

int                 replace_list_by_name                (const char *targ,
                                                         const int *src);

If targ is the name of a saved list, replace the list of that name with src.

remember_list ()

int                 remember_list                       (const int *list,
                                                         const char *name,
                                                         PRN *prn);

Adds a copy of list to the stack of saved lists and associates it with name, unless there is already a list with the given name in which case the original list is replaced. A status message is printed to prn.

copy_named_list_as ()

int                 copy_named_list_as                  (const char *orig,
                                                         const char *newname);

If a saved list is found by the name orig, a copy of this list is added to the stack of saved lists under the name newname. This is intended for use when a list is given as the argument to a user-defined function: it is copied under the name assigned by the function's parameter list.

named_list_lower_level ()

int                 named_list_lower_level              (const char *name);

If a saved list is found by the name name, at the current level of function execution, lower its level by 1. This is intended for use when a list is returned by a user-defined function: it is shifted to the level of the caller.

rename_saved_list ()

int                 rename_saved_list                   (const char *orig,
                                                         const char *newname);

Renames a saved list from orig to new. If there is already a list called newname, it is destroyed.

create_named_null_list ()

int                 create_named_null_list              (const char *name);

Creates an empty list under the given name and adds it to the stack of saved lists at the next level of function execution. This is intended for use when a null list is given as an argument to a user-defined function.

delete_list_by_name ()

int                 delete_list_by_name                 (const char *name);

destroy_saved_lists_at_level ()

int                 destroy_saved_lists_at_level        (int level);

Destroys and removes from the stack of saved lists all lists that were created at the given level. This is part of the cleanup that is performed when a user-defined function terminates.

gretl_lists_revise ()

int                 gretl_lists_revise                  (const int *dlist,
                                                         int dmin);

Goes through any saved lists, adjusting the ID numbers they contain to reflect the deletion from the dataset of certain variables: those referenced in dlist, if given, or if dlist is NULL, those variables with IDs greater than or equal to dmin.

gretl_lists_cleanup ()

void                gretl_lists_cleanup                 (void);

Frees all resources associated with the internal apparatus for saving and retrieving named lists.

load_user_lists_file ()

int                 load_user_lists_file                (const char *fname);

gretl_serialize_lists ()

int                 gretl_serialize_lists               (const char *fname);

Prints an XML representation of the current saved lists, if any.

gretl_list_print ()

void                gretl_list_print                    (const char *lname,
                                                         const DATAINFO *pdinfo,
                                                         PRN *prn);

Prints to prn the given list of variables, by name.

varname_match_list ()

int *               varname_match_list                  (const DATAINFO *pdinfo,
                                                         const char *pattern);

varname_match_any ()

int                 varname_match_any                   (const DATAINFO *pdinfo,
                                                         const char *pattern);