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_from_string ()

int*        gretl_list_from_string          (const char *liststr);

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.

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 999.

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_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.

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_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_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.

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 (if any) and retrieves the associated list.

remember_list ()

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

Adds 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 *new);

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 new. 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 *new);

Overwrites the name of a saved list.

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.

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.