Next: , Previous: Top, Up: Top


1 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).

— Function: MODF (number)

Package:SYSTEM

Returns the integer and fractional part of a floating point number mod 1.0.

— 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.