MAINT: Try instead using the inverse logic

seberg · seberg · commit 0fe5dcb19de3 · 2021-07-07T14:07:21.000-05:00
diff --git a/numpy/core/src/npymath/npy_math_internal.h.src b/numpy/core/src/npymath/npy_math_internal.h.src
@@ -632,35 +632,33 @@ NPY_INPLACE @type@
 npy_remainder@c@(@type@ a, @type@ b)
 {
     @type@ mod;
-    if (b) {
+    if (!b) {
+        /*
+         * b == 0 or is NaN. `fmod` will return the right thing (NaN)
+         * but set the error flags correct (divmod may set too many).
+         * (Using !b here, since reverse logic set incorrect flags on clang)
+         */
+        return npy_fmod@c@(a, b);
+    }
+    else {
         npy_divmod@c@(a, b, &mod);
         return mod;
     }
-    /*
-     * in2 == 0 (and not NaN). The result is always NaN here, and we need to
-     * set the invalid flag if a is not NaN.  We should be able to use the
-     * normal fmod, but clang seems to optimize the warning flags away.
-     */
-    if (!npy_isnan(a)) {
-        npy_set_floatstatus_invalid();
-    }
-    return (@type@)NPY_NAN;
 }
 
 NPY_INPLACE @type@
 npy_floor_divide@c@(@type@ a, @type@ b) {
     @type@ mod;
-    if (b) {
-        return npy_divmod@c@(a, b, &mod);
-    }
-    else {
+    if (!b) {
         /*
-         * in2 == 0 (and not NaN), normal division will give the correct
-         * result (which could be Inf or NaN) and set the correct CPU
-         * floating point error flag.
+         * b == 0 or is NaN. Division will return the right thing (Inf or NaN)
+         * but set the error flags correct (divmod may set too many).
          */
         return a / b;
     }
+    else {
+        return npy_divmod@c@(a, b, &mod);
+    }
 }
 
 /*
