numexpr 2.13.0__tar.gz → 2.13.1__tar.gz

{numexpr-2.13.0 → numexpr-2.13.1}/ANNOUNCE.rst

@@ -1,29 +1,31 @@
 =========================
-Announcing NumExpr 2.13.0
+Announcing NumExpr 2.13.
 =========================
 
 Hi everyone,
 
-NumExpr 2.13.0 introduced a bunch of new features including new
-bitwise operators (&, |, ^, ~), floor division (//). It also adds
-many new functions (like hypot, log2, maximum, minimum, nextafter...).
+NumExpr 2.13.1 introduces a couple of patches for maximum/minimum and
+multiplication/addition for booleans to match NumPy behaviour.
 Thanks to Luke Shaw for these contributions.
 
 Project documentation is available at:
 
-http://numexpr.readthedocs.io/
+https://numexpr.readthedocs.io/
 
-Changes from 2.12.0 to 2.12.1
+Changes from 2.12.1 to 2.13.0
 -----------------------------
 
-* Added complex counterparts for isnan/isfinite/isinf functions.
-  Thanks to Luke Shaw.
+* New functionality has been added:
+  * Bitwise operators (and, or, not, xor): `&, |, ~, ^`
+  * New binary arithmetic operator for floor division: `//`
+  * New functions: `signbit`, `hypot`, `copysign`, `nextafter`, `maximum`,
+    `minimum`, `log2`, `trunc`, `round` and `sign`.
+  * Also enables integer outputs for integer inputs for
+    `abs`, `fmod`, `copy`, `ones_like`, `sign` and `round`.
 
-* Updated documentation for the new functions and instructions
-  for adding new functions to the virtual machine.  Thanks to Luke Shaw.
+  Thanks to Luke Shaw for the contributions.
 
-* Fixed MKL support; it was broken in 2.12.0.  Thanks to
-  Christoph Gohlke for reporting the issue.
+* New wheels for Python 3.14 and 3.14t are provided.
 
 What's Numexpr?
 ---------------

{numexpr-2.13.0 → numexpr-2.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numexpr
-Version: 2.13.0
+Version: 2.13.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>

{numexpr-2.13.0 → numexpr-2.13.1}/RELEASE_NOTES.rst

@@ -2,22 +2,26 @@
 Release notes for NumExpr 2.13 series
 =====================================
 
+Changes from 2.13.0 to 2.13.1
+-----------------------------
+
+* Patch to maximum/minimum functions in order to match NumPy NaN handling
+* Patch to convert '+'->'|' and '*'->'&' for booleans
 
 Changes from 2.12.1 to 2.13.0
 -----------------------------
 
 * New functionality has been added:
-  * Bitwise operators (and, or, not, xor): `&, |, ~, ^`
-  * New binary arithmetic operator for floor division: `//`
-  * New functions: `signbit`, `hypot`, `copysign`, `nextafter`, `maximum`,
-    `minimum`, `log2`, `trunc`, `round` and `sign`.
-  * Also enables integer outputs for integer inputs for
-    `abs`, `fmod`, `copy`, `ones_like`, `sign` and `round`.
+ * Bitwise operators (and, or, not, xor): `&, |, ~, ^`
+ * New binary arithmetic operator for floor division: `//`
+ * New functions: `signbit`, `hypot`, `copysign`, `nextafter`, `maximum`, `minimum`, `log2`, `trunc`, `round` and `sign`.
+ * Also enables integer outputs for integer inputs for `abs`, `copy`, `ones_like`, `sign` and `round`.
 
-  Thanks to Luke Shaw for the contributions.
+ Thanks to Luke Shaw for the contributions.
 
 * New wheels for Python 3.14 and 3.14t are provided.
 
+
 Changes from 2.12.0 to 2.12.1
 -----------------------------
 

numexpr-2.13.1/VERSION

@@ -0,0 +1 @@
+2.13.1

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/bespoke_functions.hpp

@@ -35,6 +35,51 @@ inline long fabsl(long x) {return x<0 ? -x: x;}
 // inline long fmodl(long x, long y)  {return (long)fmodf((long)x, (long)y);}
 
 #ifdef USE_VML
+// To match Numpy behaviour for NaNs
+static void vsFmax_(MKL_INT n, const float* x1, const float* x2, float* dest)
+{
+    vsFmax(n, x1, x2, dest);
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        if (isnanf_(x1[j]) | isnanf_(x2[j])){
+            dest[j] = NAN;
+        }
+    };
+};
+
+static void vsFmin_(MKL_INT n, const float* x1, const float* x2, float* dest)
+{
+    vsFmin(n, x1, x2, dest);
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        if (isnanf_(x1[j]) | isnanf_(x2[j])){
+            dest[j] = NAN;
+        }
+    };
+};
+// To match Numpy behaviour for NaNs
+static void vdFmax_(MKL_INT n, const double* x1, const double* x2, double* dest)
+{
+    vdFmax(n, x1, x2, dest);
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        if (isnand(x1[j]) | isnand(x2[j])){
+            dest[j] = NAN;
+        }
+    };
+};
+
+static void vdFmin_(MKL_INT n, const double* x1, const double* x2, double* dest)
+{
+    vdFmin(n, x1, x2, dest);
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        if (isnand(x1[j]) | isnand(x2[j])){
+            dest[j] = NAN;
+        }
+    };
+};
+
 static void viRint(MKL_INT n, const int* x, int* dest)
 {
     memcpy(dest, x, n * sizeof(int)); // just copy x1 which is already int

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/expressions.py

@@ -531,6 +531,9 @@ class OpNode(ExpressionNode):
     def __init__(self, opcode=None, args=None, kind=None):
         if (kind is None) and (args is not None):
             kind = commonKind(args)
+        if kind=='bool': # handle bool*bool and bool+bool cases
+            opcode = 'and' if opcode=='mul' else opcode
+            opcode = 'or' if opcode=='add' else opcode
         ExpressionNode.__init__(self, value=opcode, kind=kind, children=args)
 
 

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/functions.hpp

@@ -56,8 +56,8 @@ FUNC_FFF(FUNC_ARCTAN2_FFF, "arctan2_fff", atan2f, atan2f2, vsAtan2)
 FUNC_FFF(FUNC_HYPOT_FFF, "hypot_fff", hypotf, hypotf2, vsHypot)
 FUNC_FFF(FUNC_NEXTAFTER_FFF, "nextafter_fff", nextafterf, nextafterf2, vsNextAfter)
 FUNC_FFF(FUNC_COPYSIGN_FFF, "copysign_fff", copysignf, copysignf2, vsCopySign)
-FUNC_FFF(FUNC_MAXIMUM_FFF,   "maximum_fff",    fmaxf, fmaxf2, vsFmax)
-FUNC_FFF(FUNC_MINIMUM_FFF,   "minimum_fff",    fminf, fminf2, vsFmin)
+FUNC_FFF(FUNC_MAXIMUM_FFF,   "maximum_fff",    fmaxf_, fmaxf2, vsFmax_)
+FUNC_FFF(FUNC_MINIMUM_FFF,   "minimum_fff",    fminf_, fminf2, vsFmin_)
 FUNC_FFF(FUNC_FFF_LAST,    NULL,          NULL,   NULL,    NULL)
 #ifdef ELIDE_FUNC_FFF
 #undef ELIDE_FUNC_FFF
@@ -140,8 +140,8 @@ FUNC_DDD(FUNC_ARCTAN2_DDD, "arctan2_ddd", atan2, vdAtan2)
 FUNC_DDD(FUNC_HYPOT_DDD, "hypot_ddd", hypot, vdHypot)
 FUNC_DDD(FUNC_NEXTAFTER_DDD, "nextafter_ddd", nextafter, vdNextAfter)
 FUNC_DDD(FUNC_COPYSIGN_DDD, "copysign_ddd", copysign, vdCopySign)
-FUNC_DDD(FUNC_MAXIMUM_DDD, "maximum_ddd",  fmaxd,  vdFmax)
-FUNC_DDD(FUNC_MINIMUM_DDD, "minimum_ddd",  fmind,  vdFmin)
+FUNC_DDD(FUNC_MAXIMUM_DDD, "maximum_ddd",  fmaxd,  vdFmax_)
+FUNC_DDD(FUNC_MINIMUM_DDD, "minimum_ddd",  fmind,  vdFmin_)
 FUNC_DDD(FUNC_DDD_LAST,    NULL,          NULL,  NULL)
 #ifdef ELIDE_FUNC_DDD
 #undef ELIDE_FUNC_DDD

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/msvc_function_stubs.hpp

@@ -16,47 +16,6 @@
    definitions in <math.h> are actually #define'd and are not usable
    as function pointers :-/ */
 
-#if _MSC_VER < 1400  // 1310 == MSVC 7.1
-/* Apparently, single precision functions are not included in MSVC 7.1 */
-
-#define sqrtf(x)    ((float)sqrt((double)(x)))
-#define sinf(x)    ((float)sin((double)(x)))
-#define cosf(x)    ((float)cos((double)(x)))
-#define tanf(x)    ((float)tan((double)(x)))
-#define asinf(x)    ((float)asin((double)(x)))
-#define acosf(x)    ((float)acos((double)(x)))
-#define atanf(x)    ((float)atan((double)(x)))
-#define sinhf(x)    ((float)sinh((double)(x)))
-#define coshf(x)    ((float)cosh((double)(x)))
-#define tanhf(x)    ((float)tanh((double)(x)))
-#define asinhf(x)    ((float)asinh((double)(x)))
-#define acoshf(x)    ((float)acosh((double)(x)))
-#define atanhf(x)    ((float)atanh((double)(x)))
-#define logf(x)    ((float)log((double)(x)))
-#define log1pf(x)    ((float)log1p((double)(x)))
-#define log10f(x)    ((float)log10((double)(x)))
-#define log2f(x)    ((float)log2((double)(x)))
-#define expf(x)    ((float)exp((double)(x)))
-#define expm1f(x)    ((float)expm1((double)(x)))
-#define fabsf(x)    ((float)fabs((double)(x)))
-#define fmodf(x, y)    ((float)fmod((double)(x), (double)(y)))
-#define atan2f(x, y)    ((float)atan2((double)(x), (double)(y)))
-#define hypotf(x, y)    ((float)hypot((double)(x), (double)(y)))
-#define copysignf(x, y)    ((float)copysign((double)(x), (double)(y)))
-#define nextafterf(x, y)    ((float)nextafter((double)(x), (double)(y)))
-#define fmaxf(x, y)    ((float)fmaxd((double)(x), (double)(y)))
-#define fminf(x, y)    ((float)fmind((double)(x), (double)(y)))
-#define ceilf(x)    ((float)ceil((double)(x)))
-#define hypotf(x)    ((float)hypot((double)(x)))
-#define rintf(x)    ((float)rint((double)(x)))
-#define truncf(x)    ((float)trunc((double)(x)))
-
-
-/* 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
-
 /* Due to casting problems (normally return ints not bools, easiest to define
 non-overloaded wrappers for these functions) */
 // MSVC version: use global ::isfinite / ::isnan
@@ -67,6 +26,57 @@ inline bool isnand(double x)    { return !!::_isnan(x); }
 inline bool isinfd(double x) { return !!::isinf(x); }
 inline bool isinff_(float x)    { return !!::isinf(x); }
 
+// To handle overloading of fmax/fmin in cmath and match NumPy behaviour for NaNs
+inline double fmaxd(double x, double y)    { return (isnand(x) | isnand(y))? NAN : fmax(x, y); }
+inline double fmind(double x, double y)    { return (isnand(x) | isnand(y))? NAN : fmin(x, y); }
+
+
+#if _MSC_VER < 1400  // 1310 == MSVC 7.1
+    /* Apparently, single precision functions are not included in MSVC 7.1 */
+
+    #define sqrtf(x)    ((float)sqrt((double)(x)))
+    #define sinf(x)    ((float)sin((double)(x)))
+    #define cosf(x)    ((float)cos((double)(x)))
+    #define tanf(x)    ((float)tan((double)(x)))
+    #define asinf(x)    ((float)asin((double)(x)))
+    #define acosf(x)    ((float)acos((double)(x)))
+    #define atanf(x)    ((float)atan((double)(x)))
+    #define sinhf(x)    ((float)sinh((double)(x)))
+    #define coshf(x)    ((float)cosh((double)(x)))
+    #define tanhf(x)    ((float)tanh((double)(x)))
+    #define asinhf(x)    ((float)asinh((double)(x)))
+    #define acoshf(x)    ((float)acosh((double)(x)))
+    #define atanhf(x)    ((float)atanh((double)(x)))
+    #define logf(x)    ((float)log((double)(x)))
+    #define log1pf(x)    ((float)log1p((double)(x)))
+    #define log10f(x)    ((float)log10((double)(x)))
+    #define log2f(x)    ((float)log2((double)(x)))
+    #define expf(x)    ((float)exp((double)(x)))
+    #define expm1f(x)    ((float)expm1((double)(x)))
+    #define fabsf(x)    ((float)fabs((double)(x)))
+    #define fmodf(x, y)    ((float)fmod((double)(x), (double)(y)))
+    #define atan2f(x, y)    ((float)atan2((double)(x), (double)(y)))
+    #define hypotf(x, y)    ((float)hypot((double)(x), (double)(y)))
+    #define copysignf(x, y)    ((float)copysign((double)(x), (double)(y)))
+    #define nextafterf(x, y)    ((float)nextafter((double)(x), (double)(y)))
+    #define ceilf(x)    ((float)ceil((double)(x)))
+    #define hypotf(x)    ((float)hypot((double)(x)))
+    #define rintf(x)    ((float)rint((double)(x)))
+    #define truncf(x)    ((float)trunc((double)(x)))
+
+
+    /* 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)))
+
+    #define fmaxf_(x, y)    ((float)fmaxd((double)(x), (double)(y))) // define fmaxf_ since fmaxf doesn't exist for early MSVC
+    #define fminf_(x, y)    ((float)fmind((double)(x), (double)(y)))
+#else
+    inline float fmaxf_(float x, float y)    { return (isnanf_(x) | isnanf_(y))? NAN : fmaxf(x, y); }
+    inline float fminf_(float x, float y)    { return (isnanf_(x) | isnanf_(y))? NAN : fminf(x, y); }
+#endif // _MSC_VER < 1400
+
+
 /* Now the actual stubs */
 
 inline float sqrtf2(float x) {
@@ -170,11 +180,11 @@ inline float copysignf2(float x, float y) {
 }
 
 inline float fmaxf2(float x, float y) {
-    return fmaxf(x, y);
+    return fmaxf_(x, y);
 }
 
 inline float fminf2(float x, float y) {
-    return fminf(x, y);
+    return fminf_(x, y);
 }
 
 

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/numexpr_config.hpp

@@ -43,9 +43,7 @@
 #include <cmath>
 //no single precision version of signbit in C++ standard
 inline bool signbitf(float x) { return signbit((double)x); }
-// To handle overloading of fmax/fmin in cmath
-inline double fmaxd(double x, double y)    { return fmax(x, y); }
-inline double fmind(double x, double y)    { return fmin(x, y); }
+
 #ifdef _WIN32
   #ifndef __MINGW32__
     #include "missing_posix_functions.hpp"
@@ -62,6 +60,12 @@ inline bool isfinited(double x) { return !!std::isfinite(x); }
 inline bool isnand(double x)    { return !!std::isnan(x); }
 inline bool isinff_(float x) { return !!std::isinf(x); }
 inline bool isinfd(double x)    { return !!std::isinf(x); }
+
+// To handle overloading of fmax/fmin in cmath and match NumPy behaviour for NaNs
+inline double fmaxd(double x, double y)    { return (isnand(x) | isnand(y))? NAN : fmax(x, y); }
+inline double fmind(double x, double y)    { return (isnand(x) | isnand(y))? NAN : fmin(x, y); }
+inline float fmaxf_(float x, float y)    { return (isnanf_(x) | isnanf_(y))? NAN : fmaxf(x, y); }
+inline float fminf_(float x, float y)    { return (isnanf_(x) | isnanf_(y))? NAN : fminf(x, y); }
 #endif
 
 #endif // NUMEXPR_CONFIG_HPP

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/tests/test_numexpr.py

@@ -484,9 +484,24 @@ class test_evaluate(TestCase):
         for dtype in [float, double, int, np.int64]:
             x = arange(10, dtype=dtype)
             y = 2 * arange(10, dtype=dtype)[::-1]
+            if dtype in (float, double):
+                y[5] = np.nan
+                x[2] = np.nan
             assert_array_equal(evaluate("maximum(x,y)"), maximum(x,y))
             assert_array_equal(evaluate("minimum(x,y)"), minimum(x,y))
 
+    def test_addmult_booleans(self):
+        x = np.asarray([0, 1, 0, 0, 1], dtype=bool)
+        y = x[::-1]
+        res_ne = evaluate("x * y")
+        res_np = x * y
+        assert_array_equal(res_ne, res_np)
+        assert res_ne.dtype == res_np.dtype
+        res_ne = evaluate("x + y")
+        res_np = x + y
+        assert_array_equal(res_ne, res_np)
+        assert res_ne.dtype == res_np.dtype
+
     def test_sign_round(self):
         for dtype in [float, double, np.int32, np.int64, complex]:
             x = arange(10, dtype=dtype)

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr/version.py

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

{numexpr-2.13.0 → numexpr-2.13.1}/numexpr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numexpr
-Version: 2.13.0
+Version: 2.13.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>

numexpr-2.13.0/VERSION

@@ -1 +0,0 @@
-2.13.0