@node Numbers, Sequences and Arrays and Hash Tables, Top, Top
@chapter Numbers


@defun SIGNUM (number)
Package:LISP

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


@end defun

@defun LOGNOT (integer)
Package:LISP

Returns the bit-wise logical NOT of INTEGER.


@end defun

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


@end defvr

@defun 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.


@end defun

@defun MINUSP (number)
Package:LISP

Returns T if NUMBER < 0; NIL otherwise.


@end defun

@defun LOGORC1 (integer1 integer2)
Package:LISP

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


@end defun

@defvr {Constant} MOST-NEGATIVE-SINGLE-FLOAT 
Package:LISP
Same as MOST-NEGATIVE-LONG-FLOAT.


@end defvr

@defvr {Constant} BOOLE-C1 
Package:LISP
Makes BOOLE return the complement of INTEGER1.


@end defvr

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


@end defvr

@defun 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.

@end defun

@defun INT-CHAR (integer)
Package:LISP

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


@end defun

@defun CHAR-INT (char)
Package:LISP

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


@end defun

@defvr {Constant} LEAST-NEGATIVE-SINGLE-FLOAT 
Package:LISP
Same as LEAST-NEGATIVE-LONG-FLOAT.


@end defvr

@defun /= (number &rest more-numbers)
Package:LISP

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


@end defun

@defun 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.


@end defun

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


@end defvr

@defun RATIONAL (number)
Package:LISP

Converts NUMBER into rational accurately and returns it.


@end defun

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


@end defvr

@defun SIN (radians)
Package:LISP

Returns the sine of RADIANS.


@end defun

@defvr {Constant} BOOLE-ORC2 
Package:LISP
Makes BOOLE return LOGORC2 of INTEGER1 and INTEGER2.


@end defvr

@defun NUMERATOR (rational)
Package:LISP

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


@end defun

@defun MASK-FIELD (bytespec integer)
Package:LISP

Extracts the specified byte from INTEGER.


@end defun

@deffn {Special Form} INCF 
Package:LISP

Syntax:
@example
(incf place [delta])
@end example

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


@end deffn

@defun SINH (number)
Package:LISP

Returns the hyperbolic sine of NUMBER.


@end defun

@defun PHASE (number)
Package:LISP

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


@end defun

@defun 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.


@end defun

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


@end defvr

@defun LOGORC2 (integer1 integer2)
Package:LISP

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


@end defun

@defvr {Constant} BOOLE-C2 
Package:LISP
Makes BOOLE return the complement of INTEGER2.


@end defvr

@defun REALPART (number)
Package:LISP

Extracts the real part of NUMBER.


@end defun


@defvr {Constant} BOOLE-CLR 
Package:LISP
Makes BOOLE return 0.


@end defvr

@defvr {Constant} BOOLE-IOR 
Package:LISP
Makes BOOLE return LOGIOR of INTEGER1 and INTEGER2.


@end defvr

@defun FTRUNCATE (number &optional (divisor 1))
Package:LISP

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


@end defun

@defun 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.


@end defun

@defun LOG (number &optional base)
Package:LISP

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


@end defun

@defvr {Constant} DOUBLE-FLOAT-NEGATIVE-EPSILON 
Package:LISP
Same as LONG-FLOAT-NEGATIVE-EPSILON.


@end defvr

@defun LOGIOR (&rest integers)
Package:LISP

Returns the bit-wise INCLUSIVE OR of its arguments.


@end defun

@defvr {Constant} MOST-NEGATIVE-DOUBLE-FLOAT 
Package:LISP
Same as MOST-NEGATIVE-LONG-FLOAT.


@end defvr

