bitarray 3.6.0__tar.gz → 3.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.6.0
+Version: 3.6.1
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -83,20 +83,13 @@ versions.  Which means you can simply:
 
     $ pip install bitarray
 
-In addition, conda packages are available (both the default Anaconda
-repository as well as conda-forge support bitarray):
-
-.. code-block:: shell-session
-
-    $ conda install bitarray
-
 Once you have installed the package, you may want to test it:
 
 .. code-block:: shell-session
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.6.0
+    bitarray version: 3.6.1
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -110,7 +103,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 589 tests in 0.163s
+    Ran 591 tests in 0.163s
 
     OK
 
@@ -427,7 +420,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.6.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.6.1 -- `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.
@@ -1003,7 +996,7 @@ This sub-module was added in version 1.2.
 
 ``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)``.
+   Equivalent to ``sum(i for i, v in enumerate(a) if v)``.
 
    New in version 3.6
 

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

@@ -51,20 +51,13 @@ versions.  Which means you can simply:
 
     $ pip install bitarray
 
-In addition, conda packages are available (both the default Anaconda
-repository as well as conda-forge support bitarray):
-
-.. code-block:: shell-session
-
-    $ conda install bitarray
-
 Once you have installed the package, you may want to test it:
 
 .. code-block:: shell-session
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.6.0
+    bitarray version: 3.6.1
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -78,7 +71,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 589 tests in 0.163s
+    Ran 591 tests in 0.163s
 
     OK
 
@@ -395,7 +388,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.6.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.6.1 -- `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.
@@ -971,7 +964,7 @@ This sub-module was added in version 1.2.
 
 ``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)``.
+   Equivalent to ``sum(i for i, v in enumerate(a) if v)``.
 
    New in version 3.6
 

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

@@ -4195,44 +4195,6 @@ Return tuple containing:\n\
 7. PY_LITTLE_ENDIAN\n\
 8. PY_BIG_ENDIAN");
 
-/* ---------- module functions exposed in debug mode for testing ------- */
-
-#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. */
-static PyObject *
-module_zlw(PyObject *module, PyObject *obj)
-{
-    bitarrayobject *a, *res;
-    uint64_t w;
-
-    assert(bitarray_Check(obj));
-    a = (bitarrayobject *) obj;
-    w = zlw(a);
-    if ((res = newbitarrayobject(&Bitarray_Type, 64, a->endian)) == NULL)
-        return NULL;
-    memcpy(res->ob_item, &w, 8);
-    return (PyObject *) res;
-}
-
-#endif  /* NDEBUG */
-
 
 static PyMethodDef module_functions[] = {
     {"bits2bytes",          (PyCFunction) bits2bytes,         METH_O,
@@ -4246,13 +4208,6 @@ static PyMethodDef module_functions[] = {
      set_default_endian_doc},
     {"_sysinfo",            (PyCFunction) sysinfo,            METH_NOARGS,
      sysinfo_doc},
-
-#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
-
     {NULL,                  NULL}  /* sentinel */
 };
 

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

@@ -265,71 +265,58 @@ Return parity of bitarray `a`.\n\
 `parity(a)` is equivalent to `a.count() % 2` but more efficient.");
 
 
+/* Internal functions, like sum_indices(), but bitarrays are limited in
+   size.  For details see: devel/test_sum_indices.py
+*/
 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)
