Skip to main content

Ordered subsets over a predefined domain

Project description

Latest PyPI Version License Downloads

Bitsets are ordered sets which are subsets of a predefined finite domain of hashable items.

They are implemented as pure Python integers representing the rank of the set in colexicographical order (a.k.a bit strings, powers of two, binary strings). Hence, they can be very space-efficient, e.g. if a large number of subsets from a collection needs to be present in memory. Furthermore, they can be compared, intersected, etc. using normal bitwise operations of integers (&, |, ^, ~).

Installation

$ pip install bitsets

Creation

Use the bitset function to create a class representing ordered subsets from a fixed set of items (the domain):

>>> from bitsets import bitset

>>> Pythons = bitset('Pythons', ('Chapman', 'Cleese', 'Gilliam', 'Idle', 'Jones', 'Palin'))

The domain collection needs to be a hashable sequence (e.g. a tuple).

The resulting class is an integer (long) subclass, so its instances (being integers) are immutable and hashable and thus in many ways similar to pythons built-in frozenset.

>>> issubclass(Pythons, long)
True

The domain items are mapped to powers of two (their rank in colexicographical order):

>>> Pythons.from_int(0)
Pythons()

>>> [Pythons.from_int(1), Pythons.from_int(2), Pythons.from_int(4)]
[Pythons(['Chapman']), Pythons(['Cleese']), Pythons(['Gilliam'])]

>>> Pythons.from_int(2 ** 6 - 1)
Pythons(['Chapman', 'Cleese', 'Gilliam', 'Idle', 'Jones', 'Palin'])

>>> Pythons.from_int((1 << 0) + (1 << 5))
Pythons(['Chapman', 'Palin'])

The class provides access to the minimal (infimum) and maximal (supremum) sets from its domain:

>>> Pythons.infimum
Pythons()

>>> Pythons.supremum
Pythons(['Chapman', 'Cleese', 'Gilliam', 'Idle', 'Jones', 'Palin'])

Basic usage

Bitsets can be created from members, bit strings, boolean sequences, and integers:

>>> Pythons(['Palin', 'Cleese'])
Pythons(['Cleese', 'Palin'])

>>> Pythons.from_bits('101000')
Pythons(['Chapman', 'Gilliam'])

>>> Pythons.from_bools([True, False, True, False, False, False])
Pythons(['Chapman', 'Gilliam'])

>>> Pythons.from_int(5)
Pythons(['Chapman', 'Gilliam'])

Members always occur in the definition order.

Bitsets cannot contain items other than those from their domain:

>>> Pythons(['Brian'])
Traceback (most recent call last):
....
KeyError: 'Brian'

Bitsets can be converted to members, bit strings, boolean sequences and integers:

>>> Pythons(['Chapman', 'Gilliam']).members()
('Chapman', 'Gilliam')

>>> Pythons(['Chapman', 'Gilliam']).bits()
'101000'

>>> Pythons(['Chapman', 'Gilliam']).bools()
(True, False, True, False, False, False)

>>> int(Pythons(['Chapman', 'Gilliam']))
5

Sorting

To facilitate sorting collections of bitsets, they have key methods for different sort orders (shortlex, longlex, shortcolex, and longcolex):

>>> Pythons(['Idle']).shortlex() < Pythons(['Palin']).shortlex()
True

Sorting a collection of bitsets without using a keyfunction will order them in colexicographical order.

Powersets

Iterate over a bitsets’ powerset in short lexicographic order:

>>> for p in Pythons(['Palin', 'Idle']).powerset():
...     print p.members()
()
('Idle',)
('Palin',)
('Idle', 'Palin')

frozenset compatibility

For convenience, bitsets provide the same methods as frozenset (i.e. issubset, issuperset, isdisjoint, intersection, union, difference, symmetric_difference, __len__, __iter__, __nonzero__, and __contains__).

>>> 'Cleese' in Pythons(['Idle'])
False

>>> 'Idle' in Pythons(['Idle'])
True

>>> Pythons(['Chapman', 'Idle']).intersection(Pythons(['Idle', 'Palin']))
Pythons(['Idle'])

Note, however that all the operators methods (+, -, &, | etc.) retain their integer semantics:

>>> Pythons(['Chapman', 'Idle']) - Pythons(['Idle'])
1L

