An "open" BitSet implementation that allows direct access to the array of words
storing the bits.

Unlike java.util.bitset, the fact that bits are packed into an array of longs
is part of the interface. This allows efficient implementation of other algorithms
by someone other than the author. It also allows one to efficiently implement
alternate serialization or interchange formats.

OpenBitSet is faster than java.util.BitSet in most operations
and *much* faster at calculating cardinality of sets and results of set operations.
It can also handle sets of larger cardinality (up to 64 * 2**32-1)

The goals of OpenBitSet are the fastest implementation possible, and
maximum code reuse. Extra safety and encapsulation
may always be built on top, but if that's built in, the cost can never be removed (and
hence people re-implement their own version in order to get better performance).
If you want a "safe", totally encapsulated (and slower and limited) BitSet
class, use java.util.BitSet.

bits

wlen

OpenBitSet

public OpenBitSet(long numBits)

Constructs an OpenBitSet large enough to hold numBits.

Parameters:

numBits -

OpenBitSet

public OpenBitSet()

OpenBitSet

public OpenBitSet(long[] bits,
int numWords)

Constructs an OpenBitSet from an existing long[].
The first 64 bits are in long[0],
with bit index 0 at the least significant bit, and bit index 63 at the most significant.
Given a bit index,
the word containing it is long[index/64], and it is at bit number index%64 within that word.

numWords are the number of elements in the array that contain
set bits (non-zero longs).
numWords should be &lt= bits.length, and
any existing words in the array at position &gt= numWords should be zero.