DOC HOME SITE MAP MAN PAGES GNU INFO SEARCH

# (guile.info.gz) Bitwise Operations Info Catalog (guile.info.gz) Primitive Numerics (guile.info.gz) Numbers (guile.info.gz) Random
```
21.2.14 Bitwise Operations
--------------------------

-- Scheme Procedure: logand n1 n2
Return the bitwise AND of the integer arguments.

(logand) => -1
(logand 7) => 7
(logand #b111 #b011 #b001) => 1

-- Scheme Procedure: logior n1 n2
Return the bitwise OR of the integer arguments.

(logior) => 0
(logior 7) => 7
(logior #b000 #b001 #b011) => 3

-- Scheme Procedure: logxor n1 n2
Return the bitwise XOR of the integer arguments.  A bit is set in
the result if it is set in an odd number of arguments.
(logxor) => 0
(logxor 7) => 7
(logxor #b000 #b001 #b011) => 2
(logxor #b000 #b001 #b011 #b011) => 1

-- Scheme Procedure: lognot n
-- C Function: scm_lognot (n)
Return the integer which is the ones-complement of the integer
argument, ie. each 0 bit is changed to 1 and each 1 bit to 0.

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

-- Scheme Procedure: logtest j k
-- C Function: scm_logtest (j, k)
(logtest j k) == (not (zero? (logand j k)))

(logtest #b0100 #b1011) => #f
(logtest #b0100 #b0111) => #t

-- Scheme Procedure: logbit? index j
-- C Function: scm_logbit_p (index, j)
(logbit? index j) == (logtest (integer-expt 2 index) j)

(logbit? 0 #b1101) => #t
(logbit? 1 #b1101) => #f
(logbit? 2 #b1101) => #t
(logbit? 3 #b1101) => #t
(logbit? 4 #b1101) => #f

-- Scheme Procedure: ash n cnt
-- C Function: scm_ash (n, cnt)
The function ash performs an arithmetic shift left by CNT bits (or
shift right, if CNT is negative).  'Arithmetic' means, that the
function does not guarantee to keep the bit structure of N, but
rather guarantees that the result will always be rounded towards
minus infinity.  Therefore, the results of ash and a corresponding
bitwise shift will differ if N is negative.

Formally, the function returns an integer equivalent to
`(inexact->exact (floor (* N (expt 2 CNT))))'.

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

-- Scheme Procedure: logcount n
-- C Function: scm_logcount (n)
Return 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.

(logcount #b10101010)
=> 4
(logcount 0)
=> 0
(logcount -2)
=> 1

-- Scheme Procedure: integer-length n
-- C Function: scm_integer_length (n)
Return the number of bits necessary to represent N.

(integer-length #b10101010)
=> 8
(integer-length 0)
=> 0
(integer-length #b1111)
=> 4

-- Scheme Procedure: integer-expt n k
-- C Function: scm_integer_expt (n, k)
Return N raised to the non-negative integer exponent K.

(integer-expt 2 5)
=> 32
(integer-expt -3 3)
=> -27

-- Scheme Procedure: bit-extract n start end
-- C Function: scm_bit_extract (n, start, end)
Return the integer composed of the START (inclusive) through END
(exclusive) bits of N.  The STARTth bit becomes the 0-th bit in
the result.

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

``` Info Catalog (guile.info.gz) Primitive Numerics (guile.info.gz) Numbers (guile.info.gz) Random
automatically generated byinfo2html