Skip to content

BitSet

Defined in: packages/data/src/bit/bit-set.ts:38

A fixed-size set of small non-negative integers, one bit per member.

Where a Set<number> costs a hash entry per member, this costs one bit per possible member — so it wins decisively when the universe is bounded and the set is dense, and loses when a handful of members are drawn from a huge range. The set operations are word-at-a-time, which is what makes them roughly 32× cheaper than the element-at-a-time equivalents.

Time complexity: O(1) for add, delete and has. count, rank and every set operation are O(size / 32). Space complexity: O(size / 8) bytes, independent of how many members are present.

Members outside 0 .. size - 1 are a programming error, not a miss: add and delete throw, so a caller cannot silently lose elements to a mis-sized set.

new BitSet(iterable?, options?): BitSet

Defined in: packages/data/src/bit/bit-set.ts:47

Iterable<number, any, any>

BitSetOptions

BitSet

readonly size: number

Defined in: packages/data/src/bit/bit-set.ts:45

The number of bits, i.e. one past the largest member this can hold.

[iterator](): Iterator<number>

Defined in: packages/data/src/bit/bit-set.ts:75

Members in ascending order.

Iterator<number>

ISet.[iterator]


add(member): void

Defined in: packages/data/src/bit/bit-set.ts:105

O(1).

number

void

If member is outside 0 .. size - 1.

ISet.add


addAll(members): void

Defined in: packages/data/src/bit/bit-set.ts:118

O(m) in the number of members added.

Iterable<number>

void

ISet.addAll


clear(): void

Defined in: packages/data/src/bit/bit-set.ts:95

Removes all elements from the collection.

void

ISet.clear


count(): number

Defined in: packages/data/src/bit/bit-set.ts:91

The number of members. O(1).

number

ISet.count


delete(member): boolean

Defined in: packages/data/src/bit/bit-set.ts:129

O(1).

number

boolean

If member is outside 0 .. size - 1.

ISet.delete


difference(other): BitSet

Defined in: packages/data/src/bit/bit-set.ts:190

O(size / 32).

Iterable<number>

BitSet

ISet.difference


has(member): boolean

Defined in: packages/data/src/bit/bit-set.ts:146

O(1). Out-of-range is a miss, not an error — a query never throws.

number

boolean

ISet.has


intersection(other): BitSet

Defined in: packages/data/src/bit/bit-set.ts:185

O(size / 32).

Iterable<number>

BitSet

ISet.intersection


isDisjointFrom(other): boolean

Defined in: packages/data/src/bit/bit-set.ts:220

O(size / 32).

Iterable<number>

boolean

ISet.isDisjointFrom


isSubsetOf(other): boolean

Defined in: packages/data/src/bit/bit-set.ts:200

O(size / 32).

Iterable<number>

boolean

ISet.isSubsetOf


isSupersetOf(other): boolean

Defined in: packages/data/src/bit/bit-set.ts:215

O(size / 32).

Iterable<number>

boolean

ISet.isSupersetOf


rank(upperBound): number

Defined in: packages/data/src/bit/bit-set.ts:162

How many members are strictly below upperBound. O(size / 32).

The companion of count(): rank(size) is count(). Together with has, this is what makes a bit set usable as a succinct index.

number

number


symmetricDifference(other): BitSet

Defined in: packages/data/src/bit/bit-set.ts:195

O(size / 32).

Iterable<number>

BitSet

ISet.symmetricDifference


union(other): BitSet

Defined in: packages/data/src/bit/bit-set.ts:180

O(size / 32). The result is sized to hold both operands’ universes.

Iterable<number>

BitSet

ISet.union