[GR-10340] No Math.isinf(), Math.isfinite() and Math.isnan() are not defined.

Author: ppisl

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

@@ -10,6 +10,8 @@
 INF = float('inf')
 NINF = float('-inf')
 NAN = float('nan')
+LONG_INT = 6227020800
+BIG_INT = 9999992432902008176640000999999
 
 """ The next three methods are needed for testing factorials
 """
@@ -87,6 +89,10 @@ def result_check(expected, got, ulp_tol=5, abs_tol=0.0):
     else:
         return None
 
+class MyFloat:
+            def __float__(self):
+                return 0.6
+
 class MathTests(unittest.TestCase):
 
     def ftest(self, name, got, expected, ulp_tol=5, abs_tol=0.0):
@@ -116,13 +122,12 @@ def testAcos(self):
         self.assertEqual(math.acos(True), 0.0)
         self.assertRaises(ValueError, math.acos, 10)
         self.assertRaises(ValueError, math.acos, -10)
+        self.assertRaises(ValueError, math.acos, LONG_INT)
+        self.assertRaises(ValueError, math.acos, BIG_INT)
         self.assertRaises(TypeError, math.acos, 'ahoj')
 
         self.assertRaises(ValueError, math.acos, 9999992432902008176640000999999)
 
-        class MyFloat:
-            def __float__(self):
-                return 0.6
         self.ftest('acos(MyFloat())', math.acos(MyFloat()), 0.9272952180016123)
 
         class MyFloat2:
@@ -135,6 +140,36 @@ def __float__(self):
                 return 'ahoj'
         self.assertRaises(TypeError, math.acos, MyFloat3())
 
+    def testIsfinite(self):
+        self.assertTrue(math.isfinite(0.0))
+        self.assertTrue(math.isfinite(-0.0))
+        self.assertTrue(math.isfinite(1.0))
+        self.assertTrue(math.isfinite(-1.0))
+        self.assertFalse(math.isfinite(float("nan")))
+        self.assertFalse(math.isfinite(float("inf")))
+        self.assertFalse(math.isfinite(float("-inf")))
+
+        self.assertTrue(math.isfinite(True))
+        self.assertTrue(math.isfinite(LONG_INT))
+        self.assertTrue(math.isfinite(BIG_INT))
+        self.assertRaises(TypeError, math.isfinite, 'ahoj')
+        self.assertTrue(math.isfinite(MyFloat()))
+
+    def testIsinf(self):
+        self.assertTrue(math.isinf(float("inf")))
+        self.assertTrue(math.isinf(float("-inf")))
+        self.assertTrue(math.isinf(1E400))
+        self.assertTrue(math.isinf(-1E400))
+        self.assertFalse(math.isinf(float("nan")))
+        self.assertFalse(math.isinf(0.))
+        self.assertFalse(math.isinf(1.))
+        
+        self.assertFalse(math.isinf(True))
+        self.assertFalse(math.isinf(LONG_INT))
+        self.assertFalse(math.isinf(BIG_INT))
+        self.assertRaises(TypeError, math.isinf, 'ahoj')
+        self.assertFalse(math.isinf(MyFloat()))
+        
     def test_ceil_basic(self):
         self.assertEqual(math.ceil(10), 10)
         self.assertEqual(math.ceil(-10), -10)
@@ -261,6 +296,7 @@ def test_isnan(self):
         self.assertRaises(TypeError, math.isnan, 'hello')
 
         self.assertFalse(math.isnan(False))
+        self.assertFalse(math.isnan(MyFloat()))
 
     def test_fabs(self):
         self.assertEqual(math.fabs(-1), 1)

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

@@ -641,17 +641,20 @@ public PTuple frexpO(Object value) {
     }
 
     @Builtin(name = "isnan", fixedNumOfArguments = 1)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @ImportStatic(MathGuards.class)
     @GenerateNodeFactory
