   This is a Texinfo GCL SYSTEM INTERNALS Manual

   Copyright 1994 William F. Schelter

Numbers
*******

 - Function: SIGNUM (NUMBER)
     Package:LISP

     If NUMBER is zero, returns NUMBER; else returns (/ NUMBER (ABS
     NUMBER)).

 - Function: LOGNOT (INTEGER)
     Package:LISP

     Returns the bit-wise logical NOT of INTEGER.

 - Constant: MOST-POSITIVE-SHORT-FLOAT
     Package:LISP The short-float closest in value to positive infinity.

 - Function: INTEGER-DECODE-FLOAT (FLOAT)
     Package:LISP

     Returns, as three values, the integer interpretation of
     significand F, the exponent E, and the sign S of the given float,
     so that 			 E 	FLOAT = S * F * B	where B = (FLOAT-RADIX
     FLOAT)

     F is a non-negative integer, E is an integer, and S is either 1 or
     -1.

 - Function: MINUSP (NUMBER)
     Package:LISP

     Returns T if NUMBER < 0; NIL otherwise.

 - Function: LOGORC1 (INTEGER1 INTEGER2)
     Package:LISP

     Returns the logical OR of (LOGNOT INTEGER1) and INTEGER2.

 - Constant: MOST-NEGATIVE-SINGLE-FLOAT
     Package:LISP Same as MOST-NEGATIVE-LONG-FLOAT.

 - Constant: BOOLE-C1
     Package:LISP Makes BOOLE return the complement of INTEGER1.

 - Constant: LEAST-POSITIVE-SHORT-FLOAT
     Package:LISP The positive short-float closest in value to zero.

 - Function: BIT-NAND (BIT-ARRAY1 BIT-ARRAY2 &optional
          (RESULT-BIT-ARRAY NIL))
     Package:LISP

     Performs a bit-wise logical NAND  on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: INT-CHAR (INTEGER)
     Package:LISP

     Performs the inverse of CHAR-INT.  Equivalent to CODE-CHAR in GCL.

 - Function: CHAR-INT (CHAR)
     Package:LISP

     Returns the font, bits, and code attributes as a single
     non-negative integer.  Equivalent to CHAR-CODE in GCL.

 - Constant: LEAST-NEGATIVE-SINGLE-FLOAT
     Package:LISP Same as LEAST-NEGATIVE-LONG-FLOAT.

 - Function: /= (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns T if no two of its arguments are numerically equal; NIL
     otherwise.

 - Function: LDB-TEST (BYTESPEC INTEGER)
     Package:LISP

     Returns T if at least one of the bits in the specified bytes of
     INTEGER is 1; NIL otherwise.

 - Constant: CHAR-CODE-LIMIT
     Package:LISP The upper exclusive bound on values produced by
     CHAR-CODE.

 - Function: RATIONAL (NUMBER)
     Package:LISP

     Converts NUMBER into rational accurately and returns it.

 - Constant: PI
     Package:LISP The floating-point number that is appropriately equal
     to the ratio of the circumference of the circle to the diameter.

 - Function: SIN (RADIANS)
     Package:LISP

     Returns the sine of RADIANS.

 - Constant: BOOLE-ORC2
     Package:LISP Makes BOOLE return LOGORC2 of INTEGER1 and INTEGER2.

 - Function: NUMERATOR (RATIONAL)
     Package:LISP

     Returns as an integer the numerator of the given rational number.

 - Function: MASK-FIELD (BYTESPEC INTEGER)
     Package:LISP

     Extracts the specified byte from INTEGER.

 - Special Form: INCF
     Package:LISP

     Syntax:
          (incf place [delta])

     Adds the number produced by DELTA (which defaults to 1) to the
     number in PLACE.

 - Function: SINH (NUMBER)
     Package:LISP

     Returns the hyperbolic sine of NUMBER.

 - Function: PHASE (NUMBER)
     Package:LISP

     Returns the angle part of the polar representation of a complex
     number.  For non-complex numbers, this is 0.

 - Function: BOOLE (OP INTEGER1 INTEGER2)
     Package:LISP

     Returns an integer produced by performing the logical operation
     specified by OP on the two integers.  OP must be the value of one
     of the following constants:
     BOOLE-CLR	BOOLE-C1	BOOLE-XOR	BOOLE-ANDC1
     BOOLE-SET	BOOLE-C2	BOOLE-EQV	BOOLE-ANDC2
     BOOLE-1		BOOLE-AND	BOOLE-NAND	BOOLE-ORC1
     BOOLE-2		BOOLE-IOR	BOOLE-NOR	BOOLE-ORC2 See
     the variable docs of these constants for their operations.

 - Constant: SHORT-FLOAT-EPSILON
     Package:LISP The smallest positive short-float that satisfies 	(not
     (= (float 1 e) (+ (float 1 e) e))).

 - Function: LOGORC2 (INTEGER1 INTEGER2)
     Package:LISP

     Returns the logical OR of INTEGER1 and (LOGNOT INTEGER2).

 - Constant: BOOLE-C2
     Package:LISP Makes BOOLE return the complement of INTEGER2.

 - Function: REALPART (NUMBER)
     Package:LISP

     Extracts the real part of NUMBER.

 - Constant: BOOLE-CLR
     Package:LISP Makes BOOLE return 0.

 - Constant: BOOLE-IOR
     Package:LISP Makes BOOLE return LOGIOR of INTEGER1 and INTEGER2.

 - Function: FTRUNCATE (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Values: (quotient remainder) Same as TRUNCATE, but returns first
     value as a float.

 - Function: EQL (X Y)
     Package:LISP

     Returns T if X and Y are EQ, or if they are numbers of the same
     type with the same value, or if they are character objects that
     represent the same character.  Returns NIL otherwise.

 - Function: LOG (NUMBER &optional BASE)
     Package:LISP

     Returns the logarithm of NUMBER in the base BASE.  BASE defaults
     to the base of natural logarithms.

 - Constant: DOUBLE-FLOAT-NEGATIVE-EPSILON
     Package:LISP Same as LONG-FLOAT-NEGATIVE-EPSILON.

 - Function: LOGIOR (&rest INTEGERS)
     Package:LISP

     Returns the bit-wise INCLUSIVE OR of its arguments.

 - Constant: MOST-NEGATIVE-DOUBLE-FLOAT
     Package:LISP Same as MOST-NEGATIVE-LONG-FLOAT.

 - Function: / (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Divides the first NUMBER by each of the subsequent NUMBERS.  With
     one arg, returns the reciprocal of the number.

 - Variable: *RANDOM-STATE*
     Package:LISP The default random-state object used by RAMDOM.

 - Function: 1+ (NUMBER)
     Package:LISP

     Returns NUMBER + 1.

 - Constant: LEAST-NEGATIVE-DOUBLE-FLOAT
     Package:LISP Same as LEAST-NEGATIVE-LONG-FLOAT.

 - Function: FCEILING (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Same as CEILING, but returns a float as the first value.

 - Constant: MOST-POSITIVE-FIXNUM
     Package:LISP The fixnum closest in value to positive infinity.

 - Function: BIT-ANDC1 (BIT-ARRAY1 BIT-ARRAY2 &optional
          (RESULT-BIT-ARRAY NIL))
     Package:LISP

     Performs a bit-wise logical ANDC1 on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: TAN (RADIANS)
     Package:LISP

     Returns the tangent of RADIANS.

 - Constant: BOOLE-NAND
     Package:LISP Makes BOOLE return LOGNAND of INTEGER1 and INTEGER2.

 - Function: TANH (NUMBER)
     Package:LISP

     Returns the hyperbolic tangent of NUMBER.

 - Function: ASIN (NUMBER)
     Package:LISP

     Returns the arc sine of NUMBER.

 - Function: BYTE (SIZE POSITION)
     Package:LISP

     Returns a byte specifier.  In GCL, a byte specifier is represented
     by a dotted pair (<size> . <position>).

 - Function: ASINH (NUMBER)
     Package:LISP

     Returns the hyperbolic arc sine of NUMBER.

 - Constant: MOST-POSITIVE-LONG-FLOAT
     Package:LISP The long-float closest in value to positive infinity.

 - Macro: SHIFTF
     Package:LISP

     Syntax:
          (shiftf {place}+ newvalue)

     Evaluates all PLACEs and NEWVALUE in turn, then assigns the value
     of each form to the PLACE on its left.  Returns the original value
     of the leftmost form.

 - Constant: LEAST-POSITIVE-LONG-FLOAT
     Package:LISP The positive long-float closest in value to zero.

 - Function: DEPOSIT-FIELD (NEWBYTE BYTESPEC INTEGER)
     Package:LISP

     Returns an integer computed by replacing the specified byte of
     INTEGER with the specified byte of NEWBYTE.

 - Function: BIT-AND (BIT-ARRAY1 BIT-ARRAY2 &optional (RESULT-BIT-ARRAY
          NIL))
     Package:LISP

     Performs a bit-wise logical AND on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: LOGNAND (INTEGER1 INTEGER2)
     Package:LISP

     Returns the complement of the logical AND of INTEGER1 and INTEGER2.

 - Function: BYTE-POSITION (BYTESPEC)
     Package:LISP

     Returns the position part (in GCL, the cdr part) of the byte
     specifier.

 - Macro: ROTATEF
     Package:LISP

     Syntax:
          (rotatef {place}*)

     Evaluates PLACEs in turn, then assigns to each PLACE the value of
     the form to its right.  The rightmost PLACE gets the value of the
     leftmost PLACE.  Returns NIL always.

 - Function: BIT-ANDC2 (BIT-ARRAY1 BIT-ARRAY2 &optional
          (RESULT-BIT-ARRAY NIL))
     Package:LISP

     Performs a bit-wise logical ANDC2 on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: TRUNCATE (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Values: (quotient remainder) Returns NUMBER/DIVISOR as an integer,
     rounded toward 0.  The second returned value is the remainder.

 - Constant: BOOLE-EQV
     Package:LISP Makes BOOLE return LOGEQV of INTEGER1 and INTEGER2.

 - Constant: BOOLE-SET
     Package:LISP Makes BOOLE return -1.

 - Function: LDB (BYTESPEC INTEGER)
     Package:LISP

     Extracts and right-justifies the specified byte of INTEGER, and
     returns the result.

 - Function: BYTE-SIZE (BYTESPEC)
     Package:LISP

     Returns the size part (in GCL, the car part) of the byte specifier.

 - Constant: SHORT-FLOAT-NEGATIVE-EPSILON
     Package:LISP The smallest positive short-float that satisfies 	(not
     (= (float 1 e) (- (float 1 e) e))).

 - Function: REM (NUMBER DIVISOR)
     Package:LISP

     Returns the second value of (TRUNCATE NUMBER DIVISOR).

 - Function: MIN (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns the least of its arguments.

 - Function: EXP (NUMBER)
     Package:LISP

     Calculates e raised to the power NUMBER, where e is the base of
     natural logarithms.

 - Function: DECODE-FLOAT (FLOAT)
     Package:LISP

     Returns, as three values, the significand F, the exponent E, and
     the sign S of the given float, so that 			 E 	FLOAT = S * F *
     B	where B = (FLOAT-RADIX FLOAT)

     S and F are floating-point numbers of the same float format as
     FLOAT, and E is an integer.

 - Constant: LONG-FLOAT-EPSILON
     Package:LISP The smallest positive long-float that satisfies 	(not
     (= (float 1 e) (+ (float 1 e) e))).

 - Function: FROUND (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Same as ROUND, but returns first value as a float.

 - Function: LOGEQV (&rest INTEGERS)
     Package:LISP

     Returns the bit-wise EQUIVALENCE of its arguments.

 - Constant: MOST-NEGATIVE-SHORT-FLOAT
     Package:LISP The short-float closest in value to negative infinity.

 - Function: BIT-NOR (BIT-ARRAY1 BIT-ARRAY2 &optional (RESULT-BIT-ARRAY
          NIL))
     Package:LISP

     Performs a bit-wise logical NOR  on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: CEILING (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Returns the smallest integer not less than or NUMBER/DIVISOR.
     Returns the remainder as the second value.

 - Constant: LEAST-NEGATIVE-SHORT-FLOAT
     Package:LISP The negative short-float closest in value to zero.

 - Function: 1- (NUMBER)
     Package:LISP

     Returns NUMBER - 1.

 - Function: <= (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns T if arguments are in strictly non-decreasing order; NIL
     otherwise.

 - Function: IMAGPART (NUMBER)
     Package:LISP

     Extracts the imaginary part of NUMBER.

 - Function: INTEGERP (X)
     Package:LISP

     Returns T if X is an integer (fixnum or bignum); NIL otherwise.

 - Function: ASH (INTEGER COUNT)
     Package:LISP

     Shifts INTEGER left by COUNT places.  Shifts right if COUNT is
     negative.

 - Function: LCM (INTEGER &rest MORE-INTEGERS)
     Package:LISP

     Returns the least common multiple of the arguments.

 - Function: COS (RADIANS)
     Package:LISP

     Returns the cosine of RADIANS.

 - Special Form: DECF
     Package:LISP

     Syntax:
          (decf place [delta])
     Subtracts the number produced by DELTA (which defaults to 1) from
     the number in PLACE.

 - Function: ATAN (X &optional (Y 1))
     Package:LISP  Returns the arc tangent of X/Y.

 - Constant: BOOLE-ANDC1
     Package:LISP Makes BOOLE return LOGANDC1 of INTEGER1 and INTEGER2.

 - Function: COSH (NUMBER)
     Package:LISP  Returns the hyperbolic cosine of NUMBER.

 - Function: FLOAT-RADIX (FLOAT)
     Package:LISP

     Returns the representation radix (or base) of the floating-point
     number.

 - Function: ATANH (NUMBER)
     Package:LISP

     Returns the hyperbolic arc tangent of NUMBER.

 - Function: EVENP (INTEGER)
     Package:LISP  Returns T if INTEGER is even.  Returns NIL if
     INTEGER is odd.

 - Function: ZEROP (NUMBER)
     Package:LISP  Returns T if NUMBER = 0; NIL otherwise.

 - Function: FLOATP (X)
     Package:LISP

     Returns T if X is a floating-point number; NIL otherwise.

 - Function: SXHASH (OBJECT)
     Package:LISP

     Computes a hash code for OBJECT and returns it as an integer.

 - Constant: BOOLE-1
     Package:LISP Makes BOOLE return INTEGER1.

 - Constant: MOST-POSITIVE-SINGLE-FLOAT
     Package:LISP Same as MOST-POSITIVE-LONG-FLOAT.

 - Function: LOGANDC1 (INTEGER1 INTEGER2)
     Package:LISP

     Returns the logical AND of (LOGNOT INTEGER1) and INTEGER2.

 - Constant: LEAST-POSITIVE-SINGLE-FLOAT
     Package:LISP Same as LEAST-POSITIVE-LONG-FLOAT.

 - Function: COMPLEXP (X)
     Package:LISP

     Returns T if X is a complex number; NIL otherwise.

 - Constant: BOOLE-AND
     Package:LISP Makes BOOLE return LOGAND of INTEGER1 and INTEGER2.

 - Function: MAX (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns the greatest of its arguments.

 - Function: FLOAT-SIGN (FLOAT1 &optional (FLOAT2 (FLOAT 1 FLOAT1)))
     Package:LISP

     Returns a floating-point number with the same sign as FLOAT1 and
     with the same absolute value as FLOAT2.

 - Constant: BOOLE-ANDC2
     Package:LISP Makes BOOLE return LOGANDC2 of INTEGER1 and INTEGER2.

 - Function: DENOMINATOR (RATIONAL)
     Package:LISP

     Returns the denominator of RATIONAL as an integer.

 - Function: FLOAT (NUMBER &optional OTHER)
     Package:LISP

     Converts a non-complex number to a floating-point number.  If
     NUMBER is already a float, FLOAT simply returns NUMBER.
     Otherwise, the format of the returned float depends on OTHER;  If
     OTHER is not provided, FLOAT returns a SINGLE-FLOAT.  If OTHER is
     provided, the result is in the same float format as OTHER's.

 - Function: ROUND (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Rounds NUMBER/DIVISOR to nearest integer.  The second returned
     value is the remainder.

 - Function: LOGAND (&rest INTEGERS)
     Package:LISP

     Returns the bit-wise AND of its arguments.

 - Constant: BOOLE-2
     Package:LISP Makes BOOLE return INTEGER2.

 - Function: * (&rest NUMBERS)
     Package:LISP

     Returns the product of its arguments.  With no args, returns 1.

 - Function: < (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns T if its arguments are in strictly increasing order; NIL
     otherwise.

 - Function: COMPLEX (REALPART &optional (IMAGPART 0))
     Package:LISP

     Returns a complex number with the given real and imaginary parts.

 - Constant: SINGLE-FLOAT-EPSILON
     Package:LISP Same as LONG-FLOAT-EPSILON.

 - Function: LOGANDC2 (INTEGER1 INTEGER2)
     Package:LISP

     Returns the logical AND of INTEGER1 and (LOGNOT INTEGER2).

 - Function: INTEGER-LENGTH (INTEGER)
     Package:LISP

     Returns the number of significant bits in the absolute value of
     INTEGER.

 - Constant: MOST-NEGATIVE-FIXNUM
     Package:LISP The fixnum closest in value to negative infinity.

 - Constant: LONG-FLOAT-NEGATIVE-EPSILON
     Package:LISP The smallest positive long-float that satisfies 	(not
     (= (float 1 e) (- (float 1 e) e))).

 - Function: >= (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns T if arguments are in strictly non-increasing order; NIL
     otherwise.

 - Constant: BOOLE-NOR
     Package:LISP Makes BOOLE return LOGNOR of INTEGER1 and INTEGER2.

 - Function: ACOS (NUMBER)
     Package:LISP

     Returns the arc cosine of NUMBER.

 - Function: MAKE-RANDOM-STATE (&optional (STATE *RANDOM-STATE*))
     Package:LISP

     Creates and returns a copy of the specified random state.  If
     STATE is NIL, then the value of *RANDOM-STATE* is used.  If STATE
     is T, then returns a random state object generated from the
     universal time.

 - Function: EXPT (BASE-NUMBER POWER-NUMBER)
     Package:LISP

     Returns BASE-NUMBER raised to the power POWER-NUMBER.

 - Function: SQRT (NUMBER)
     Package:LISP

     Returns the principal square root of NUMBER.

 - Function: SCALE-FLOAT (FLOAT INTEGER)
     Package:LISP

     Returns (* FLOAT (expt (float-radix FLOAT) INTEGER)).

 - Function: ACOSH (NUMBER)
     Package:LISP

     Returns the hyperbolic arc cosine of NUMBER.

 - Constant: MOST-NEGATIVE-LONG-FLOAT
     Package:LISP The long-float closest in value to negative infinity.

 - Constant: LEAST-NEGATIVE-LONG-FLOAT
     Package:LISP The negative long-float closest in value to zero.

 - Function: FFLOOR (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Same as FLOOR, but returns a float as the first value.

 - Function: LOGNOR (INTEGER1 INTEGER2)
     Package:LISP

     Returns the complement of the logical OR of INTEGER1 and INTEGER2.

 - Function: PARSE-INTEGER (STRING
     &key (start 0) (end (length string)) (radix 10) (junk-allowed nil))
     Package:LISP

     Parses STRING for an integer and returns it.

 - Function: + (&rest NUMBERS)
     Package:LISP

     Returns the sum of its arguments.  With no args, returns 0.

 - Function: = (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns T if all of its arguments are numerically equal; NIL
     otherwise.

 - Function: NUMBERP (X)
     Package:LISP

     Returns T if X is any kind of number; NIL otherwise.

 - Constant: MOST-POSITIVE-DOUBLE-FLOAT
     Package:LISP Same as MOST-POSITIVE-LONG-FLOAT.

 - Function: LOGTEST (INTEGER1 INTEGER2)
     Package:LISP

     Returns T if LOGAND of INTEGER1 and INTEGER2 is not zero; NIL
     otherwise.

 - Function: RANDOM-STATE-P (X)
     Package:LISP

     Returns T if X is a random-state object; NIL otherwise.

 - Constant: LEAST-POSITIVE-DOUBLE-FLOAT
     Package:LISP Same as LEAST-POSITIVE-LONG-FLOAT.

 - Function: FLOAT-PRECISION (FLOAT)
     Package:LISP

     Returns the number of significant radix-B digits used to represent
     the significand F of the floating-point number, where B =
     (FLOAT-RADIX FLOAT).

 - Constant: BOOLE-XOR
     Package:LISP Makes BOOLE return LOGXOR of INTEGER1 and INTEGER2.

 - Function: DPB (NEWBYTE BYTESPEC INTEGER)
     Package:LISP

     Returns an integer computed by replacing the specified byte of
     INTEGER with NEWBYTE.

 - Function: ABS (NUMBER)
     Package:LISP

     Returns the absolute value of NUMBER.

 - Function: CONJUGATE (NUMBER)
     Package:LISP

     Returns the complex conjugate of NUMBER.

 - Function: CIS (RADIANS)
     Package:LISP

     Returns e raised to i*RADIANS.

 - Function: ODDP (INTEGER)
     Package:LISP

     Returns T if INTEGER is odd; NIL otherwise.

 - Function: RATIONALIZE (NUMBER)
     Package:LISP

     Converts NUMBER into rational approximately and returns it.

 - Function: ISQRT (INTEGER)
     Package:LISP

     Returns the greatest integer less than or equal to the square root
     of the given non-negative integer.

 - Function: LOGXOR (&rest INTEGERS)
     Package:LISP

     Returns the bit-wise EXCLUSIVE OR of its arguments.

 - Function: > (NUMBER &rest MORE-NUMBERS)
     Package:LISP

     Returns T if its arguments are in strictly decreasing order; NIL
     otherwise.

 - Function: LOGBITP (INDEX INTEGER)
     Package:LISP

     Returns T if the INDEX-th bit of INTEGER is 1.

 - Constant: DOUBLE-FLOAT-EPSILON
     Package:LISP Same as LONG-FLOAT-EPSILON.

 - Function: LOGCOUNT (INTEGER)
     Package:LISP

     If INTEGER is negative, returns the number of 0 bits.  Otherwise,
     returns the number of 1 bits.

 - Function: GCD (&rest INTEGERS)
     Package:LISP

     Returns the greatest common divisor of INTEGERs.

 - Function: RATIONALP (X)
     Package:LISP

     Returns T if X is an integer or a ratio; NIL otherwise.

 - Function: MOD (NUMBER DIVISOR)
     Package:LISP

     Returns the second result of (FLOOR NUMBER DIVISOR).

 - Constant: BOOLE-ORC1
     Package:LISP Makes BOOLE return LOGORC1 of INTEGER1 and INTEGER2.

 - Constant: SINGLE-FLOAT-NEGATIVE-EPSILON
     Package:LISP Same as LONG-FLOAT-NEGATIVE-EPSILON.

 - Function: FLOOR (NUMBER &optional (DIVISOR 1))
     Package:LISP

     Returns the largest integer not larger than the NUMBER divided by
     DIVISOR.  The second returned value is (- NUMBER (* first-value
     DIVISOR)).

 - Function: PLUSP (NUMBER)
     Package:LISP

     Returns T if NUMBER > 0; NIL otherwise.

 - Function: FLOAT-DIGITS (FLOAT)
     Package:LISP

     Returns the number of radix-B digits used to represent the
     significand F of the floating-point number, where B = (FLOAT-RADIX
     FLOAT).

 - Function: RANDOM (NUMBER &optional (STATE *RANDOM-STATE*))
     Package:LISP

     Generates a uniformly distributed pseudo-random number between zero
     (inclusive) and NUMBER (exclusive), by using the random state
     object STATE.

Sequences and Arrays and Hash Tables
************************************

 - Function: VECTOR (&rest OBJECTS)
     Package:LISP

     Constructs a Simple-Vector from the given objects.

 - Function: SUBSEQ (SEQUENCE START &optional (END (LENGTH SEQUENCE)))
     Package:LISP

     Returns a copy of a subsequence of SEQUENCE between START
     (inclusive) and END (exclusive).

 - Function: COPY-SEQ (SEQUENCE)
     Package:LISP

     Returns a copy of SEQUENCE.

 - Function: POSITION (ITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (key #'identity)) Package:LISP

     Returns the index of the first element in SEQUENCE that satisfies
     TEST with ITEM; NIL if no such element exists.

 - Function: ARRAY-RANK (ARRAY)
     Package:LISP

     Returns the number of dimensions of ARRAY.

 - Function: SBIT (SIMPLE-BIT-ARRAY &rest SUBSCRIPTS)
     Package:LISP

     Returns the bit from SIMPLE-BIT-ARRAY at SUBSCRIPTS.

 - Function: STRING-CAPITALIZE (STRING &key (START 0) (END (LENGTH
          STRING)))
     Package:LISP

     Returns a copy of STRING with the first character of each word
     converted to upper-case, and remaining characters in the word
     converted to lower case.

 - Function: NSUBSTITUTE-IF-NOT (NEW TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a sequence of the same kind as SEQUENCE with the same
     elements

     except that all elements not satisfying TEST are replaced with
     NEWITEM.  SEQUENCE may be destroyed.

 - Function: FIND-IF (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence)) (key
     #'identity)) Package:LISP

     Returns the index of the first element in SEQUENCE that satisfies
     TEST; NIL if no such element exists.

 - Function: BIT-EQV (BIT-ARRAY1 BIT-ARRAY2 &optional (RESULT-BIT-ARRAY
          NIL))
     Package:LISP

     Performs a bit-wise logical EQV  on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: STRING< (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     If STRING1 is lexicographically less than STRING2, then returns
     the longest common prefix of the strings.  Otherwise, returns NIL.

 - Function: REVERSE (SEQUENCE)
     Package:LISP

     Returns a new sequence containing the same elements as SEQUENCE
     but in reverse order.

 - Function: NSTRING-UPCASE (STRING &key (START 0) (END (LENGTH
          STRING)))
     Package:LISP

     Returns STRING with all lower case characters converted to
     uppercase.

 - Function: STRING>= (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     If STRING1 is lexicographically greater than or equal to STRING2,
     then returns the longest common prefix of the strings.  Otherwise,
     returns NIL.

 - Function: ARRAY-ROW-MAJOR-INDEX (ARRAY &rest SUBSCRIPTS)
     Package:LISP

     Returns the index into the data vector of ARRAY for the element of
     ARRAY specified by SUBSCRIPTS.

 - Function: ARRAY-DIMENSION (ARRAY AXIS-NUMBER)
     Package:LISP

     Returns the length of AXIS-NUMBER of ARRAY.

 - Function: FIND (ITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (key #'identity)) Package:LISP

     Returns the first element in SEQUENCE satisfying TEST with ITEM;
     NIL if no such element exists.

 - Function: STRING-NOT-EQUAL (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Similar to STRING=, but ignores cases.

 - Function: STRING-RIGHT-TRIM (CHAR-BAG STRING)
     Package:LISP

     Returns a copy of STRING with the characters in CHAR-BAG removed
     from the right end.

 - Function: DELETE-IF-NOT (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a sequence formed by destructively removing the elements
     not satisfying TEST from SEQUENCE.

 - Function: REMOVE-IF-NOT (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a copy of SEQUENCE with elements not satisfying TEST
     removed.

 - Function: STRING= (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Returns T if the two strings are character-wise CHAR=; NIL
     otherwise.

 - Function: NSUBSTITUTE-IF (NEW TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a sequence of the same kind as SEQUENCE with the same
     elements except that all elements satisfying TEST are replaced
     with NEWITEM.  SEQUENCE may be destroyed.

 - Function: SOME (PREDICATE SEQUENCE &rest MORE-SEQUENCES)
     Package:LISP

     Returns T if at least one of the elements in SEQUENCEs satisfies
     PREDICATE; NIL otherwise.

 - Function: MAKE-STRING (SIZE &key (INITIAL-ELEMENT #\SPACE))
     Package:LISP

     Creates and returns a new string of SIZE length whose elements are
     all INITIAL-ELEMENT.

 - Function: NSUBSTITUTE (NEWITEM OLDITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (count most-positive-fixnum)
     (key #'identity)) Package:LISP

     Returns a sequence of the same kind as SEQUENCE with the same
     elements except that OLDITEMs are replaced with NEWITEM.  SEQUENCE
     may be destroyed.

 - Function: STRING-EQUAL (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Given two strings (string1 and string2), and optional integers
     start1, start2, end1 and end2, compares characters in string1 to
     characters in string2 (using char-equal).

 - Function: STRING-NOT-GREATERP (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Similar to STRING<=, but ignores cases.

 - Function: STRING> (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     If STRING1 is lexicographically greater than STRING2, then returns
     the longest common prefix of the strings.  Otherwise, returns NIL.

 - Function: STRINGP (X)
     Package:LISP

     Returns T if X is a string; NIL otherwise.

 - Function: DELETE-IF (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a sequence formed by removing the elements satisfying TEST
     destructively from SEQUENCE.

 - Function: SIMPLE-STRING-P (X)
     Package:LISP

     Returns T if X is a simple string; NIL otherwise.

 - Function: REMOVE-IF (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a copy of SEQUENCE with elements satisfying TEST removed.

 - Function: HASH-TABLE-COUNT (HASH-TABLE)
     Package:LISP

     Returns the number of entries in the given Hash-Table.

 - Function: ARRAY-DIMENSIONS (ARRAY)
     Package:LISP

     Returns a list whose elements are the dimensions of ARRAY

 - Function: SUBSTITUTE-IF-NOT (NEW TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a sequence of the same kind as SEQUENCE with the same
     elements except that all elements not satisfying TEST are replaced
     with NEWITEM.

 - Function: ADJUSTABLE-ARRAY-P (ARRAY)
     Package:LISP

     Returns T if ARRAY is adjustable; NIL otherwise.

 - Function: SVREF (SIMPLE-VECTOR INDEX)
     Package:LISP

     Returns the INDEX-th element of SIMPLE-VECTOR.

 - Function: VECTOR-PUSH-EXTEND (NEW-ELEMENT VECTOR &optional
          (EXTENSION (LENGTH VECTOR)))
     Package:LISP

     Similar to VECTOR-PUSH except that, if the fill pointer gets too
     large, extends VECTOR rather then simply returns NIL.

 - Function: DELETE (ITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (count most-positive-fixnum)
     (key #'identity)) Package:LISP

     Returns a sequence formed by removing the specified ITEM
     destructively from SEQUENCE.

 - Function: REMOVE (ITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (count most-positive-fixnum)
     (key #'identity)) Package:LISP

     Returns a copy of SEQUENCE with ITEM removed.

 - Function: STRING (X)
     Package:LISP

     Coerces X into a string.  If X is a string, then returns X itself.
     If X is a symbol, then returns X's print name.  If X is a
     character, then returns a one element string containing that
     character.  Signals an error if X cannot be coerced into a string.

 - Function: STRING-UPCASE (STRING &key (START 0) (END (LENGTH STRING)))
     Package:LISP

     Returns a copy of STRING with all lower case characters converted
     to uppercase.

 - Function: GETHASH (KEY HASH-TABLE &optional (DEFAULT NIL))
     Package:LISP

     Finds the entry in HASH-TABLE whose key is KEY and returns the
     associated value and T, as multiple values.  Returns DEFAULT and
     NIL if there is no such entry.

 - Function: MAKE-HASH-TABLE (&key (TEST 'EQL) (SIZE 1024) (REHASH-SIZE
          1.5) (REHASH-THRESHOLD 0.7))
     Package:LISP

     Creates and returns a hash table.

 - Function: STRING/= (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Returns NIL if STRING1 and STRING2 are character-wise CHAR=.
     Otherwise, returns the index to the longest common prefix of the
     strings.

 - Function: STRING-GREATERP (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Similar to STRING>, but ignores cases.

 - Function: ELT (SEQUENCE INDEX)
     Package:LISP

     Returns the INDEX-th element of SEQUENCE.

 - Function: MAKE-ARRAY (DIMENSIONS
     &key (element-type t) initial-element (initial-contents nil)
          (adjustable nil) (fill-pointer nil) (displaced-to nil)
          (displaced-index-offset 0) static) Package:LISP

     Creates an array of the specified DIMENSIONS.  The default for
     INITIAL- ELEMENT depends on ELEMENT-TYPE.  MAKE-ARRAY will always
     try to find the `best' array to accommodate the element-type
     specified.   For example on a SUN element-type (mod 1) -> bit
     (integer 0 10) -> unsigned-char (integer -3 10) -> signed-char
     si::best-array-element-type is the function doing this.  It is
     also used by the compiler, for coercing array element types.  If
     you are going to declare an array you should use the same element
     type as was used in making it.  eg (setq my-array (make-array 4
     :element-type '(integer 0 10))) (the (array (integer 0 10))
     my-array)     When wanting to optimize references to an array you
     need to declare the array eg: (the (array (integer -3 10))
     my-array) if ar were constructed using the (integer -3 10)
     element-type.  You could of course have used signed-char, but
     since the ranges may be implementation dependent it is better to
     use -3 10 range.  MAKE-ARRAY needs to do some calculation with the
     element-type if you don't provide a primitive data-type.  One way
     of doing this in a machine independent fashion:

     (defvar *my-elt-type* #.        (array-element-type (make-array 1
     :element-type '(integer -3 10))))

     Then calls to (make-array n :element-type *my-elt-type*) will not
     have to go through a type inclusion computation.  The keyword
     STATIC (GCL specific) if non nil, will cause the array body to be
     non relocatable.

 - Function: NSTRING-DOWNCASE (STRING &key
     (start 0) (end (length string))) Package:LISP  Returns STRING with
     all upper case characters converted to lowercase.

 - Function: ARRAY-IN-BOUNDS-P (ARRAY
     &rest subscripts) Package:LISP  Returns T if SUBSCRIPTS are valid
     subscripts for ARRAY; NIL otherwise.

 - Function: SORT (SEQUENCE PREDICATE &key (KEY #'IDENTITY))
     Package:LISP  Destructively sorts SEQUENCE.  PREDICATE should
     return non-NIL if its first argument is to precede its second
     argument.

 - Function: HASH-TABLE-P (X)
     Package:LISP

     Returns T if X is a hash table object; NIL otherwise.

 - Function: COUNT-IF-NOT (TEST
     sequence        &key (from-end nil) (start 0) (end (length
     sequence)) (key #'identity)) Package:LISP

     Returns the number of elements in SEQUENCE not satisfying TEST.

 - Function: FILL-POINTER (VECTOR)
     Package:LISP

     Returns the fill pointer of VECTOR.

 - Function: ARRAYP (X)
     Package:LISP

     Returns T if X is an array; NIL otherwise.

 - Function: REPLACE (SEQUENCE1 SEQUENCE2
     &key (start1 0) (end1 (length sequence1))             (start2 0)
     (end2 (length sequence2))) Package:LISP

     Destructively modifies SEQUENCE1 by copying successive elements
     into it from SEQUENCE2.

 - Function: BIT-XOR (BIT-ARRAY1 BIT-ARRAY2 &optional (RESULT-BIT-ARRAY
          NIL))
     Package:LISP

     Performs a bit-wise logical XOR on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: CLRHASH (HASH-TABLE)
     Package:LISP

     Removes all entries of HASH-TABLE and returns the hash table
     itself.

 - Function: SUBSTITUTE-IF (NEWITEM TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     (count most-positive-fixnum) (key #'identity)) Package:LISP

     Returns a sequence of the same kind as SEQUENCE with the same
     elements except that all elements satisfying TEST are replaced
     with NEWITEM.

 - Function: MISMATCH (SEQUENCE1 SEQUENCE2
     &key (from-end nil) (test #'eql) test-not (start1 0) (start2 0)
             (end1 (length sequence1)) (end2 (length sequence2))
          (key #'identity)) Package:LISP

     The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared
     element-wise.  If they are of equal length and match in every
     element, the result is NIL.  Otherwise, the result is a
     non-negative integer, the index within SEQUENCE1 of the leftmost
     position at which they fail to match; or, if one is shorter than
     and a matching prefix of the other, the index within SEQUENCE1
     beyond the last position tested is returned.

 - Constant: ARRAY-TOTAL-SIZE-LIMIT
     Package:LISP The exclusive upper bound on the total number of
     elements of an array.

 - Function: VECTOR-POP (VECTOR)
     Package:LISP

     Attempts to decrease the fill-pointer of VECTOR by 1 and returns
     the element pointed to by the new fill pointer.  Signals an error
     if the old value of the fill pointer is 0.

 - Function: SUBSTITUTE (NEWITEM OLDITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (count most-positive-fixnum)
     (key #'identity)) Package:LISP

     Returns a sequence of the same kind as SEQUENCE with the same
     elements except that OLDITEMs are replaced with NEWITEM.

 - Function: ARRAY-HAS-FILL-POINTER-P (ARRAY)
     Package:LISP

     Returns T if ARRAY has a fill pointer; NIL otherwise.

 - Function: CONCATENATE (RESULT-TYPE &rest SEQUENCES)
     Package:LISP

     Returns a new sequence of the specified RESULT-TYPE, consisting of
     all elements in SEQUENCEs.

 - Function: VECTOR-PUSH (NEW-ELEMENT VECTOR)
     Package:LISP

     Attempts to set the element of ARRAY designated by its fill
     pointer to NEW-ELEMENT and increments the fill pointer by one.
     Returns NIL if the fill pointer is too large.  Otherwise, returns
     the new fill pointer value.

 - Function: STRING-TRIM (CHAR-BAG STRING)
     Package:LISP

     Returns a copy of STRING with the characters in CHAR-BAG removed
     from both ends.

 - Function: ARRAY-ELEMENT-TYPE (ARRAY)
     Package:LISP

     Returns the type of the elements of ARRAY

 - Function: NOTANY (PREDICATE SEQUENCE &rest MORE-SEQUENCES)
     Package:LISP

     Returns T if none of the elements in SEQUENCEs satisfies
     PREDICATE; NIL otherwise.

 - Function: BIT-NOT (BIT-ARRAY &optional (RESULT-BIT-ARRAY NIL))
     Package:LISP

     Performs a bit-wise logical NOT in the elements of BIT-ARRAY.
     Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL,
     into BIT-ARRAY if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY
     otherwise.

 - Function: BIT-ORC1 (BIT-ARRAY1 BIT-ARRAY2 &optional
          (RESULT-BIT-ARRAY NIL))
     Package:LISP

     Performs a bit-wise logical ORC1 on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: COUNT-IF (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence)) (key
     #'identity)) Package:LISP

     Returns the number of elements in SEQUENCE satisfying TEST.

 - Function: MAP (RESULT-TYPE FUNCTION SEQUENCE &rest MORE-SEQUENCES)
     Package:LISP

     FUNCTION must take as many arguments as there are sequences
     provided.  The result is a sequence such that the i-th element is
     the result of applying FUNCTION to the i-th elements of the
     SEQUENCEs.

 - Constant: ARRAY-RANK-LIMIT
     Package:LISP The exclusive upper bound on the rank of an array.

 - Function: COUNT (ITEM SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (key #'identity)) Package:LISP

     Returns the number of elements in SEQUENCE satisfying TEST with
     ITEM.

 - Function: BIT-VECTOR-P (X)
     Package:LISP

     Returns T if X is a bit vector; NIL otherwise.

 - Function: NSTRING-CAPITALIZE (STRING &key (START 0) (END (LENGTH
          STRING)))
     Package:LISP

     Returns STRING with the first character of each word converted to
     upper-case, and remaining characters in the word converted to
     lower case.

 - Function: ADJUST-ARRAY (ARRAY DIMENSIONS
     &key (element-type (array-element-type array))
     initial-element (initial-contents nil) (fill-pointer nil)
       (displaced-to nil) (displaced-index-offset 0)) Package:LISP

     Adjusts the dimensions of ARRAY to the given DIMENSIONS.  The
     default value of INITIAL-ELEMENT depends on ELEMENT-TYPE.

 - Function: SEARCH (SEQUENCE1 SEQUENCE2
     &key (from-end nil) (test #'eql) test-not (start1 0) (start2 0)
             (end1 (length sequence1)) (end2 (length sequence2))
          (key #'identity)) Package:LISP

     A search is conducted for the first subsequence of SEQUENCE2 which
     element-wise matches SEQUENCE1.  If there is such a subsequence in
     SEQUENCE2, the index of the its leftmost element is returned;
     otherwise, NIL is returned.

 - Function: SIMPLE-BIT-VECTOR-P (X)
     Package:LISP

     Returns T if X is a simple bit-vector; NIL otherwise.

 - Function: MAKE-SEQUENCE (TYPE LENGTH &key INITIAL-ELEMENT)
     Package:LISP

     Returns a sequence of the given TYPE and LENGTH, with elements
     initialized to INITIAL-ELEMENT.  The default value of
     INITIAL-ELEMENT depends on TYPE.

 - Function: BIT-ORC2 (BIT-ARRAY1 BIT-ARRAY2 &optional
          (RESULT-BIT-ARRAY NIL))
     Package:LISP

     Performs a bit-wise logical ORC2 on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: NREVERSE (SEQUENCE)
     Package:LISP

     Returns a sequence of the same elements as SEQUENCE but in reverse
     order.  SEQUENCE may be destroyed.

 - Constant: ARRAY-DIMENSION-LIMIT
     Package:LISP The exclusive upper bound of the array dimension.

 - Function: NOTEVERY (PREDICATE SEQUENCE &rest MORE-SEQUENCES)
     Package:LISP

     Returns T if at least one of the elements in SEQUENCEs does not
     satisfy PREDICATE; NIL otherwise.

 - Function: POSITION-IF-NOT (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence)) (key
     #'identity)) Package:LISP

     Returns the index of the first element in SEQUENCE that does not
     satisfy TEST; NIL if no such element exists.

 - Function: STRING-DOWNCASE (STRING &key (START 0) (END (LENGTH
          STRING)))
     Package:LISP

     Returns a copy of STRING with all upper case characters converted
     to lowercase.

 - Function: BIT (BIT-ARRAY &rest SUBSCRIPTS)
     Package:LISP

     Returns the bit from BIT-ARRAY at SUBSCRIPTS.

 - Function: STRING-NOT-LESSP (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Similar to STRING>=, but ignores cases.

 - Function: CHAR (STRING INDEX)
     Package:LISP

     Returns the INDEX-th character in STRING.

 - Function: AREF (ARRAY &rest SUBSCRIPTS)
     Package:LISP

     Returns the element of ARRAY specified by SUBSCRIPTS.

 - Function: FILL (SEQUENCE ITEM &key (START 0) (END (LENGTH SEQUENCE)))
     Package:LISP

     Replaces the specified elements of SEQUENCE all with ITEM.

 - Function: STABLE-SORT (SEQUENCE PREDICATE &key (KEY #'IDENTITY))
     Package:LISP

     Destructively sorts SEQUENCE.  PREDICATE should return non-NIL if
     its first argument is to precede its second argument.

 - Function: BIT-IOR (BIT-ARRAY1 BIT-ARRAY2 &optional (RESULT-BIT-ARRAY
          NIL))
     Package:LISP

     Performs a bit-wise logical IOR on the elements of BIT-ARRAY1 and
     BIT-ARRAY2.  Puts the results into a new bit array if
     RESULT-BIT-ARRAY is NIL, into BIT-ARRAY1 if RESULT-BIT-ARRAY is T,
     or into RESULT-BIT-ARRAY otherwise.

 - Function: REMHASH (KEY HASH-TABLE)
     Package:LISP

     Removes any entry for KEY in HASH-TABLE.  Returns T if such an
     entry existed; NIL otherwise.

 - Function: VECTORP (X)
     Package:LISP

     Returns T if X is a vector; NIL otherwise.

 - Function: STRING<= (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     If STRING1 is lexicographically less than or equal to STRING2,
     then returns the longest common prefix of the two strings.
     Otherwise, returns NIL.

 - Function: SIMPLE-VECTOR-P (X)
     Package:LISP

     Returns T if X is a simple vector; NIL otherwise.

 - Function: STRING-LEFT-TRIM (CHAR-BAG STRING)
     Package:LISP

     Returns a copy of STRING with the characters in CHAR-BAG removed
     from the left end.

 - Function: ARRAY-TOTAL-SIZE (ARRAY)
     Package:LISP

     Returns the total number of elements of ARRAY.

 - Function: FIND-IF-NOT (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence)) (key
     #'identity)) Package:LISP

     Returns the index of the first element in SEQUENCE that does not
     satisfy TEST; NIL if no such element exists.

 - Function: DELETE-DUPLICATES (SEQUENCE &key (FROM-END NIL) (TEST
          #'EQL) TEST-NOT (START 0)
     (end (length sequence)) (key #'identity)) Package:LISP

     Returns a sequence formed by removing duplicated elements
     destructively from SEQUENCE.

 - Function: REMOVE-DUPLICATES (SEQUENCE
     &key (from-end nil) (test #'eql) test-not (start 0)
     (end (length sequence)) (key #'identity)) Package:LISP

     The elements of SEQUENCE are examined, and if any two match, one
     is discarded.  Returns the resulting sequence.

 - Function: POSITION-IF (TEST SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence)) (key
     #'identity)) Package:LISP

     Returns the index of the first element in SEQUENCE that satisfies
     TEST; NIL if no such element exists.

 - Function: MERGE (RESULT-TYPE SEQUENCE1 SEQUENCE2 PREDICATE &key (KEY
          #'IDENTITY))
     Package:LISP

     SEQUENCE1 and SEQUENCE2 are destructively merged into a sequence
     of type RESULT-TYPE using PREDICATE to order the elements.

 - Function: EVERY (PREDICATE SEQUENCE &rest MORE-SEQUENCES)
     Package:LISP

     Returns T if every elements of SEQUENCEs satisfy PREDICATE; NIL
     otherwise.

 - Function: REDUCE (FUNCTION SEQUENCE
     &key (from-end nil) (start 0) (end (length sequence))
     initial-value) Package:LISP

     Combines all the elements of SEQUENCE using a binary operation
     FUNCTION.  If INITIAL-VALUE is supplied, it is logically placed
     before the SEQUENCE.

 - Function: STRING-LESSP (STRING1 STRING2
     &key (start1 0) (end1 (length string1))             (start2 0)
     (end2 (length string2))) Package:LISP

     Similar to STRING<, but ignores cases.