CHANGE_LOG

2025-XX-XX   3.1.1:
-------------------
  * ppdated `pythoncapi_compat.h` for pypy3.11 support, see #227
  * use `__builtin_parityll()` when available in `util.parity()`
  * add `parity_64()` to header
  * add LFSR example


2025-02-19   3.1.0:
-------------------
  * allow mask assignment to bitarrays, see #225
  * add missing masked operations to pyi-file
  * refactor `resize()` and avoid overallocation when downsizing buffer
  * update `build_wheels.yml`
  * fix some typos
  * minor simplifications
  * rename `growth/` example to `resize/` and add tests for `resize()`
  * update gene example
  * add comments


2024-10-15   3.0.0:
-------------------
  * see [Bitarray 3 transition](bitarray3.rst)
  * remove Python 2.7 support
  * `.decode()` now returns iterator (equivalent to past `.iterdecode()`)
  * `.search()` now returns iterator (equivalent to past `.itersearch()`)
  * remove `.iterdecode()` and `.itersearch()`
  * remove `util.rindex()`, use `.index(..., right=1)` instead,
    deprecated since 2.9
  * remove `util.make_endian()`, use `bitarray(..., endian=...)` instead,
    deprecated since 2.9
  * remove hackish support for `bitarray()` handling unpickling,
    see detailed explaination in #207 - closes #206


2024-10-10   2.9.3:
-------------------
  * add official Python 3.13 support
  * update cibuildwheel to 2.21.3
  * minor simplifications
  * fix some typos


2024-01-01   2.9.2:
-------------------
  * optimize initialization from strings by not constantly resizing buffer
  * optimize `util.hex2ba()` and `util.base2ba()` by avoiding unnecessary
    copies
  * optimize `util.base2ba()` and `util.ba2base()` for `n=16` (hexadecimal)


2023-12-23   2.9.1:
-------------------
  * avoid buffer being unnecessarily initialized with 0s in several
    functions of the `bitarray.util` module
  * fix `.count()` type hint in pyi-file
  * improve testing


