Next: Modular Arithmetic, Previous: Mathematical Packages, Up: Mathematical Packages [Contents][Index]

`(require 'logical)`

or `(require 'srfi-60)`

The bit-twiddling functions are made available through the use of the
`logical`

package. `logical`

is loaded by inserting
`(require 'logical)`

before the code that uses these functions.
These functions behave as though operating on integers in
two’s-complement representation.

- Function:
**logand***n1 …*¶ - Function:
**bitwise-and***n1 …*¶ Returns the integer which is the bit-wise AND of the integer arguments.

Example:

(number->string (logand #b1100 #b1010) 2) ⇒ "1000"

- Function:
**logior***n1 …*¶ - Function:
**bitwise-ior***n1 …*¶ Returns the integer which is the bit-wise OR of the integer arguments.

Example:

(number->string (logior #b1100 #b1010) 2) ⇒ "1110"

- Function:
**logxor***n1 …*¶ - Function:
**bitwise-xor***n1 …*¶ Returns the integer which is the bit-wise XOR of the integer arguments.

Example:

(number->string (logxor #b1100 #b1010) 2) ⇒ "110"

- Function:
**lognot***n*¶ - Function:
**bitwise-not***n*¶ Returns the integer which is the one’s-complement of the integer argument.

Example:

(number->string (lognot #b10000000) 2) ⇒ "-10000001" (number->string (lognot #b0) 2) ⇒ "-1"

- Function:
**logcount***n*¶ Returns the number of bits in integer

`n`. If integer is positive, the 1-bits in its binary representation are counted. If negative, the 0-bits in its two’s-complement binary representation are counted. If 0, 0 is returned.Example:

(logcount #b10101010) ⇒ 4 (logcount 0) ⇒ 0 (logcount -2) ⇒ 1

On `discuss@r6rs.org`

Ben Harris credits Simon Tatham with the
idea to have `bitwise-bit-count`

return a negative count for
negative inputs. Alan Bawden came up with the succinct invariant.

- Function:
**bitwise-bit-count***n*¶ If

`n`is non-negative, this procedure returns the number of 1 bits in the two’s-complement representation of`n`. Otherwise it returns the result of the following computation:(bitwise-not (bitwise-bit-count (bitwise-not

`n`)))

- Function:
**integer-length***n*¶ Returns the number of bits neccessary to represent

`n`.Example:

(integer-length #b10101010) ⇒ 8 (integer-length 0) ⇒ 0 (integer-length #b1111) ⇒ 4

- Function:
**log2-binary-factors***n*¶ - Function:
**first-set-bit***n*¶ Returns the number of factors of two of integer

`n`. This value is also the bit-index of the least-significant ‘`1`’ bit in`n`.(require 'printf) (do ((idx 0 (+ 1 idx))) ((> idx 16)) (printf "%s(%3d) ==> %-5d %s(%2d) ==> %-5d\n" 'log2-binary-factors (- idx) (log2-binary-factors (- idx)) 'log2-binary-factors idx (log2-binary-factors idx))) -| log2-binary-factors( 0) ==> -1 log2-binary-factors( 0) ==> -1 log2-binary-factors( -1) ==> 0 log2-binary-factors( 1) ==> 0 log2-binary-factors( -2) ==> 1 log2-binary-factors( 2) ==> 1 log2-binary-factors( -3) ==> 0 log2-binary-factors( 3) ==> 0 log2-binary-factors( -4) ==> 2 log2-binary-factors( 4) ==> 2 log2-binary-factors( -5) ==> 0 log2-binary-factors( 5) ==> 0 log2-binary-factors( -6) ==> 1 log2-binary-factors( 6) ==> 1 log2-binary-factors( -7) ==> 0 log2-binary-factors( 7) ==> 0 log2-binary-factors( -8) ==> 3 log2-binary-factors( 8) ==> 3 log2-binary-factors( -9) ==> 0 log2-binary-factors( 9) ==> 0 log2-binary-factors(-10) ==> 1 log2-binary-factors(10) ==> 1 log2-binary-factors(-11) ==> 0 log2-binary-factors(11) ==> 0 log2-binary-factors(-12) ==> 2 log2-binary-factors(12) ==> 2 log2-binary-factors(-13) ==> 0 log2-binary-factors(13) ==> 0 log2-binary-factors(-14) ==> 1 log2-binary-factors(14) ==> 1 log2-binary-factors(-15) ==> 0 log2-binary-factors(15) ==> 0 log2-binary-factors(-16) ==> 4 log2-binary-factors(16) ==> 4

- Function:
**logbit?***index n*¶ - Function:
**bit-set?***index n*¶ (logbit? index n) ≡ (logtest (expt 2 index) n) (logbit? 0 #b1101) ⇒ #t (logbit? 1 #b1101) ⇒ #f (logbit? 2 #b1101) ⇒ #t (logbit? 3 #b1101) ⇒ #t (logbit? 4 #b1101) ⇒ #f

- Function:
**copy-bit***index from bit*¶ Returns an integer the same as

`from`except in the`index`th bit, which is 1 if`bit`is`#t`

and 0 if`bit`is`#f`

.Example:

(number->string (copy-bit 0 0 #t) 2) ⇒ "1" (number->string (copy-bit 2 0 #t) 2) ⇒ "100" (number->string (copy-bit 2 #b1111 #f) 2) ⇒ "1011"

- Function:
**bit-field***n start end*¶ Returns the integer composed of the

`start`(inclusive) through`end`(exclusive) bits of`n`. The`start`th bit becomes the 0-th bit in the result.Example:

(number->string (bit-field #b1101101010 0 4) 2) ⇒ "1010" (number->string (bit-field #b1101101010 4 9) 2) ⇒ "10110"

- Function:
**copy-bit-field***to from start end*¶ Returns an integer the same as

`to`except possibly in the`start`(inclusive) through`end`(exclusive) bits, which are the same as those of`from`. The 0-th bit of`from`becomes the`start`th bit of the result.Example:

(number->string (copy-bit-field #b1101101010 0 0 4) 2) ⇒ "1101100000" (number->string (copy-bit-field #b1101101010 -1 0 4) 2) ⇒ "1101101111" (number->string (copy-bit-field #b110100100010000 -1 5 9) 2) ⇒ "110100111110000"

- Function:
**ash***n count*¶ - Function:
**arithmetic-shift***n count*¶ Returns an integer equivalent to

`(inexact->exact (floor (*`

.`n`(expt 2`count`))))Example:

(number->string (ash #b1 3) 2) ⇒ "1000" (number->string (ash #b1010 -1) 2) ⇒ "101"

- Function:
**rotate-bit-field***n count start end*¶ Returns

`n`with the bit-field from`start`to`end`cyclically permuted by`count`bits towards high-order.Example:

(number->string (rotate-bit-field #b0100 3 0 4) 2) ⇒ "10" (number->string (rotate-bit-field #b0100 -1 0 4) 2) ⇒ "10" (number->string (rotate-bit-field #b110100100010000 -1 5 9) 2) ⇒ "110100010010000" (number->string (rotate-bit-field #b110100100010000 1 5 9) 2) ⇒ "110100000110000"

- Function:
**reverse-bit-field***n start end*¶ Returns

`n`with the order of bits`start`to`end`reversed.(number->string (reverse-bit-field #xa7 0 8) 16) ⇒ "e5"

- Function:
**integer->list***k len*¶ - Function:
**integer->list***k*¶ `integer->list`

returns a list of`len`booleans corresponding to each bit of the non-negative integer`k`. #t is coded for each 1; #f for 0. The`len`argument defaults to`(integer-length`

.`k`)

- Function:
**list->integer***list*¶ `list->integer`

returns an integer formed from the booleans in the list`list`, which must be a list of booleans. A 1 bit is coded for each #t; a 0 bit for #f.(list->integer (integer->list

`k`)) ⇒`k`

- Function:
**booleans->integer***bool1 …*¶ Returns the integer coded by the

`bool1`… arguments.