numexpr 2.10.2__tar.gz → 2.12.0__tar.gz

numexpr-2.12.0/ADDFUNCS.rst

@@ -0,0 +1,222 @@
+Functions and Function signatures
+=================================
+
+Adding functions
+----------------
+
+In order to add new functions to ``numexpr``, currently it is necessary to edit several files. Consider adding a function
+``out_type myfunc(arg_type)``.
+
+* ``numexpr/expressions.py``
+Add ``'myfunc': func(numpy.myfunc, out_dtype),`` to the dict of functions, ``functions = {...``. If the return type of the function is ``bool``, add
+the function to the list ``if opcode in ("isnan", "isfinite"):`` in the ``__init__`` function of the ``FuncNode`` class.
+In the future it might be nice to refactor this function since it sets the output type based on the type of the inputs in general.
+
+* ``numexpr/necompiler.py``
+Add ``"myfunc"`` to the list of functions:
+
+.. code-block:: python3
+
+    "floor",
+    "isnan",
+    "isfinite",
+    "myfunc"
+    ]
+
+* ``numexpr/functions.hpp``
+Find the correct function signature ``FUNC_OA`` where ``O`` is the return type, and ``A`` the argument type(s). For example, if the function
+is ``double myfunc(double)``, one should edit within the ``FUNC_DD`` clause. If you cannot find your function signature you will have to add it,
+following the template of the other functions.
+Most likely, you will want to add support for several function signatures (e.g. double -> bool and float -> bool) and so you will have to add the
+function in two clauses. If your function has a float input, you will see that there are 5 arguments in the
+``FUNC_OA`` macro, and you will have to add ``myfunc2`` here is order to compile on MSVC machines (i.e. Windows, see following).
+Example:
+
+.. code-block:: cpp
+   :emphasize-lines: 6, 20
+
+    #ifndef FUNC_DD
+    #define ELIDE_FUNC_DD
+    #define FUNC_DD(...)
+    #endif
+    ...
+    FUNC_DD(FUNC_MYFUNC_DD, "myfunc_dd", myfunc, vdMyfunc)
+    FUNC_DD(FUNC_DD_LAST,    NULL,          NULL,  NULL)
+    #ifdef ELIDE_FUNC_DD
+    #undef ELIDE_FUNC_DD
+    #undef FUNC_DD
+    #endif
+
+    ...
+
+    #ifndef FUNC_FF
+    #define ELIDE_FUNC_FF
+    #define FUNC_FF(...)
+    #endif
+    ...
+    FUNC_FF(FUNC_MYFUNC_FF, "myfunc_ff", myfuncf, myfuncf2, vfMyfunc)
+    FUNC_FF(FUNC_FF_LAST,    NULL,       NULL,    NULL,     NULL)
+    #ifdef ELIDE_FUNC_FF
+    #undef ELIDE_FUNC_FF
+    #undef FUNC_FF
+    #endif
+
+* ``numexpr/msvc_function_stubs.hpp``
+In order to support float arguments, due to oddities of MSVC, you have to provide explicit support for your function in this file.
+Add ``#define myfuncf(x)  ((float)floor((double)(x)))`` (if your function is float -> float) to the ``#if`` clause at the top of the file
+which is for old versions of MSVC which did not have support for single precision fucntions. Then in the body, add an inline function
+
+.. code-block:: cpp
+
+    inline float myfuncf2(float x) {
+        return myfuncf(x);
+    }
+
+This is the function that appears as the ``f_win32`` parameter in ``functions.hpp``.
+
+* ``numexpr/tests/test_numexpr.py``
+Don't forget to add a test for your function!
+
+Adding function signatures
+--------------------------
+It may so happen that you cannot find your desired function signature in ``functions.hpp``. This means you will have to add it yourself!
+This involves editing a few more files. In addition, there may be certain bespoke changes, specific to the function signature
+that you may have to make (see Notes, below)
+
+* ``numexpr/functions.hpp``
+Firstly, add clause(s) for your function signature. For example, if the function signature is ``bool(double)`` and ``bool(float)``, add
+``FUNC_BD`` and ``FUNC_BF`` clauses (in the latter case you will need the macro to take 5 arguments for MSVC-compatibility.)
+
+.. code-block:: cpp
+
+    #ifndef FUNC_BD
+    #define ELIDE_FUNC_BD
+    #define FUNC_BD(...)
+    #endif
+    ...
+    FUNC_BD(FUNC_BD_LAST,    NULL,          NULL,  NULL)
+    #ifdef ELIDE_FUNC_BD
+    #undef ELIDE_FUNC_BD
+    #undef FUNC_BD
+    #endif
+
+    #ifndef FUNC_BF
+    #define ELIDE_FUNC_BF
+    #define FUNC_BF(...)
+    #endif
+    ...
+    FUNC_BF(FUNC_BF_LAST,    NULL,     NULL,     NULL,  NULL)
+    #ifdef ELIDE_FUNC_BF
+    #undef ELIDE_FUNC_BF
+    #undef FUNC_BF
+    #endif
+
+The ultimate source of the functions in the macro ``FUNC_BF(...)`` are the headers included in ``numexpr/interpreter.cpp`` (in particular
+``numexpr/numexpr_config.hpp``, which can be used to overwrite ``<math.h>`` functions), so the functions should be available from there.
+
+* ``numexpr/interp_body.cpp``
+Add case support for OPCODES associated to your new function signatures via e.g. ``case OP_FUNC_BFN`` and ``case OP_FUNC_BDN``, following
+the framework suggested by the other functions:
+
+.. code-block:: cpp
+
+    case OP_FUNC_BFN:
+    #ifdef USE_VML
+                VEC_ARG1_VML(functions_bf_vml[arg2](BLOCK_SIZE,
+                                                    (float*)x1, (bool*)dest));
+    #else
+                VEC_ARG1(b_dest = functions_bf[arg2](f1));
+    #endif
+
+Note that it is important that the out variable matches the output type of the function (i.e. ``b_dest`` for bool, ``f_dest`` for float etc.)
+
+* ``numexpr/interpreter.hpp``
+Add clauses to read the ``functions.hpp`` macros correctly
+
+.. code-block:: cpp
+
+    enum FuncBFCodes {
+    #define FUNC_BF(fop, ...) fop,
+    #include "functions.hpp"
+    #undef FUNC_BF
+    };
+
+* ``numexpr/interpreter.cpp``
+Add clauses to generate the FUNC_CODES from the ``functions.hpp`` header, making sure to include clauses for ``_WIN32`` and
+``VML`` as necessary accoridng to the framework suggested by the other functions.
+
+.. code-block:: cpp
+
+    typedef bool (*FuncBFPtr)(float);
+    #ifdef _WIN32
+    FuncBFPtr functions_bf[] = {
+    #define FUNC_BF(fop, s, f, f_win32, ...) f_win32,
+    #include "functions.hpp"
+    #undef FUNC_BF
+    };
+    #else
+    FuncBFPtr functions_bf[] = {
+    #define FUNC_BF(fop, s, f, ...) f,
+    #include "functions.hpp"
+    #undef FUNC_BF
+    };
+    #endif
+
+    #ifdef USE_VML
+    typedef void (*FuncBFPtr_vml)(MKL_INT, const float*, bool*);
+    FuncBFPtr_vml functions_bf_vml[] = {
+    #define FUNC_BF(fop, s, f, f_win32, f_vml) f_vml,
+    #include "functions.hpp"
+    #undef FUNC_BF
+    };
+    #endif
+
+Add case handling to the ``check_program`` function
+
+.. code-block:: cpp
+
+    else if (op == OP_FUNC_BDN) {
+        if (arg < 0 || arg >= FUNC_BD_LAST) {
+            PyErr_Format(PyExc_RuntimeError, "invalid program: funccode out of range (%i) at %i", arg, argloc);
+            return -1;
+        }
+    }
+    else if (op == OP_FUNC_BFN) {
+        if (arg < 0 || arg >= FUNC_BF_LAST) {
+            PyErr_Format(PyExc_RuntimeError, "invalid program: funccode out of range (%i) at %i", arg, argloc);
+            return -1;
+        }
+    }
+
+* ``numexpr/module.cpp``
+Add code here to define the ``FUNC_OA`` macros you require
+
+.. code-block:: cpp
+
+    #define FUNC_BF(name, sname, ...)  add_func(name, sname);
+    #define FUNC_BD(name, sname, ...)  add_func(name, sname);
+    ...
+    #include "functions.hpp"
+    ...
+    #undef FUNC_BD
+    #undef FUNC_BF
+
+* ``numexpr/opcodes.hpp``
+Finally, add the ``OP_FUNC_BDN`` etc. codes here. It is necessary for the OPCODES in the file to be in (ascending order) with
+``NOOP`` as 0 and ``OP_LAST`` as the largest number. Secondly, all reduction OPCODES must appear last. Hence, after adding your
+function signatures (just before the reduction OPCODES) it is necessary to increment all succeeding OPCODES.
+
+.. code-block:: cpp
+
+    OPCODE(106, OP_FUNC_BDN, "func_bdn", Tb, Td, Tn, T0)
+    OPCODE(107, OP_FUNC_BFN, "func_bfn", Tb, Tf, Tn, T0)
+
+Notes
+-----
+In many cases this process will not be very smooth since one relies on the internal C/C++ standard functions (which can be fussy, to varying degrees on different platforms). Some common gotchas are then:
+
+* OPCODES are currently only supported up to 255 - if it becomes necessary to increment further, one will have to change the ``latin_1`` encoding used in ``quadrupleToString`` in ``necompiler.py``. In addition, since the OPCDE table is assumed to be of type ``unsigned char`` the ``get_return_sig`` function in ``numexpr/interpreter.cpp`` may have to be changed (possibly other changes too).
+
+* Depending on the new function signature (above all if the out type is different to the input types), one may have to edit the ``__init__`` function in the ``FuncNode`` class in ``expressions.py``.
+
+* Depending on MSVC support, namespace clashes, casting problems, it may be necessary to make various changes to ``numexpr/numexpr_config.hpp`` and ``numexpr/msvc_function_stubs.hpp``. For example, in PR #523, non-clashing wrappers were introduced for ``isnan`` and ``isfinite`` since the float versions ``isnanf, isfinitef`` were inconsistently defined (and output ints) - depending on how strict the platform interpreter is, the implicit cast from int to bool was acceptable or not for example. In addition, the base functions were in different namespaces or had different names across platforms.

