Pop-11 provides a collection of operations for manipulating integers considered as bit patterns. In order to see which bits are involved in a positive integer, use the pr_binary procedure defined above, e.g.
pr_binary(-100);
1100100
The rightmost bit corresponds to bit 0, and if there are N+1 bits the
Nth bit is the leftmost one thus printed, except that negative numbers
conceptually have 1 bits extending indefinitely to the left of the sign
bit representation. In all the following definitions remember that the
lowest value for N is 0, not 1.
testbit(INT, N) -> BOOL
This procedure tests the bit at position N in the integer INT
returning true for 1 and false for 0. It has an unusual updater,
which also returns a result:
BOOL -> testbit(INT, N) -> NEWINT
This clears or sets the N'th bit of INT to 1 if BOOL is true or 0 if
false, and the returns NEWINT as the resulting integer.
integer_leastbit(INT) -> N
Returns the bit position N of the least-significant bit set in the
integer INT. E.g.
integer_leastbit(4), integer_leastbit(5) =>
** 2 0
integer_length(INT) -> N
Returns the length in bits of INT as a two's-complement integer.
That is, N is the smallest integer such that
INT < ( 1 << N), if INT >= 0
INT >= (-1 << N), if INT < 0
Put another way: if INT is non-negative then the representation of
INT as an unsigned integer requires a field of at least N bits;
alternatively, a minimum of N+1 bits are required to represent INT
as a signed integer, regardless of its sign.
integer_bitcount(INT)
Counts the number of 1 or 0 bits in the two's-complement
representation of INT. If INT is non-negative, N is the number of 1
bits; if INT is negative, it is the number of 0 bits.
For more information on any of theses see REF NUMBERS
OPERATOR PRECEDENCE DESCRIPTION
&& 4 Logical and of bits in two integers
&&~~ 4 Logical and of first argument and negation of
second. (Useful for clearing bits.)
|| 4 Logical "inclusive or" bits in two integers.
||/& 4 Logical "exclusive or" of bits in two integers.
&&/=_0 6
&&=_0 6
These two operators provide the same results as the
boolean expressions
INT1 && INT2 /== 0
INT1 && INT2 == 0
but are more efficient and avoid producing intermediate
results.
The unary operator ~~ has precedence 4
It produces the logical complement of its argument, i.e. there is a
1 in the result for each bit position for which the argument has 0.
It is always true that ~~ INT = -(INT + 1)
OPERATOR PRECEDENCE DESCRIPTION
I << N 4 Shifts the bits in I N places left (or -N places
right if N is negative).
I >> N 4 Shifts the bits in I N places right (or -N places
left if N is negative).
integer_field(SIZE, POSITION) -> ACCESS_P
This procedure, described fully in REF NUMBERS can be used to create
very efficient procedures for accessing and updating sub-bitfields
within integers, and provides a more convenient (and more efficient)
way of manipulating such fields than by masking and shifting with
the operators && and >>, etc.