numexpr 2.11.0__tar.gz → 2.12.1__tar.gz

numexpr-2.12.1/ADDFUNCS.rst

@@ -0,0 +1,241 @@
+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
+
+Some functions (e.g. ``fmod``, ``isnan``) are not available in MKL, and so must be hard-coded here as well:
+
+.. code-block:: cpp
+
+    #ifdef USE_VML
+    /* no isnan, isfinite or isinf in VML */
+    static void vdIsfinite(MKL_INT n, const double* x1, bool* dest)
+    {
+        MKL_INT j;
+        for (j=0; j<n; j++) {
+            dest[j] = isfinited(x1[j]);
+        };
+    };
+    #endif
+
+The complex case is slightlñy different (see other examples in the same file).
+
+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``.
+
+* Functions which accept and/or return complex arguments must be added to the ``complex_functions.hpp`` file (take care when adding them in ``interpreter.cpp`` and ``interp_body.cpp``, since their signatures are usually a bit different).
+
+* 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.11.0 → numexpr-2.12.1}/ANNOUNCE.rst

@@ -1,33 +1,27 @@
 =========================
-Announcing NumExpr 2.11.0
+Announcing NumExpr 2.12.1
 =========================
 
 Hi everyone,
 
-NumExpr 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.
-Finally, Python 3.10 is now the minimum supported version.
+NumExpr 2.12.1 allows isnan/isfinite/isinf functions to be used with complex.
+Also, OneAPI MKL has been fixed.  Thanks to Luke Shaw for these contributions.
 
 Project documentation is available at:
 
 http://numexpr.readthedocs.io/
 
-Changes from 2.10.2 to 2.11.0
+Changes from 2.12.0 to 2.12.1
 -----------------------------
 
-* 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.
+* Added complex counterparts for isnan/isfinite/isinf functions.
+  Thanks to Luke Shaw.
 
-* 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.
+* Updated documentation for the new functions and instructions
+  for adding new functions to the virtual machine.  Thanks to Luke Shaw.
 
-* 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.
+* Fixed MKL support; it was broken in 2.12.0.  Thanks to
+  Christoph Gohlke for reporting the issue.
 
 What's Numexpr?
 ---------------

numexpr-2.12.1/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.11.0 → numexpr-2.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numexpr
-Version: 2.11.0
+Version: 2.12.1
 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>
@@ -21,10 +21,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 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
 
@@ -136,7 +137,7 @@ See `requirements.txt` for the required version of NumPy.
 
 NumExpr is built in the standard Python way::
 
-  python setup.py build install
+  pip install [-e] .
 
 You can test `numexpr` with::
 

{numexpr-2.11.0 → numexpr-2.12.1}/README.rst

@@ -106,7 +106,7 @@ See `requirements.txt` for the required version of NumPy.
 
 NumExpr is built in the standard Python way::
 
-  python setup.py build install
+  pip install [-e] .
 
 You can test `numexpr` with::
 

{numexpr-2.11.0 → numexpr-2.12.1}/RELEASE_NOTES.rst

@@ -1,7 +1,33 @@
 =====================================
-Release notes for NumExpr 2.11 series
+Release notes for NumExpr 2.12 series
 =====================================
 
+Changes from 2.12.0 to 2.12.1
+-----------------------------
+
+* Added complex counterparts for isnan/isfinite/isinf functions.
+  Thanks to Luke Shaw.
+
+* Updated documentation for the new functions and instructions
+  for adding new functions to the virtual machine.  Thanks to Luke Shaw.
+
+* Fixed MKL support; it was broken in 2.12.0.  Thanks to
+  Christoph Gohlke for reporting the issue.
+
+
+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
 -----------------------------
 
@@ -19,6 +45,7 @@ Changes from 2.10.2 to 2.11.0
 
 * Python 3.10 is now the minimum supported version.
 
+
 Changes from 2.10.1 to 2.10.2
 -----------------------------
 

numexpr-2.12.1/VERSION

@@ -0,0 +1 @@
+2.12.1

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/complex_functions.hpp

@@ -424,4 +424,33 @@ nc_abs(std::complex<double> *x, std::complex<double> *r)
     r->imag(0);
 }
 
