bitarray 3.5.1__tar.gz → 3.6.0__tar.gz

{bitarray-3.5.1 → bitarray-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.5.1
+Version: 3.6.0
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -96,7 +96,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.5.1
+    bitarray version: 3.6.0
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -110,7 +110,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 579 tests in 0.162s
+    Ran 589 tests in 0.163s
 
     OK
 
@@ -427,7 +427,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.5.1 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.6.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -928,11 +928,25 @@ This sub-module was added in version 1.2.
    New in version 1.8
 
 
+``random_k(n, /, k, endian=None)`` -> bitarray
+   Return (pseudo-) random bitarray of length ``n`` with ``k`` elements
+   set to one.  Mathematically equivalent to setting (in a bitarray of
+   length ``n``) all bits at indices ``random.sample(range(n), k)`` to one.
+   The random bitarrays are reproducible when giving Python's ``random.seed()``
+   with a specific seed value.
+
+   This function requires Python 3.9 or higher, as it depends on the standard
+   library function ``random.randbytes()``.  Raises ``NotImplementedError``
+   when Python version is too low.
+
+   New in version 3.6
+
+
 ``random_p(n, /, p=0.5, endian=None)`` -> bitarray
-   Return (pseudo-) random bitarray of length ``n``.  Each bit has probability ``p``
-   of being one (independent of any other bits).  Mathematically equivalent
-   to ``bitarray((random() < p for _ in range(n)), endian)``, but much faster
-   for large ``n``.  The random bitarrays are reproducible when giving
+   Return (pseudo-) random bitarray of length ``n``, where each bit has
+   probability ``p`` of being one (independent of any other bits).  Mathematically
+   equivalent to ``bitarray((random() < p for _ in range(n)), endian)``, but much
+   faster for large ``n``.  The random bitarrays are reproducible when giving
    Python's ``random.seed()`` with a specific seed value.
 
    This function requires Python 3.12 or higher, as it depends on the standard
@@ -987,6 +1001,13 @@ This sub-module was added in version 1.2.
    iteration is stopped as soon as one mismatch is found.
 
 
+``sum_indices(a, /)`` -> int
+   Return sum of indices of all active bits in bitarray ``a``.
+   This is equivalent to ``sum(i for i, v in enumerate(a) if v)``.
+
+   New in version 3.6
+
+
 ``urandom(n, /, endian=None)`` -> bitarray
    Return random bitarray of length ``n`` (uses ``os.urandom()``).
 
@@ -1016,7 +1037,7 @@ This sub-module was added in version 1.2.
 ``xor_indices(a, /)`` -> int
    Return xor reduced indices of all active bits in bitarray ``a``.
    This is essentially equivalent to
-   ``reduce(operator.xor, [i for i, v in enumerate(a) if v])``.
+   ``reduce(operator.xor, (i for i, v in enumerate(a) if v))``.
 
    New in version 3.2
 

{bitarray-3.5.1 → bitarray-3.6.0}/README.rst

@@ -64,7 +64,7 @@ Once you have installed the package, you may want to test it:
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.5.1
+    bitarray version: 3.6.0
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -78,7 +78,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 579 tests in 0.162s
+    Ran 589 tests in 0.163s
 
     OK
 
@@ -395,7 +395,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.5.1 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.6.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
 
 In the following, ``item`` and ``value`` are usually a single bit -
 an integer 0 or 1.
@@ -896,11 +896,25 @@ This sub-module was added in version 1.2.
    New in version 1.8
 
 
+``random_k(n, /, k, endian=None)`` -> bitarray
+   Return (pseudo-) random bitarray of length ``n`` with ``k`` elements
+   set to one.  Mathematically equivalent to setting (in a bitarray of
+   length ``n``) all bits at indices ``random.sample(range(n), k)`` to one.
+   The random bitarrays are reproducible when giving Python's ``random.seed()``
+   with a specific seed value.
+
+   This function requires Python 3.9 or higher, as it depends on the standard
+   library function ``random.randbytes()``.  Raises ``NotImplementedError``
+   when Python version is too low.
+
+   New in version 3.6
+
+
 ``random_p(n, /, p=0.5, endian=None)`` -> bitarray
-   Return (pseudo-) random bitarray of length ``n``.  Each bit has probability ``p``
-   of being one (independent of any other bits).  Mathematically equivalent
-   to ``bitarray((random() < p for _ in range(n)), endian)``, but much faster
-   for large ``n``.  The random bitarrays are reproducible when giving
+   Return (pseudo-) random bitarray of length ``n``, where each bit has
+   probability ``p`` of being one (independent of any other bits).  Mathematically
+   equivalent to ``bitarray((random() < p for _ in range(n)), endian)``, but much
+   faster for large ``n``.  The random bitarrays are reproducible when giving
    Python's ``random.seed()`` with a specific seed value.
 
    This function requires Python 3.12 or higher, as it depends on the standard
@@ -955,6 +969,13 @@ This sub-module was added in version 1.2.
    iteration is stopped as soon as one mismatch is found.
 
 
+``sum_indices(a, /)`` -> int
+   Return sum of indices of all active bits in bitarray ``a``.
+   This is equivalent to ``sum(i for i, v in enumerate(a) if v)``.
+
+   New in version 3.6
+
+
 ``urandom(n, /, endian=None)`` -> bitarray
    Return random bitarray of length ``n`` (uses ``os.urandom()``).
 
@@ -984,7 +1005,7 @@ This sub-module was added in version 1.2.
 ``xor_indices(a, /)`` -> int
    Return xor reduced indices of all active bits in bitarray ``a``.
    This is essentially equivalent to
-   ``reduce(operator.xor, [i for i, v in enumerate(a) if v])``.
+   ``reduce(operator.xor, (i for i, v in enumerate(a) if v))``.
 
    New in version 3.2
 

{bitarray-3.5.1 → bitarray-3.6.0}/bitarray/_bitarray.c

@@ -189,21 +189,6 @@ buffers_overlap(bitarrayobject *self, bitarrayobject *other)
 #undef PIB
 }
 
