[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

another operation




Hello Aubrey,

Recently, I have been using bit-twiddling extensively for representing and manipulating
subsets of finite sets---one of the purposes you mention in the SRFI document.

Two remarks:

1. As it turns out, I frequently need the following operation missing in SRFI-60:

        (FOO x) ==> i         ; this is not my proposal for the procedure's name ;-)

        i >= 0 is the index of the least significant bit set in integer x in case x > 0,
        or in -x-1 if x < 0. If x = 0 then [choose: i = -1 OR (error ...) OR i = #f OR ...]
           In other words, i = max {k >= 0 : 2^k divides x} for x > 0.

Note that FOO can be terribly slow when implemented representation-agnostic,
while being lightning fast if the implementor has access to the actual machine words.

2. When scanning different libraries of bit-twiddling, I had stumbled across an implicit
design decision that is worth mentioning because it might swiftly break portability's neck:

        "What is the value of (LOGAND)?"

In my application I define (LOGAND) := 0 because the subsets my numbers represent
are finite from way back, their parents are finite, they stay finite and vote finite. However,
(LOGAND) := -1 also makes a lot of sense because -1 (= all bits set) is the neutral element
for bitwise AND---and one can even interpret negative numbers as the complements of
finite sets. (A concept that I later abandonned because the saved case distinctions do
not make up for the confusion this creates.)

Sebastian.


P.S. Just for information, here is the specification of the Bitset (BSET) data type I use.
It turned out to be useful, convenient, and complete for its purpose (which is of course
only one of the potential applications of bit-twiddling):

; Bitsets (BSET)
; ==============
;
; A bset s represents a subset S of a fixed set X = {x[0], .., x[n-1]}.
; The set X, called the universe, is implicit in the context and is
; only passed explicitly when bsets are constructed and the subsets
; they represent are accessed.
;
; For convenience, we even identify X with {0..n-1} and delegate the
; bijection between a general finite set of cardinality n and {0..n-1}
; to other data structures, e.g. search trees. A bset s is a non-negative
; integer of which the x-th bit is set if and only if x is an element of
; the set being represented by s.
;
; Naming convention:
;   n        : cardinality of the universe, exact integer, n >= 0
;   s, t, .. : bsets, i.e. exact integers in {0..2^n-1}
;   x, y, .. : elements of {0..n-1}
;
; Procedures:
;
; (bset? obj)               test if obj is exact non-negative integer
; (bset x ...)              smallest set containing the given elements
; (bset-full n)             the set {0..n-1}, n >= 0
; (bset-empty? s)           test if s = {}
; (bset-in? x s)            test if x in s
; (bset-equal? s t)         test if s = t
; (bset-compare s t)        -1 if s < t, 0 if s = t, 1 if s > t
; (bset-subset? s t)        test if s is a subset of t
; (bset-disjoint? s t)      test if s and t are disjoint
; (bset-size s)             number of elements of s
; (bset-min s)              minimal element of s, or #f if s is empty
; (bset-max s)              maximal element of s, or #f if s is empty
; (bset-union s ...)        union of the sets, (bset-union) = 0
; (bset-intersection s ...) intersection of the sets, (bset-intersection) = 0
; (bset-difference s t ...) difference of s and union of the t's
; (bset->list s)            list of elements in s in increasing order
;
; Macros using and extending SRFI-42 'Eager comprehensions':
;
; (bset-ec <qualifier>^* <element>)
;    the bset of the elements obtained by evaluating <element> for
;    each binding in the sequence defined by <qualifier>^*.
;
; (bset-union-ec <qualifier>^* <bset>)
;    the union of the bsets obtained by evaluating <bset> for each
;    binding in the sequence defined by the <qualifier>^*.
;
; (:bset <x> [ (index <i>) ] <bset>)
;    binds <x> in turn to each element in <bset>. The elements
;    of <bset> are enumerated in strictly increasing order.
;
; (:bset-in? <in?> [ (index <x>) ] [ <n> ] <bset>)
;    binds <in?> to #t if x is in <bset> and to #f otherwise.
;    The sequence enumerates all elements x in {0..<n>-1},
;    or in {0..max(<bset>)} if n is not provided, in strictly
;    increasing order.

----
Dr. Sebastian Egner
Senior Scientist
Philips Research Laboratories
Prof. Holstlaan 4 (postbox WY63, kamer WY 6-55)
5656 AA Eindhoven
The Netherlands
tel:       +31 40 27-42069
fax:      +31 40 27-42566
email: sebastian.egner@xxxxxxxxxxx