+static bool
+nc_isinf(std::complex<double> *x)
+{
+    double xr=x->real(), xi=x->imag();
+    bool bi,br;
+    bi = isinfd(xi);
+    br = isinfd(xr);
+    return bi || br;
+}
+
+static bool
+nc_isnan(std::complex<double> *x)
+{
+    double xr=x->real(), xi=x->imag();
+    bool bi,br;
+    bi = isnand(xi);
+    br = isnand(xr);
+    return bi || br;
+}
+
+static bool
+nc_isfinite(std::complex<double> *x)
+{
+    double xr=x->real(), xi=x->imag();
+    bool bi,br;
+    bi = isfinited(xi);
+    br = isfinited(xr);
+    return bi && br;
+}
 #endif // NUMEXPR_COMPLEX_FUNCTIONS_HPP

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/expressions.py

@@ -366,6 +366,10 @@ functions = {
     'complex': func(complex, 'complex'),
     'conj': func(numpy.conj, 'complex'),
 
+    'isnan': func(numpy.isnan, 'bool'),
+    'isfinite': func(numpy.isfinite, 'bool'),
+    'isinf': func(numpy.isinf, 'bool'),
+
     'sum': gen_reduce_axis_func('sum'),
     'prod': gen_reduce_axis_func('prod'),
     'min': gen_reduce_axis_func('min'),
@@ -521,4 +525,6 @@ class FuncNode(OpNode):
     def __init__(self, opcode=None, args=None, kind=None):
         if (kind is None) and (args is not None):
             kind = commonKind(args)
+        if opcode in ("isnan", "isfinite", "isinf"): # bodge for boolean return functions
+            kind = 'bool'
         OpNode.__init__(self, opcode, args, kind)

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/functions.hpp

@@ -86,6 +86,34 @@ FUNC_DD(FUNC_DD_LAST,    NULL,          NULL,  NULL)
 #undef FUNC_DD
 #endif
 
+// double -> boolean functions
+#ifndef FUNC_BD
+#define ELIDE_FUNC_BD
+#define FUNC_BD(...)
+#endif
+FUNC_BD(FUNC_ISNAN_BD,   "isnan_bd",    isnand, vdIsnan)
+FUNC_BD(FUNC_ISFINITE_BD, "isfinite_bd", isfinited, vdIsfinite)
+FUNC_BD(FUNC_ISINF_BD, "isinf_bd", isinfd, vdIsinf)
+FUNC_BD(FUNC_BD_LAST,    NULL,          NULL,  NULL)
+#ifdef ELIDE_FUNC_BD
+#undef ELIDE_FUNC_BD
+#undef FUNC_BD
+#endif
+
+// float -> boolean functions (C99 defines the same function for all types)
+#ifndef FUNC_BF
+#define ELIDE_FUNC_BF
+#define FUNC_BF(...)
+#endif // use wrappers as there is name collision with isnanf in std
+FUNC_BF(FUNC_ISNAN_BF,   "isnan_bf",    isnanf_,  isnanf2, vfIsnan)
+FUNC_BF(FUNC_ISFINITE_BF, "isfinite_bf", isfinitef_, isfinitef2, vfIsfinite)
+FUNC_BF(FUNC_ISINF_BF, "isinf_bf", isinff_, isinff2, vfIsinf)
+FUNC_BF(FUNC_BF_LAST,    NULL,            NULL,        NULL,    NULL)
+#ifdef ELIDE_FUNC_BF
+#undef ELIDE_FUNC_BF
+#undef FUNC_BF
+#endif
+
 #ifndef FUNC_DDD
 #define ELIDE_FUNC_DDD
 #define FUNC_DDD(...)
@@ -138,3 +166,17 @@ FUNC_CCC(FUNC_CCC_LAST,  NULL,      NULL)
 #undef ELIDE_FUNC_CCC
 #undef FUNC_CCC
 #endif
+
+// complex -> boolean functions
+#ifndef FUNC_BC
+#define ELIDE_FUNC_BC
+#define FUNC_BC(...)
+#endif // use wrappers as there is name collision with isnanf in std
+FUNC_BC(FUNC_ISNAN_BC,   "isnan_bc",    nc_isnan, vzIsnan)
+FUNC_BC(FUNC_ISFINITE_BC, "isfinite_bc", nc_isfinite, vzIsfinite)
+FUNC_BC(FUNC_ISINF_BC, "isinf_bc", nc_isinf, vzIsinf)
+FUNC_BC(FUNC_BC_LAST,    NULL,            NULL,        NULL)
+#ifdef ELIDE_FUNC_BC
+#undef ELIDE_FUNC_BC
+#undef FUNC_BC
+#endif

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/interp_body.cpp

@@ -451,6 +451,35 @@
         case OP_COMPLEX_CDD: VEC_ARG2(cr_dest = d1;
                                       ci_dest = d2);
 
+        // Boolean return types
+        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
+
+
+        case OP_FUNC_BDN:
+#ifdef USE_VML
+            VEC_ARG1_VML(functions_bd_vml[arg2](BLOCK_SIZE,
+                                                (double*)x1, (bool*)dest));
+#else
+            VEC_ARG1(b_dest = functions_bd[arg2](d1));
+#endif
+
+        case OP_FUNC_BCN:
+#ifdef USE_VML
+            VEC_ARG1_VML(functions_bc_vml[arg2](BLOCK_SIZE,
+                        (const MKL_Complex16*)x1, (bool*)dest));
+#else
+            VEC_ARG1(ca.real(c1r);
+                     ca.imag(c1i);
+                     b_dest = functions_bc[arg2](&ca));
+#endif
+
+
         /* Reductions */
         case OP_SUM_IIN: VEC_ARG1(i_reduce += i1);
         case OP_SUM_LLN: VEC_ARG1(l_reduce += l1);

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/interpreter.cpp

@@ -204,6 +204,138 @@ FuncDDPtr functions_dd[] = {
 #undef FUNC_DD
 };
 
+// Boolean output functions
+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
+/* no isnan, isfinite or isinf in VML */
+static void vfIsfinite(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isfinitef_(x1[j]);
+    };
+};
+static void vfIsinf(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isinff_(x1[j]);
+    };
+};
+static void vfIsnan(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isnanf_(x1[j]);
+    };
+};
+#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
+
+typedef bool (*FuncBDPtr)(double);
+FuncBDPtr functions_bd[] = {
+#define FUNC_BD(fop, s, f, ...) f,
+#include "functions.hpp"
+#undef FUNC_BD
+};
+
+#ifdef USE_VML
+/* no isnan, isfinite or isinf in VML */
+static void vdIsfinite(MKL_INT n, const double* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isfinited(x1[j]);
+    };
+};
+static void vdIsinf(MKL_INT n, const double* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isinfd(x1[j]);
+    };
+};
+static void vdIsnan(MKL_INT n, const double* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isnand(x1[j]);
+    };
+};
+#endif
+
+#ifdef USE_VML
+typedef void (*FuncBDPtr_vml)(MKL_INT, const double*, bool*);
+FuncBDPtr_vml functions_bd_vml[] = {
+#define FUNC_BD(fop, s, f, f_vml) f_vml,
+#include "functions.hpp"
+#undef FUNC_BD
+};
+#endif
+
+typedef bool (*FuncBCPtr)(std::complex<double>*);
+FuncBCPtr functions_bc[] = {
+#define FUNC_BC(fop, s, f, ...) f,
+#include "functions.hpp"
+#undef FUNC_BC
+};
+
+#ifdef USE_VML
+/* no isnan, isfinite or isinf in VML */
+static void vzIsfinite(MKL_INT n, const MKL_Complex16* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isfinited(x1[j].real) && isfinited(x1[j].imag);
+    };
+};
+static void vzIsinf(MKL_INT n, const MKL_Complex16* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isinfd(x1[j].real) || isinfd(x1[j].imag);
+    };
+};
+static void vzIsnan(MKL_INT n, const MKL_Complex16* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isnand(x1[j].real) || isnand(x1[j].imag);
+    };
+};
+#endif
+
+#ifdef USE_VML
+typedef void (*FuncBCPtr_vml)(MKL_INT, const MKL_Complex16[], bool*);
+FuncBCPtr_vml functions_bc_vml[] = {
+#define FUNC_BC(fop, s, f, f_vml) f_vml,
+#include "functions.hpp"
+#undef FUNC_BC
+};
+#endif
+
 #ifdef USE_VML
 /* Fake vdConj function just for casting purposes inside numexpr */
 static void vdConj(MKL_INT n, const double* x1, double* dest)
