numexpr 2.12.1__tar.gz → 2.13.0__tar.gz

{numexpr-2.12.1 → 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,7 +171,7 @@ 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 here as well:
+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
 
@@ -186,7 +186,7 @@ Some functions (e.g. ``fmod``, ``isnan``) are not available in MKL, and so must
     };
     #endif
 
-The complex case is slightlñy different (see other examples in the same file).
+The complex case is slightly different (see other examples in the same file).
 
 Add case handling to the ``check_program`` function
 

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

@@ -1,11 +1,13 @@
 =========================
-Announcing NumExpr 2.12.1
+Announcing NumExpr 2.13.0
 =========================
 
 Hi everyone,
 
-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.
+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:
 

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

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

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

@@ -1,7 +1,23 @@
 =====================================
-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
 -----------------------------
 

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.1 → 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,6 +436,13 @@ 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)
 {
@@ -453,4 +472,24 @@ nc_isfinite(std::complex<double> *x)
     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.1 → 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)

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

@@ -30,12 +30,17 @@ FUNC_FF(FUNC_ARCTANH_FF, "arctanh_ff",  atanhf, atanhf2, vsAtanh)
 FUNC_FF(FUNC_LOG_FF,     "log_ff",      logf,   logf2,   vsLn)
 FUNC_FF(FUNC_LOG1P_FF,   "log1p_ff",    log1pf, log1pf2, vsLog1p)
 FUNC_FF(FUNC_LOG10_FF,   "log10_ff",    log10f, log10f2, vsLog10)
+FUNC_FF(FUNC_LOG2_FF,    "log2_ff",     log2f,  log2f2,  vsLog2)
 FUNC_FF(FUNC_EXP_FF,     "exp_ff",      expf,   expf2,   vsExp)
 FUNC_FF(FUNC_EXPM1_FF,   "expm1_ff",    expm1f, expm1f2, vsExpm1)
 FUNC_FF(FUNC_ABS_FF,     "absolute_ff", fabsf,  fabsf2,  vsAbs)
 FUNC_FF(FUNC_CONJ_FF,    "conjugate_ff",fconjf, fconjf2, vsConj)
 FUNC_FF(FUNC_CEIL_FF,    "ceil_ff",     ceilf,  ceilf2,  vsCeil)
 FUNC_FF(FUNC_FLOOR_FF,   "floor_ff",    floorf, floorf2, vsFloor)
+FUNC_FF(FUNC_TRUNC_FF,   "trunc_ff",    truncf, truncf2, vsTrunc)
+FUNC_FF(FUNC_SIGN_FF,   "sign_ff",    signf, signf2, vsSign)
+//rint rounds to nearest even integer, matching NumPy (round doesn't)
+FUNC_FF(FUNC_ROUND_FF,   "round_ff",    rintf,  rintf2,  vsRint)
 FUNC_FF(FUNC_FF_LAST,    NULL,          NULL,   NULL,    NULL)
 #ifdef ELIDE_FUNC_FF
 #undef ELIDE_FUNC_FF
@@ -48,6 +53,11 @@ FUNC_FF(FUNC_FF_LAST,    NULL,          NULL,   NULL,    NULL)
 #endif
 FUNC_FFF(FUNC_FMOD_FFF,    "fmod_fff",    fmodf,  fmodf2,  vsfmod)
 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_FFF_LAST,    NULL,          NULL,   NULL,    NULL)
 #ifdef ELIDE_FUNC_FFF
 #undef ELIDE_FUNC_FFF
@@ -74,12 +84,17 @@ FUNC_DD(FUNC_ARCTANH_DD, "arctanh_dd",  atanh, vdAtanh)
 FUNC_DD(FUNC_LOG_DD,     "log_dd",      log,   vdLn)
 FUNC_DD(FUNC_LOG1P_DD,   "log1p_dd",    log1p, vdLog1p)
 FUNC_DD(FUNC_LOG10_DD,   "log10_dd",    log10, vdLog10)
+FUNC_DD(FUNC_LOG2_DD,   "log2_dd",      log2,  vdLog2)
 FUNC_DD(FUNC_EXP_DD,     "exp_dd",      exp,   vdExp)
 FUNC_DD(FUNC_EXPM1_DD,   "expm1_dd",    expm1, vdExpm1)
 FUNC_DD(FUNC_ABS_DD,     "absolute_dd", fabs,  vdAbs)
 FUNC_DD(FUNC_CONJ_DD,    "conjugate_dd",fconj, vdConj)
 FUNC_DD(FUNC_CEIL_DD,    "ceil_dd",     ceil,  vdCeil)
 FUNC_DD(FUNC_FLOOR_DD,   "floor_dd",    floor, vdFloor)
+FUNC_DD(FUNC_TRUNC_DD,   "trunc_dd",    trunc, vdTrunc)
+FUNC_DD(FUNC_SIGN_DD,    "sign_dd",     sign,  vdSign)
+//rint rounds to nearest even integer, matching NumPy (round doesn't)
+FUNC_DD(FUNC_ROUND_DD,   "round_dd",    rint,  vdRint)
 FUNC_DD(FUNC_DD_LAST,    NULL,          NULL,  NULL)
 #ifdef ELIDE_FUNC_DD
 #undef ELIDE_FUNC_DD