{numexpr-2.10.2 → numexpr-2.12.0}/ANNOUNCE.rst

@@ -1,28 +1,29 @@
 =========================
-Announcing NumExpr 2.10.2
+Announcing NumExpr 2.12.0
 =========================
 
 Hi everyone,
 
-NumExpr 2.10.2 provides wheels for Python 2.13 for first time.
-Also, there is better support for CPUs that do not have a power
-of 2 number of cores.  Finally, numexpr is allowed to run with
-the multithreading package in Python.
+NumExpr 2.12.0 comes with new isnan/isfinite/isinf functions.
+Most importantly, we have added instructions for adding new functions
+to the virtual machine.  See ADDFUNCS.rst for more details.  Thanks to
+Luke Shaw for these contributions.
 
 Project documentation is available at:
 
 http://numexpr.readthedocs.io/
 
-Changes from 2.10.1 to 2.10.2
+Changes from 2.11.0 to 2.12.0
 -----------------------------
 
-* Better support for CPUs that do not have a power of 2 number of
-  cores.  See #479 and #490.  Thanks to @avalentino.
+* Added isnan/isfinite/isinf functions.  Thanks to Luke Shaw.
 
-* Allow numexpr to run with the multithreading package in Python.
-  See PR #496.  Thanks to @emmaai
+* New instructions for adding new functions to the virtual machine.
+  They are available at ADDFUNCS.rst.  Thanks to Luke Shaw.
 