In tight loops it might be worth to use bitwise expressions (&, |, ^, ~) for set comparisons/operation instead of the frozenset-compatible methods:

>>> # is subset ?
>>> Pythons(['Idle']) & Pythons(['Chapman', 'Idle']) == Pythons(['Idle'])
True

Added functionality

Differing from frozenset, you can also retrieve the complement set of a bitset:

>>> Pythons(['Idle']).complement()
Pythons(['Chapman', 'Cleese', 'Gilliam', 'Jones', 'Palin'])

>>> Pythons().complement().complement()
Pythons()

Test if a bitset is maximal (supremum):

>>> Pythons(['Idle']).all()
False

>>> Pythons(['Chapman', 'Cleese', 'Gilliam', 'Idle', 'Jones', 'Palin']).all()
True

Test if a bitset is non-minimal (infimum), same as bool(bitset):

>>> Pythons(['Idle']).any()
True

>>> Pythons().any()
False

Visualization

With the help of the Graphviz graph layout library and this Python interface (pip install graphviz), the bitsets.visualize module can create hasse diagrams of all bitsets from your domain:

>>> from bitsets import visualize
>>> Four = bitset('Four', (1, 2, 3, 4))

>>> dot = visualize.bitset(Four)

>>> print dot.source  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
// <class bitsets.meta.bitset('Four', (1, 2, 3, 4), 0x..., BitSet, None, None)>
digraph Four {
edge [dir=none]
    b0 [label=0000]
            b1 -> b0
            b2 -> b0
...
https://raw.github.com/xflr6/bitsets/master/docs/hasse-bits.png

Show members instead of bits:

>>> dot = visualize.bitset(Four, member_labels=True)

>>> print dot.source  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
// <class bitsets.meta.bitset('Four', (1, 2, 3, 4), 0x..., BitSet, None, None)>
digraph Four {
edge [dir=none]
    b0 [label="{}"]
            b1 -> b0
            b2 -> b0
...
https://raw.github.com/xflr6/bitsets/master/docs/hasse-members.png

Advanced usage

To use a customized bitset, extend a class from the bitsets.bases module and pass it to the bitset function.

>>> import bitsets

>>> class ProperSet(bitsets.bases.BitSet):
...     def issubset_proper(self, other):
...         return self & other == self != other

>>> Ints = bitsets.bitset('Ints', tuple(range(1, 7)), base=ProperSet)

>>> issubclass(Ints, ProperSet)
True

>>> Ints([1]).issubset_proper(Ints([1, 2]))
True

>>> Ints([1, 2]).issubset_proper(Ints([1, 2]))
False

When activated, each bitset class comes with tailored collection classes (bitset list and bitset tuple) for its instances.

>>> Letters = bitsets.bitset('Letters', 'abcdef', list=True)

>>> Letters.List.from_members(['a', 'bcd', 'ef'])
LettersList('100000', '011100', '000011')

To use a customized bitset collection class, extend a class from the bitsets.series module and pass it to the bitset function

>>> class ReduceList(bitsets.series.List):
...     def intersection(self):
...         return self.BitSet.from_int(reduce(long.__and__, self))
...     def union(self):
...         return self.BitSet.from_int(reduce(long.__or__, self))

>>> Nums = bitsets.bitset('Nums', (1, 2, 3), list=ReduceList)

>>> issubclass(Nums.List, ReduceList)
True

>>> numslist = Nums.List.from_members([(1, 2, 3), (1, 2), (2, 3)])

>>> numslist.intersection()
Nums([2])

>>> numslist.union()
Nums([1, 2, 3])

Bitset classes, collection classes and their instances are pickleable:

>>> import pickle

>>> pickle.loads(pickle.dumps(Pythons)) is Pythons
True

>>> pickle.loads(pickle.dumps(Pythons()))
Pythons()

>>> pickle.loads(pickle.dumps(Nums.List)) is Nums.List  # doctest: +SKIP
True

>>> pickle.loads(pickle.dumps(Nums.List()))  # doctest: +SKIP
NumsList()

Further reading

See also

License

Bitsets is distributed under the MIT license.

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

bitsets-0.3.zip (100.1 kB view hashes)

Uploaded Source

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page