numexpr 2.12.0__tar.gz → 2.13.0__tar.gz

{numexpr-2.12.0 → numexpr-2.13.0}/ADDFUNCS.rst

@@ -54,7 +54,7 @@ Example:
     #define FUNC_FF(...)
     #endif
     ...
-    FUNC_FF(FUNC_MYFUNC_FF, "myfunc_ff", myfuncf, myfuncf2, vfMyfunc)
+    FUNC_FF(FUNC_MYFUNC_FF, "myfunc_ff", myfuncf, myfuncf2, vsMyfunc)
     FUNC_FF(FUNC_FF_LAST,    NULL,       NULL,    NULL,     NULL)
     #ifdef ELIDE_FUNC_FF
     #undef ELIDE_FUNC_FF
@@ -171,6 +171,23 @@ Add clauses to generate the FUNC_CODES from the ``functions.hpp`` header, making
     };
     #endif
 
+Some functions (e.g. ``fmod``, ``isnan``) are not available in MKL, and so must be hard-coded in ``bespoke_functions.hpp`` 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 slightly different (see other examples in the same file).
+
 Add case handling to the ``check_program`` function
 
 .. code-block:: cpp
@@ -219,4 +236,6 @@ In many cases this process will not be very smooth since one relies on the inter
 
 * 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.12.0 → numexpr-2.13.0}/ANNOUNCE.rst

@@ -1,29 +1,29 @@
 =========================
-Announcing NumExpr 2.12.0
+Announcing NumExpr 2.13.0
 =========================
 
 Hi everyone,
 
-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.
+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...).
+Thanks to Luke Shaw for these contributions.
 
 Project documentation is available at:
 
 http://numexpr.readthedocs.io/
 
-Changes from 2.11.0 to 2.12.0
+Changes from 2.12.0 to 2.12.1
 -----------------------------
 
-* Added isnan/isfinite/isinf functions.  Thanks to Luke Shaw.
+* Added complex counterparts for 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.
+* Updated documentation for the new functions and instructions
+  for adding new functions to the virtual machine.  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.
+* Fixed MKL support; it was broken in 2.12.0.  Thanks to
+  Christoph Gohlke for reporting the issue.
 
 What's Numexpr?
 ---------------

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

@@ -29,3 +29,6 @@ since 2016 to 2023.
 
 Teng Liu fixed many bugs, and in particular, contributed valuable fixes
 to the new regex sanitizer for expressions.
+
+Luke Shaw contributed a bunch of new functions, and expanded the amount
+of opcodes from 128 to 256.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numexpr
-Version: 2.12.0
+Version: 2.13.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>
@@ -137,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.12.0 → numexpr-2.13.0}/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.12.0 → numexpr-2.13.0}/RELEASE_NOTES.rst

@@ -1,7 +1,36 @@
 =====================================
-Release notes for NumExpr 2.12 series
+Release notes for NumExpr 2.13 series
 =====================================
 