-* Wheels for Python 3.13 are now provided.
+* We are distributing binary wheels for Python 3.14 and 3.14t now.
+
+* We are distributing musllinux wheels too!  Thanks to Clément Robert.
 
 What's Numexpr?
 ---------------

{numexpr-2.10.2 → numexpr-2.12.0}/AUTHORS.txt

@@ -23,7 +23,7 @@ Google Inc. contributed bug fixes.
 
 David Cox improved readability of the Readme.
 
-Robert A. McLeod contributed bug fixes and ported the documentation to 
+Robert A. McLeod contributed bug fixes and ported the documentation to
 numexpr.readthedocs.io. He has served as the maintainer of the package
 since 2016 to 2023.
 

numexpr-2.12.0/LICENSES/cpuinfo.txt

@@ -0,0 +1,31 @@
+Copyright statement for `cpuinfo` module.
+
+Copyright 2002 Pearu Peterson all rights reserved,
+Pearu Peterson <pearu@cens.ioc.ee>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Pearu Peterson nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+HIS SOFTWARE IS PROVIDED BY PEARU PETERSON ''AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PEARU PETERSON BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

{numexpr-2.10.2 → numexpr-2.12.0}/PKG-INFO

@@ -1,9 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: numexpr
-Version: 2.10.2
+Version: 2.12.0
 Summary: Fast numerical expression evaluator for NumPy
 Author-email: "David M. Cooke, Francesc Alted, and others" <blosc@blosc.org>
 Maintainer-email: Blosc Development Team <blosc@blosc.org>
