[GR-10330] Correct and finish implementation of Math.acos() function.

Author: ppisl

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

@@ -102,6 +102,39 @@ def ftest(self, name, got, expected, ulp_tol=5, abs_tol=0.0):
         if failure is not None:
             self.fail("{}: {}".format(name, failure))
 
+    def testAcos(self):
+        self.assertRaises(TypeError, math.acos)
+        self.ftest('acos(-1)', math.acos(-1), math.pi)
+        self.ftest('acos(0)', math.acos(0), math.pi/2)
+        self.ftest('acos(1)', math.acos(1), 0)
+        self.assertRaises(ValueError, math.acos, INF)
+        self.assertRaises(ValueError, math.acos, NINF)
+        self.assertRaises(ValueError, math.acos, 1 + eps)
+        self.assertRaises(ValueError, math.acos, -1 - eps)
+        self.assertTrue(math.isnan(math.acos(NAN)))
+
+        self.assertEqual(math.acos(True), 0.0)
+        self.assertRaises(ValueError, math.acos, 10)
+        self.assertRaises(ValueError, math.acos, -10)
+        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:
+            def __float__(self):
+                return 1.6
+        self.assertRaises(ValueError, math.acos, MyFloat2())        
+
+        class MyFloat3:
+            def __float__(self):
+                return 'ahoj'
+        self.assertRaises(TypeError, math.acos, MyFloat3())
+
     def test_ceil_basic(self):
         self.assertEqual(math.ceil(10), 10)
         self.assertEqual(math.ceil(-10), -10)

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

@@ -40,6 +40,7 @@
 import com.oracle.graal.python.builtins.objects.floats.PFloat;
 import com.oracle.graal.python.builtins.objects.ints.PInt;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
+import com.oracle.graal.python.nodes.PNode;
 import com.oracle.graal.python.nodes.call.special.LookupAndCallUnaryNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
 import com.oracle.graal.python.nodes.truffle.PythonArithmeticTypes;
@@ -827,19 +828,52 @@ public double ldexpOO(Object mantissa, Object exp) {
 
     }
 
-    @Builtin(name = "acos", fixedNumOfArguments = 1)
+    @Builtin(name = "acos", fixedNumOfArguments = 1, doc = "Return the arc cosine (measured in radians) of x.")
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @ImportStatic(MathGuards.class)
     @GenerateNodeFactory
     public abstract static class AcosNode extends PythonBuiltinNode {
 
+        public abstract double execute(Object value);
+
         @Specialization
-        public double acos(int value) {
+        public double acos(int value,
+                        @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
+            if (doNotFit.profile(value > 1 || value < -1)) {
+                throw raise(ValueError, "math domain error");
+            }
             return Math.acos(value);
         }
 
         @Specialization
-        public double acos(double value) {
+        public double acos(PInt value,
+                        @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
+            return acos(value.intValue(), doNotFit);
+        }
+
+        @Specialization
+        public double acos(double value,
+                        @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
+            if (doNotFit.profile(Double.isInfinite(value) || -1 > value || value > 1)) {
+                throw raise(ValueError, "math domain error");
+            }
             return Math.acos(value);
         }
+
+        @Specialization(guards = "!isNumber(value)")
+        public double acos(Object value,
+                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode dispatchFloat,
+                        @Cached("create()") AcosNode acosNode) {
+            Object result = dispatchFloat.executeObject(value);
+            if (result == PNone.NO_VALUE) {
+                throw raise(TypeError, "must be real number, not %p", value);
+            }
+            return acosNode.execute(result);
+        }
+
+        protected AcosNode create() {
+            return MathModuleBuiltinsFactory.AcosNodeFactory.create(new PNode[0]);
+        }
     }
 
     @Builtin(name = "cos", fixedNumOfArguments = 1)