Bitwise Operations

primitive: logand n1 n2
Returns the integer which is the bit-wise AND of the two integer arguments.

Example:

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

primitive: logior n1 n2
Returns the integer which is the bit-wise OR of the two integer arguments.

Example:

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

primitive: logxor n1 n2
Returns the integer which is the bit-wise XOR of the two integer arguments.

Example:

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

primitive: lognot n
Returns the integer which is the 2s-complement of the integer argument.

Example:

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

primitive: logtest j k
```(logtest j k) == (not (zero? (logand j k)))

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

primitive: logbit? 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
```

primitive: ash int count
Returns an integer equivalent to `(inexact->exact (floor (* int (expt 2 count))))`.

Example:

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

primitive: 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
```

primitive: 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
```

primitive: integer-expt n k
Returns n raised to the non-negative integer exponent k.

Example:

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

primitive: bit-extract n start end
Returns the integer composed of the start (inclusive) through end (exclusive) bits of n. The startth bit becomes the 0-th bit in the result.

Example:

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