+License-Expression: MIT
 Project-URL: homepage, https://github.com/pydata/numexpr
 Project-URL: documentation, https://numexpr.readthedocs.io
 Project-URL: repository, https://github.com/pydata/numexpr
@@ -11,21 +12,22 @@ Classifier: Development Status :: 6 - Mature
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-License-File: AUTHORS.txt
+License-File: LICENSES/cpuinfo.txt
 Requires-Dist: numpy>=1.23.0
+Dynamic: license-file
 
 ======================================================
 NumExpr: Fast numerical expression evaluator for NumPy
@@ -188,6 +190,24 @@ Usage
   array([ True, False, False], dtype=bool)
 
 
+Free-threading support
+----------------------
+Starting on CPython 3.13 onwards there is a new distribution that disables the
+Global Interpreter Lock (GIL) altogether, thus increasing the performance yields
+under multi-threaded conditions on a single interpreter, as opposed to having to use
+multiprocessing.
+
+Whilst numexpr has been demonstrated to work under free-threaded
+CPython, considerations need to be taken when using numexpr native parallel
+implementation vs using Python threads directly in order to prevent oversubscription,
+we recommend either using the main CPython interpreter thread to spawn multiple C threads
+using the parallel numexpr API, or spawning multiple CPython threads that do not use
+the parallel API.
+
+For more information about free-threaded CPython, we recommend visiting the following
+`community Wiki <https://py-free-threading.github.io/>`
+
+
 Documentation
 -------------
 

{numexpr-2.10.2 → numexpr-2.12.0}/README.rst

@@ -159,6 +159,24 @@ Usage
   array([ True, False, False], dtype=bool)
 
 
+Free-threading support
+----------------------
+Starting on CPython 3.13 onwards there is a new distribution that disables the
+Global Interpreter Lock (GIL) altogether, thus increasing the performance yields
+under multi-threaded conditions on a single interpreter, as opposed to having to use
+multiprocessing.
+
+Whilst numexpr has been demonstrated to work under free-threaded
+CPython, considerations need to be taken when using numexpr native parallel
+implementation vs using Python threads directly in order to prevent oversubscription,
+we recommend either using the main CPython interpreter thread to spawn multiple C threads
+using the parallel numexpr API, or spawning multiple CPython threads that do not use
+the parallel API.
+
+For more information about free-threaded CPython, we recommend visiting the following
+`community Wiki <https://py-free-threading.github.io/>`
+
+
 Documentation
 -------------
 

{numexpr-2.10.2 → numexpr-2.12.0}/RELEASE_NOTES.rst

@@ -1,7 +1,38 @@
 =====================================
-Release notes for NumExpr 2.10 series
+Release notes for NumExpr 2.12 series
 =====================================
 