+
+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`.
+
+  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
+-----------------------------
+
+* 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
 -----------------------------
 

numexpr-2.13.0/VERSION

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

numexpr-2.13.0/numexpr/bespoke_functions.hpp

@@ -0,0 +1,294 @@
+#include <numpy/npy_cpu.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+#include <vector>
+#include "numexpr_config.hpp" // isnan definitions
+
+// Generic sign function
+inline int signi(int x) {return (0 < x) - (x < 0);}
+inline long signl(long x) {return (0 < x) - (x < 0);}
+inline double sign(double x){
+        // Floats: -1.0, 0.0, +1.0, NaN stays NaN
+        if (isnand(x)) {return NAN;}
+        if (x > 0) {return 1;}
+        if (x < 0) {return -1;}
+        return 0; // handles +0.0 and -0.0
+    }
+inline float signf(float x){
+        // Floats: -1.0, 0.0, +1.0, NaN stays NaN
+        if (isnanf_(x)) {return NAN;}
+        if (x > 0) {return 1;}
+        if (x < 0) {return -1;}
+        return 0; // handles +0.0 and -0.0
+    }
+
+// round function for ints
+inline int rinti(int x) {return x;}
+inline long rintl(long x) {return x;}
+// abs function for ints
+inline int fabsi(int x) {return x<0 ? -x: x;}
+inline long fabsl(long x) {return x<0 ? -x: x;}
+// fmod function for ints
+// TODO: Have to add FUNC_III, FUNC_LLL signatures to functions.hpp to enable these
+// inline int fmodi(int x, int y) {return (int)fmodf((float)x, (float)y);}
+// inline long fmodl(long x, long y)  {return (long)fmodf((long)x, (long)y);}
+
+#ifdef USE_VML
+static void viRint(MKL_INT n, const int* x, int* dest)
+{
+    memcpy(dest, x, n * sizeof(int)); // just copy x1 which is already int
+};
+
+static void vlRint(MKL_INT n, const long* x, long* dest)
+{
+    memcpy(dest, x, n * sizeof(long)); // just copy x1 which is already int
+};
+
+static void viFabs(MKL_INT n, const int* x, int* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = x[j] < 0 ? -x[j]: x[j];
+    };
+};
+
+static void vlFabs(MKL_INT n, const long* x, long* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = x[j] < 0 ? -x[j]: x[j];
+    };
+};
+
+/* Fake vsConj function just for casting purposes inside numexpr */
+static void vsConj(MKL_INT n, const float* x1, float* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = x1[j];
+    };
+};
+
+/* fmod not available in VML */
+static void vsfmod(MKL_INT n, const float* x1, const float* x2, float* dest)
+{
+    MKL_INT j;
+    for(j=0; j < n; j++) {
+    dest[j] = fmodf(x1[j], x2[j]);
+    };
+}
+static void vdfmod(MKL_INT n, const double* x1, const double* x2, double* dest)
+{
+    MKL_INT j;
+    for(j=0; j < n; j++) {
+    dest[j] = fmod(x1[j], x2[j]);
+    };
+};
+// TODO: Have to add FUNC_III, FUNC_LLL signatures to functions.hpp
+// static void vifmod(MKL_INT n, const int* x1, const int* x2, int* dest)
+// {
+//     MKL_INT j;
+//     for(j=0; j < n; j++) {
+//     dest[j] = fmodi(x1[j], x2[j]);
+//     };
+// };
+// static void vlfmod(MKL_INT n, const long* x1, const long* x2, long* dest)
+// {
+//     MKL_INT j;
+//     for(j=0; j < n; j++) {
+//     dest[j] = fmodl(x1[j], x2[j]);
+//     };
+// };
+
+/* no isnan, isfinite, isinf or signbit in VML */
+static void vsIsfinite(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isfinitef_(x1[j]);
+    };
+};
+static void vsIsinf(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isinff_(x1[j]);
+    };
+};
+static void vsIsnan(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = isnanf_(x1[j]);
+    };
+};
+static void vsSignBit(MKL_INT n, const float* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = signbitf(x1[j]);
+    };
+};
+
+/* no isnan, isfinite, isinf, signbit 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]);
+    };
+};
+static void vdSignBit(MKL_INT n, const double* x1, bool* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = signbit(x1[j]);
+    };
+};
+
+/* 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);
+    };
+};
+
+/* Fake vdConj function just for casting purposes inside numexpr */
+static void vdConj(MKL_INT n, const double* x1, double* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j] = x1[j];
+    };
+};
+
+/* various functions not available in VML */
+static void vzExpm1(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
+{
+    MKL_INT j;
+    vzExp(n, x1, dest);
+    for (j=0; j<n; j++) {
+        dest[j].real -= 1.0;
+    };
+};
+
+static void vzLog1p(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j].real = x1[j].real + 1;
+        dest[j].imag = x1[j].imag;
+    };
+    vzLn(n, dest, dest);
+};
+
+static void vzLog2(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
+{
+    MKL_INT j;
+    vzLn(n, x1, dest);
+    for (j=0; j<n; j++) {
+        dest[j].real = dest[j].real * M_LOG2_E;
+        dest[j].imag = dest[j].imag * M_LOG2_E;
+    };
+};
+
+static void vzRint(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j].real = rint(x1[j].real);
+        dest[j].imag = rint(x1[j].imag);
+    };
+};
+
+/* Use this instead of native vzAbs in VML as it seems to work badly */
+static void vzAbs_(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
+{
+    MKL_INT j;
+    for (j=0; j<n; j++) {
+        dest[j].real = sqrt(x1[j].real*x1[j].real + x1[j].imag*x1[j].imag);
+        dest[j].imag = 0;
+    };
+};
+
+/*sign functions*/
+static void vsSign(MKL_INT n, const float* x1, float* dest)
+{
+    MKL_INT j;
+    for(j=0; j < n; j++) {
+        dest[j] = signf(x1[j]);
+    };
+};
+static void vdSign(MKL_INT n, const double* x1, double* dest)
+{
+    MKL_INT j;
+    for(j=0; j < n; j++) {
+        dest[j] = sign(x1[j]);
+    };
+};
+static void viSign(MKL_INT n, const int* x1, int* dest)
+{
+    MKL_INT j;
+    for(j=0; j < n; j++) {
+        dest[j] = signi(x1[j]);
+    };
+};
+static void vlSign(MKL_INT n, const long* x1, long* dest)
+{
+    MKL_INT j;
+    for(j=0; j < n; j++) {
+        dest[j] = signl(x1[j]);
+    };
+};
+static void vzSign(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
+{
+    MKL_INT j;
+    double mag;
+    for(j=0; j < n; j++) {
+        mag = sqrt(x1[j].real*x1[j].real + x1[j].imag*x1[j].imag);
+        if (isnand(mag)) {
+            dest[j].real = NAN;
+            dest[j].imag = NAN;
+        }
+        else if (mag == 0) {
+            dest[j].real = 0;
+            dest[j].imag = 0;
+        }
+        else {
+            dest[j].real = x1[j].real / mag;
+            dest[j].imag = x1[j].imag / mag;
+        }
+    };
+};
+#endif

{numexpr-2.12.0 → numexpr-2.13.0}/numexpr/complex_functions.hpp

@@ -11,6 +11,7 @@
 **********************************************************************/
 
 // Replace npy_cdouble with std::complex<double>
+#include <math.h> // NAN
 #include <complex>
 
 /* constants */
@@ -347,6 +348,8 @@ nc_cosh(std::complex<double> *x, std::complex<double> *r)
 
 
 #define M_LOG10_E 0.434294481903251827651128918916605082294397
+#define M_LOG2_E  1.44269504088896340735992468100189213742664
+
 
 static void
 nc_log10(std::complex<double> *x, std::complex<double> *r)
@@ -357,6 +360,15 @@ nc_log10(std::complex<double> *x, std::complex<double> *r)
     return;
 }
 
+static void
+nc_log2(std::complex<double> *x, std::complex<double> *r)
+{
+    nc_log(x, r);
+    r->real(r->real() * M_LOG2_E);
+    r->imag(r->imag() * M_LOG2_E);
+    return;
+}
+
 static void
 nc_sin(std::complex<double> *x, std::complex<double> *r)
 {
@@ -424,4 +436,60 @@ nc_abs(std::complex<double> *x, std::complex<double> *r)
     r->imag(0);
 }
 
+static void
+nc_rint(std::complex<double> *x, std::complex<double> *r)
+{
+    r->real(rint(x->real()));
+    r->imag(rint(x->imag()));
+}
+
+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;
+}
+
+static void
+nc_sign(std::complex<double> *x, std::complex<double> *r)
+{
+    if (nc_isnan(x)){
+        r->real(NAN);
+        r->imag(NAN);
+    }
+    std::complex<double> mag;
+    nc_abs(x, &mag);
+    if (mag.real() == 0){
+        r->real(0);
+        r->imag(0);
+    }
+    else{
+        r->real(x->real()/mag.real());
+        r->imag(x->imag()/mag.real());
+    }
+}
+
 #endif // NUMEXPR_COMPLEX_FUNCTIONS_HPP

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

@@ -186,11 +186,12 @@ def func(func, minkind=None, maxkind=None):
             return ConstantNode(func(*[x.value for x in args]))
         kind = commonKind(args)
         if kind in ('int', 'long'):
-            # Exception for following NumPy casting rules
-            #FIXME: this is not always desirable. The following
-            # functions which return ints (for int inputs) on numpy
-            # but not on numexpr: copy, abs, fmod, ones_like
-            kind = 'double'
+            if func.__name__ not in ('copy', 'abs', 'ones_like', 'round', 'sign'):
+                # except for these special functions (which return ints for int inputs in NumPy)
+                # just do a cast to double
+                # FIXME: 'fmod' outputs ints for NumPy when inputs are ints, but need to
+                # add new function signatures FUNC_LLL FUNC_III to support this
+                kind = 'double'
         else:
             # Apply regular casting rules
             if minkind and kind_rank.index(minkind) > kind_rank.index(kind):
@@ -348,16 +349,26 @@ functions = {
 
     'fmod': func(numpy.fmod, 'float'),
     'arctan2': func(numpy.arctan2, 'float'),
+    'hypot': func(numpy.hypot, 'double'),
+    'nextafter': func(numpy.nextafter, 'double'),
+    'copysign': func(numpy.copysign, 'double'),
+    'maximum': func(numpy.maximum, 'double'),
+    'minimum': func(numpy.minimum, 'double'),
+
 
     'log': func(numpy.log, 'float'),
     'log1p': func(numpy.log1p, 'float'),
     'log10': func(numpy.log10, 'float'),
+    'log2': func(numpy.log2, 'float'),
     'exp': func(numpy.exp, 'float'),
     'expm1': func(numpy.expm1, 'float'),
 
     'abs': func(numpy.absolute, 'float'),
     'ceil': func(numpy.ceil, 'float', 'double'),
     'floor': func(numpy.floor, 'float', 'double'),
+    'round': func(numpy.round, 'double'),
+    'trunc': func(numpy.trunc, 'double'),
+    'sign': func(numpy.sign, 'double'),
 
     'where': where_func,
 
@@ -366,9 +377,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'),
+    'isnan': func(numpy.isnan, 'double'),
+    'isfinite': func(numpy.isfinite, 'double'),
+    'isinf': func(numpy.isinf, 'double'),
+    'signbit': func(numpy.signbit, 'double'),
 
     'sum': gen_reduce_axis_func('sum'),
     'prod': gen_reduce_axis_func('prod'),
@@ -441,6 +453,7 @@ class ExpressionNode():
     __mul__ = __rmul__ = binop('mul')
     __truediv__ = truediv_op
     __rtruediv__ = rtruediv_op
+    __floordiv__ = binop("floordiv")
     __pow__ = pow_op
     __rpow__ = binop('pow', reversed=True)
     __mod__ = binop('mod')
@@ -451,10 +464,10 @@ class ExpressionNode():
     __rshift__ = binop('rshift')
     __rrshift__ = binop('rshift', reversed=True)
 
-    # boolean operations
-
-    __and__ = binop('and', kind='bool')
-    __or__ = binop('or', kind='bool')
+    # bitwise or logical operations
+    __and__ = binop('and')
+    __or__ = binop('or')
+    __xor__ = binop('xor')
 
     __gt__ = binop('gt', kind='bool')
     __ge__ = binop('ge', kind='bool')
@@ -525,6 +538,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
+        if opcode in ("isnan", "isfinite", "isinf", "signbit"): # bodge for boolean return functions
             kind = 'bool'
         OpNode.__init__(self, opcode, args, kind)