@defun / (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.


@end defun

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


@end defvar

@defun 1+ (number)
Package:LISP

Returns NUMBER + 1.


@end defun

@defvr {Constant} LEAST-NEGATIVE-DOUBLE-FLOAT 
Package:LISP
Same as LEAST-NEGATIVE-LONG-FLOAT.


@end defvr

@defun FCEILING (number &optional (divisor 1))
Package:LISP

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


@end defun

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


@end defvr

@defun 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.


@end defun

@defun TAN (radians)
Package:LISP

Returns the tangent of RADIANS.


@end defun

@defvr {Constant} BOOLE-NAND 
Package:LISP
Makes BOOLE return LOGNAND of INTEGER1 and INTEGER2.


@end defvr

@defun TANH (number)
Package:LISP

Returns the hyperbolic tangent of NUMBER.


@end defun

@defun ASIN (number)
Package:LISP

Returns the arc sine of NUMBER.


@end defun

@defun BYTE (size position)
Package:LISP

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


@end defun

@defun ASINH (number)
Package:LISP

Returns the hyperbolic arc sine of NUMBER.


@end defun

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


@end defvr

@deffn {Macro} SHIFTF 
Package:LISP

Syntax:
@example
(shiftf @{place@}+ newvalue)
@end example

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.


@end deffn

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


@end defvr

@defun DEPOSIT-FIELD (newbyte bytespec integer)
Package:LISP

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


@end defun

@defun 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.


@end defun

@defun LOGNAND (integer1 integer2)
Package:LISP

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


@end defun

@defun BYTE-POSITION (bytespec)
Package:LISP

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


@end defun

@deffn {Macro} ROTATEF 
Package:LISP

Syntax:
@example
(rotatef @{place@}*)
@end example

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.


@end deffn

@defun 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.


@end defun

@defun 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.


@end defun

@defvr {Constant} BOOLE-EQV 
Package:LISP
Makes BOOLE return LOGEQV of INTEGER1 and INTEGER2.


@end defvr

@defvr {Constant} BOOLE-SET 
Package:LISP
Makes BOOLE return -1.


@end defvr

@defun LDB (bytespec integer)
Package:LISP

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


@end defun

@defun BYTE-SIZE (bytespec)
Package:LISP

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


@end defun

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


@end defvr

@defun REM (number divisor)
Package:LISP

Returns the second value of (TRUNCATE NUMBER DIVISOR).


@end defun

@defun MIN (number &rest more-numbers)
Package:LISP

Returns the least of its arguments.


@end defun

@defun EXP (number)
Package:LISP

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


@end defun

@defun 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.



@end defun

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


@end defvr

@defun FROUND (number &optional (divisor 1))
Package:LISP

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


@end defun

@defun LOGEQV (&rest integers)
Package:LISP

Returns the bit-wise EQUIVALENCE of its arguments.


@end defun

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


@end defvr

@defun 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.


@end defun

@defun CEILING (number &optional (divisor 1))
Package:LISP

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


@end defun

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


@end defvr

@defun 1- (number)
Package:LISP

Returns NUMBER - 1.


@end defun

@defun <= (number &rest more-numbers)
Package:LISP

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


@end defun

@defun IMAGPART (number)
Package:LISP

Extracts the imaginary part of NUMBER.


@end defun

@defun INTEGERP (x)
Package:LISP

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


@end defun

@defun ASH (integer count)
Package:LISP

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


@end defun

@defun LCM (integer &rest more-integers)
Package:LISP

Returns the least common multiple of the arguments.


@end defun

@defun COS (radians)
Package:LISP

Returns the cosine of RADIANS.


@end defun

@deffn {Special Form} DECF 
Package:LISP

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


@end deffn

@defun ATAN (x &optional (y 1))
Package:LISP
 Returns the arc tangent of
X/Y.


@end defun

@defvr {Constant} BOOLE-ANDC1 
Package:LISP
Makes BOOLE return LOGANDC1 of INTEGER1 and INTEGER2.


@end defvr

@defun COSH (number)
Package:LISP
 Returns the hyperbolic cosine of
NUMBER.


@end defun

@defun FLOAT-RADIX  (float)
Package:LISP

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


@end defun

@defun ATANH  (number)
Package:LISP

Returns the hyperbolic arc tangent of NUMBER.


@end defun

@defun EVENP  (integer)
Package:LISP
 Returns T
if INTEGER is even.  Returns NIL if INTEGER is odd.


@end defun

@defun ZEROP (number)
Package:LISP
 Returns T if NUMBER = 0; NIL
otherwise.


@end defun

@defun FLOATP (x)
Package:LISP

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


@end defun

@defun SXHASH (object)
Package:LISP

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


@end defun

@defvr {Constant} BOOLE-1 
Package:LISP
Makes BOOLE return INTEGER1.


@end defvr

@defvr {Constant} MOST-POSITIVE-SINGLE-FLOAT 
Package:LISP
Same as MOST-POSITIVE-LONG-FLOAT.


@end defvr

@defun LOGANDC1 (integer1 integer2)
Package:LISP

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


@end defun

@defvr {Constant} LEAST-POSITIVE-SINGLE-FLOAT 
Package:LISP
Same as LEAST-POSITIVE-LONG-FLOAT.


@end defvr

@defun COMPLEXP (x)
Package:LISP

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


@end defun

@defvr {Constant} BOOLE-AND 
Package:LISP
Makes BOOLE return LOGAND of INTEGER1 and INTEGER2.


@end defvr

@defun MAX (number &rest more-numbers)
Package:LISP

Returns the greatest of its arguments.


@end defun

@defun 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.


@end defun

@defvr {Constant} BOOLE-ANDC2 
Package:LISP
Makes BOOLE return LOGANDC2 of INTEGER1 and INTEGER2.


@end defvr

@defun DENOMINATOR (rational)
Package:LISP

Returns the denominator of RATIONAL as an integer.


@end defun

@defun 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.


@end defun

@defun ROUND (number &optional (divisor 1))
Package:LISP

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


@end defun

@defun LOGAND (&rest integers)
Package:LISP

Returns the bit-wise AND of its arguments.


@end defun

@defvr {Constant} BOOLE-2 
Package:LISP
Makes BOOLE return INTEGER2.


@end defvr

@defun * (&rest numbers)
Package:LISP

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


@end defun

@defun < (number &rest more-numbers)
Package:LISP

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


@end defun

@defun COMPLEX (realpart &optional (imagpart 0))
Package:LISP

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


@end defun

@defvr {Constant} SINGLE-FLOAT-EPSILON 
Package:LISP
Same as LONG-FLOAT-EPSILON.


@end defvr

@defun LOGANDC2 (integer1 integer2)
Package:LISP

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


@end defun

@defun INTEGER-LENGTH (integer)
Package:LISP

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


@end defun

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


@end defvr

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


@end defvr

@defun >= (number &rest more-numbers)
Package:LISP

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


@end defun

@defvr {Constant} BOOLE-NOR 
Package:LISP
Makes BOOLE return LOGNOR of INTEGER1 and INTEGER2.


@end defvr

@defun ACOS (number)
Package:LISP

Returns the arc cosine of NUMBER.


@end defun

@defun 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.


@end defun

@defun EXPT (base-number power-number)
Package:LISP

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


@end defun

@defun SQRT (number)
Package:LISP

Returns the principal square root of NUMBER.


@end defun

@defun SCALE-FLOAT (float integer)
Package:LISP

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


@end defun

@defun ACOSH (number)
Package:LISP

Returns the hyperbolic arc cosine of NUMBER.


@end defun

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


@end defvr

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


@end defvr

@defun FFLOOR (number &optional (divisor 1))
Package:LISP

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


@end defun

@defun LOGNOR (integer1 integer2)
Package:LISP

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


@end defun

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

Parses STRING for an integer and returns it.


@end defun

@defun + (&rest numbers)
Package:LISP

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


@end defun

@defun = (number &rest more-numbers)
Package:LISP

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


@end defun

@defun NUMBERP (x)
Package:LISP

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


@end defun

@defvr {Constant} MOST-POSITIVE-DOUBLE-FLOAT 
Package:LISP
Same as MOST-POSITIVE-LONG-FLOAT.


@end defvr

@defun LOGTEST (integer1 integer2)
Package:LISP

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


@end defun

@defun RANDOM-STATE-P (x)
Package:LISP

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


@end defun

@defvr {Constant} LEAST-POSITIVE-DOUBLE-FLOAT 
Package:LISP
Same as LEAST-POSITIVE-LONG-FLOAT.


@end defvr

@defun 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).