-    @SuppressWarnings("unused")
     public abstract static class IsNanNode extends PythonBuiltinNode {
 
+        public abstract boolean execute(Object value);
+
         @Specialization
-        public boolean isNan(int value) {
+        public boolean isNan(@SuppressWarnings("unused") long value) {
             return false;
         }
 
         @Specialization
-        public boolean isNan(long value) {
+        public boolean isNan(@SuppressWarnings("unused") PInt value) {
             return false;
         }
 
@@ -660,24 +663,19 @@ public boolean isNan(double value) {
             return Double.isNaN(value);
         }
 
-        @Specialization
-        public boolean isNan(PInt value) {
-            return false;
-        }
-
-        @Specialization
-        public boolean isNan(PFloat value) {
-            return Double.isNaN(value.getValue());
+        @Specialization(guards = "!isNumber(value)")
+        public boolean isinf(Object value,
+                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode dispatchFloat,
+                        @Cached("create()") IsNanNode isNanNode) {
+            Object result = dispatchFloat.executeObject(value);
+            if (result == PNone.NO_VALUE) {
+                throw raise(TypeError, "must be real number, not %p", value);
+            }
+            return isNanNode.execute(result);
         }
 
-        @Specialization
-        public boolean isNan(boolean value) {
-            return false;
-        }
-
-        @Fallback
-        public boolean isNan(Object value) {
-            throw raise(TypeError, "must be real number, not %p", value);
+        protected IsNanNode create() {
+            return MathModuleBuiltinsFactory.IsNanNodeFactory.create(new PNode[0]);
         }
     }
 
@@ -837,7 +835,7 @@ public abstract static class AcosNode extends PythonBuiltinNode {
         public abstract double execute(Object value);
 
         @Specialization
-        public double acos(int value,
+        public double acos(long value,
                         @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
             if (doNotFit.profile(value > 1 || value < -1)) {
                 throw raise(ValueError, "math domain error");
@@ -906,6 +904,84 @@ public double sin(double value) {
         }
     }
 
+    @Builtin(name = "isfinite", fixedNumOfArguments = 1)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @ImportStatic(MathGuards.class)
+    @GenerateNodeFactory
+    public abstract static class IsFiniteNode extends PythonBuiltinNode {
+
+        public abstract boolean execute(Object value);
+
+        @Specialization
+        public boolean isfinite(@SuppressWarnings("unused") long value) {
+            return true;
+        }
+
+        @Specialization
+        public boolean isfinite(@SuppressWarnings("unused") PInt value) {
+            return true;
+        }
+
+        @Specialization
+        public boolean isfinite(double value) {
+            return Double.isFinite(value);
+        }
+
+        @Specialization(guards = "!isNumber(value)")
+        public boolean isinf(Object value,
+                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode dispatchFloat,
+                        @Cached("create()") IsFiniteNode isFiniteNode) {
+            Object result = dispatchFloat.executeObject(value);
+            if (result == PNone.NO_VALUE) {
+                throw raise(TypeError, "must be real number, not %p", value);
+            }
+            return isFiniteNode.execute(result);
+        }
+
+        protected IsFiniteNode create() {
+            return MathModuleBuiltinsFactory.IsFiniteNodeFactory.create(new PNode[0]);
+        }
+    }
+
+    @Builtin(name = "isinf", fixedNumOfArguments = 1)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @ImportStatic(MathGuards.class)
+    @GenerateNodeFactory
+    public abstract static class IsInfNode extends PythonBuiltinNode {
+
+        public abstract boolean execute(Object value);
+
+        @Specialization
+        public boolean isinf(@SuppressWarnings("unused") long value) {
+            return false;
+        }
+
+        @Specialization
+        public boolean isfinite(@SuppressWarnings("unused") PInt value) {
+            return false;
+        }
+
+        @Specialization
+        public boolean isinf(double value) {
+            return Double.isInfinite(value);
+        }
+
+        @Specialization(guards = "!isNumber(value)")
+        public boolean isinf(Object value,
+                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode dispatchFloat,
+                        @Cached("create()") IsInfNode isInfNode) {
+            Object result = dispatchFloat.executeObject(value);
+            if (result == PNone.NO_VALUE) {
+                throw raise(TypeError, "must be real number, not %p", value);
+            }
+            return isInfNode.execute(result);
+        }
+
+        protected IsInfNode create() {
+            return MathModuleBuiltinsFactory.IsInfNodeFactory.create(new PNode[0]);
+        }
+    }
+
     @Builtin(name = "log", minNumOfArguments = 1, maxNumOfArguments = 2)
     @GenerateNodeFactory
     public abstract static class LogNode extends PythonBuiltinNode {