Implementation of Math.modf

Author: ppisl

graalpython/com.oracle.graal.python.test/src/tests/test_math.py

@@ -1216,3 +1216,26 @@ def testRadians(self):
         self.assertRaises(TypeError, math.radians, 'ahoj')
         self.ftest('radians(BIG_INT)', math.radians(BIG_INT), 1.7453279312865818e+29)
 
+    def testModf(self):
+        self.assertRaises(TypeError, math.modf)
+
+        def testmodf(name, result, expected):
+            (v1, v2), (e1, e2) = result, expected
+            if abs(v1-e1) > eps or abs(v2-e2):
+                self.fail('%s returned %r, expected %r'%\
+                          (name, result, expected))
+
+        testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
+        testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))
+
+        self.assertEqual(math.modf(INF), (0.0, INF))
+        self.assertEqual(math.modf(NINF), (-0.0, NINF))
+
+        modf_nan = math.modf(NAN)
+        self.assertTrue(math.isnan(modf_nan[0]))
+        self.assertTrue(math.isnan(modf_nan[1]))
+
+        # test of specializations
+        testmodf('modf(MyFloat())', math.modf(MyFloat()), (0.6, 0.0))
+        self.assertRaises(TypeError, math.modf, 'ahoj')
+        testmodf('modf(BIG_INT)', math.modf(BIG_INT), (0.0, 9.999992432902008e+30))

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

@@ -966,6 +966,43 @@ public double ldexpOO(Object mantissa, Object exp) {
 
     }
 
+    @Builtin(name = "modf", fixedNumOfArguments = 1)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @ImportStatic(MathGuards.class)
+    @GenerateNodeFactory
+    public abstract static class ModfNode extends MathUnaryBuiltinNode {
+
+        @Specialization
+        public PTuple modfD(double value) {
+            if (!Double.isFinite(value)) {
+                if (Double.isInfinite(value)) {
+                    return factory().createTuple(new Object[]{Math.copySign(0., value), value});
+                } else if (Double.isNaN(value)) {
+                    return factory().createTuple(new Object[]{value, value});
+                }
+            }
+            double fraction = value % 1;
+            double integral = value - fraction;
+            return factory().createTuple(new Object[]{fraction, integral});
+        }
+
+        @Specialization
+        public PTuple modfL(long value) {
+            return modfD(value);
+        }
+
+        @Specialization
+        public PTuple frexpPI(PInt value) {
+            return modfD(value.doubleValue());
+        }
+
+        @Specialization(guards = "!isNumber(value)")
+        public PTuple frexpO(Object value,
+                        @Cached("create()") ConvertToFloatNode convertToFloatNode) {
+            return modfD(convertToFloatNode.execute(value));
+        }
+    }
+
     @Builtin(name = "acos", fixedNumOfArguments = 1, doc = "Return the arc cosine (measured in radians) of x.")
     @GenerateNodeFactory
     public abstract static class AcosNode extends MathDoubleUnaryBuiltinNode {