+ssqi(PyObject *module, PyObject *args)
 {
-    static char table[256];
-    static int setup = -1;      /* endianness of table */
-    PyObject *res;
+    static char count_table[256], sum_table[256], sum_sqr_table[256];
+    static int setup = -1;      /* endianness of tables */
     bitarrayobject *a;
-    Py_ssize_t nbytes, i;
+    uint64_t nbytes, i;
     uint64_t sm = 0;            /* accumulated sum */
+    int mode = 1;
 
-    if (ensure_bitarray(obj) < 0)
+    if (!PyArg_ParseTuple(args, "O!|i", bitarray_type,
+                          (PyObject *) &a, &mode))
         return NULL;
-
-    res = PyLong_FromLong(0);
-    a = (bitarrayobject *) obj;
-    nbytes = Py_SIZE(a);
-    set_padbits(a);
+    if (mode < 1 || mode > 2)
+        return PyErr_Format(PyExc_ValueError, "unexpected mode %d", mode);
+    if (((uint64_t) a->nbits) > (mode == 1 ? 6074001000LLU : 3810778LLU))
+        return PyErr_Format(PyExc_OverflowError, "ssqi %zd", a->nbits);
 
     if (setup != a->endian) {
-        setup_table(table, IS_LE(a) ? 'a' : 'A');
+        setup_table(count_table, 'c');
+        setup_table(sum_table, IS_LE(a) ? 'a' : 'A');
+        setup_table(sum_sqr_table, IS_LE(a) ? 's' : 'S');
         setup = a->endian;
     }
 
+    nbytes = Py_SIZE(a);
+    set_padbits(a);
     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;
+        if (c) {
+            uint64_t k = count_table[c], z1 = sum_table[c];
+            if (mode == 1) {
+                sm += k * 8LLU * i + z1;
+            }
+            else {
+                uint64_t z2 = (unsigned char) sum_sqr_table[c];
+                sm += (k * 64LLU * i + 16LLU * z1) * i + z2;
+            }
         }
     }
-    return add_uint64(res, sm);
+    return PyLong_FromUnsignedLongLong(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 */
+    static char parity_table[256], xor_table[256];
+    static int setup = -1;      /* endianness of xor_table */
     bitarrayobject *a;
     Py_ssize_t res = 0, nbytes, i;
 
@@ -341,15 +328,16 @@ xor_indices(PyObject *module, PyObject *obj)
     set_padbits(a);
 
     if (setup != a->endian) {
-        setup_table(table, IS_LE(a) ? 'x' : 'X');
+        setup_table(xor_table, IS_LE(a) ? 'x' : 'X');
+        setup_table(parity_table, 'p');
         setup = a->endian;
     }
 
     for (i = 0; i < nbytes; i++) {
         unsigned char c = a->ob_item[i];
-        if (parity_64(c))
+        if (parity_table[c])
             res ^= i << 3;
-        res ^= table[c];
+        res ^= xor_table[c];
     }
     return PyLong_FromSsize_t(res);
 }
