Fixed handling of signs in float mod and divmod

Author: otethal

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java

@@ -95,6 +95,7 @@
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes;
 import com.oracle.graal.python.builtins.objects.complex.PComplex;
 import com.oracle.graal.python.builtins.objects.dict.PDict;
+import com.oracle.graal.python.builtins.objects.floats.FloatBuiltins;
 import com.oracle.graal.python.builtins.objects.floats.PFloat;
 import com.oracle.graal.python.builtins.objects.frame.PFrame;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
@@ -519,8 +520,11 @@ public PTuple doLongZero(long a, long b) {
 
         @Specialization
         public PTuple doDouble(double a, double b) {
+            if (b == 0) {
+                throw raise(PythonErrorType.ZeroDivisionError, ErrorMessages.DIVISION_BY_ZERO);
+            }
             double q = Math.floor(a / b);
-            return factory().createTuple(new Object[]{q, a % b});
+            return factory().createTuple(new Object[]{q, FloatBuiltins.ModNode.op(a, b)});
         }
 
         @Specialization

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/floats/FloatBuiltins.java

@@ -608,19 +608,19 @@ abstract static class DivModNode extends FloatBinaryBuiltinNode {
         @Specialization
         PTuple doDL(double left, long right) {
             raiseDivisionByZero(right == 0);
-            return factory().createTuple(new Object[]{Math.floor(left / right), left % right});
+            return factory().createTuple(new Object[]{Math.floor(left / right), ModNode.op(left, right)});
         }
 
         @Specialization
         PTuple doDD(double left, double right) {
             raiseDivisionByZero(right == 0.0);
-            return factory().createTuple(new Object[]{Math.floor(left / right), left % right});
+            return factory().createTuple(new Object[]{Math.floor(left / right), ModNode.op(left, right)});
         }
 
         @Specialization
         PTuple doLD(long left, double right) {
             raiseDivisionByZero(right == 0.0);
-            return factory().createTuple(new Object[]{Math.floor(left / right), left % right});
+            return factory().createTuple(new Object[]{Math.floor(left / right), ModNode.op(left, right)});
         }
 
         @Specialization(guards = {"accepts(left)", "accepts(right)"})
@@ -820,42 +820,54 @@ public String hexD(double value) {
     @Builtin(name = __MOD__, minNumOfPositionalArgs = 2)
     @TypeSystemReference(PythonArithmeticTypes.class)
     @GenerateNodeFactory
-    abstract static class ModNode extends FloatBinaryBuiltinNode {
+    public abstract static class ModNode extends FloatBinaryBuiltinNode {
         @Specialization
         double doDL(double left, long right) {
             raiseDivisionByZero(right == 0);
-            return left % right;
+            return op(left, right);
         }
 
         @Specialization
         double doDL(double left, PInt right) {
             raiseDivisionByZero(right.isZero());
-            return left % right.doubleValue();
+            return op(left, right.doubleValue());
         }
 
         @Specialization
         double doDD(double left, double right) {
             raiseDivisionByZero(right == 0.0);
-            return left % right;
+            return op(left, right);
         }
 
         @Specialization
         double doLD(long left, double right) {
             raiseDivisionByZero(right == 0.0);
-            return left % right;
+            return op(left, right);
         }
 
         @Specialization
         double doPiD(PInt left, double right) {
             raiseDivisionByZero(right == 0.0);
-            return left.doubleValue() % right;
+            return op(left.doubleValue(), right);
         }
 
         @SuppressWarnings("unused")
         @Fallback
         PNotImplemented doGeneric(Object right, Object left) {
             return PNotImplemented.NOT_IMPLEMENTED;
         }
+
+        public static double op(double left, double right) {
+            double mod = left % right;
+            if (mod != 0.0) {
+                if ((right < 0) != (mod < 0)) {
+                    mod += right;
+                }
+            } else {
+                mod = right < 0 ? -0.0 : 0.0;
+            }
+            return mod;
+        }
     }
 
     @Builtin(name = __RTRUEDIV__, minNumOfPositionalArgs = 2, reverseOperation = true)