-/* setup translation table, which maps each byte to its reversed:
-   reverse_trans = {0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, ..., 0xff} */
-static void
-setup_reverse_trans(void)
-{
-    int j, k;
-
-    for (k = 0; k < 256; k++) {
-        reverse_trans[k] = 0x00;
-        for (j = 0; j < 8; j++)
-            if (k & 128 >> j)
-                reverse_trans[k] |= 1 << j;
-    }
-}
-
 /* reverse bits in first n characters of p */
 static void
 bytereverse(char *p, Py_ssize_t n)
@@ -221,7 +206,7 @@ bytereverse(char *p, Py_ssize_t n)
    They operate on little-endian and bit-endian bitarrays respectively.
    As we shift right, we need to start with the highest address and loop
    downwards such that lower bytes are still unaltered.
-   See also examples/shift_r8.c
+   See also devel/shift_r8.c
 */
 static void
 shift_r8le(unsigned char *buff, Py_ssize_t n, int k)
@@ -321,7 +306,7 @@ shift_r8(bitarrayobject *self, Py_ssize_t a, Py_ssize_t b, int k)
 }
 
 /* Copy n bits from other (starting at b) onto self (starting at a).
-   Please see examples/copy_n.py for more details.
+   Please see devel/copy_n.py for more details.
 
    Notes:
      - self and other may have opposite bit-endianness
@@ -4214,6 +4199,20 @@ Return tuple containing:\n\
 
 #ifndef NDEBUG
 
+static PyObject *
+module_setup_table(PyObject *module, PyObject *obj)
+{
+    char table[256];
+    Py_UCS4 ch;
+
+    assert(PyUnicode_Check(obj));
+    assert(PyUnicode_GET_LENGTH(obj) == 1);
+    ch = PyUnicode_READ_CHAR(obj, 0);
+
+    setup_table(table, ch);
+    return PyBytes_FromStringAndSize(table, 256);
+}
+
 /* Return zlw(a) as a new bitarray, rather than an int object.
    This makes testing easier, because the int result would depend
    on the machine byteorder. */