@end defun

@defvr {Constant} BOOLE-XOR 
Package:LISP
Makes BOOLE return LOGXOR of INTEGER1 and INTEGER2.


@end defvr

@defun DPB (newbyte bytespec integer)
Package:LISP

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


@end defun

@defun ABS (number)
Package:LISP

Returns the absolute value of NUMBER.


@end defun

@defun CONJUGATE (number)
Package:LISP

Returns the complex conjugate of NUMBER.


@end defun

@defun CIS (radians)
Package:LISP

Returns e raised to i*RADIANS.


@end defun

@defun ODDP (integer)
Package:LISP

Returns T if INTEGER is odd; NIL otherwise.


@end defun

@defun RATIONALIZE (number)
Package:LISP

Converts NUMBER into rational approximately and returns it.


@end defun

@defun ISQRT (integer)
Package:LISP

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


@end defun

@defun LOGXOR (&rest integers)
Package:LISP

Returns the bit-wise EXCLUSIVE OR of its arguments.


@end defun

@defun > (number &rest more-numbers)
Package:LISP

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


@end defun

@defun LOGBITP (index integer)
Package:LISP

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


@end defun

@defvr {Constant} DOUBLE-FLOAT-EPSILON 
Package:LISP
Same as LONG-FLOAT-EPSILON.


@end defvr

@defun LOGCOUNT (integer)
Package:LISP

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


@end defun

@defun GCD (&rest integers)
Package:LISP

Returns the greatest common divisor of INTEGERs.


@end defun

@defun RATIONALP (x)
Package:LISP

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


@end defun

@defun MOD (number divisor)
Package:LISP

Returns the second result of (FLOOR NUMBER DIVISOR).


@end defun

@defvr {Constant} BOOLE-ORC1 
Package:LISP
Makes BOOLE return LOGORC1 of INTEGER1 and INTEGER2.


@end defvr

@defvr {Constant} SINGLE-FLOAT-NEGATIVE-EPSILON 
Package:LISP
Same as LONG-FLOAT-NEGATIVE-EPSILON.


@end defvr

@defun 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)).


@end defun

@defun PLUSP (number)
Package:LISP

Returns T if NUMBER > 0; NIL otherwise.


@end defun

@defun 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).


@end defun

@defun 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.


@end defun
