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