REF ARRAYS                                Titch Le Bek, Rob Duncan, 1986

       COPYRIGHT University of Sussex 1993. All Rights Reserved.

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<<                             >>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<<    LISP ARRAY PROCEDURES    >>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<<                             >>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

This file  briefly  describes  the functions,  variables  and  constants
documented in Chapter 17  of the standard Common  Lisp guide, which  is:
Common Lisp: The Language (Guy L. Steele, Digital Press, 1984).


-------------------------------------------------
1  A Listing of Functions Variables and Constants
-------------------------------------------------

(adjust-array array dimensions                                [function]
            &key
            :element-type :initial-element
            :initial-contents :fill-pointer
            :displaced-to :displaced-index-offset)

        Returns array  resized  according  to  dimensions  and  contents
        according to the &key specifications. The options are similar to
        those of make-array.


(adjustable-array-p array)                                    [function]
        True if array is an adjustable array; nil otherwise.


(aref array &rest subscripts)                                 [function]
        Returns the element of array specified by subscripts.


(array-dimension array number)                                [function]
        Returns the length of array dimension number.


array-dimension-limit                                         [constant]
        The upper exclusive  bound on  each individual  dimension of  an
        array. Value in this implementation: 16777216.


(array-dimensions array)                                      [function]
        Returns a list specifying the dimensions of array.


(array-element-type array)                                    [function]
        Returns a type-specifier describing the set of objects that  can
        be stored in array.


(array-has-fill-pointer-p array)                              [function]
        True if array has a fill-pointer; nil otherwise.


(array-in-bounds-p array &rest subscripts)                    [function]
        True if  subscripts  specify  a  legal  element  of  array;  nil
        otherwise.


(array-rank array)                                            [function]
        Returns the number of dimensions in array.


array-rank-limit                                              [constant]
        The upper exclusive bound on the rank of an array. Value in this
        implementation: 256.


(array-row-major-index array &rest subscripts)                [function]
        Returns an integer that identifies  the accessed element in  the
        row-major ordering of the elements.


(array-total-size array)                                      [function]
        Returns the total number of elements in array.


array-total-size-limit                                        [constant]
        The upper exclusive bound on the total number of elements in  an
        array. Value in this implementation: 536870912.


(bit bit-array &rest subscripts)                              [function]
        Returns the element of bit-array specified by subscript.


(bit-and bit-array1 bit-array2 &optional result-bit-array)    [function]
        Applies  the  bit-wise  logical   operation  AND  on  the   args
        bit-array1 and bit-array2.


(bit-andc1 bit-array1 bit-array2 &optional result-bit-array)  [function]
        Takes the  bit-wise logical-complement  of bit-array1  and  then
        performs a bit-wise logical-and on this and bit-array2.


(bit-andc2 bit-array1 bit-array2 &optional result-bit-array)  [function]
        Takes the  bit-wise logical-complement  of bit-array2  and  then
        performs a bit-wise logical-and on this and bit-array1.


(bit-eqv bit-array1 bit-array2 &optional result-bit-array)    [function]
        Applies  a  bit-wise   logical-equivalence  (exclusive-nor)   to
        bit-array1 and bit-array2.


(bit-ior bit-array1 bit-array2 &optional result-bit-array)    [function]
        Applies  a  bit-wise  logical  inclusive-or  to  bit-array1  and
        bit-array2.


(bit-nand bit-array1 bit-array2 &optional result-bit-array)   [function]
        Applies a bit-wise logical not-and to bit-array1 and bit-array2.


(bit-nor bit-array1 bit-array2 &optional result-bit-array)    [function]
        Applies a bit-wise logical not-or to bit-array1 and bit-array2.


(bit-not bit-array &optional result-bit-array)                [function]
        Applies a bit-wise logical not to bit-array1.


(bit-orc1 bit-array1 bit-array2 &optional result-bit-array)   [function]
        Takes the  bit-wise logical-complement  of bit-array1  and  then
        performs a bit-wise logical-or on this and bit-array2.


(bit-orc2 bit-array1 bit-array2 &optional result-bit-array)   [function]
        Takes the  bit-wise logical-complement  of bit-array2  and  then
        performs a bit-wise logical-or on this and bit-array1.


(bit-xor bit-array1 bit-array2 &optional result-bit-array)    [function]
        Applies  a  bit-wise  logical  exclusive-or  to  bit-array1  and
        bit-array2.


(fill-pointer vector)                                         [function]
        Returns the fill-pointer of vector.  Signals an error if  vector
        does not possess a fill-pointer.


(make-array dimensions                                        [function]
            &key
            :element-type :initial element
            :initial contents :adjustable
            :fill-pointer :displaced-to
            :displaced-index-offset)

        This is the primitive function for making arrays. dimensions  is
        a list of non-negative integers that are to be the dimensions of
        the array; the  length of  the list  specifies the  rank of  the
        array. Each dimension must be smaller than array-dimension-limit
        and the  product of  all  the dimensions  must be  smaller  than
        array-total-size-limit. The keyword arguments are as follows:

         :element-type
            specifies the type of the elements of the array

         :initial-element
         :initial-contents
            used to initialize the contents of the array

         :adjustable
            If specified and not nil, indicates that it must be possible
            to alter the array's size dynamically after it is created

         :fill-pointer
            initializes the fill-pointer for an array; if the value t is
            specified the length of the array is used, otherwise the
            value must be an integer between 0 and the length of the
            array, or it defaults to nil

         :displaced-to
            if not nil, specifies that the array will be a displaced
            array; the argument must be an array and the result array
            will share its contents

         :displaced-index-offset
            may be used only in conjunction with :displaced-to. The
            argument must be a non-negative integer, and the effect is
            that all accesses to the new array are mapped onto the
            shared array offset by that number of elements.

        If make-array is called with the :adjustable, :fill-pointer, and
        :displaced-to arguments unspecified  or nil  then the  resulting
        array is guaranteed to be a simple array.


(row-major-aref array index)                                  [function]
        Indexes  into   array  as   if   its  elements   were   arranged
        one-dimensionally in row-major order, and returns the  indicated
        element.


(sbit array &rest subscripts)                                 [function]
        sbit is  like  bit but  additionally  requires that  array  be a
        simple array.


(svref vector index)                                          [function]
        Returns the element  of the  simple vector  vector specified  by
        index. In some situations svref may be faster than aref.


(vector &rest objects)                                        [function]
        Creates and  returns a  simple general  vector for  the  initial
        contents in objects. It is analagous to the function list.


(vector-pop vector)                                           [function]
        Decrements the fill-pointer  of vector  by one  and returns  the
        corresponding vector value. vector-pop  signals an error if  the
        fill-pointer is zero.


(vector-push object vector)                                   [function]
        Inserts object into vector using the current fill-pointer  value
        and increments the fill-pointer by one. The value of vector-push
        is the index of the new element pushed.


(vector-push-extend object vector &optional integer)          [function]
        Like vector-push except that if the fill-pointer gets too large,
        vector is extended so that it can contain more elements. If  the
        vector is  not  adjustable then  vector-push-extend  signals  an
        error. integer specifies  the minimum number  of elements to  be
        added to the vector if it must be extended; its default value is
        implementation-dependent.



--- C.all/lisp/ref/arrays
--- Copyright University of Sussex 1993. All rights reserved.