@@ -4250,6 +4249,7 @@ static PyMethodDef module_functions[] = {
 
 #ifndef NDEBUG
     /* functions exposed in debug mode for testing */
+    {"_setup_table",        (PyCFunction) module_setup_table, METH_O,  0},
     {"_zlw",                (PyCFunction) module_zlw,         METH_O,  0},
 #endif
 
@@ -4291,7 +4291,9 @@ PyInit__bitarray(void)
 {
     PyObject *m;
 
-    setup_reverse_trans();
+    /* setup translation table, which maps each byte to its reversed:
+       reverse_trans = {0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, ..., 0xff} */
+    setup_table(reverse_trans, 'r');
 
     if ((m = PyModule_Create(&moduledef)) == NULL)
         return NULL;

{bitarray-3.5.1 → bitarray-3.6.0}/bitarray/_util.c

@@ -265,20 +265,91 @@ Return parity of bitarray `a`.\n\
 `parity(a)` is equivalent to `a.count() % 2` but more efficient.");
 
 
+static PyObject *
+add_uint64(PyObject *number, uint64_t i)
+{
+    PyObject *res, *tmp = PyLong_FromUnsignedLongLong(i);
+
+    res = PyNumber_Add(number, tmp);
+    Py_DECREF(tmp);
+    Py_DECREF(number);
+    return res;
+}
+
+static PyObject *
+sum_indices(PyObject *module, PyObject *obj)
+{
+    static char table[256];
+    static int setup = -1;      /* endianness of table */
+    PyObject *res;
+    bitarrayobject *a;
+    Py_ssize_t nbytes, i;
+    uint64_t sm = 0;            /* accumulated sum */
+
+    if (ensure_bitarray(obj) < 0)
+        return NULL;
+
+    res = PyLong_FromLong(0);
+    a = (bitarrayobject *) obj;
+    nbytes = Py_SIZE(a);
+    set_padbits(a);
+
+    if (setup != a->endian) {
+        setup_table(table, IS_LE(a) ? 'a' : 'A');
+        setup = a->endian;
+    }
+
+    for (i = 0; i < nbytes; i++) {
+        unsigned char c = a->ob_item[i];
+        if (!c)
+            continue;
+        sm += ((uint64_t) i) * ((uint64_t) (8 * popcnt_64(c)));
+        sm += table[c];
+
+        if (sm > ((uint64_t ) 1) << 63) {
+            /* Flush accumulated sum into Python number object.
+               For ones(n) this will already happen when n > 2**32.
+               printf("%llu  %30zd\n", sm, i);  */
+            if ((res = add_uint64(res, sm)) == NULL)
+                return NULL;
+            sm = 0;
+        }
+    }
+    return add_uint64(res, sm);
+}
+
+PyDoc_STRVAR(sum_indices_doc,
+"sum_indices(a, /) -> int\n\
+\n\
+Return sum of indices of all active bits in bitarray `a`.\n\
+This is equivalent to `sum(i for i, v in enumerate(a) if v)`.");
+
+
 static PyObject *
 xor_indices(PyObject *module, PyObject *obj)
 {
+    static char table[256];
+    static int setup = -1;      /* endianness of table */
     bitarrayobject *a;
-    Py_ssize_t res = 0, n, i;
+    Py_ssize_t res = 0, nbytes, i;
 
     if (ensure_bitarray(obj) < 0)
         return NULL;
 
     a = (bitarrayobject *) obj;
-    n = a->nbits;
-    for (i = 1; i < n; i++) {
-        if (getbit(a, i))
-            res ^= i;
+    nbytes = Py_SIZE(a);
+    set_padbits(a);
+
+    if (setup != a->endian) {
+        setup_table(table, IS_LE(a) ? 'x' : 'X');
+        setup = a->endian;
+    }
+
+    for (i = 0; i < nbytes; i++) {
+        unsigned char c = a->ob_item[i];
+        if (parity_64(c))
+            res ^= i << 3;
+        res ^= table[c];
     }
     return PyLong_FromSsize_t(res);
 }
@@ -288,7 +359,7 @@ PyDoc_STRVAR(xor_indices_doc,
 \n\
 Return xor reduced indices of all active bits in bitarray `a`.\n\
 This is essentially equivalent to\n\
-`reduce(operator.xor, [i for i, v in enumerate(a) if v])`.");
+`reduce(operator.xor, (i for i, v in enumerate(a) if v))`.");
 
 /* --------------------------- binary functions ------------------------ */
 
@@ -786,6 +857,7 @@ digit_to_int(int m, char c)
     static int setup = 0;
     int i;
 
+    assert(1 <= m && m <= 6);
     if (m < 5) {                                 /* base 2, 4, 8, 16 */
         i = hex_to_int(c);
         return i >> m ? -1 : i;
@@ -2084,6 +2156,9 @@ static PyMethodDef module_functions[] = {
                                            METH_VARARGS, ones_doc},
     {"count_n",   (PyCFunction) count_n,   METH_VARARGS, count_n_doc},
     {"parity",    (PyCFunction) parity,    METH_O,       parity_doc},
+    {"sum_indices",
+                  (PyCFunction) sum_indices,
+                                           METH_O,       sum_indices_doc},
     {"xor_indices",
                   (PyCFunction) xor_indices,
                                            METH_O,       xor_indices_doc},

{bitarray-3.5.1 → bitarray-3.6.0}/bitarray/bitarray.h

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.5.1"
+#define BITARRAY_VERSION  "3.6.0"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -225,6 +225,27 @@ swap_bytes(char *p, Py_ssize_t n)
     }
 }
 
+/* write 256 characters into table for given kernel operation */
+static inline void
+setup_table(char *table, char kop)
+{
+    int j, k;
+    for (k = 0; k < 256; k++) {
+        table[k] = 0;
+        for (j = 0; j < 8; j++) {
+            if (k & 1 << j)
+                switch (kop) {
+                case 'a': table[k] += j;        break;
+                case 'A': table[k] += 7 - j;    break;
+                case 'x': table[k] ^= j;        break;
+                case 'X': table[k] ^= 7 - j;    break;
+                case 'r': table[k] |= 128 >> j; break;
+                default: Py_UNREACHABLE();
+                }
+        }
+    }
+}
+
 /* Return distance [0..3] to next aligned pointer.
    While on modern compilers uint64_t pointers may be misaligned, it may
    cause problems on older ones.  Moreover, it may lead to slowdown (even

{bitarray-3.5.1 → bitarray-3.6.0}/bitarray/test_bitarray.py

@@ -43,9 +43,6 @@ SYSINFO = _sysinfo()
 PTRSIZE = SYSINFO[0]  # pointer size in bytes
 DEBUG = SYSINFO[6]
 
-if DEBUG:
-    from bitarray._bitarray import _zlw  # type: ignore
-
 
 def buffer_info(a, key=None):
     fields = (
@@ -581,217 +578,6 @@ class MetaDataTests(unittest.TestCase):
             a = bitarray(endian=endian)
             self.assertEqual(a.endian, endian)
 
-# ------------------------- Internal debug tests ----------------------------
-
-# Internal functionality exposed for the purpose of testing.
-# These classes will only be part of the test suite in debug mode.
-
-@skipIf(not DEBUG)
-class ShiftR8_Tests(unittest.TestCase, Util):
-
-    def test_empty(self):
-        a = bitarray()
-        a._shift_r8(0, 0, 3)
-        self.assertEqual(a, bitarray())
-
-    def test_explicit(self):
-        x = bitarray('11000100 11111111 11100111 10111111 00001000')
-        y = bitarray('11000100 00000111 11111111 00111101 00001000')
-        x._shift_r8(1, 4, 5)
-        self.assertEqual(x, y)
-        x._shift_r8(2, 1, 5)  # start > stop  --  do nothing
-        self.assertEqual(x, y)
-        x._shift_r8(0, 5, 0)  # shift = 0  --  do nothing
-        self.assertEqual(x, y)
-
-        x = bitarray('11000100 11110')
-        y = bitarray('00011000 10011')
-        x._shift_r8(0, 2, 3)
-        self.assertEqual(x, y)
-
-        x = bitarray('1100011')
-        y = bitarray('0110001')
-        x._shift_r8(0, 1, 1)
-        self.assertEqual(x, y)
-
-    def test_random(self):
-        for _ in range(2000):
-            n = randrange(200)
-            x = urandom_2(n)
-            a = randint(0, x.nbytes)
-            b = randint(a, x.nbytes)
-            k = randrange(8)
-            y = x.copy()
-            y[8 * a : 8 * b] >>= k
-            s = x.to01()
-            if a < b:
-                s = s[:8 * a] + k * "0" + s[8 * a : 8 * b - k] + s[8 * b:]
-                if 8 * b > n:
-                    s = s[:n]
-            x._shift_r8(a, b, k)
-            self.assertEqual(x.to01(), s)
-            self.assertEqual(x, y)
-            self.assertEqual(x.endian, y.endian)
-            self.assertEqual(len(x), n)
-
-@skipIf(not DEBUG)
-class CopyN_Tests(unittest.TestCase, Util):
-
-    def test_explicit(self):
-        x = bitarray('11000100 11110')
-        #                 ^^^^ ^
-        y = bitarray('0101110001')
-        #              ^^^^^
-        x._copy_n(4, y, 1, 5)
-        self.assertEqual(x, bitarray('11001011 11110'))
-        #                                 ^^^^ ^
-        x = bitarray('10110111 101', 'little')
-        y = x.copy()
-        x._copy_n(3, x, 3, 7)  # copy region of x onto x
-        self.assertEqual(x, y)
-        x._copy_n(3, bitarray(x, 'big'), 3, 7)  # as before but other endian
-        self.assertEqual(x, y)
-        x._copy_n(5, bitarray(), 0, 0)  # copy empty bitarray onto x
-        self.assertEqual(x, y)
-
-    def test_example(self):
-        # example given in examples/copy_n.py
-        y = bitarray(
-            '00101110 11111001 01011101 11001011 10110000 01011110 011')
-        x =  bitarray(
-            '01011101 11100101 01110101 01011001 01110100 10001010 01111011')
-        x._copy_n(21, y, 6, 31)
-        self.assertEqual(x, bitarray(
-            '01011101 11100101 01110101 11110010 10111011 10010111 01101011'))
-
-    def check_copy_n(self, N, M, a, b, n):
-        x = urandom_2(N)
-        x_lst = x.tolist()
-        y = x if M < 0 else urandom_2(M)
-        y_lst = y.tolist()
-        x_lst[a:a + n] = y_lst[b:b + n]
-        x._copy_n(a, y, b, n)
-        self.assertEqual(x, bitarray(x_lst))
-        self.assertEqual(len(x), N)
-        self.check_obj(x)
-
-        if M < 0:
-            return
-        self.assertEqual(y, bitarray(y_lst))
-        self.assertEqual(len(y), M)
-        self.check_obj(y)
-
-    def test_random(self):
-        for _ in range(1000):
-            N = randrange(1000)
-            n = randint(0, N)
-            a = randint(0, N - n)
-            b = randint(0, N - n)
-            self.check_copy_n(N, -1, a, b, n)
-
-            M = randrange(1000)
-            n = randint(0, min(N, M))
-            a = randint(0, N - n)
-            b = randint(0, M - n)
-            self.check_copy_n(N, M, a, b, n)
-
-    @staticmethod
-    def getslice(a, start, slicelength):
-        # this is the Python eqivalent of __getitem__ for slices with step=1
-        b = bitarray(slicelength, a.endian)
-        b._copy_n(0, a, start, slicelength)
-        return b
-
-    def test_getslice(self):
-        for a in self.randombitarrays():
-            a_lst = a.tolist()
-            n = len(a)
-            i = randint(0, n)
-            j = randint(i, n)
-            b = self.getslice(a, i, j - i)
-            self.assertEqual(b.tolist(), a_lst[i:j])
-            self.assertEQUAL(b, a[i:j])
-
-@skipIf(not DEBUG)
-class Overlap_Tests(unittest.TestCase, Util):
-
-    def check_overlap(self, a, b, res):
-        r1 = a._overlap(b)
-        r2 = b._overlap(a)
-        self.assertTrue(r1 is r2 is res)
-        self.check_obj(a)
-        self.check_obj(b)
-
-    def test_empty(self):
-        a = bitarray()
-        self.check_overlap(a, a, False)
-        b = bitarray()
-        self.check_overlap(a, b, False)
-
-    def test_distinct(self):
-        for a in self.randombitarrays():
-            # buffers overlaps with itself, unless buffer is NULL
-            self.check_overlap(a, a, bool(a))
-            b = a.copy()
-            self.check_overlap(a, b, False)
-
-    def test_shared(self):
-        a = bitarray(64)
-        b = bitarray(buffer=a)
-        self.check_overlap(b, a, True)
-
-        c = bitarray(buffer=memoryview(a)[2:4])
-        self.check_overlap(c, a, True)
-
-        d = bitarray(buffer=memoryview(a)[5:])
-        self.check_overlap(d, c, False)
-        self.check_overlap(d, b, True)
-
-        e = bitarray(buffer=memoryview(a)[3:3])
-        self.check_overlap(e, c, False)
-        self.check_overlap(e, d, False)
-
-    def test_shared_random(self):
-        n = 100  # buffer size in bytes
-        a = bitarray(8 * n)
-        for _ in range(1000):
-            i1 = randint(0, n)
-            j1 = randint(i1, n)
-            b1 = bitarray(buffer=memoryview(a)[i1:j1])
-
-            i2 = randint(0, n)
-            j2 = randint(i2, n)
-            b2 = bitarray(buffer=memoryview(a)[i2:j2])
-
-            r1, r2 = range(i1, j1), range(i2, j2)
-            res = bool(r1) and bool(r2) and (i2 in r1 or i1 in r2)
-            self.check_overlap(b1, b2, res)
-
-@skipIf(not DEBUG)
-class ZLW_Tests(unittest.TestCase, Util):
-
-    def test_zeros(self):
-        for n in range(200):
-            a = zeros(n, self.random_endian())
-            self.assertEqual(_zlw(a), zeros(64))
-
-    def test_ones(self):
-        for n in range(200):
-            a = ones(n, self.random_endian())
-            b = _zlw(a)
-            r = n % 64
-            self.assertEqual(b, ones(r) + zeros(64 - r))
-
-    def test_random(self):
-        for n in range(200):
-            a = urandom_2(n)
-            b = _zlw(a)
-            self.assertEqual(len(b), 64)
-            self.assertEqual(a.endian, b.endian)
-            self.assertEqual(b[63], 0)  # last bit is always 0
-            q, r = divmod(n, 64)
-            self.assertEqual(b, a[64 * q:] + zeros(64 - r))
-
 # -------------------------- (Number) index tests ---------------------------
 
 class GetItemTests(unittest.TestCase, Util):