@@ -2103,14 +2091,43 @@ static PyTypeObject CHDI_Type = {
 
 #ifndef NDEBUG
 
+static PyObject *
+module_setup_table(PyObject *module, PyObject *obj)
+{
+    char table[256];
+
+    assert(PyUnicode_Check(obj));
+    assert(PyUnicode_GET_LENGTH(obj) == 1);
+    setup_table(table, PyUnicode_READ_CHAR(obj, 0));
+    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. */
+static PyObject *
+module_zlw(PyObject *module, PyObject *obj)
+{
+    bitarrayobject *a, *res;
+    uint64_t w;
+
+    assert(bitarray_Check(obj));
+    a = (bitarrayobject *) obj;
+    w = zlw(a);
+    if ((res = new_bitarray(64, Py_None, -1)) == NULL)
+        return NULL;
+    res->endian = a->endian;
+    memcpy(res->ob_item, &w, 8);
+    return (PyObject *) res;
+}
+
 static PyObject *
 module_cfw(PyObject *module, PyObject *args)  /* count_from_word() */
 {
     bitarrayobject *a;
     Py_ssize_t i;
 
-    if (!PyArg_ParseTuple(args, "O!n",
-                          bitarray_type, (PyObject *) &a, &i))
+    if (!PyArg_ParseTuple(args, "O!n", bitarray_type, (PyObject *) &a, &i))
         return NULL;
     return PyLong_FromSsize_t(count_from_word(a, i));
 }
@@ -2156,12 +2173,8 @@ 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},
+    {"_ssqi",     (PyCFunction) ssqi,      METH_VARARGS, 0},
+    {"xor_indices", (PyCFunction) xor_indices, METH_O,       xor_indices_doc},
     {"count_and", (PyCFunction) count_and, METH_VARARGS, count_and_doc},
     {"count_or",  (PyCFunction) count_or,  METH_VARARGS, count_or_doc},
     {"count_xor", (PyCFunction) count_xor, METH_VARARGS, count_xor_doc},
@@ -2171,10 +2184,8 @@ static PyMethodDef module_functions[] = {
                   (PyCFunction) correspond_all,
                                            METH_VARARGS, correspond_all_doc},
     {"byteswap",  (PyCFunction) byteswap,  METH_VARARGS, byteswap_doc},
-    {"serialize", (PyCFunction) serialize, METH_O,       serialize_doc},
-    {"deserialize",
-                  (PyCFunction) deserialize,
-                                           METH_O,       deserialize_doc},
+    {"serialize",   (PyCFunction) serialize,   METH_O,   serialize_doc},
+    {"deserialize", (PyCFunction) deserialize, METH_O,   deserialize_doc},
     {"ba2hex",    (PyCFunction) ba2hex,    METH_KEYWORDS |
                                            METH_VARARGS, ba2hex_doc},
     {"hex2ba",    (PyCFunction) hex2ba,    METH_KEYWORDS |
@@ -2193,10 +2204,12 @@ static PyMethodDef module_functions[] = {
 
 #ifndef NDEBUG
     /* functions exposed in debug mode for testing */
-    {"_cfw",      (PyCFunction) module_cfw,     METH_VARARGS, 0},
-    {"_read_n",   (PyCFunction) module_read_n,  METH_VARARGS, 0},
-    {"_write_n",  (PyCFunction) module_write_n, METH_VARARGS, 0},
-    {"_sc_rts",   (PyCFunction) module_sc_rts,  METH_O,       0},
+    {"_setup_table", (PyCFunction) module_setup_table, METH_O,       0},
+    {"_zlw",         (PyCFunction) module_zlw,         METH_O,       0},
+    {"_cfw",         (PyCFunction) module_cfw,         METH_VARARGS, 0},
+    {"_read_n",      (PyCFunction) module_read_n,      METH_VARARGS, 0},
+    {"_write_n",     (PyCFunction) module_write_n,     METH_VARARGS, 0},
+    {"_sc_rts",      (PyCFunction) module_sc_rts,      METH_O,       0},
 #endif
 
     {NULL,        NULL}  /* sentinel */

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

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.6.0"
+#define BITARRAY_VERSION  "3.6.1"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -229,20 +229,28 @@ swap_bytes(char *p, Py_ssize_t n)
 static inline void
 setup_table(char *table, char kop)
 {
-    int j, k;
+    int k;
     for (k = 0; k < 256; k++) {
-        table[k] = 0;
+        char t = 0, j;
         for (j = 0; j < 8; j++) {
             if (k & 1 << j)
+                /* j are the indices of active bits in k (little endian) */
                 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;
+                case 'a': t += j;        break;  /* add active indices */
+                case 'A': t += 7 - j;    break;  /* 'a' for big endian */
+                case 's': t += j * j;    /* add squares of active indices */
+                    break;
+                case 'S': t += (7-j) * (7-j);    /* 's' for big endian */
+                    break;
+                case 'x': t ^= j;        break;  /* xor active indices */
+                case 'X': t ^= 7 - j;    break;  /* 'x' for big endian */
+                case 'c': t++;           break;  /* bit count */
+                case 'p': t ^= 1;        break;  /* parity */
+                case 'r': t |= 128 >> j; break;  /* reverse bits */
                 default: Py_UNREACHABLE();
                 }
         }
+        table[k] = t;
     }
 }
 

{bitarray-3.6.0 → bitarray-3.6.1}/bitarray/test_util.py

@@ -17,7 +17,8 @@ import unittest
 from io import StringIO
 from functools import reduce
 from string import hexdigits
-from random import choice, getrandbits, randrange, randint, random, seed
+from random import (choice, getrandbits, randrange, randint, random, sample,
+                    seed)
 from collections import Counter
 
 from bitarray import (bitarray, frozenbitarray, decodetree, bits2bytes,
@@ -36,7 +37,7 @@ from bitarray.util import (
     _huffman_tree, huffman_code, canonical_huffman, canonical_decode,
 )
 
-from bitarray.util import _Random  # type: ignore
+from bitarray.util import _Random, _ssqi  # type: ignore
 
 # ---------------------------------------------------------------------------
 
@@ -147,6 +148,7 @@ class Random_K_Tests(unittest.TestCase):
         self.assertRaises(TypeError, R, 4)
         self.assertRaises(TypeError, R, 1, "0.5")
         self.assertRaises(TypeError, R, 1, p=1)
+        self.assertRaises(TypeError, R, 11, 5.5)  # see issue #239
         self.assertRaises(ValueError, R, -1, 0)
         for k in -1, 11:  # k is not 0 <= k <= n
             self.assertRaises(ValueError, R, 10, k)
@@ -157,6 +159,12 @@ class Random_K_Tests(unittest.TestCase):
             self.assertEqual(R(n, k=n), ones(n))
 
     def test_count(self):
+        for n in range(10):  # test explicitly for small n
+            for k in range(n + 1):
+                a = random_k(n, k)
+                self.assertEqual(len(a), n)
+                self.assertEqual(a.count(), k)
+
         for _ in range(100):
             n = randrange(10_000)
             k = randint(0, n)
@@ -358,7 +366,7 @@ class Random_P_Tests(unittest.TestCase):
 
     def test_small_p_limit(self):
         # For understanding how the algorithm works, see ./doc/random_p.rst
-        # Also, see VerificationTests in ./devel/test_random.py
+        # Also, see VerificationTests in devel/test_random.py
         r = _Random()
         limit = 1.0 / (r.K + 1)  # lower limit for p
         self.assertTrue(r.SMALL_P > limit)
@@ -1022,50 +1030,114 @@ class ParityTests(unittest.TestCase, Util):
 
 # ---------------------------------------------------------------------------
 
-class SumIndicesTests(unittest.TestCase, Util):
+class SumIndicesUtil(unittest.TestCase):
 
-    def test_explicit(self):
-        for s, r in [("", 0), ("0", 0), ("1", 0), ("11", 1),
-                     ("011", 3), ("001", 2), ("0001100", 7),
-                     ("00001111", 22), ("01100111 1101", 49)]:
-            a = bitarray(s, self.random_endian())
-            self.assertEqual(sum_indices(a), r)
+    def check_explicit(self, S):
+        for s, r1, r2 in [
+                ("", 0, 0), ("0", 0, 0), ("1", 0, 0), ("11", 1, 1),
+                ("011", 3, 5), ("001", 2, 4), ("0001100", 7, 25),
+                ("00001111", 22, 126), ("01100111 1101", 49, 381),
+        ]:
+            for a in [bitarray(s, choice(['little', 'big'])),
+                      frozenbitarray(s, choice(['little', 'big']))]:
+                self.assertEqual(S(a, 1), r1)
+                self.assertEqual(S(a, 2), r2)
+                self.assertEqual(a, bitarray(s))
 
-    def test_wrong_args(self):
-        S = sum_indices
+    def check_wrong_args(self, S):
         self.assertRaises(TypeError, S, '')
-        self.assertRaises(TypeError, S, 1)
+        self.assertRaises(TypeError, S, 1.0)
         self.assertRaises(TypeError, S)
-        self.assertRaises(TypeError, S, bitarray("110"), 1)
+        for mode in -1, 0, 3, 4:
+            self.assertRaises(ValueError, S, bitarray("110"), mode)
+
+    def check_urandom(self, S, n):
+        a = urandom_2(n)
+        self.assertEqual(S(a, 1), sum(i for i, v in enumerate(a) if v))
+        self.assertEqual(S(a, 2), sum(i * i for i, v in enumerate(a) if v))
+
+    def check_sparse(self, S, n, k, mode=1, freeze=False, inv=False):
+        a = zeros(n, choice(['little', 'big']))
+        self.assertEqual(S(a, mode), 0)
+        self.assertFalse(a.any())
+
+        indices = sample(range(n), k)
+        a[indices] = 1
+        res = sum(indices) if mode == 1 else sum(i * i for i in indices)
+
+        if inv:
+            a.invert()
+            sum_ones = 3 if mode == 1 else 2 * n - 1
+            sum_ones *= n * (n - 1)
+            sum_ones //= 6
+            res = sum_ones - res
 
-    def test_ones_small(self):
+        if freeze:
+            a = frozenbitarray(a)
+
+        c = a.copy()
+        self.assertEqual(a.count(), n - k if inv else k)
+        self.assertEqual(S(a, mode), res)
+        self.assertEqual(a, c)
+
+
+class SSQI_Tests(SumIndicesUtil):
+
+    # Additional tests for _ssqi() in: devel/test_sum_indices.py
+
+    def test_explicit(self):
+        self.check_explicit(_ssqi)
+
+    def test_wrong_args(self):
+        self.check_wrong_args(_ssqi)
+
+    def test_small(self):
         a = bitarray()
-        sm = 0
-        for i in range(1000):
-            a.append(1)
-            sm += i
-            self.assertEqual(sum_indices(a), sm)
-
-    def test_large_ones(self):
-        # Note that this will also work on 32-bit machines, even though
-        # for n=100_000, we get: n*(n-1)/2 = 4999950000 > 2**32
-        n = 100_000
-        a = bitarray(n)
-        self.assertEqual(sum_indices(a), 0)
-        a.setall(1)
-        self.assertEqual(sum_indices(a), n * (n - 1) // 2)
+        sm1 = sm2 = 0
+        for i in range(100):
+            v = getrandbits(1)
+            a.append(v)
+            if v:
+                sm1 += i
+                sm2 += i * i
+            self.assertEqual(_ssqi(a, 1), sm1)
+            self.assertEqual(_ssqi(a, 2), sm2)
 
-    def test_large_random(self):
-        n = 100_000
-        a = urandom_2(n)
-        self.assertEqual(sum_indices(a),
-                         sum(i for i, v in enumerate(a) if v))
+    def test_urandom(self):
+        self.check_urandom(_ssqi, 10_037)
 
-    def test_random(self):
-        for a in self.randombitarrays():
-            res = sum_indices(a)
-            self.assertEqual(res, sum(i for i, v in enumerate(a) if v))
-            self.assertEqual(res, sum(a.search(1)))
+    def test_sparse(self):
+        for _ in range(5):
+            mode = randint(1, 2)
+            freeze = getrandbits(1)
+            inv = getrandbits(1)
+            self.check_sparse(_ssqi, n=1_000_003, k=400,
+                              mode=mode, freeze=freeze, inv=inv)
+
+
+class SumIndicesTests(SumIndicesUtil):
+
+    # Additional tests in: devel/test_sum_indices.py
+
+    def test_explicit(self):
+        self.check_explicit(sum_indices)
+
+    def test_wrong_args(self):
+        self.check_wrong_args(sum_indices)
+
+    def test_ones(self):
+        for mode in 1, 2:
+            self.check_sparse(sum_indices, n=1_600_037, k=0,
+                              mode=mode, freeze=True, inv=True)
+
+    def test_sparse(self):
+        for _ in range(20):
+            n = choice([500_029, 600_011])  # below and above block size
+            k = randrange(1_000)
+            mode = randint(1, 2)
+            freeze = getrandbits(1)
+            inv = getrandbits(1)
+            self.check_sparse(sum_indices, n, k, mode, freeze, inv)
 
 # ---------------------------------------------------------------------------
 
@@ -1075,8 +1147,9 @@ class XoredIndicesTests(unittest.TestCase, Util):
         for s, r in [("", 0), ("0", 0), ("1", 0), ("11", 1),
                      ("011", 3), ("001", 2), ("0001100", 7),
                      ("01100111 1101", 13)]:
-            a = bitarray(s, self.random_endian())
-            self.assertEqual(xor_indices(a), r)
+            for a in [bitarray(s, self.random_endian()),
+                      frozenbitarray(s, self.random_endian())]:
+                self.assertEqual(xor_indices(a), r)
 
     def test_wrong_args(self):
         X = xor_indices
@@ -1099,22 +1172,18 @@ class XoredIndicesTests(unittest.TestCase, Util):
                 self.assertEqual(lst[i], x)
 
     def test_large_random(self):
-        n = 100_000
-        a = urandom_2(n)
-        self.assertEqual(
-            xor_indices(a),
-            reduce(operator.xor, (i for i, v in enumerate(a) if v))
-        )
+        n = 10_037
+        for a in [urandom_2(n), frozenbitarray(urandom_2(n))]:
+            res = reduce(operator.xor, (i for i, v in enumerate(a) if v))
+            b = a.copy()
+            self.assertEqual(xor_indices(a), res)
+            self.assertEqual(a, b)
 
     def test_random(self):
         for a in self.randombitarrays():
-            cnt = a.count()
-            if cnt == 0:
-                c = 0
-            elif cnt == 1:
-                c = a.index(1)
-            else:
-                c = reduce(operator.xor, (i for i, v in enumerate(a) if v))
+            c = 0
+            for i, v in enumerate(a):
+                c ^= i * v
             self.assertEqual(xor_indices(a), c)
 
     def test_flips(self):
@@ -2239,22 +2308,6 @@ class MixedTests(unittest.TestCase, Util):
                 c <<= n
                 self.assertEqual(ba2int(c), i << n)
 
-    def test_primes(self):  # Sieve of Eratosthenes
-        sieve = ones(10000)
-        sieve[:2] = 0  # zero and one are not prime
-        for i in range(2, 100):
-            if sieve[i]:
-                sieve[i * i::i] = 0
-        # primes up to 40
-        self.assertEqual(list(sieve.search(1, 0, 40)),
-                         [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37])
-        # there are 1229 primes between 1 and 10000
-        self.assertEqual(sieve.count(1), 1229)
-        # there are 119 primes between 4000 and 5000
-        self.assertEqual(sieve.count(1, 4000, 5000), 119)
-        # the 1000th prime is 7919
-        self.assertEqual(count_n(sieve, 1000) - 1, 7919)
-
 # ---------------------------------------------------------------------------
 
 class SerializationTests(unittest.TestCase, Util):

{bitarray-3.6.0 → bitarray-3.6.1}/bitarray/util.py

@@ -15,7 +15,7 @@ import random
 from bitarray import bitarray, bits2bytes
 
 from bitarray._util import (
-    zeros, ones, count_n, parity, sum_indices, xor_indices,
+    zeros, ones, count_n, parity, _ssqi, xor_indices,
     count_and, count_or, count_xor, any_and, subset,
     correspond_all, byteswap,
     serialize, deserialize,
@@ -69,6 +69,9 @@ when Python version is too low.
         raise NotImplementedError("bitarray.util.random_k() requires "
                                   "Python 3.9 or higher")
     r = _Random(__n, endian)
+    if not isinstance(k, int):
+        raise TypeError("int expected, got '%s'" % type(k).__name__)
+
     return r.random_k(k)
 
 
@@ -97,7 +100,7 @@ class _Random:
     # individually in the test class Random_P_Tests in 'test_util.py'.
     # The test class also contains many comments and explanations.
     # To better understand how the algorithm works, see ./doc/random_p.rst
-    # See also, VerificationTests in ./devel/test_random.py
+    # See also, VerificationTests in devel/test_random.py
 
     # maximal number of calls to .random_half() in .combine()
     M = 8
@@ -165,7 +168,7 @@ class _Random:
             a.invert()  # use in-place to avoid copying
             return a
 
-        # decide on sequence, see VerificationTests ./devel/test_random.py
+        # decide on sequence, see VerificationTests devel/test_random.py
         if k < 16 or k * self.K < 3 * n:
             i = 0
         else:
@@ -225,7 +228,7 @@ class _Random:
 
         # calculate operator sequence
         i = int(p * self.K)
-        if p * (self.K + 1) > i + 1: # see ./devel/test_random.py
+        if p * (self.K + 1) > i + 1: # see devel/test_random.py
             i += 1
         seq = self.op_seq(i)
         q = i / self.K
@@ -247,6 +250,50 @@ class _Random:
         return a
 
 
+def sum_indices(__a, __mode=1):
+    """sum_indices(a, /) -> int
+
+Return sum of indices of all active bits in bitarray `a`.
+Equivalent to `sum(i for i, v in enumerate(a) if v)`.
+"""
+    if __mode not in (1, 2):
+        raise ValueError("unexpected mode %r" % __mode)
+
+    # For details see: devel/test_sum_indices.py
+    n = 1 << 19  # block size  512 Kbits
+    if len(__a) <= n:  # shortcut for single block
+        return _ssqi(__a, __mode)
+
+    # Constants
+    m = n // 8  # block size in bytes
+    o1 = n * (n - 1) // 2
+    o2 = o1 * (2 * n - 1) // 3
+
+    nblocks = (len(__a) + n - 1) // n
+    padbits = __a.padbits
+    sm = 0
+    for i in range(nblocks):
+        # use memoryview to avoid copying memory
+        v = memoryview(__a)[i * m : (i + 1) * m]
+        block = bitarray(None, __a.endian, buffer=v)
+        if padbits and i == nblocks - 1:
+            if block.readonly:
+                block = bitarray(block)
+            block[-padbits:] = 0
+
+        k = block.count()
+        if k:
+            y = n * i
+            z1 = o1 if k == n else _ssqi(block)
+            if __mode == 1:
+                sm += k * y + z1
+            else:
+                z2 = o2 if k == n else _ssqi(block, 2)
+                sm += (k * y + 2 * z1) * y + z2
+
+    return sm
+
+
 def pprint(__a, stream=None, group=8, indent=4, width=80):
     """pprint(bitarray, /, stream=None, group=8, indent=4, width=80)
 

{bitarray-3.6.0 → bitarray-3.6.1}/bitarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.6.0
+Version: 3.6.1
 Summary: efficient arrays of booleans -- C extension
 Home-page: https://github.com/ilanschnell/bitarray
 Author: Ilan Schnell
@@ -83,20 +83,13 @@ versions.  Which means you can simply:
 
     $ pip install bitarray
 
-In addition, conda packages are available (both the default Anaconda
-repository as well as conda-forge support bitarray):
-
-.. code-block:: shell-session
-
-    $ conda install bitarray
-
 Once you have installed the package, you may want to test it:
 
 .. code-block:: shell-session
 
     $ python -c 'import bitarray; bitarray.test()'
     bitarray is installed in: /Users/ilan/bitarray/bitarray
-    bitarray version: 3.6.0
+    bitarray version: 3.6.1
     sys.version: 3.13.5 (main, Jun 16 2025) [Clang 18.1.8]
     sys.prefix: /Users/ilan/miniforge
     pointer size: 64 bit
@@ -110,7 +103,7 @@ Once you have installed the package, you may want to test it:
     .........................................................................
     ................................................................
     ----------------------------------------------------------------------
-    Ran 589 tests in 0.163s
+    Ran 591 tests in 0.163s
 
     OK
 
@@ -427,7 +420,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.6.0 -- `change log <https://github.com/ilanschnell/bitarray/blob/master/doc/changelog.rst>`__
+bitarray version: 3.6.1 -- `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.
@@ -1003,7 +996,7 @@ This sub-module was added in version 1.2.
 
 ``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)``.
+   Equivalent to ``sum(i for i, v in enumerate(a) if v)``.
 
    New in version 3.6