bitarray 3.5.2__tar.gz → 3.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitarray
-Version: 3.5.2
+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.5.2
+    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 578 tests in 0.162s
+    Ran 591 tests in 0.163s
 
     OK
 
@@ -427,7 +420,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.5.2 -- `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.
@@ -928,11 +921,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 +994,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``.
+   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 +1030,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.2 → 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.5.2
+    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 578 tests in 0.162s
+    Ran 591 tests in 0.163s
 
     OK
 
@@ -395,7 +388,7 @@ and can therefore be used as a dictionary key:
 Reference
 =========
 
-bitarray version: 3.5.2 -- `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.
@@ -896,11 +889,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 +962,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``.
+   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 +998,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.2 → bitarray-3.6.1}/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
@@ -4210,30 +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
-
-/* 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,
@@ -4247,12 +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 */
-    {"_zlw",                (PyCFunction) module_zlw,         METH_O,  0},
-#endif
-
     {NULL,                  NULL}  /* sentinel */
 };
 
@@ -4291,7 +4246,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.2 → bitarray-3.6.1}/bitarray/_util.c

@@ -265,20 +265,79 @@ 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 *
+ssqi(PyObject *module, PyObject *args)
+{
+    static char count_table[256], sum_table[256], sum_sqr_table[256];
+    static int setup = -1;      /* endianness of tables */
+    bitarrayobject *a;
+    uint64_t nbytes, i;
+    uint64_t sm = 0;            /* accumulated sum */
+    int mode = 1;
+
+    if (!PyArg_ParseTuple(args, "O!|i", bitarray_type,
+                          (PyObject *) &a, &mode))
+        return NULL;
+    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(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) {
+            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 PyLong_FromUnsignedLongLong(sm);
+}
+
+
 static PyObject *
 xor_indices(PyObject *module, PyObject *obj)
 {
+    static char parity_table[256], xor_table[256];
+    static int setup = -1;      /* endianness of xor_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(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_table[c])
+            res ^= i << 3;
+        res ^= xor_table[c];
     }
     return PyLong_FromSsize_t(res);
 }
@@ -288,7 +347,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 +845,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;
@@ -2031,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));
 }
@@ -2084,9 +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},
-    {"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},
@@ -2096,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 |
@@ -2118,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.5.2 → bitarray-3.6.1}/bitarray/bitarray.h

@@ -4,7 +4,7 @@
 
    Author: Ilan Schnell
 */
-#define BITARRAY_VERSION  "3.5.2"
+#define BITARRAY_VERSION  "3.6.1"
 
 #ifdef STDC_HEADERS
 #  include <stddef.h>
@@ -225,6 +225,35 @@ 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 k;
+    for (k = 0; k < 256; k++) {
+        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': 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;
+    }
+}
+
 /* 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