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.