Boole is a generalized operator capable of performing any of the 16 bitwise logical operations on its arguments. The first argument, key, is a fixnum which designates the operation desired. The remaining arguments (i₁, i₂, ...) are the data to be operated on, and must be fixnums. The key is a four-bit number with digits ABCD, where A=1 if f(0,0) is to equal 1, B=1 if f(1,0)=1, C=1 if f(0,1) is to equal 1, and D=1 if f(1,1).

If only i₁ and i₂ are given, a single binary operation is performed. If more than 2 of these arguments is given, the selected boolean function is applied first to the first 2 arguments, and then to that result and the third argument, and so on.

The most common values for key are 1 (and), 7 (ior), 6 (xor). However, for stylistic clarity, these operations should be written as LOGAND, LOGIOR, and LOGXOR instead.

Bitwise complement can be done by (BOOLE 6 i₁ -1.). However, again for style, LOGNOT is preferred.

Examples:

Returns the logical and of its fixnum arguments. In the compiler, a macro which expands into a call to BOOLE. In the interpreter, a normal function of 2 or more arguments.

Returns the logical inclusive or of its fixnum arguments. In the compiler, a macro which expands into a call to BOOLE. In the interpreter, a normal function of 2 or more arguments.

Returns the logical exclusive or of its fixnum arguments. In the compiler, a macro which expands into a call to BOOLE. In the interpreter, a normal function of 2 or more arguments.

Returns the logical negation of its fixnum argument. In the compiler, a macro which expands into a call to BOOLE. In the interpreter, a normal function of 1 argument.

Returns T if any of the bits in the fixnum bitmask are also in the fixnum bitvector, else NIL. Same as: (ZEROP (LOGAND bitmask bitvector)).

Returns a fixnum in which all the bits are set if they were set in bitvector or were specified by the fixnum bitmask. Same as (LOGIOR bitmask bitvector).

Returns a fixnum in which all the bits are set if they were set in bitvector unless they were specified by the fixnum bitmask. Same as (BOOLE 2. bitmask bitvector).

Logical Shift. Returns k shifted left i bits if i is positive, or k shifted right (ABS i) bits if i is negative. 0 bits are shifted in to fill unused positions. The result is undefined if (ABS i) > 36. If i=0, no shift occurs, but the datatype of k is changed to fixnum. (Useful to change a flonum to fixnum for storage in a fixnum array. See FSC)

Note that (LSH -1 -1) returns the most positive fixnum for a given implementation.

Examples:

ASH is the least intuitive of the arithmetic shift operations. Basically, it is like a LSH except that the high bit (sign bit) is always preserved and sometimes stretches. Specifically: When shifting right (negative 2nd arg), the high (sign) bit is copied into the bits opened by shifting. When shifting left, only the bottom 35 bits are shifted; the sign bit is held constant and zeros pad out opened places on the low end of the word.

For a description of the potential danger of this operation, see Guy Steele's “Arithmetic Shifting Considered Harmful,” MIT AI Memo 378, September 1976.

Examples:

This is a hook into the PDP-10 floating-point scale instruction.

(FSC k #o1000000), where k is a fixnum, will convert it to a floating point number without normalizing it, skipping the actual FSC and just changing the type information of k. (See LSH)

Examples:

Returns as a fixnum the 36-bit representation of k, rotated left i bits if i is positive, or rotated right (ABS i) bits if i is negative. k and i should be fixnums. The results are undefined if (ABS i) > 36.

If k is a flonum, its datatype will be changed to fixnum without affecting its bitpattern. (See LSH and FSC.)

Note that (ROT 1 -1) returns the most negative fixnum for a given implementation.

Examples:

If i is non-negative, returns the high-order i bits of j; if i is negative, returns the (ABS i) low-order bits of j. j may be a fixnum or bignum; i must be a fixnum. The value returned is a fixnum or a bignum, as appropriate. If (ABS i) is bigger than the number of significant bits in j, (ABS j) is returned.

By the way, HAIPART has been recently identified as buggy such that if j is negative and (HAULONG j) is less than i, it returns a negative number.

Note: HAIPART is pronounced “HIGH-part.”

Examples:

Returns the number of significant bits in j. j can be a fixnum or a bignum. The result is the least integer not less than the base-two logarithm of (1+ (ABS j)).

The expression (1+ (HAULONG (LSH -1. -1.))) will return the word size of the machine.

Note: HAULONG is pronounced “HOW-long.”

Examples:

[PDP-10 Only] Returns the fixnum which is the result of placing val in the size bits beginning at bit pos in word. Bits are numbered from right to left, beginning with 0.

Examples:

[PDP-10 Only] Returns the contents of the size bits beginning at bit pos in word. Bits are numbered from right to left, beginning with 0.

Examples:

A LispM-compatible version of the DEPOSIT-BYTE concept. The second arg, bytepointer, is made from two octal digits specifying the starting position followed by two octal digits specifying the number of bits. The first arg, val, is the value to deposit in word.

Multics users must (%include runtime) to get DPB.

Example:

This is a LispM-compatible version of the LOAD-BYTE concept. The bytepointer is made from two octal digits specifying the starting position followed by two octal digits specifying the number of bits. The second arg is the word from which to extract the specified bitfield.

Multics users must (%include runtime) to get LDB.

Example:

[PDP-10 Only] For use by the compiler only. Same as DEPOSIT-BYTE.

Example:

[PDP-10 Only] For use by the compiler only. Same as LOAD-BYTE.

Example:

[PDP-10 Only] For use by the compiler only. Different from DPB only in that bytepointer is shifted left 24.

Example:

[PDP-10 Only] For use by the compiler only. Different from LDB only in that bytepointer is shifted left 24.

Example: