/**************************************************************************** ** *A list.h GAP source Martin Schoenert ** *H @(#)$Id: list.h,v 3.9 1994/01/28 12:26:12 fceller Rel $ ** *Y Copyright 1990-1992, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ** ** This file declares the functions and macros that make it possible to ** access all various types of lists in a homogenous way. ** ** This package serves two purposes. First it provides a uniform interface ** to the functions that access lists and their elements for the other ** packages in the GAP kernel. For example, 'EvFor' can loop over the ** elements in a list with the macros 'LEN_LIST' and 'ELM_LIST' independent ** of the type of the list. Second it implements the functions that make ** the list functionality available to the GAP evaluator, e.g., it ** implements 'EvElmList' and 'EvIn'. ** *H $Log: list.h,v $ *H Revision 3.9 1994/01/28 12:26:12 fceller *H added 'DepthVector' *H *H Revision 3.8 1993/02/04 10:51:10 martin *H changed to the new list interface *H *H Revision 3.7 1992/12/08 11:50:26 martin *H added '{}' *H *H Revision 3.6 1992/01/06 14:03:27 martin *H changed the implementation of '~' slightly *H *H Revision 3.5 1992/01/02 14:44:34 martin *H added magic variable '~' *H *H Revision 3.4 1991/04/30 16:12:27 martin *H initial revision under RCS *H *H Revision 3.3 1990/12/19 12:00:00 martin *H improved 'Position' to accept a starting position *H *H Revision 3.2 1990/12/19 12:00:00 martin *H improved the list like objects package interface *H *H Revision 3.1 1990/12/06 12:00:00 martin *H added yet another list package *H *H Revision 3.0 1990/11/20 12:00:00 martin *H added new list package */ /**************************************************************************** ** *F IS_LIST() . . . . . . . . . . . . . . . . . . is an object a list *V TabIsList[] . . . . . . . . . . . . . . . . . . table for list test ** ** 'IS_LIST' returns 1 if the object is a list and 0 otherwise. ** ** Note that 'IS_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'IS_LIST' simply returns the value in 'TabIsList'. ** ** A package implementing a list type must set this value to 1. If the list ** type is actually a vector type, then it must be set to 2, and the ** corresponding entry for the extended matrix type must be set to 3. */ #define IS_LIST(LIST) (TabIsList[TYPE(LIST)] != 0) extern long TabIsList [T_VAR]; /**************************************************************************** ** *F LEN_LIST() . . . . . . . . . . . . . . . . . . length of a list *V TabLenList[] . . . . . . . . . . . . . . table of length functions *F CantLenList() . . . . . . . . . . . . . . . error length function ** ** 'LEN_LIST' returns the logical length of the list as a C ** integer. An error is signalled if is not a list. ** ** Note that 'LEN_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'LEN_LIST' only calls the function pointed to by 'TabLenList[]', ** passing as argument. If is not the type of a list, then ** 'TabLenList[]' points to 'CantLenList', which just signals an ** error. ** ** A package implementing a list type must provide such a function and ** install it in 'TabLenList'. */ #define LEN_LIST(LIST) ((*TabLenList[TYPE(LIST)])(LIST)) extern long (*TabLenList[T_VAR]) P(( TypHandle )); extern long CantLenList P(( TypHandle hdList )); /**************************************************************************** ** *F ELM_LIST(,) . . . . . . . . . select an element from a list *V TabElmList[] . . . . . . . . . . . . table of selection functions *F ELMF_LIST(,) . . . select an element from a list w/o checks *V TabElmfList[] . . . . . . . . . . table of fast selection functions *F ELML_LIST(,) . . . . . . . . . select an element from a list *V TabElmlList[] . . . . . . . . . . . . table of selection functions *F ELMR_LIST(,) . . . . . . . . . select an element from a list *V TabElmrList[] . . . . . . . . . . . . table of selection functions *F CantElmList(,) . . . . . . . . . . error selection function ** ** 'ELM_LIST' returns the handle of the element at position in the ** list . It is the responsibility of the caller to ensure that ** is positive. An error is signalled if is not a list, if ** has no assigned value at position , or if is larger ** than 'LEN_LIST()'. ** ** Note that 'ELM_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'ELMF_LIST' does the same thing as 'ELM_LIST', but the functions ** implementing this do not need to check that is less than or equal ** to 'LEN_LIST()'. Also 'ELMF_LIST' returns 0 if has no ** assigned value at the position . It is thus the responsibility of ** the caller to ensure that is positive and less than or equal to ** 'LEN_LIST()'. ** ** 'ELML_LIST' does the same thing as 'ELMF_LIST', but the functions ** implementing this are allowed to select the elements into a fixed bag, ** that will be overwritten by the next call to 'ELML_LIST'. ** ** 'ELMR_LIST' does the same thing as 'ELML_LIST' but uses a different fixed ** bag than 'ELML_LIST'. ** ** 'ELML_LIST' and 'ELMR_LIST' are used in the generic comparison functions. ** There the elements selected are only compared and can be overwritten ** afterwards. This makes it possible to implement the comparison functions ** in such a way that they do not allocate new memory. ** *N 1992/12/08 martin this is critical if the comparison recurses ** ** 'ELM_LIST' only calls the function pointed to by 'TabElmList[]', ** passing and as arguments. If is not the type of a ** list, then 'TabElmList[]' points to 'CantElmList', which just ** signals an error. ** ** A package implementing a list type must provide such functions and ** install them in 'TabElmList', 'TabElmfList', 'TabElmlList', and ** 'TabElmrList'. */ #define ELM_LIST(LIST,POS) ((*TabElmList[TYPE(LIST)])(LIST,POS)) #define ELMF_LIST(LIST,POS) ((*TabElmfList[TYPE(LIST)])(LIST,POS)) #define ELML_LIST(LIST,POS) ((*TabElmlList[TYPE(LIST)])(LIST,POS)) #define ELMR_LIST(LIST,POS) ((*TabElmrList[TYPE(LIST)])(LIST,POS)) extern TypHandle (*TabElmList[T_VAR]) P(( TypHandle, long )); extern TypHandle (*TabElmfList[T_VAR]) P(( TypHandle, long )); extern TypHandle (*TabElmlList[T_VAR]) P(( TypHandle, long )); extern TypHandle (*TabElmrList[T_VAR]) P(( TypHandle, long )); extern TypHandle CantElmList P(( TypHandle hdList, long pos )); /**************************************************************************** ** *F ELMS_LIST(,) . . . . . . . select a sublist from a list *V TabElmsList[] . . . . . . . . table of sublist selection functions *F CantElmsList(,) . . . . error sublist selection function ** ** 'ELMS_LIST' returns a new list containing the elements at the positions ** given in the list from the list . It is the ** responsibility of the caller to ensure that is dense and ** contains only positive integers. An error is signalled if is ** not a list, if has no assigned value at any of the positions in ** , or if an element of is larger than ** 'LEN_LIST()'. ** ** Note that 'ELMS_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'ELMS_LIST' only calls the function pointed to by 'TabElmsList[]', ** passing and as arguments. If is not the type of ** a list, then 'TabElmsList[]' points to 'CantElmsList', which just ** signals an error. ** ** Note that functions implementing 'ELMS_LIST' *must* create a new list, ** even if is equal to '[1..Length()]'. 'EvElmsList' ** depends on this. */ #define ELMS_LIST(LIST,POSS) ((*TabElmsList[TYPE(LIST)])(LIST,POSS)) extern TypHandle (*TabElmsList[T_VAR]) P(( TypHandle, TypHandle )); extern TypHandle CantElmsList P(( TypHandle hdList, TypHandle hdPoss )); /**************************************************************************** ** *F ASS_LIST(,,) . . . . . . . . . . . assign to a list *V TabAssList[] . . . . . . . . . . . . table of assignment functions *F CantAssList(,,) . . . . . . error assignment function ** ** 'ASS_LIST' assigns the object to the list at the ** position . Note that the assignment may change the type of the list ** . It is the responsibility of the caller to ensure that is ** positive, and that is not 'HdVoid'. An error is signalled if ** is not a list. ** ** Note that 'ASS_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'ASS_LIST' only calls the function pointed to by 'TabAssList[]', ** passing , , and as arguments. If is not the ** type of a list, then 'TabAssList[]' points to 'CantAssList', which ** just signals an error. */ #define ASS_LIST(LIST,POS,VAL) ((*TabAssList[TYPE(LIST)])(LIST,POS,VAL)) extern TypHandle (*TabAssList[T_VAR]) P(( TypHandle, long, TypHandle )); extern TypHandle CantAssList P(( TypHandle hdList, long pos, TypHandle hdVal )); /**************************************************************************** ** *F ASSS_LIST(,,) . assign several elements to a list *V TabAsssList[] . . . . . . . . . . . . table of assignment function *F CantAsssList(,,) . . . error assignment function ** ** 'ASSS_LIST' assignes the values from the list at the positions ** given in the list to the list . It is the ** responsibility of the caller to ensure that is dense and ** contains only positive integers, that and have the same ** length, and that is dense. An error is signalled if is ** not a list. ** ** Note that 'ASSS_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'ASSS_LIST' only calls the function pointed to by 'TabAsssList[]', ** passing , , and as arguments. If is not ** the type of a list, then 'TabAsssList[]' points to 'CantAsssList', ** which just signals an error. */ #define ASSS_LIST(LI,POSS,VALS) ((*TabAsssList[TYPE(LI)])(LI,POSS,VALS)) extern TypHandle (*TabAsssList[T_VAR]) P(( TypHandle, TypHandle, TypHandle )); extern TypHandle CantAsssList P(( TypHandle hdList, TypHandle hdPoss, TypHandle hdVals )); /**************************************************************************** ** *F POS_LIST(,,) . . . . . . find an element in a list *V TabPosList[] . . . . . . . . . . . . table of searching functions *F CantPosList(,,) . . . . . error searching function ** ** 'POS_LIST' returns the position of the first occurence of the value ** , which may be an object of arbitrary type, in the list ** after the position as a C integer. 0 is returned if is ** not in the list. An error is signalled if is not a list. ** ** Note that 'POS_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'POS_LIST' only calls the function pointed to by 'TabPosList[]', ** passing , , and as arguments. If is not ** the type of a list, then 'TabPosList[]' points to 'CantPosList', ** which just signals an error. */ #define POS_LIST(LIST,VAL,START) ((*TabPosList[TYPE(LIST)])(LIST,VAL,START)) extern long (*TabPosList[T_VAR]) P(( TypHandle, TypHandle, long )); extern long CantPosList P(( TypHandle hdList, TypHandle hdVal, long start )); /**************************************************************************** ** *F PLAIN_LIST() . . . . . . . . . . convert a list to a plain list *V TabPlainList[] . . . . . . . . . . . table of conversion functions *F CantPlainList() . . . . . . . . . . . . error conversion function ** ** 'PLAIN_LIST' converts the list to a plain list, e.g., one that ** has the same representation as lists of type 'T_LIST', *in place*. Note ** that the type of need not be 'T_LIST' afterwards, it could also ** be 'T_SET' or 'T_VECTOR'. An error is signalled if is not a ** list. ** ** Note that 'PLAIN_LIST' is a macro, so do not call it with arguments that ** have sideeffects. ** ** 'PLAIN_LIST' only calls the function pointed to by ** 'TabPlainList[]', passing as argument. If is not ** the type of a list, then 'TabPlainList[]' points to ** 'CantPlainList', which just signals an error. */ #define PLAIN_LIST(LIST) ((*TabPlainList[TYPE(LIST)])(LIST)) extern void (*TabPlainList[T_VAR]) P(( TypHandle )); extern void CantPlainList P(( TypHandle hdList )); /*N 1992/12/11 martin only here for backward compatibility */ extern long IsList P(( TypHandle hdObj )); /**************************************************************************** ** *F IS_DENSE_LIST() . . . . . . . . . . . . . . test for dense lists *V TabIsDenseList[] . . . . . . . table for dense list test functions *F NotIsDenseList() . . . . . dense list test function for non lists ** ** 'IS_DENSE_LIST' returns 1 if the list is a dense list and 0 ** otherwise, i.e., if either is not a list, or if it is not dense. ** ** 'IS_DENSE_LIST' only calls the function pointed to by ** 'TabIsDenseList[]', passing as argument. If is not ** the type of a list, then 'TabIsDenseList[]' points to ** 'NotIsDenseList', which just returns 0. */ #define IS_DENSE_LIST(LIST) ((*TabIsDenseList[TYPE(LIST)])(LIST)) extern long (*TabIsDenseList[T_VAR]) P(( TypHandle )); extern long NotIsDenseList P(( TypHandle hdObj )); /**************************************************************************** ** *F IS_POSS_LIST() . . . . . . . . . . . . test for positions lists *V TabIsPossList[] . . . . . . . table of positions list test function *F NotIsPossList() . . . positions list test function for non lists ** ** 'IS_POSS_LIST' returns 1 if the list is a dense list containing ** only positive integers and 0 otherwise, i.e., if either is not ** a list, or if it is not dense, or if it contains an element that is not a ** positive integer. ** ** 'IS_POSS_LIST' only calls the function pointed to by ** 'TabIsPossList[]', passing as argument. If is not ** the type of a list, then 'TabIsPossList[]' points to ** 'NotIsPossList', which just returns 0. */ #define IS_POSS_LIST(LIST) ((*TabIsPossList[TYPE(LIST)])(LIST)) extern long (*TabIsPossList[T_VAR]) P(( TypHandle )); extern long NotIsPossList P(( TypHandle hdObj )); /**************************************************************************** ** *F XType() . . . . . . . . . . . . . . . extended type of an object *F IS_XTYPE_LIST(,) . . . . . . . . . test for extended type *V TabIsXTypeList[] . . . . . . table of extended type test functions ** ** 'XType' returns the extended type of the object . For everything ** except objects of type 'T_LIST' and 'T_SET' this is just the type of this ** object. For objects of type 'T_LIST' and 'T_SET' 'XType' examines the ** objects closer and returns 'T_VECTOR', 'T_VECFFE', 'T_BLIST', 'T_STRING', ** 'T_RANGE', 'T_MATRIX', 'T_MATFFE', and 'T_LISTX'. As a sideeffect the ** object is converted into the representation of the extended type, ** e.g., if 'XType' returns 'T_MATFFE', is converted into a list of ** vectors over a common finite field. 'XType' is used by the binary ** operations functions for lists to decide to which function they should ** dispatch. 'T_LISTX' is the extended type of otherwise untypable lists. ** The only operation defined for such lists is the product with a scalar ** (where 'PROD( [], )' decides whether the multiplication ** is allowed or not). ** ** 'XType' calls 'IS_XTYPE_LIST(,)' with running from ** 'T_VECTOR' to 'T_MATFFE' and returns the first type for which this ** function returns 1. If no one returns 1, then 'XType' returns 'T_LISTX' ** (and leaves the list as 'T_LIST' or 'T_SET'). */ #define IS_XTYPE_LIST(T,LIST) ((*TabIsXTypeList[T])(LIST)) extern long (*TabIsXTypeList[T_VAR]) P(( TypHandle )); extern long XType P(( TypHandle hdObj )); /**************************************************************************** ** *F EvList() . . . . . . . . . . . . . . . . . . . . evaluate a list ** ** 'EvList' returns the value of the list . The value of a list is ** just the list itself, since lists are constants and thus selfevaluating. */ extern TypHandle EvList P(( TypHandle hdList )); /**************************************************************************** ** *F PrList() . . . . . . . . . . . . . . . . . . . . . print a list ** ** 'PrList' prints the list . It is a generic function that can be ** used for all kinds of lists. ** ** Linebreaks are preferred after the commas. */ extern void PrList P(( TypHandle hdList )); /**************************************************************************** ** *F EqList(,) . . . . . . . . . . . . . test if two lists are equal ** ** 'EqList' returns 'true' if the two lists and are equal and ** 'false' otherwise. This is a generic function that works for all kinds ** of lists. ** ** Is called from the 'EQ' binop so both operands are already evaluated. */ extern TypHandle EqList P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F LtList(,) . . . . . . . . . . . . . test if two lists are equal ** ** 'LtList' returns 'true' if the list is less than the list and ** 'false' otherwise. ** ** Is called from the 'LT' binop so both operands are already evaluated. */ extern TypHandle LtList P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F SumList(,) . . . . . . . . . . . . . . . . . . . sum of lists *F SumSclList(,) . . . . . . . . . . . sum of a scalar and a list *F SumListScl(,) . . . . . . . . . . . sum of a list and a scalar *F SumListList(,) . . . . . . . . . . . . . . . sum of two lists ** ** 'SumList' is the generic dispatcher for the sums involving lists. That ** is, whenever two lists are added and 'TabSum' does not point to a special ** routine then 'SumList' is called. 'SumList' determines the extended ** types of the arguments (e.g., including 'T_MATRIX', 'T_MATFFE', and ** 'T_LISTX') and then dispatches through 'TabSum' again. ** ** 'SumSclList' is a generic function for the first kind of sum, that of a ** scalar with a list. ** ** 'SumListScl' is a generic function for the second kind of sum, that of a ** list and a scalar. ** ** 'SumListList' is a generic function for the third kind of sum, that of ** two lists. */ extern TypHandle SumList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle SumSclList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle SumListScl P(( TypHandle hdL, TypHandle hdR )); extern TypHandle SumListList P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F DiffList(,) . . . . . . . . . . . . . . . . difference of lists *F DiffSclList(,) . . . . . . . difference of a scalar and a list *F DiffListScl(,) . . . . . . . difference of a list and a scalar *F DiffListList(,) . . . . . . . . . . . . difference of two lists ** ** 'DiffList' is the generic dispatcher for the differences involving lists. ** That is, whenever two lists are subtracted and 'TabDiff' does not point ** to a special routine then 'DiffList' is called. 'DiffList' determines ** the extended types of the arguments (e.g., including 'T_MATRIX', ** 'T_MATFFE', and 'T_LISTX') and then dispatches through 'TabDiff' again. ** ** 'DiffSclList' is a generic function for the first kind of difference, ** that of a scalar with a list. ** ** 'DiffListScl' is a generic function for the second kind of difference, ** that of a list and a scalar. ** ** 'DiffListList' is a generic function for the third kind of difference, ** that of two lists. */ extern TypHandle DiffList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle DiffSclList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle DiffListScl P(( TypHandle hdL, TypHandle hdR )); extern TypHandle DiffListList P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F ProdList(,) . . . . . . . . . . . . . . . . . product of lists *F ProdSclList(,) . . . . . . . . product of a scalar and a list *F ProdListScl(,) . . . . . . . . product of a list and a scalar *F ProdListList(,) . . . . . . . . . . . . . product of two lists ** ** 'ProdList' is the generic dispatcher for the products involving lists. ** That is, whenever two lists are multiplied and 'TabProd' does not point ** to a special routine then 'ProdList' is called. 'ProdList' determines ** the extended types of the arguments (e.g., including 'T_MATRIX', ** 'T_MATFFE', and 'T_LISTX') and then dispatches through 'TabProd' again. ** ** 'ProdSclList' is a generic function for the first kind of product, that ** of a scalar with a list. Note that this includes the product of a matrix ** with a list of matrices. ** ** 'ProdListScl' is a generic function for the second kind of product, that ** of a list and a scalar. Note that this includes the product of a matrix ** with a vector. ** ** 'ProdListList' is a generic function for the third kind of product, that ** of two lists. Note that this includes the product of a vector and a ** matrix. */ extern TypHandle ProdList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle ProdSclList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle ProdListScl P(( TypHandle hdL, TypHandle hdR )); extern TypHandle ProdListList P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F QuoList(,) . . . . . . . . . . . . . . . . . quotient of lists *F QuoLists(,) . . . . . . . . . . . . . . . . . quotient of lists ** ** 'QuoList' is the generic dispatcher for the quotients involving lists. ** This is, whenever two lists are divided and 'TabQuo' does not point to a ** special routine then 'QuoList' is called. 'QuoList' determines the ** extended types of the arguments (e.g., including 'T_MATRIX', 'T_MATFFE', ** and 'T_LISTX') and then dispatches through 'TabProd' again. ** ** 'QuoLists' is a generic function, which only returns the product of ** and the inverse of (computed as ^-1). The right operand must ** either be a scalar or an invertable square matrix. */ extern TypHandle QuoList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle QuoLists P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F ModList(,) . . . . . . . . . . . . . . . . . quotient of lists *F ModLists(,) . . . . . . . . . . . . . . . . . quotient of lists ** ** 'ModList' is the generic dispatcher for left quotients involving lists. ** This is, whenever two lists are divided and 'TabMod' does not point to a ** special routine then 'ModList' is called. 'ModList' determines the ** extended types of the arguments (e.g., including 'T_MATRIX', 'T_MATFFE', ** and 'T_LISTX') and then dispatches through 'TabProd' again. ** ** 'ModLists' is a generic function, which only returns the product of ** and the inverse of (computed as ^-1). The left operand must ** either be a scalar or an invertable square matrix. */ extern TypHandle ModList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle ModLists P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F PowList(,) . . . . . . . . . . . . . . . . . . power of lists *F PowLists(,) . . . . . . . . . . . . . . . power of two matrices ** ** 'PowList' returns the power of the left operand by the right ** operand . Two cases are actually possible, is a matrix and ** is an integer, or both are matrices. 'PowList' determines the ** extended types of the arguments (e.g., including 'T_MATRIX' and ** 'T_MATFFE') and then dispatches through 'TabPow' again. ** ** 'PowLists' is a generic function for the third kind of power, that of two ** matrices, which is defined as the conjugation. */ extern TypHandle PowList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle PowLists P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F CommList(,) . . . . . . . . . . . . . . . . commutator of lists *F CommLists(,) . . . . . . . . . . . commutator of two matrices ** ** 'CommList' returns the commutator of the two operands and , ** which must both be matrices. 'CommList' determines the extended types of ** the arguments (e.g., including 'T_MATRIX' and 'T_MATFFE') and then ** dispatches through 'TabComm' again. ** ** 'CommLists' is a generic function for the commutator of two matrices. */ extern TypHandle CommList P(( TypHandle hdL, TypHandle hdR )); extern TypHandle CommLists P(( TypHandle hdL, TypHandle hdR )); /**************************************************************************** ** *F EvElmList() . . . . . . . . . . . . . select an element of a list ** ** 'EvElmList' returns the value of the element at the position '[1]' ** in the list '[0]'. Both '[0]' and '[1]' first have ** to be evaluated. */ extern TypHandle EvElmList P(( TypHandle hdSel )); /**************************************************************************** ** *F EvElmListLevel() . . select elements of several lists in parallel ** ** 'EvElmListLevel' evaluates a list selection of the form ** '...{}...[]', where there may actually be ** several '{}' selections between and '[]'. ** The number of those is called the level. 'EvElmListLevel' goes that deep ** into the left operand and selects the element at from each of ** those lists. Thus if the level is one, the left operand must be a list ** of lists and 'EvElmListLevel' selects the element at from each ** of the lists and returns the list of those values. ** ** We assume that 'EvElmsList' (the function evaluating ** '...{}') creates dense lists, so that we can select ** elements with 'ELMF_LIST'. We also assume that a list of lists has the ** representation of plain lists, so that we can assign with ** 'PTR()[i] = ;' Finally we assume that 'EvElmsList' ** creates a new list, so that we can overwrite this list with the selected ** values. */ extern TypHandle EvElmListLevel P(( TypHandle hdSel )); /**************************************************************************** ** *F EvElmsList() . . . . . . . . . . . . . select a sublist of a list ** ** 'EvElmsList' returns the sublist of the elements at the positions given ** in the list '[1]' in the list '[0]'. Both '[0]' and ** '[1]' first have to be evaluated. This implements the construct ** '{}'. */ extern TypHandle EvElmsList P(( TypHandle hdSel )); /**************************************************************************** ** *F EvElmsListLevel() . select sublists of several lists in parallel ** ** 'EvElmsListLevel' evaluates a list selection of the form ** '...{}...{]', where there may actually be ** several '{}' selections between and '{}'. ** The number of those is called the level. 'EvElmsListLevel' goes that ** deep into the left operand and selects the elements at from ** each of those lists. Thus if the level is one, the left operand must be ** a list of lists and 'EvElmsListLevel' selects the elements at ** from each of the lists and returns the list of those sublists. ** ** We assume that 'EvElmsList' (the function evaluating ** '...{}') creates dense lists, so that we can select ** elements with 'ELMF_LIST'. We also assume that a list of lists has the ** representation of plain lists, so that we can assign with ** 'PTR()[i] = ;' Finally we assume that 'EvElmsList' ** creates a new list, so that we can overwrite this list with the selected ** values. */ extern TypHandle EvElmsListLevel P(( TypHandle hdSel )); /**************************************************************************** ** *F EvAssList() . . . . . . . . . . . assign to an element of a list ** ** 'EvAssList' assigns the object '[1]' to the list element ** '[0]', i.e., to the element at position '[0][1]' in the ** list '[0][0]'. */ extern TypHandle EvAssList P(( TypHandle hdAss )); /**************************************************************************** ** *F EvAssListLevel() . assign to elements of several lists in parallel ** ** 'EvAssListLevel' evaluates a list assignment of the form ** '...{}...[] := ;', where there may ** actually be several '{}' selections between and ** '[]'. The number of those is called the level. ** 'EvAssListLevel' goes that deep into the left operand and and ** assigns the values from to each of those lists. Thus if the level ** is one, the left operand must be a list of lists, must be a list, ** and 'EvAssListLevel' assigns the element '[]' to the list ** '[]' at . ** ** We assume that 'EvElmsList' (the function evaluating ** '...{}') creates dense lists, so that we can select ** elements with 'ELMF_LIST'. */ extern TypHandle EvAssListLevel P(( TypHandle hdAss )); /**************************************************************************** ** *F EvAsssList() . . . . . . . . . . . . assign to a sublist of a list ** ** 'EvAssList' assigns the object '[1]' to the list sublist ** '[0]', i.e., to the elements at positions '[0][1]' in the ** list '[0][0]'. */ extern TypHandle EvAsssList P(( TypHandle hdAss )); /**************************************************************************** ** *F EvAsssListLevel() assign to sublists of several lists in parallel ** ** 'EvAssListLevel' evaluates a list assignment of the form ** '...{}...{} := ;', where there may ** actually be several '{}' selections between and ** '{}'. The number of those is called the level. ** 'EvAssListLevel' goes that deep into the left operand and and ** assigns the sublists from to each of those lists. Thus if the ** level is one, the left operand must be a list of lists, must be a ** list, and 'EvAssListLevel' assigns the sublist '[]' to the list ** '[]' at the positions . ** ** We assume that 'EvElmsList' (the function evaluating ** '...{}') created a new dense list. */ extern TypHandle EvAsssListLevel P(( TypHandle hdAss )); /**************************************************************************** ** *F PrElmList() . . . . . . . . . . . . . . . print a list selection ** ** 'PrElmList' prints the list selection . ** ** Linebreaks are preferred after the '['. */ extern void PrElmList P(( TypHandle hdSel )); /**************************************************************************** ** *F PrElmsList() . . . . . . . . . . . . . . . print a list selection ** ** 'PrElmsList' prints the list selection . ** ** Linebreaks are preferred after the '{'. */ extern void PrElmsList P(( TypHandle hdSel )); /**************************************************************************** ** *F PrAssList() . . . . . . . . print an assignment to a list element ** ** 'PrAssList' prints the assignment to a list element. ** ** Linebreaks are preferred before the ':='. */ extern void PrAssList P(( TypHandle hdAss )); /**************************************************************************** ** *F EvIn() . . . . . . . . . . . . . . . test for membership in a list ** ** 'EvIn' implements the membership operator ' in '. ** ** 'in' returns 'true' if the object is an element of the list ** and 'false' otherwise. 'in' works fastest if is a proper set, ** i.e., has no holes, is sorted and contains no duplicates because in this ** case 'in' can use a binary search. If is a general list 'in' ** employs a linear search. */ extern TypHandle EvIn P(( TypHandle hdIn )); /**************************************************************************** ** *F FunIsList() . . . . . . . . . . . . . . . . . . . test for lists ** ** 'FunIsList' implements the internal function 'IsList( )'. ** ** 'IsList' returns 'true' if its argument is a list and 'false' ** otherwise. */ extern TypHandle FunIsList P(( TypHandle hdCall )); /**************************************************************************** ** *F FunIsVector() . . . . . . . . . . . . test if a list is a vector *F IsVector() . . . . . . . . . . . . . . test if a list is a vector ** ** 'FunIsVector' implements the internal function 'IsVector'. ** ** 'IsVector( )' ** ** 'IsVector' return 'true' if , which can be an object of arbitrary ** type, is a vector and 'false' otherwise. Will cause an error if is ** an unbound variable. */ extern long IsVector P(( TypHandle hdObj )); extern TypHandle FunIsVector P(( TypHandle hdCall )); /**************************************************************************** ** *F FunIsMat() . . . . . . . . . . . . . test if a list is a matrix ** ** 'FunIsMat' implements the internal function 'IsMat'. ** ** 'IsMat( )' ** ** 'IsMat' return 'true' if , which can be an object of arbitrary ** type, is a matrix and 'false' otherwise. Will cause an error if is ** an unbound variable. */ extern TypHandle FunIsMat P(( TypHandle hdCall )); /**************************************************************************** ** *F FunLength() . . . . . . . . . . . . . . . . . . length of a list ** ** 'FunLength' implements the internal function 'Length'. ** ** 'Length( )' ** ** 'Length' returns the length of a list ''. */ extern TypHandle FunLength P(( TypHandle hdCall )); /**************************************************************************** ** *F FunAdd() . . . . . . . . . . add an element to the end of a list ** ** 'FunAdd' implements the internal function 'Add(,)'. ** ** 'Add' adds the object to the end of the list , i.e., it is ** equivalent to the assignment '[ Length() + 1 ] := '. ** The list is automatically extended to make room for the new element. ** 'Add' returns nothing, it is called only for its sideeffect. */ extern TypHandle FunAdd P(( TypHandle hdCall )); /**************************************************************************** ** *F FunAppend() . . . . . . . . . . . . . . append elements to a list ** ** 'FunAppend' implements the function 'Append(,)'. ** ** 'Append' adds (see "Add") the elements of the list to the end of ** the list . It is allowed that contains empty positions, ** in which case the corresponding positions will be left empty in . ** 'Append' returns nothing, it is called only for its side effect. */ extern TypHandle FunAppend P(( TypHandle hdCall )); /**************************************************************************** ** *F FunPosition() . . . . . . . . . . . . . find an element in a list ** ** 'FunPosition' implements the internal function 'Position' ** ** 'Position(,[,])'. ** ** 'Position' returns the position of the object in the list . ** 'HdFalse' is returned if the object does not occur in the list. */ extern TypHandle FunPosition P(( TypHandle hdCall )); /**************************************************************************** ** *F FunOnPoints() . . . . . . . . . . . . . . . . operation on points ** ** 'FunOnPoints' implements the internal function 'OnPoints'. ** ** 'OnPoints( , )' ** ** specifies the canonical default operation. Passing this function is ** equivalent to specifying no operation. This function exists because ** there are places where the operation in not an option. */ extern TypHandle FunOnPoints P(( TypHandle hdCall )); /**************************************************************************** ** *F FunOnPairs() . . . . . . . . . . . operation on pairs of points ** ** 'FunOnPairs' implements the internal function 'OnPairs'. ** ** 'OnPairs( , )' ** ** specifies the componentwise operation of group elements on pairs ** of points, which are represented by lists of length 2. */ extern TypHandle FunOnPairs P(( TypHandle hdCall )); /**************************************************************************** ** *F FunOnTuples() . . . . . . . . . . . operation on tuples of points ** ** 'FunOnTuples' implements the internal function 'OnTuples'. ** ** 'OnTuples( , )' ** ** specifies the componentwise operation of group elements on tuples of ** points, which are represented by lists. 'OnPairs' is the special case of ** 'OnTuples' for tuples with two elements. */ extern TypHandle FunOnTuples P(( TypHandle hdCall )); /**************************************************************************** ** *F FunOnSets() . . . . . . . . . . . . . operation on sets of points ** ** 'FunOnSets' implements the internal function 'OnSets'. ** ** 'OnSets( , )' ** ** specifies the operation of group elements on sets of points, which are ** represented by sorted lists of points without duplicates (see "Sets"). */ extern TypHandle FunOnSets P(( TypHandle hdCall )); /**************************************************************************** ** *F FunOnRight() . . . . operation by multiplication from the right ** ** 'FunOnRight' implements the internal function 'OnRight'. ** ** 'OnRight( , )' ** ** specifies that group elements operate by multiplication from the right. */ extern TypHandle FunOnRight P(( TypHandle hdCall )); /**************************************************************************** ** *F FunOnLeft() . . . . . . operation by multiplication from the left ** ** 'FunOnLeft' implements the internal function 'OnLeft'. ** ** 'OnLeft( , )' ** ** specifies that group elements operate by multiplication from the left. */ extern TypHandle FunOnLeft P(( TypHandle hdCall )); /**************************************************************************** ** *F DepthListx( ) . . . . . . . . . . . . . . . . . . depth of a vector */ extern TypHandle DepthListx P(( TypHandle hdVec )); /**************************************************************************** ** *F FunDepthVector( ) . . . . . . . internal function 'DepthVector' */ extern TypHandle (*TabDepthVector[T_VAR]) P(( TypHandle )); extern TypHandle FunDepthVector P(( TypHandle hdCall )); /**************************************************************************** ** *F InitList() . . . . . . . . . . . . . . . . . initialize the list package ** ** 'InitList' initializes the generic list package. */ extern void InitList P(( ));