+Changes from 2.11.0 to 2.12.0
+-----------------------------
+
+* Added isnan/isfinite/isinf functions.  Thanks to Luke Shaw.
+
+* New instructions for adding new functions to the virtual machine.
+  They are available at ADDFUNCS.rst.  Thanks to Luke Shaw.
+
+* We are distributing binary wheels for Python 3.14 and 3.14t now.
+
+* We are distributing musllinux wheels too!  Thanks to Clément Robert.
+
+
+Changes from 2.10.2 to 2.11.0
+-----------------------------
+
+* Initial support for free-threaded Python 3.13t has been added.
+  This is still experimental, so please report any issues you find.
+  For more info, see discussions PRs #504, #505 and #508.
+  Thanks to @andfoy, @rgommers and @FrancescAlted for the work.
+
+* Fix imaginary evaluation in the form of `1.1e1j`.  This was
+  previously not supported and would raise an error.  Thanks to @27rabbitlt
+  for the fix.
+
+* The test suite has been modernized to use `pytest` instead of `unittest`.
+  This should make it easier to run the tests and contribute to the project.
+
+* Python 3.10 is now the minimum supported version.
+
+
 Changes from 2.10.1 to 2.10.2
 -----------------------------
 

numexpr-2.12.0/VERSION

@@ -0,0 +1 @@
+2.12.0

{numexpr-2.10.2 → numexpr-2.12.0}/bench/boolean_timing.py

@@ -9,8 +9,10 @@
 ####################################################################
 
 from __future__ import print_function
+
 import sys
 import timeit
+
 import numpy
 
 array_size = 5_000_000

numexpr-2.12.0/bench/free_threading.py