@@ -94,6 +109,7 @@ FUNC_DD(FUNC_DD_LAST,    NULL,          NULL,  NULL)
 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_SIGNBIT_BD, "signbit_bd",  signbit, vdSignBit)
 FUNC_BD(FUNC_BD_LAST,    NULL,          NULL,  NULL)
 #ifdef ELIDE_FUNC_BD
 #undef ELIDE_FUNC_BD
@@ -105,9 +121,10 @@ FUNC_BD(FUNC_BD_LAST,    NULL,          NULL,  NULL)
 #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_ISNAN_BF,   "isnan_bf",    isnanf_,  isnanf2, vsIsnan)
+FUNC_BF(FUNC_ISFINITE_BF, "isfinite_bf", isfinitef_, isfinitef2, vsIsfinite)
+FUNC_BF(FUNC_ISINF_BF, "isinf_bf", isinff_, isinff2, vsIsinf)
+FUNC_BF(FUNC_SIGNBIT_BF, "signbit_bf", signbitf, signbitf2, vsSignBit)
 FUNC_BF(FUNC_BF_LAST,    NULL,            NULL,        NULL,    NULL)
 #ifdef ELIDE_FUNC_BF
 #undef ELIDE_FUNC_BF
@@ -120,6 +137,11 @@ FUNC_BF(FUNC_BF_LAST,    NULL,            NULL,        NULL,    NULL)
 #endif
 FUNC_DDD(FUNC_FMOD_DDD,    "fmod_ddd",    fmod,  vdfmod)
 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_DDD_LAST,    NULL,          NULL,  NULL)
 #ifdef ELIDE_FUNC_DDD
 #undef ELIDE_FUNC_DDD
@@ -146,10 +168,14 @@ FUNC_CC(FUNC_ARCTANH_CC, "arctanh_cc",  nc_atanh,  vzAtanh)
 FUNC_CC(FUNC_LOG_CC,     "log_cc",      nc_log,    vzLn)
 FUNC_CC(FUNC_LOG1P_CC,   "log1p_cc",    nc_log1p,  vzLog1p)
 FUNC_CC(FUNC_LOG10_CC,   "log10_cc",    nc_log10,  vzLog10)
+FUNC_CC(FUNC_LOG2_CC,    "log2_cc",     nc_log2,   vzLog2)
 FUNC_CC(FUNC_EXP_CC,     "exp_cc",      nc_exp,    vzExp)
 FUNC_CC(FUNC_EXPM1_CC,   "expm1_cc",    nc_expm1,  vzExpm1)
 FUNC_CC(FUNC_ABS_CC,     "absolute_cc", nc_abs,    vzAbs_)
 FUNC_CC(FUNC_CONJ_CC,    "conjugate_cc",nc_conj,   vzConj)
+FUNC_CC(FUNC_SIGN_CC,   "sign_cc",    nc_sign,   vzSign)
+// rint rounds to nearest even integer, matches NumPy behaviour (round doesn't)
+FUNC_CC(FUNC_ROUND_CC,   "round_cc",    nc_rint,   vzRint)
 FUNC_CC(FUNC_CC_LAST,    NULL,          NULL,      NULL)
 #ifdef ELIDE_FUNC_CC
 #undef ELIDE_FUNC_CC
@@ -180,3 +206,30 @@ FUNC_BC(FUNC_BC_LAST,    NULL,            NULL,        NULL)
 #undef ELIDE_FUNC_BC
 #undef FUNC_BC
 #endif
+
+// int -> int functions
+#ifndef FUNC_II
+#define ELIDE_FUNC_II
+#define FUNC_II(...)
+#endif
+FUNC_II(FUNC_SIGN_II,   "sign_ii",  signi, viSign)
+FUNC_II(FUNC_ROUND_II,  "round_ii", rinti, viRint)
+FUNC_II(FUNC_ABS_II,  "absolute_ii", fabsi, viFabs)
+FUNC_II(FUNC_II_LAST,  NULL,      NULL, NULL)
+#ifdef ELIDE_FUNC_II
+#undef ELIDE_FUNC_II
+#undef FUNC_II
+#endif
+
+#ifndef FUNC_LL
+#define ELIDE_FUNC_LL
+#define FUNC_LL(...)
+#endif
+FUNC_LL(FUNC_SIGN_LL,  "sign_ll",   signl,   vlSign)
+FUNC_LL(FUNC_ROUND_LL, "round_ll",  rintl,   vlRint)
+FUNC_LL(FUNC_ABS_LL,  "absolute_ll", fabsl, vlFabs)
+FUNC_LL(FUNC_LL_LAST,  NULL,      NULL, NULL)
+#ifdef ELIDE_FUNC_LL
+#undef ELIDE_FUNC_LL
+#undef FUNC_LL
+#endif