2023-12-17   2.9.0:
-------------------
  * deprecate support for Python 2 - Python 2.7 support will be removed
    in bitarray version 3.0,
    see [roadmap](https://github.com/ilanschnell/bitarray#roadmap)
  * `bitarray(n)` for integer initializer `n` will always return a bitarray
    of length `n` with all items initialized to `0`, see #212
  * allow sub-bitarray in `.count()`, #212
  * add `util.ones()`
  * `.find()` and `.index()`: add keyword argument `right` for rightmost index
  * `.itersearch()`: add start and stop argument, and keyword
    argument `right` (for descending order - starting with rightmost match)
  * deprecate `util.rindex()` (will be removed in 3.0 release),
    use `.index(..., right=True)` instead
  * deprecate `util.make_endian()` (will be removed in 3.0 release),
    use `bitarray(..., endian=...)` instead


2023-12-09   2.8.5:
-------------------
  * speedup unaligned copies by always using word shifts (in combination
    with builtin byte swap 64 when available) when bit-endianness and
    machine byte-order are opposite
  * add `HAVE_BUILTIN_BSWAP64` to header
  * avoid misaligned pointers when casting to `(uint64_t *)`
  * add tests


2023-12-04   2.8.4:
-------------------
  * simplify `copy_n()` (remove special cases), see #d2d6fd53
  * add [word shift example C program](../examples/shift_r8.c),
    and simplify `shift_r8()`
  * improve documentation and testing
  * add [roadmap](https://github.com/ilanschnell/bitarray#roadmap)


2023-11-11   2.8.3:
-------------------
  * ensure readonly attribute is set correctly when creating new objects,
    see #211
  * optimize sparse bitarray compression for raw block type
  * improve hash functions in Bloom filter example


2023-10-03   2.8.2:
-------------------
  * update cibuildwheel to 2.16.1 in order to provide cp312 wheels on PyPI
  * improve error messages for masked assignment
  * simplify test collection
  * added `pytest.ini` to allow running pytest with no additional arguments,
    see #208
  * `util.sc_encode()`: avoid writing empty blocks at end of compressed
    stream, i.e. skip encoding when total population count is reached


2023-08-06   2.8.1:
-------------------
  * use reconstructor function for pickling, see #207
  * simplify implementation of `.reverse()`


2023-07-22   2.8.0:
-------------------
  * allow [integer sequence indexing](indexing.rst) by list of indices,
    see #204 (addresses #156 and #190)
  * add [masked indexing](indexing.rst) by bitarray masks,
    see #205 (addresses #190)
  * improve `.bytereverse()` docstring, see issue #202


2023-06-24   2.7.6:
-------------------
  * remove caching hash value, fixes issue #201


2023-06-10   2.7.5:
-------------------
  * fix for pypy3.9-v7.3.11, #198 (fixes #188)
  * enable building wheels for PyPy


2023-05-29   2.7.4:
-------------------
  * register `bitarray` as `abc.MutableSequence`, see #196
  * cibuildwheel: update macOS version to 11 from unsupported 10.15, see
    https://github.com/actions/runner-images/issues/5583
  * improve documentation regarding type when indexing single
    bitarray items, #192


2023-02-20   2.7.3:
-------------------
  * fix popcount64 name conflict on NetBSD, #189
  * even though PyPy is not actively supported, allow running tests for
    PyPy 3.7 and 3.8, see also #188
  * allow running `python setup.py test`
  * add official Python 3.12 support
  * simplify count functionality in util module
  * retire `bitcount_lookup[256]` table
  * improve `util.count_n()` error messages
  * avoid `util` module tests from being run more than once in each
    call to `bitarray.test()` when called multiple times in the same
    Python process, see #6e52e49a
  * improve testing


2023-02-12   2.7.2:
-------------------
  * speedup all count functionality by using `__builtin_popcountll` when
    available, see #187
  * add `popcount64()` to `bitarray.h` - we assume now that `uint64_t` is
    always available
  * improve testing


2023-02-10   2.7.1:
-------------------
  * optimize `util.sc_encode()`


2023-02-05   2.7.0:
-------------------
  * add `util.sc_encode()` and `util.sc_decode()` for
    [compression of sparse bitarrays](sparse_compression.rst)
  * add `util.any_and()`
  * add `util.intervals()`
  * move functionality of the following utility functions entirely to C:
    `hex2ba()`, `base2ba()`, `deserialize()`, `vl_decode()`, `zeros()`
  * improve error checking for unpickling
  * add [distance metrics](../examples/distance.py) example:
    dice, hamming, jaccard, kulczynski1, rogerstanimoto, russellrao,
    sokalmichener, sokalsneath, yule
  * add example [sparse bitarray](../examples/sparse) implementations


2023-01-01   2.6.2:
-------------------
  * optimize `richcompare()` for opposite endianness
  * improve some docstrings add tests


2022-12-18   2.6.1:
-------------------
  * add documentation on shift operators, #181
  * fix typo in iterable initializer description, #179
  * optimize `richcompare()`


2022-07-19   2.6.0:
-------------------
  * add data descriptions: `.nbytes`, `.padbits`, `.readonly`
  * allow optional `endian` argument to be `None` when creating bitarrays
  * fix type annotation for `canonical_decode()`, #178
  * frozenbitarray's pad bits are now guaranteed to be zero
  * add tests


2022-05-10   2.5.1:
-------------------
  * optimize `.reverse()`, see #177
  * allow negative (byte) indices in `.bytereverse()`


2022-05-04   2.5.0:
-------------------
  * add calculating of canonical Huffman codes `util.canonical_huffman()`
    and decoding thereof `util.canonical_decode()`, see #173
  * allow creating "Huffman codes" from frequency maps with a single symbol
    in `util.huffman_code()` and `util.canonical_huffman()`, see #172
  * allow bytes-like argument in `.frombytes()` and `.pack()` - previously,
    the arguments were limited to the `bytes` object, see #174
  * allow bytes-like arguments in `util.deserialize()`
  * add official [pyodide](https://pyodide.org/) support
  * add [DEFLATE decompression](../examples/puff/) example
  * optimize `.bytereverse()`
  * optimize `delslice()` for cases like `del a[1:17:2]` when `a` is large
  * fix `examples/huffman/compress.py` to handle files with 0 or 1 characters,
    see also #172
  * add `skipIF` decorator for skipping tests
  * add tests


2022-03-29   2.4.1:
-------------------
  * improve `resize()`, see #167
  * optimize `copy_n()` by avoiding loops, #171
  * `.bytereverse()` no longer sets unused pad bits to zero


2022-03-01   2.4.0:
-------------------
  * enable building wheels for multiple platforms and Python versions using
    pypa/cibuildwheel, see #165 and #170 (thanks Brian Thorne, @hardbyte)
  * use setuptools instead of distutils in `setup.py`, #168
  * add missing type hinting for `.count()` step argument


2022-02-21   2.3.7:
-------------------
  * add optional step argument to `.count()` method, see #162 and #163
  * add tests


2022-02-07   2.3.6:
-------------------
  * add optional value parameter to `util.count_n()`, see #154 and #161
  * determine machine endianness at build time when possible, by using
    the `PY_LITTLE_ENDIAN` macro, in order to optimize `shift_r8()`
  * add official Python 3.11 support


2022-01-07   2.3.5:
-------------------
  * Fixed bug for big-endian systems (such as IBM s390), see #159 and #160
  * Pass `zip_safe=False` to `setup()`, see #151


2021-09-12   2.3.4:
-------------------
  * Fix `util.ba2int()` for frozenbitarrays.  A bug was introduced in 2.3.0
    as `.tobytes()` no longer treats pad bits for read-only buffers as zero.
  * add tests


2021-09-05   2.3.3:
-------------------
  * improve some error messages
  * add tests


2021-08-23   2.3.2:
-------------------
  * fix slice assignment for shared buffer with offset case, see #3ba05687
    and #73081e98
  * add tests (including internal debug mode tests for `buffers_overlap()`)


2021-08-20   2.3.1:
-------------------
  * fix special shared buffer copy case, see #815c2a11
  * add and improve tests


2021-08-15   2.3.0:
-------------------
  * add optional `buffer` argument to `bitarray()` to import the buffer of
    another object, #141, #146, see also: [buffer protocol](buffer.rst)
  * update `.buffer_info()` to include: a read-only flag, an imported buffer
    flag, and the number of buffer exports
  * add optional start and stop arguments to `util.rindex()`
  * add [memory-mapped file](../examples/mmapped-file.py) example
  * ignore underscore (`_`) in string input, e.g. `bitarray('1100_0111')`
  * add missing type hinting for new `.bytereverse()` arguments
  * fix `.extend()` type annotations, #145
  * avoid `.reverse()` using temporary memory
  * make `.unpack()`, `util.serialize()`, `util.vl_encode()`
    and `.__reduce__()` more memory efficient
  * add and improve tests


2021-08-07   2.2.5:
-------------------
  * speedup `find_bit()` and `find_last()` using uint64 checking, this means
    a speedup for `.find()`, `.index()`, `.search()` and `util.rindex()`
  * add optional start and stop arguments to `.bytereverse()`
  * add example to illustrate how
    [unaligned copying](../examples/copy_n.py) works internally
  * add documentation
  * add tests


2021-07-29   2.2.4:
-------------------
  * use shift operations to speedup all unaligned copy operations, #142
  * expose functionality to Python level only in debug mode for testing
  * add and improve tests


2021-07-22   2.2.3:
-------------------
  * speedup `repeat()`, #136
  * speedup shift operations, #139
  * optimize slice assignment with negative step, e.g.: `a[::-1] = 1`
  * add tests


2021-07-16   2.2.2:
-------------------
  * speedup slice assignment, see #132 and #135
  * speedup bitwise operations, #133
  * optimize `getbit()` and `setbit()` in `bitarray.h`
  * fix TypeError messages when bitarray or int (0, 1) are expected (bool
    is a subclass of int)
  * add and improve tests


2021-07-06   2.2.1:
-------------------
  * improve documentation
  * speedup `vl_encode()`
  * `bitarray.h`: make `getbit()` always an (inline) function
  * add assertions in C code


2021-07-03   2.2.0:
-------------------
  * add `bitarray.util.vl_encode()` and `bitarray.util.vl_decode()` which
    uses a [variable length bitarray format](variable_length.rst), #131


2021-06-15   2.1.3:
-------------------
  * Fix building with MSVC / Bullseye, #129


2021-06-13   2.1.2:
-------------------
  * support type hinting for all Python 3 versions (that bitarray supports,
    3.5 and higher currently), fixed #128
  * add explicit endianness to two tests, fixes #127


2021-06-11   2.1.1:
-------------------
  * add type hinting (see PEP 484, 561) using stub (`.pyi`) files
  * add tests


2021-05-05   2.1.0:
-------------------
  * add `.find()` method, see #122
  * `.find()`, `.index()`, `.search()` and `.itersearch()` now all except
    both (sub-) bitarray as well as bool items to be searched for
  * improve encode/decode error messages
  * add [lexicographical permutations example](../examples/lexico.py)
  * add tests


2021-04-19   2.0.1:
-------------------
  * update documentation
  * improve some error messages


2021-04-14   2.0.0:
-------------------
  * require more specific objects, int (0 or 1) or bool, see #119
  * items are always returned as int 0 or 1, #119
  * remove `.length()` method (deprecated since 1.5.1 - use `len()`)
  * in `.unpack()` the `one` argument now defaults to 0x01 (was 0xff)
  * `.tolist()` now always returns a list of integers (0 or 1)
  * fix frozenbitarray hash function, see #121
  * fix frozenbitarray being mutable by `<<=` and `>>=`
  * support sequence protocol in `.extend()` (and bitarray creation)
  * improve OverflowError messages from `util.int2ba()`
  * add [hexadecimal example](../examples/hexadecimal.py)


2021-04-10   1.9.2:
-------------------
  * update pythoncapi_compat: Fix support with PyPy 3.7, #120
  * update readme


2021-04-05   1.9.1:
-------------------
  * switch documentation from markdown to reStructuredText
  * add tests


2021-04-03   1.9.0:
-------------------
  * add shift operations (`<<`, `>>`, `<<=`, `>>=`), see #117
  * add `bitarray.util.ba2base()` and `bitarray.util.base2ba()`,
    see last paragraph in [Bitarray representations](represent.rst)
  * documentation and tests


2021-03-31   1.8.2:
-------------------
  * fix crash caused by unsupported types in binary operations, #116
  * speedup initializing or extending a bitarray from another with different
    bit-endianness
  * add formatting options to `bitarray.util.pprint()`
  * add documentation on [bitarray representations](represent.rst)
  * add and improve tests (all 291 tests run in less than half a second on
    a modern machine)


2021-03-25   1.8.1:
-------------------
  * moved implementation of and `hex2ba()` and `ba2hex()` to C-level
  * add `bitarray.util.parity()`


2021-03-21   1.8.0:
-------------------
  * add `bitarray.util.serialize()` and `bitarray.util.deserialize()`
  * allow whitespace (ignore space and `\n\r\t\v`) in input strings,
    e.g. `bitarray('01 11')` or `a += '10 00'`
  * add `bitarray.util.pprint()`
  * When initializing a bitarray from another with different bit-endianness,
    e.g. `a = bitarray('110', 'little')` and `b = bitarray(a, 'big')`,
    the buffer used to be simply copied, with consequence that `a == b` would
    result in `False`.  This is fixed now, that is `a == b` will always
    evaluate to `True`.
  * add test for loading existing pickle file (created using bitarray 1.5.0)
  * add example showing how to [jsonize bitarrays](../examples/extend_json.py)
  * add tests


2021-03-12   1.7.1:
-------------------
  * fix issue #114, raise TypeError when incorrect index is used during
    assignment, e.g. `a[1.5] = 1`
  * raise TypeError (not IndexError) when assigning slice to incorrect type,
    e.g. `a[1:4] = 1.2`
  * improve some docstrings and tests


2021-02-27   1.7.0:
-------------------
  * add `bitarray.util.urandom()`
  * raise TypeError when trying to extend bitarrays from bytes on Python 3,
    i.e. `bitarray(b'011')` and `.extend(b'110')`.  (Deprecated since 1.4.1)


2021-01-20   1.6.3:
-------------------
  * add missing .h files to sdist tarball, #113


2021-01-20   1.6.2:
-------------------
  * use `Py_SET_TYPE()` and `Py_SET_SIZE()` for Python 3.10, #109
  * add official Python 3.10 support
  * fix slice assignment to same object,
    e.g. `a[2::] = a` or `a[::-1] = a`, #112
  * add bitarray.h, #110


2020-11-05   1.6.1:
-------------------
  * use PyType_Ready for all types: bitarray, bitarrayiterator,
    decodeiterator, decodetree, searchiterator


2020-10-17   1.6.0:
-------------------
  * add `decodetree` object, for speeding up consecutive calls
    to `.decode()` and `.iterdecode()`, in particular when dealing
    with large prefix codes, see #103
  * add optional parameter to `.tolist()` which changes the items in the
    returned list to integers (0 or 1), as opposed to Booleans
  * remove deprecated `bitdiff()`, which has been deprecated since version
    1.2.0, use `bitarray.util.count_xor()` instead
  * drop Python 2.6 support
  * update license file, #104


2020-08-24   1.5.3:
-------------------
  * add optional index parameter to `.index()` to invert single bit
  * fix `sys.getsizeof(bitarray)` by adding `.__sizeof__()`, see issue #100


2020-08-16   1.5.2:
-------------------
  * add PyType_Ready usage, issue #66
  * speedup search() for bitarrays with length 1 in sparse bitarrays,
    see issue #67
  * add tests


2020-08-10   1.5.1:
-------------------
  * support signed integers in `util.ba2int()` and `util.int2ba()`,
    see issue #85
  * deprecate `.length()` in favor of `len()`


2020-08-05   1.5.0:
-------------------
  * Use `Py_ssize_t` for bitarray index.  This means that on 32bit
    systems, the maximum number of elements in a bitarray is 2 GBits.
    We used to have a special 64bit index type for all architectures, but
    this prevented us from using Python's sequence, mapping and number
    methods, and made those method lookups slow.
  * speedup slice operations when step size = 1 (if alignment allows
    copying whole bytes)
  * Require equal endianness for operations: `&`, `|`, `^`, `&=`, `|=`, `^=`.
    This should have always been the case but was overlooked in the past.
  * raise TypeError when trying to create bitarray from boolean
  * This will be last release to still support Python 2.6 (which was retired
    in 2013).  We do NOT plan to stop support for Python 2.7 anytime soon.


2020-07-15   1.4.2:
-------------------
  * add more tests
  * C-level:
      - simplify pack/unpack code
      - fix memory leak in `~` operation (bitarray_cpinvert)


2020-07-14   1.4.1:
-------------------
  * add official Python 3.9 support
  * improve many docstrings
  * add DeprecationWarning for `bitdiff()`
  * add DeprecationWarning when trying to extend bitarrays
    from bytes on Python 3 (`bitarray(b'011')` and `.extend(b'110')`)
  * C-level:
      - Rewrote `.fromfile()` and `.tofile()` implementation,
        such that now the same code is used for Python 2 and 3.
        The new implementation is more memory efficient on
        Python 3.
      - use `memcmp()` in `richcompare()` to shortcut EQ/NE, when
        comparing two very large bitarrays for equality the
        speedup can easily be 100x
      - simplify how unpacking is handled
  * add more tests


2020-07-11   1.4.0:
-------------------
  * add `.clear()` method (Python 3.3 added this method to lists)
  * avoid over-allocation when bitarray objects are initially created
  * raise BufferError when resizing bitarrays which is exporting buffers
  * add example to study the resize() function
  * improve some error messages
  * add more tests
  * raise `NotImplementedError` with (useful message) when trying to call
    the `.fromstring()` or `.tostring()` methods, which have been removed
    in the last release


2020-07-06   1.3.0:
-------------------
  * add `bitarray.util.make_endian()`
  * `util.ba2hex()` and `util.hex2ba()` now also support little-endian
  * add `bitarray.get_default_endian()`
  * made first argument of initializer a positional-only parameter
  * remove `.fromstring()` and `.tostring()` methods, these have been
    deprecated 8 years ago, since version 0.4.0
  * add `__all__` in `bitarray/__init__.py`
  * drop Python 3.3 and 3.4 support


2020-05-18   1.2.2:
-------------------
  * `util.ba2hex()` now always return a string object (instead of bytes
    object for Python 3), see issue #94
  * `util.hex2ba` allows a unicode object as input on Python 2
  * Determine 64-bitness of interpreter in a cross-platform fashion #91,
    in order to better support PyPy


2020-01-06   1.2.1:
-------------------
  * simplify markdown of readme so PyPI renders better
  * make tests for bitarray.util required (instead of warning when
    they cannot be imported)


2019-12-06   1.2.0:
-------------------
  * add bitarray.util module which provides useful utility functions
  * deprecate `bitarray.bitdiff()` in favor of `bitarray.util.count_xor()`
  * use markdown for documentation
  * fix bug in `.count()` on 32bit systems in special cases when array size
    is 2^29 bits or larger
  * simplified tests by using bytes syntax
  * update smallints and sieve example to use new utility module
  * simplified mandel example to use numba
  * use file context managers in tests


2019-11-07   1.1.0:
-------------------
  * add frozenbitarray object
  * add optional start and stop arguments to `.count()` method
  * add official Python 3.8 support
  * optimize `setrange()` (C-function) by using `memset()`
  * fix issue #74, bitarray is hashable on Python 2
  * fix issue #68, `unittest.TestCase.assert_` deprecated
  * improved test suite - tests should run in about 1 second
  * update documentation to use positional-only syntax in docstrings
  * update readme to pass Python 3 doctest
  * add utils module to examples


2019-07-19   1.0.1:
-------------------
  * fix readme to pass `twine check`


2019-07-15   1.0.0:
-------------------
  * fix bitarrays beings created from unicode in Python 2
  * use `PyBytes_*` in C code, treating the Py3k function names as default,
    which also removes all redefinitions of `PyString_*`
  * handle negative arguments of .index() method consistently with how
    they are treated for lists
  * add a few more comments to the C code
  * move imports outside tests: pickle, io, etc.
  * drop Python 2.5 support


2019-05-20   0.9.3:
-------------------
  * refactor resize() - only shrink allocated memory if new size falls
    lower than half the allocated size
  * improve error message when trying to initialize from float or complex


2019-04-29   0.9.2:
-------------------
  * fix to compile on Windows with VS 2015, issue #72


2019-04-28   0.9.1:
-------------------
  * fix types to actually be types, #29
  * check for ambiguous prefix codes when building binary tree for decoding
  * remove Python level methods: encode, decode, iterdecode (in favor of
    having these implemented on the C-level along with check_codedict)
  * fix self tests for Python 2.5 and 2.6
  * move all Huffman code related example code into examples/huffman
  * add code to generate graphviz .dot file of Huffman tree to examples


2019-04-22   0.9.0:
-------------------
  * more efficient decode and iterdecode by using C-level binary tree
    instead of a python one, #54
  * added buffer protocol support for Python 3, #55
  * fixed invalid pointer exceptions in pypy, #47
  * made all examples Py3k compatible
  * add gene sequence example
  * add official Python 3.7 support
  * drop Python 2.4, 3.1 and 3.2 support


2018-07-06   0.8.3:
-------------------
  * add exception to setup.py when README.rst cannot be opened


2018-05-30   0.8.2:
-------------------
  * add official Python 3.6 support (although it was already working)
  * fix description of `fill()`, #52
  * handle extending self correctly, #28
  * `copy_n()`: fast copy with `memmove()` fixed, #43
  * minor clarity/wording changes to README, #23


2013-03-30   0.8.1:
-------------------
  * fix issue #10, i.e. `int(bitarray())` segfault
  * added tests for using a bitarray object as an argument to functions
    like int, long (on Python 2), float, list, tuple, dict


2012-04-04   0.8.0:
-------------------
  * add Python 2.4 support
  * add (module level) function bitdiff for calculating the difference
    between two bitarrays


2012-02-15   0.7.0:
-------------------
  * add iterdecode method (C level), which returns an iterator but is
    otherwise like the decode method
  * improve memory efficiency and speed of pickling large bitarray objects


2012-02-06   0.6.0:
-------------------
  * add buffer protocol to bitarray objects (Python 2.7 only)
  * allow slice assignment to 0 or 1, e.g. `a[::3] = 0`  (in addition to
    booleans)
  * moved implementation of itersearch method to C level (Lluis Pamies)
  * search, itersearch now only except bitarray objects,
    whereas `__contains__` excepts either booleans or bitarrays
  * use a priority queue for Huffman tree example (thanks to Ushma Bhatt)
  * improve documentation


2012-02-02   0.5.2:
-------------------
  * fixed MSVC compile error on Python 3 (thanks to Chris Gohlke)
  * add missing start and stop optional parameters to index() method
  * add examples/compress.py


2012-01-31   0.5.1:
-------------------
  * update documentation to use tobytes and frombytes, rather than tostring
    and fromstring (which are now deprecated)
  * simplified how tests are run


2012-01-23   0.5.0:
-------------------
  * added itersearch method
  * added Bloom filter example
  * minor fixes in docstrings, added more tests


2011-12-29   0.4.0:
-------------------
  * porting to Python 3.x (Roland Puntaier)
  * introduced `.tobytes()` and `.frombytes()` (`.tostring()`
    and `.fromstring()` are now deprecated)
  * updated development status
  * added sieve prime number example
  * moved project to github: https://github.com/ilanschnell/bitarray


2009-04-06   0.3.5:
-------------------
  * fixed reference counts bugs
  * added possibility to slice assign to `True` or `False`,
    e.g. `a[::3] = True` will set every third element to `True`


2009-01-15   0.3.4:
-------------------
  * Made C code less ambiguous, such that the package compiles on
    Visual Studio, with all tests passing.


2008-12-14   0.3.3:
-------------------
  * Made changes to the C code to allow compilation with more compilers.
    Compiles on Visual Studio, although there are still a few tests failing.


2008-10-19   0.3.2:
-------------------
  * Added sequential search method.
  * The special method `__contains__` now also takes advantage of the
    sequential search.


2008-10-12   0.3.1:
-------------------
  * Simplified state information for pickling.  Argument for count is now
    optional, defaults to True.  Fixed typos.


2008-09-30   0.3.0:
-------------------
  * Fixed a severe bug for 64-bit machines.  Implemented all methods in C,
    improved tests.
  * Removed deprecated methods `.from01()` and `.fromlist()`.


2008-09-23   0.2.5:
-------------------
  * Added section in README about prefix codes.  Implemented _multiply method
    for faster `__mul__` and `__imul__`.  Fixed some typos.


2008-09-22   0.2.4:
-------------------
  * Implemented encode and decode method (in C) for variable-length prefix
    codes.
  * Added more examples, wrote README for the examples.
  * Added more tests, fixed some typos.


2008-09-16   0.2.3:
-------------------
  * Fixed a memory leak, implemented a number of methods in C.
    These include __getitem__, __setitem__, __delitem__, pop, remove,
    insert.  The methods implemented on the Python level is very limit now.
  * Implemented bitwise operations.


2008-09-09   0.2.2:
-------------------
  * Rewrote parts of the README
  * Implemented memory efficient algorithm for the reverse method
  * Fixed typos, added a few tests, more C refactoring.


2008-09-07   0.2.1:
-------------------
  * Improved tests, in particular added checking for memory leaks.
  * Refactored many things on the C level.
  * Implemented a few more methods.


2008-09-02   0.2.0:
-------------------
  * Added bit-endianness property to the bitarray object
  * Added the examples to the release package.


2008-08-17   0.1.0:
-------------------
  * First official release; put project to
    http://pypi.python.org/pypi/bitarray/


May 2008:
---------
Wrote the initial code, and put it on my personal web-site:
http://ilan.schnell-web.net/prog/