@@ -0,0 +1,171 @@
+#################################################################################
+# To compare the performance of numexpr when free-threading CPython is used.
+#
+# This example makes use of Python threads, as opposed to C native ones
+# in order to highlight the improvement introduced by free-threading CPython,
+# which now disables the GIL altogether.
+#################################################################################
+"""
+Results with GIL-enabled CPython:
+
+Benchmarking Expression 1:
+NumPy time (threaded over 32 chunks with 16 threads): 1.173090 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 0.951071 seconds
+numexpr speedup: 1.23x
+----------------------------------------
+Benchmarking Expression 2:
+NumPy time (threaded over 32 chunks with 16 threads): 10.410874 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 8.248753 seconds
+numexpr speedup: 1.26x
+----------------------------------------
+Benchmarking Expression 3:
+NumPy time (threaded over 32 chunks with 16 threads): 9.605909 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 11.087108 seconds
+numexpr speedup: 0.87x
+----------------------------------------
+Benchmarking Expression 4:
+NumPy time (threaded over 32 chunks with 16 threads): 3.836962 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 18.054531 seconds
+numexpr speedup: 0.21x
+----------------------------------------
+
+Results with free-threading CPython:
+
+Benchmarking Expression 1:
+NumPy time (threaded over 32 chunks with 16 threads): 3.415349 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 2.618876 seconds
+numexpr speedup: 1.30x
+----------------------------------------
+Benchmarking Expression 2:
+NumPy time (threaded over 32 chunks with 16 threads): 19.005238 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 12.611407 seconds
+numexpr speedup: 1.51x
+----------------------------------------
+Benchmarking Expression 3:
+NumPy time (threaded over 32 chunks with 16 threads): 20.555149 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 17.690749 seconds
+numexpr speedup: 1.16x
+----------------------------------------
+Benchmarking Expression 4:
+NumPy time (threaded over 32 chunks with 16 threads): 38.338372 seconds
+numexpr time (threaded with re_evaluate over 32 chunks with 16 threads): 35.074684 seconds
+numexpr speedup: 1.09x
+----------------------------------------
+"""
+
+import os
+
+os.environ["NUMEXPR_NUM_THREADS"] = "2"
+import threading
+import timeit
+
+import numpy as np
+
+import numexpr as ne
+
+array_size = 10**8
+num_runs = 10
+num_chunks = 32  # Number of chunks
+num_threads = 16  # Number of threads constrained by how many chunks memory can hold
+
+a = np.random.rand(array_size).reshape(10**4, -1)
+b = np.random.rand(array_size).reshape(10**4, -1)
+c = np.random.rand(array_size).reshape(10**4, -1)
+
+chunk_size = array_size // num_chunks
+
+expressions_numpy = [
+    lambda a, b, c: a + b * c,
+    lambda a, b, c: a**2 + b**2 - 2 * a * b * np.cos(c),
+    lambda a, b, c: np.sin(a) + np.log(b) * np.sqrt(c),
+    lambda a, b, c: np.exp(a) + np.tan(b) - np.sinh(c),
+]
+
+expressions_numexpr = [
+    "a + b * c",
+    "a**2 + b**2 - 2 * a * b * cos(c)",
+    "sin(a) + log(b) * sqrt(c)",
+    "exp(a) + tan(b) - sinh(c)",
+]
+
+
+def benchmark_numpy_chunk(func, a, b, c, results, indices):
+    for index in indices:
+        start = index * chunk_size
+        end = (index + 1) * chunk_size
+        time_taken = timeit.timeit(
+            lambda: func(a[start:end], b[start:end], c[start:end]), number=num_runs
+        )
+        results.append(time_taken)
+
+
+def benchmark_numexpr_re_evaluate(expr, a, b, c, results, indices):
+    for index in indices:
+        start = index * chunk_size
+        end = (index + 1) * chunk_size
+        # if index == 0:
+        # Evaluate the first chunk with evaluate
+        time_taken = timeit.timeit(
+            lambda: ne.evaluate(
+                expr,
+                local_dict={
+                    "a": a[start:end],
+                    "b": b[start:end],
+                    "c": c[start:end],
+                },
+            ),
+            number=num_runs,
+        )
+        results.append(time_taken)
+
+
+def run_benchmark_threaded():
+    chunk_indices = list(range(num_chunks))
+
+    for i in range(len(expressions_numpy)):
+        print(f"Benchmarking Expression {i+1}:")
+
+        results_numpy = []
+        results_numexpr = []
+
+        threads_numpy = []
+        for j in range(num_threads):
+            indices = chunk_indices[j::num_threads]  # Distribute chunks across threads
+            thread = threading.Thread(
+                target=benchmark_numpy_chunk,
+                args=(expressions_numpy[i], a, b, c, results_numpy, indices),
+            )
+            threads_numpy.append(thread)
+            thread.start()
+
+        for thread in threads_numpy:
+            thread.join()
+
+        numpy_time = sum(results_numpy)
+        print(
+            f"NumPy time (threaded over {num_chunks} chunks with {num_threads} threads): {numpy_time:.6f} seconds"
+        )
+
+        threads_numexpr = []
+        for j in range(num_threads):
+            indices = chunk_indices[j::num_threads]  # Distribute chunks across threads
+            thread = threading.Thread(
+                target=benchmark_numexpr_re_evaluate,
+                args=(expressions_numexpr[i], a, b, c, results_numexpr, indices),
+            )
+            threads_numexpr.append(thread)
+            thread.start()
+
+        for thread in threads_numexpr:
+            thread.join()
+
+        numexpr_time = sum(results_numexpr)
+        print(
+            f"numexpr time (threaded with re_evaluate over {num_chunks} chunks with {num_threads} threads): {numexpr_time:.6f} seconds"
+        )
+        print(f"numexpr speedup: {numpy_time / numexpr_time:.2f}x")
+        print("-" * 40)
+
+
+if __name__ == "__main__":
+    run_benchmark_threaded()

{numexpr-2.10.2 → numexpr-2.12.0}/bench/issue-36.py

@@ -2,10 +2,14 @@
 # performs better than the serial code.  See issue #36 for details.
 
 from __future__ import print_function
+
+from time import time
+
 import numpy as np
-import numexpr as ne
 from numpy.testing import assert_array_equal
-from time import time
+
+import numexpr as ne
+
 
 def bench(N):
     print("*** array length:", N)
@@ -31,4 +35,3 @@ if __name__ == "__main__":
     ne.set_num_threads(2)
     for N in range(10, 20):
         bench(2**N)
-

{numexpr-2.10.2 → numexpr-2.12.0}/bench/issue-47.py

@@ -1,4 +1,5 @@
 import numpy
+
 import numexpr
 
 numexpr.set_num_threads(8)

{numexpr-2.10.2 → numexpr-2.12.0}/bench/large_array_vs_numpy.py

@@ -31,10 +31,12 @@ numexpr speedup: 2.38x
 import os
 
 os.environ["NUMEXPR_NUM_THREADS"] = "16"
+import threading
+import timeit
+
 import numpy as np
+
 import numexpr as ne
-import timeit
-import threading
 
 array_size = 10**8
 num_runs = 10