@@ -312,11 +444,11 @@ FuncCCCPtr functions_ccc[] = {
 
 char
 get_return_sig(PyObject* program)
-{
+{ // use unsigned chars to match OPCODE table and allow OPCODE > 127
     int sig;
-    char last_opcode;
+    unsigned char last_opcode;
     Py_ssize_t end = PyBytes_Size(program);
-    char *program_str = PyBytes_AS_STRING(program);
+    unsigned char *program_str = (unsigned char *)PyBytes_AS_STRING(program);
 
     do {
         end -= 4;
@@ -464,7 +596,26 @@ check_program(NumExprObject *self)
                         PyErr_Format(PyExc_RuntimeError, "invalid program: funccode out of range (%i) at %i", arg, argloc);
                         return -1;
                     }
-                } else if (op >= OP_REDUCTION) {
+                }
+                  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;
+                    }
+                }
+                  else if (op == OP_FUNC_BCN) {
+                    if (arg < 0 || arg >= FUNC_BC_LAST) {
+                        PyErr_Format(PyExc_RuntimeError, "invalid program: funccode out of range (%i) at %i", arg, argloc);
+                        return -1;
+                    }
+                }
+                  else if (op >= OP_REDUCTION) {
                     ;
                 } else {
                     PyErr_Format(PyExc_RuntimeError, "invalid program: internal checker error processing %i", argloc);

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/interpreter.hpp

@@ -18,6 +18,12 @@ enum FuncFFCodes {
 #undef FUNC_FF
 };
 
+enum FuncBFCodes {
+#define FUNC_BF(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_BF
+};
+
 enum FuncFFFCodes {
 #define FUNC_FFF(fop, ...) fop,
 #include "functions.hpp"
@@ -30,6 +36,18 @@ enum FuncDDCodes {
 #undef FUNC_DD
 };
 
+enum FuncBDCodes {
+#define FUNC_BD(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_BD
+};
+
+enum FuncBCCodes {
+#define FUNC_BC(fop, ...) fop,
+#include "functions.hpp"
+#undef FUNC_BC
+};
+
 enum FuncDDDCodes {
 #define FUNC_DDD(fop, ...) fop,
 #include "functions.hpp"

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/module.cpp

@@ -506,6 +506,9 @@ PyInit_interpreter(void) {
 #define FUNC_FF(name, sname, ...)  add_func(name, sname);
 #define FUNC_FFF(name, sname, ...) add_func(name, sname);
 #define FUNC_DD(name, sname, ...)  add_func(name, sname);
+#define FUNC_BF(name, sname, ...)  add_func(name, sname);
+#define FUNC_BD(name, sname, ...)  add_func(name, sname);
+#define FUNC_BC(name, sname, ...)  add_func(name, sname);
 #define FUNC_DDD(name, sname, ...) add_func(name, sname);
 #define FUNC_CC(name, sname, ...)  add_func(name, sname);
 #define FUNC_CCC(name, sname, ...) add_func(name, sname);
@@ -513,7 +516,9 @@ PyInit_interpreter(void) {
 #undef FUNC_CCC
 #undef FUNC_CC
 #undef FUNC_DDD
-#undef FUNC_DD
+#undef FUNC_BC
+#undef FUNC_BD
+#undef FUNC_BF
 #undef FUNC_DD
 #undef FUNC_FFF
 #undef FUNC_FF

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/msvc_function_stubs.hpp

@@ -1,3 +1,5 @@
+#include <float.h>  // for _finite, _isnan on MSVC
+
 #ifndef NUMEXPR_MSVC_FUNCTION_STUBS_HPP
 #define NUMEXPR_MSVC_FUNCTION_STUBS_HPP
 
@@ -43,9 +45,17 @@
 /* The next are directly called from interp_body.cpp */
 #define powf(x, y)    ((float)pow((double)(x), (double)(y)))
 #define floorf(x)    ((float)floor((double)(x)))
-
-#endif  // _MSC_VER < 1400
-
+#endif // _MSC_VER < 1400
+
+/* Due to casting problems (normally return ints not bools, easiest to define
+non-overloaded wrappers for these functions) */
+// MSVC version: use global ::isfinite / ::isnan
+inline bool isfinitef_(float x) { return !!::_finite(x); }   // MSVC has _finite
+inline bool isnanf_(float x)    { return !!::_isnan(x); }    // MSVC has _isnan
+inline bool isfinited(double x) { return !!::_finite(x); }
+inline bool isnand(double x)    { return !!::_isnan(x); }
+inline bool isinfd(double x) { return !!::isinf(x); }
+inline bool isinff_(float x)    { return !!::isinf(x); }
 
 /* Now the actual stubs */
 
@@ -133,6 +143,20 @@ inline float atan2f2(float x, float y) {
     return atan2f(x, y);
 }
 
+// Boolean output functions
+inline bool isnanf2(float x) {
+    return isnanf_(x);
+}
+
+inline bool isfinitef2(float x) {
+    return isfinitef_(x);
+}
+
+inline bool isinff2(float x) {
+    return isinff_(x);
+}
+
+
 // Needed for allowing the internal casting in numexpr machinery for
 // conjugate operations
 inline float fconjf2(float x) {

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/necompiler.py

@@ -69,7 +69,10 @@ vml_functions = [
     "arctan2",
     "fmod",
     "ceil",
-    "floor"
+    "floor",
+    "isnan",
+    "isfinite",
+    "isinf",
     ]
 
 
@@ -520,7 +523,7 @@ def compileThreeAddrForm(program):
             return bytes([reg.n])
 
     def quadrupleToString(opcode, store, a1=None, a2=None):
-        cop = chr(interpreter.opcodes[opcode]).encode('ascii')
+        cop = chr(interpreter.opcodes[opcode]).encode('latin_1')
         cs = nToChr(store)
         ca1 = nToChr(a1)
         ca2 = nToChr(a2)
@@ -904,7 +907,7 @@ def evaluate(ex: str,
              global_dict: Optional[Dict] = None,
              out: numpy.ndarray = None,
              order: str = 'K',
-             casting: str = 'safe',
+             casting: str = 'same_kind',
              sanitize: Optional[bool] = None,
              _frame_depth: int = 3,
              **kwargs) -> numpy.ndarray:

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/numexpr_config.hpp

@@ -46,6 +46,17 @@
     #include "missing_posix_functions.hpp"
   #endif
   #include "msvc_function_stubs.hpp"
+#else
+/* GCC/Clang version: use std:: (can't use it for windows)
+msvc_function_stubs contains windows alternatives
+/* Due to casting problems (normally return ints not bools, easiest to define
+non-overloaded wrappers for these functions) */
+inline bool isfinitef_(float x) { return !!::isfinite(x); }
+inline bool isnanf_(float x)    { return !!::isnan(x); }
+inline bool isfinited(double x) { return !!::isfinite(x); }
+inline bool isnand(double x)    { return !!::isnan(x); }
+inline bool isinff_(float x) { return !!::isinf(x); }
+inline bool isinfd(double x)    { return !!::isinf(x); }
 #endif
 
 #endif // NUMEXPR_CONFIG_HPP

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/opcodes.hpp

@@ -15,6 +15,9 @@ OPCODE(n, enum_name, exported, return_type, arg1_type, arg2_type, arg3_type)
 Types are Tb, Ti, Tl, Tf, Td, Tc, Ts, Tn, and T0; these symbols should be
 #defined to whatever is needed. (T0 is the no-such-arg type.)
 
+When adding new OPCODES, one has to respect the order of the numeration, as
+there are parts of the code (iterations) which assume that the OPCODES are ordered.
+
 */
 OPCODE(0, OP_NOOP, "noop", T0, T0, T0, T0)
 
@@ -144,36 +147,47 @@ OPCODE(103, OP_COPY_SS, "copy_ss", Ts, Ts, T0, T0)
 OPCODE(104, OP_WHERE_BBBB, "where_bbbb", Tb, Tb, Tb, Tb)
 
 OPCODE(105, OP_CONTAINS_BSS, "contains_bss", Tb, Ts, Ts, T0)
+//Boolean outputs
+OPCODE(106, OP_FUNC_BDN, "func_bdn", Tb, Td, Tn, T0)
+OPCODE(107, OP_FUNC_BFN, "func_bfn", Tb, Tf, Tn, T0)
+OPCODE(108, OP_FUNC_BCN, "func_bcn", Tb, Tc, Tn, T0)
 
-OPCODE(106, OP_REDUCTION, NULL, T0, T0, T0, T0)
+// Reductions always have to be at the end - parts of the code
+// use > OP_REDUCTION to decide whether operation is a reduction
+OPCODE(109, OP_REDUCTION, NULL, T0, T0, T0, T0)
 
 /* Last argument in a reduction is the axis of the array the
    reduction should be applied along. */
 
-OPCODE(107, OP_SUM_IIN, "sum_iin", Ti, Ti, Tn, T0)
-OPCODE(108, OP_SUM_LLN, "sum_lln", Tl, Tl, Tn, T0)
-OPCODE(109, OP_SUM_FFN, "sum_ffn", Tf, Tf, Tn, T0)
-OPCODE(110, OP_SUM_DDN, "sum_ddn", Td, Td, Tn, T0)
-OPCODE(111, OP_SUM_CCN, "sum_ccn", Tc, Tc, Tn, T0)
-
-OPCODE(112, OP_PROD, NULL, T0, T0, T0, T0)
-OPCODE(113, OP_PROD_IIN, "prod_iin", Ti, Ti, Tn, T0)
-OPCODE(114, OP_PROD_LLN, "prod_lln", Tl, Tl, Tn, T0)
-OPCODE(115, OP_PROD_FFN, "prod_ffn", Tf, Tf, Tn, T0)
-OPCODE(116, OP_PROD_DDN, "prod_ddn", Td, Td, Tn, T0)
-OPCODE(117, OP_PROD_CCN, "prod_ccn", Tc, Tc, Tn, T0)
-
-OPCODE(118, OP_MIN, NULL, T0, T0, T0, T0)
-OPCODE(119, OP_MIN_IIN, "min_iin", Ti, Ti, Tn, T0)
-OPCODE(120, OP_MIN_LLN, "min_lln", Tl, Tl, Tn, T0)
-OPCODE(121, OP_MIN_FFN, "min_ffn", Tf, Tf, Tn, T0)
-OPCODE(122, OP_MIN_DDN, "min_ddn", Td, Td, Tn, T0)
-
-OPCODE(123, OP_MAX, NULL, T0, T0, T0, T0)
-OPCODE(124, OP_MAX_IIN, "max_iin", Ti, Ti, Tn, T0)
-OPCODE(125, OP_MAX_LLN, "max_lln", Tl, Tl, Tn, T0)
-OPCODE(126, OP_MAX_FFN, "max_ffn", Tf, Tf, Tn, T0)
-OPCODE(127, OP_MAX_DDN, "max_ddn", Td, Td, Tn, T0)
+OPCODE(110, OP_SUM_IIN, "sum_iin", Ti, Ti, Tn, T0)
+OPCODE(111, OP_SUM_LLN, "sum_lln", Tl, Tl, Tn, T0)
+OPCODE(112, OP_SUM_FFN, "sum_ffn", Tf, Tf, Tn, T0)
+OPCODE(113, OP_SUM_DDN, "sum_ddn", Td, Td, Tn, T0)
+OPCODE(114, OP_SUM_CCN, "sum_ccn", Tc, Tc, Tn, T0)
+
+OPCODE(115, OP_PROD, NULL, T0, T0, T0, T0)
+OPCODE(116, OP_PROD_IIN, "prod_iin", Ti, Ti, Tn, T0)
+OPCODE(117, OP_PROD_LLN, "prod_lln", Tl, Tl, Tn, T0)
+OPCODE(118, OP_PROD_FFN, "prod_ffn", Tf, Tf, Tn, T0)
+OPCODE(119, OP_PROD_DDN, "prod_ddn", Td, Td, Tn, T0)
+OPCODE(120, OP_PROD_CCN, "prod_ccn", Tc, Tc, Tn, T0)
+
+OPCODE(121, OP_MIN, NULL, T0, T0, T0, T0)
+OPCODE(122, OP_MIN_IIN, "min_iin", Ti, Ti, Tn, T0)
+OPCODE(123, OP_MIN_LLN, "min_lln", Tl, Tl, Tn, T0)
+OPCODE(124, OP_MIN_FFN, "min_ffn", Tf, Tf, Tn, T0)
+OPCODE(125, OP_MIN_DDN, "min_ddn", Td, Td, Tn, T0)
+
+OPCODE(126, OP_MAX, NULL, T0, T0, T0, T0)
+OPCODE(127, OP_MAX_IIN, "max_iin", Ti, Ti, Tn, T0)
+OPCODE(128, OP_MAX_LLN, "max_lln", Tl, Tl, Tn, T0)
+OPCODE(129, OP_MAX_FFN, "max_ffn", Tf, Tf, Tn, T0)
+OPCODE(130, OP_MAX_DDN, "max_ddn", Td, Td, Tn, T0)
 
+/*
+When we get to 255, will maybe have to change code again
+(change latin_1 encoding in necompiler.py, use something
+other than unsigned char for OPCODE table)
+*/
 /* Should be the last opcode */
-OPCODE(128, OP_END, NULL, T0, T0, T0, T0)
+OPCODE(131, OP_END, NULL, T0, T0, T0, T0)

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/tests/conftest.py

@@ -10,6 +10,7 @@
 
 import pytest
 
+
 def pytest_configure(config):
     config.addinivalue_line(
         "markers", "thread_unsafe: mark test as unsafe for parallel execution"

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr/tests/test_numexpr.py

@@ -683,7 +683,6 @@ class test_evaluate(TestCase):
         out_l = evaluate('base ** -1.0')
         assert_equal(out_l, np.power(base, -1.0))
 
-
     def test_ex_uses_vml(self):
         vml_funcs = [ "sin", "cos", "tan", "arcsin", "arccos", "arctan",
                       "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh",
@@ -694,6 +693,28 @@ class test_evaluate(TestCase):
             _, ex_uses_vml = numexpr.necompiler.getExprNames(strexpr, {})
             assert_equal(ex_uses_vml, use_vml, strexpr)
 
+    def test_bool_funcs(self):
+        # Test functions with boolean outputs
+        array_size = 100
+        dtype = np.float32
+        a = np.arange(2 * array_size, dtype=dtype)
+        a[array_size//2] = np.nan
+        a[array_size//3] = np.inf
+
+        assert np.all(evaluate("isnan(a)") == np.isnan(a))
+        assert np.all(evaluate("isfinite(a)") == np.isfinite(a))
+        assert np.all(evaluate("isinf(a)") == np.isinf(a))
+        a = a.astype(np.float64)
+        assert a.dtype == np.float64
+        assert np.all(evaluate("isnan(a)") == np.isnan(a))
+        assert np.all(evaluate("isfinite(a)") == np.isfinite(a))
+        assert np.all(evaluate("isinf(a)") == np.isinf(a))
+        a = a.astype(np.complex128)
+        assert a.dtype == np.complex128
+        assert np.all(evaluate("isnan(a)") == np.isnan(a))
+        assert np.all(evaluate("isfinite(a)") == np.isfinite(a))
+        assert np.all(evaluate("isinf(a)") == np.isinf(a))
+
     if 'sparc' not in platform.machine():
         # Execution order set here so as to not use too many threads
         # during the rest of the execution.  See #33 for details.
@@ -892,7 +913,6 @@ def test_expressions(
             npval={npval!r} ({type(npval)!r} - {shape(npval)!r})
             neval={neval!r} ({type(neval)!r} - {shape(neval)!r}))"""
 
-
 class test_int64(TestCase):
     def test_neg(self):
         a = array([2 ** 31 - 1, 2 ** 31, 2 ** 32, 2 ** 63 - 1], dtype=int64)

numexpr-2.12.1/numexpr/version.py

@@ -0,0 +1,5 @@
+# THIS FILE IS GENERATED BY `setup.py`
+__version__ = '2.12.1'
+version = '2.12.1'
+numpy_build_version = '2.3.3'
+platform_machine = 'AMD64'

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numexpr
-Version: 2.11.0
+Version: 2.12.1
 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>
@@ -21,10 +21,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 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
 
@@ -136,7 +137,7 @@ See `requirements.txt` for the required version of NumPy.
 
 NumExpr is built in the standard Python way::
 
-  python setup.py build install
+  pip install [-e] .
 
 You can test `numexpr` with::
 

{numexpr-2.11.0 → numexpr-2.12.1}/numexpr.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+ADDFUNCS.rst
 ANNOUNCE.rst
 AUTHORS.txt
 LICENSE.txt
@@ -9,6 +10,7 @@ pyproject.toml
 requirements.txt
 setup.py
 site.cfg.example
+LICENSES/cpuinfo.txt
 bench/boolean_timing.py
 bench/free_threading.py
 bench/issue-36.py

{numexpr-2.11.0 → numexpr-2.12.1}/pyproject.toml

@@ -1,7 +1,6 @@
 [build-system]
 requires = [
-    "setuptools",
-    "wheel",
+    "setuptools>=77.0.0",
     "numpy>=2.0.0",
 ]
 build-backend = "setuptools.build_meta"
@@ -16,6 +15,7 @@ readme = "README.rst"
 authors = [{name = "David M. Cooke, Francesc Alted, and others", email = "blosc@blosc.org"}]
 maintainers = [{ name = "Blosc Development Team", email = "blosc@blosc.org"}]
 license = "MIT"
+license-files = ["LICENSE.txt", "LICENSES/*"]
 classifiers = [
     "Development Status :: 6 - Mature",
     "Intended Audience :: Developers",
@@ -30,6 +30,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 requires-python = ">=3.10"
 # Follow guidelines from https://scientific-python.org/specs/spec-0000/
@@ -43,8 +44,21 @@ homepage = "https://github.com/pydata/numexpr"
 documentation = "https://numexpr.readthedocs.io"
 repository = "https://github.com/pydata/numexpr"
 
+[dependency-groups]
+test = [
+    "pytest>=7.0.0",
+    "pytest-run-parallel>=0.6.0",
+]
+
 [tool.cibuildwheel]
-skip = "cp36-* cp37-* pp37-* cp38-* pp* *-manylinux_i686 *_ppc64le *_s390x"
+build-verbosity = 1
+skip = ["*-manylinux_i686", "*_ppc64le", "*_s390x"]
 # Let's use a more recent version of the manylinux image for more modern compilers
 manylinux-x86_64-image = "manylinux_2_28"
 manylinux-aarch64-image = "manylinux_2_28"
+test-groups = ["test"]
+test-command = ["python -m pytest --pyargs numexpr"]
+
+[[tool.cibuildwheel.overrides]]
+select = "cp31*t-*"
+test-command = ["python -m pytest --parallel-threads=4 --pyargs numexpr"]

{numexpr-2.11.0 → numexpr-2.12.1}/site.cfg.example

@@ -2,10 +2,12 @@
 # file to "site.cfg" and edit the paths according to your installation of the
 # Intel MKL.
 
-# Example for Intel(R) MKL 2018 on Linux
+# Example for Intel(R) OneAPI MKL 2025 on Linux
+# When compiling (with e.g. `pip install -e. -v`), first do a:
+# $ source /opt/intel/oneapi/setvars.sh >/dev/null 2>&1 || true
 # [mkl]
-# library_dirs = /opt/intel/compilers_and_libraries_2018/linux/mkl/lib/intel64
-# include_dirs = /opt/intel/compilers_and_libraries_2018/linux/mkl/include
+# include_dirs = /opt/intel/oneapi/mkl/latest/include
+# library_dirs = /opt/intel/oneapi/mkl/latest/lib/intel64
 # libraries = mkl_rt
 
 

numexpr-2.11.0/VERSION

@@ -1 +0,0 @@
-2.11.0

numexpr-2.11.0/numexpr/version.py

@@ -1,5 +0,0 @@
-# THIS FILE IS GENERATED BY `setup.py`
-__version__ = '2.11.0'
-version = '2.11.0'
-numpy_build_version = '2.3.0'
-platform_machine = 'AMD64'