Improve casting for ints to match Numpy and add docs

Author: lshaw8317

doc/user_guide.rst

@@ -188,10 +188,10 @@ Supported operators
 
 *NumExpr* supports the set of operators listed below:
 
-    * Bitwise operators (and, or, not, xor): :code:`&, |, ~, ^`
+    * Bitwise and logical operators (and, or, not, xor): :code:`&, |, ~, ^`
     * Comparison operators: :code:`<, <=, ==, !=, >=, >`
     * Unary arithmetic operators: :code:`-`
-    * Binary arithmetic operators: :code:`+, -, *, /, **, %, <<, >>`
+    * Binary arithmetic operators: :code:`+, -, *, /, //, **, %, <<, >>`
 
 
 Supported functions
@@ -203,22 +203,33 @@ The next are the current supported set:
       is true, number2 otherwise.
     * :code:`{isinf, isnan, isfinite}(float|complex): bool` -- returns element-wise True
       for ``inf`` or ``NaN``, ``NaN``, not ``inf`` respectively.
+    * :code:`signbit(float|complex): bool` -- returns element-wise True if signbit is set
+      False otherwise.
     * :code:`{sin,cos,tan}(float|complex): float|complex` -- trigonometric sine,
       cosine or tangent.
     * :code:`{arcsin,arccos,arctan}(float|complex): float|complex` -- trigonometric
       inverse sine, cosine or tangent.
     * :code:`arctan2(float1, float2): float` -- trigonometric inverse tangent of
       float1/float2.
+    * :code:`hypot(float1, float2): float` -- Euclidean distance between float1, float2
+    * :code:`nextafter(float1, float2): float` -- next representable floating-point value after
+      float1 in direction of float2
+    * :code:`copysign(float1, float2): float` -- return number with magnitude of float1 and
+      sign of float2
+    * :code:`{maximum,minimum}(float1, float2): float` -- return max/min of float1, float2
     * :code:`{sinh,cosh,tanh}(float|complex): float|complex` -- hyperbolic sine,
       cosine or tangent.
     * :code:`{arcsinh,arccosh,arctanh}(float|complex): float|complex` -- hyperbolic
       inverse sine, cosine or tangent.
-    * :code:`{log,log10,log1p}(float|complex): float|complex` -- natural, base-10 and
+    * :code:`{log,log10,log1p,log2}(float|complex): float|complex` -- natural, base-10 and
       log(1+x) logarithms.
     * :code:`{exp,expm1}(float|complex): float|complex` -- exponential and exponential
       minus one.
     * :code:`sqrt(float|complex): float|complex` -- square root.
-    * :code:`abs(float|complex): float|complex`  -- absolute value.
+    * :code:`trunc(float): float` -- round towards zero
+    * :code:`round(float|complex|int): float|complex|int` -- round to nearest integer (`rint`)
+    * :code:`sign(float|complex|int): float|complex|int` -- return -1, 0, +1 depending on sign
+    * :code:`abs(float|complex|int): float|complex|int`  -- absolute value.
     * :code:`conj(complex): complex` -- conjugate value.
     * :code:`{real,imag}(complex): float` -- real or imaginary part of complex.
     * :code:`complex(float, float): complex` -- complex from real and imaginary

numexpr/bespoke_functions.hpp

@@ -23,8 +23,43 @@ inline float signf(float x){
         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
+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)
 {
@@ -39,9 +74,31 @@ 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] = fmod(x1[j], x2[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]);
+    };
+};
+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)
 {
@@ -134,15 +191,6 @@ static void vdConj(MKL_INT n, const double* x1, double* dest)
     };
 };
 
-/* fmod not available in VML */
-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]);
-    };
-};
-
 /* various functions not available in VML */
 static void vzExpm1(MKL_INT n, const MKL_Complex16* x1, MKL_Complex16* dest)
 {

numexpr/expressions.py

@@ -186,11 +186,10 @@ def function(*args):
             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', 'fmod', 'ones_like', 'round', 'sign'):
+                # except for these special functions (which return ints for int inputs in NumPy)
+                # just do a cast to double
+                kind = 'double'
         else:
             # Apply regular casting rules
             if minkind and kind_rank.index(minkind) > kind_rank.index(kind):

numexpr/functions.hpp

@@ -212,7 +212,9 @@ FUNC_BC(FUNC_BC_LAST,    NULL,            NULL,        NULL)
 #define ELIDE_FUNC_II
 #define FUNC_II(...)
 #endif
-FUNC_II(FUNC_SIGN_II,   "sign_ii", signi, viSign)
+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
@@ -223,7 +225,9 @@ FUNC_II(FUNC_II_LAST,  NULL,      NULL, NULL)
 #define ELIDE_FUNC_LL
 #define FUNC_LL(...)
 #endif
-FUNC_LL(FUNC_SIGN_LL,   "sign_LL", signl, vlSign)
+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

numexpr/tests/test_numexpr.py

@@ -487,14 +487,17 @@ def test_maximum_minimum(self):
             assert_array_equal(evaluate("maximum(x,y)"), maximum(x,y))
             assert_array_equal(evaluate("minimum(x,y)"), minimum(x,y))
 
-    def test_sign(self):
-        for dtype in [float, double, int, np.int64, complex]:
+    def test_sign_round(self):
+        for dtype in [float, double, np.int32, np.int64, complex]:
             x = arange(10, dtype=dtype)
             y = 2 * arange(10, dtype=dtype)[::-1]
             r = x-y
             if not np.issubdtype(dtype, np.integer):
                 r[-1] = np.nan
+            assert evaluate("round(r)").dtype == round(r).dtype
+            assert evaluate("sign(r)").dtype == sign(r).dtype
             assert_array_equal(evaluate("sign(r)"), sign(r))
+            assert_array_equal(evaluate("round(r)"), round(r))
 
     def test_rational_expr(self):
         a = arange(1e6)