These functions operate on the 2’s complement binary representation of an exact integer.
Returns the bit-wise logical inverse of the argument. More formally, returns the exact integer whose two’s complement representation is the one’s complement of the two’s complement representation of
i
.
These procedures return the exact integer that is the bit-wise “and”, “inclusive or”, or “exclusive or” of the two’s complement representations of their arguments. If they are passed only one argument, they return that argument. If they are passed no arguments, they return the integer that acts as identity for the operation: -1, 0, or 0, respectively.
Procedure: bitwise-if
i1
i2
i3
Returns the exact integer that is the bit-wise “if” of the twos complement representations of its arguments, i.e. for each bit, if it is 1 in i1, the corresponding bit in i2 becomes the value of the corresponding bit in the result, and if it is 0, the corresponding bit in i3 becomes the corresponding bit in the value of the result. This is equivaent to the following computation:
(bitwise-ior (bitwise-and i1 i2) (bitwise-and (bitwise-not i1) i3))
Procedure: bitwise-bit-count
i
If i is non-negative, returns the number of 1 bits in the twos complement representation of i. Otherwise it returns the result of the following computation:
(bitwise-not (bitwise-bit-count (bitwise-not i)))
Returns the number of bits needed to represent i if it is positive, and the number of bits needed to represent
(bitwise-not
if it is negative, which is the exact integer that is the result of the following computation:i
)(do ((result 0 (+ result 1)) (bits (if (negative? i) (bitwise-not i) ei) (bitwise-arithmetic-shift bits -1))) ((zero? bits) result))This is the number of bits needed to represent
i
in an unsigned field.
Procedure: bitwise-first-bit-set
i
Returns the index of the least significant 1 bit in the twos complement representation of i. If i is 0, then - 1 is returned.
(bitwise-first-bit-set 0) ⇒ -1 (bitwise-first-bit-set 1) ⇒ 0 (bitwise-first-bit-set -4) ⇒ 2
Procedure: bitwise-bit-set?
i1
i2
Returns
#t
if the i2’th bit (wherei2
must be non-negative) is 1 in the two’s complement representation ofi1
, and#f
otherwise. This is the result of the following computation:(not (zero? (bitwise-and (bitwise-arithmetic-shift-left 1 i2) i1)))
Procedure: bitwise-copy-bit
i
bitno
replacement-bit
Returns the result of replacing the
bitno
’th bit ofi
byreplacement-bit
, wherebitno
must be non-negative, andreplacement-bit
must be either 0 or 1. This is the result of the following computation:(let* ((mask (bitwise-arithmetic-shift-left 1 bitno))) (bitwise-if mask (bitwise-arithmetic-shift-left replacement-bit bitno) i))
Procedure: bitwise-bit-field
n
start
end
Returns the integer formed from the (unsigned) bit-field starting at
start
and ending just beforeend
. Same as:(let ((mask (bitwise-not (bitwise-arithmetic-shift-left -1end
)))) (bitwise-arithmetic-shift-right (bitwise-andn
mask)start
))
Procedure: bitwise-copy-bit-field
to
start
end
from
Returns the result of replacing in
to
the bits at positions fromstart
(inclusive) toend
(exclusive) by the bits infrom
from position 0 (inclusive) to positionend
-start
(exclusive). Bothstart
andstart
must be non-negative, andstart
must be less than or equal tostart
.This is the result of the following computation:
(let* ((mask1 (bitwise-arithmetic-shift-left -1 start)) (mask2 (bitwise-not (bitwise-arithmetic-shift-left -1 end))) (mask (bitwise-and mask1 mask2))) (bitwise-if mask (bitwise-arithmetic-shift-left from start) to))
Procedure: bitwise-arithmetic-shift
i
j
Shifts
i
byj
. It is a “left” shift if, and a “right” shift if
j
>0. The result is equal to
j
<0(floor (*
.i
(expt 2j
)))Examples:
(bitwise-arithmetic-shift -6 -1) ⇒-3 (bitwise-arithmetic-shift -5 -1) ⇒ -3 (bitwise-arithmetic-shift -4 -1) ⇒ -2 (bitwise-arithmetic-shift -3 -1) ⇒ -2 (bitwise-arithmetic-shift -2 -1) ⇒ -1 (bitwise-arithmetic-shift -1 -1) ⇒ -1
Procedure: bitwise-arithmetic-shift-left
i
amount
Procedure: bitwise-arithmetic-shift-right
i
amount
The
amount
must be non-negative Thebitwise-arithmetic-shift-left
procedure returns the same result asbitwise-arithmetic-shift
, and(bitwise-arithmetic-shift-right
returns the same result asi
amount
)(bitwise-arithmetic-shift
.i
(-amount
))If
i
is a primitive integer type, thenamount
must be less than the number of bits in the promoted type ofi
(32 or 64). If the type is unsigned, an unsigned (logic) shift is done forbitwise-arithmetic-shift-right
, rather than a signed (arithmetic) shift.
Procedure: bitwise-rotate-bit-field
n
start
end
count
Returns the result of cyclically permuting in
n
the bits at positions fromstart
(inclusive) toend
(exclusive) bycount
bits towards the more significant bits,start
andend
must be non-negative, andstart
must be less than or equal toend
. This is the result of the following computation:(let* ((n ei1) (width (- end start))) (if (positive? width) (let* ((count (mod count width)) (field0 (bitwise-bit-field n start end)) (field1 (bitwise-arithmetic-shift-left field0 count)) (field2 (bitwise-arithmetic-shift-right field0 (- width count))) (field (bitwise-ior field1 field2))) (bitwise-copy-bit-field n start end field)) n))
Procedure: bitwise-reverse-bit-field
i
start
end
Returns the result obtained from
i
by reversing the order of the bits at positions fromstart
(inclusive) toend
(exclusive), wherestart
andend
must be non-negative, andstart
must be less than or equal toend
.(bitwise-reverse-bit-field #b1010010 1 4) ⇒ 88 ; #b1011000
Perform one of the 16 bitwise operations of
x
andy
, depending onop
.
Returns true if the arguments have any bits in common. Same as
(not (zero? (bitwise-and
, but is more efficient.i
j
)))
Kawa supports SRFI-60 “Integers as Bits” as well, although we
generally recommend using the R6RS-compatible functions instead when
possible. Unless noted as being a builtin function, to use these you
must first (require 'srfi-60)
or (import (srfi :60))
(or (import (srfi :60 integer-bits))
).
Equivalent to
(bitwise-and
. Builtin.i
...)
Equivalent to
(bitwise-ior
. Builtin.i
...)
Equivalent to
(bitwise-xor
. Builtin.i
...)
Equivalent to
(bitwise-not
. Builtin.i
)
Procedure: bitwise-merge
mask
i
j
Equivalent to
(bitwise-if
.mask
i
j
)
Equivalent to
(logtest
.i
j
)
Count the number of 1-bits in
i
, if it is non-negative. Ifi
is negative, count number of 0-bits. Same as(bitwise-bit-count
ifi
)i
is non-negative. Builtin aslogcount
.
Equivalent to
(bitwise-length
. Builtin.i
)
Procedure: log2-binary-factors
i
Equivalent to
(bitwise-first-bit-set
.i
)
Equivalent to
(bitwise-bit-set?
.i
pos
)
Procedure: copy-bit
bitno
i
bool
Equivalent to
(bitwise-copy-bit
.i
bitno
(ifbool
1 0))
Procedure: bit-field
n
start
end
Equivalent to
(bitwise-bit-field
.n
start
end
)
Procedure: copy-bit-field
to
from
start
end
Equivalent to
(bitwise-copy-bit-field
.to
start
end
from
)
Procedure: arithmetic-shift
i
j
Equivalent to
(bitwise-arithmetic-shift
. Builtin.i
j
)
Alias for
arithmetic-shift
. Builtin.
Procedure: rotate-bit-field
n
count
start
end
Equivalent to
(bitwise-rotate-bit-field
.n
start
end
count
)
Procedure: reverse-bit-field
i
start
end
Equivalent to
(bitwise-reverse-bit-field
.i
start
end
)
Procedure: integer->list
[k
]length
The
integer->list
procedure returns a list oflength
booleans corresponding to the bits of the non-negative integerk
, with#t
for1
and#f
for0
.length
defaults to(bitwise-length
. The list will be in order from MSB to LSB, with the value ofk
)(odd?
in the last car.k
)The
list->integer
procedure returns the integer corresponding to the booleans in the listlist
. Theinteger->list
andlist->integer
procedures are inverses so far asequal?
is concerned.
Procedure: booleans->integer
bool1
...
Returns the integer coded by the
bool1
... arguments. Equivalent to(list->integer (list
.bool1
...))