[GR-10334] Math.acosh is missing.

Author: ppisl

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

@@ -5,6 +5,7 @@
 import math
 import unittest
 import sys
+import struct
 
 eps = 1E-05
 INF = float('inf')
@@ -44,6 +45,40 @@ def py_factorial(n):
         outer *= inner
     return outer << (n - count_set_bits(n))
 
+def to_ulps(x):
+    """Convert a non-NaN float x to an integer, in such a way that
+    adjacent floats are converted to adjacent integers.  Then
+    abs(ulps(x) - ulps(y)) gives the difference in ulps between two
+    floats.
+
+    The results from this function will only make sense on platforms
+    where native doubles are represented in IEEE 754 binary64 format.
+
+    Note: 0.0 and -0.0 are converted to 0 and -1, respectively.
+    """
+    n = struct.unpack('<q', struct.pack('<d', x))[0]
+    if n < 0:
+        n = ~(n+2**63)
+    return n
+
+def ulp_abs_check(expected, got, ulp_tol, abs_tol):
+    """Given finite floats `expected` and `got`, check that they're
+    approximately equal to within the given number of ulps or the
+    given absolute tolerance, whichever is bigger.
+
+    Returns None on success and an error message on failure.
+    """
+    ulp_error = abs(to_ulps(expected) - to_ulps(got))
+    abs_error = abs(expected - got)
+
+    # Succeed if either abs_error <= abs_tol or ulp_error <= ulp_tol.
+    if abs_error <= abs_tol or ulp_error <= ulp_tol:
+        return None
+    else:
+        fmt = ("error = {:.3g} ({:d} ulps); "
+               "permitted error = {:.3g} or {:d} ulps")
+        return fmt.format(abs_error, ulp_error, abs_tol, ulp_tol)
+
 def result_check(expected, got, ulp_tol=5, abs_tol=0.0):
     # Common logic of MathTests.(ftest, test_testcases, test_mtestcases)
     """Compare arguments expected and got, as floats, if either
@@ -140,6 +175,24 @@ def __float__(self):
                 return 'ahoj'
         self.assertRaises(TypeError, math.acos, MyFloat3())
 
+    def testAcosh(self):
+        self.assertRaises(TypeError, math.acosh)
+        self.ftest('acosh(1)', math.acosh(1), 0)
+        # TODO uncomment when GR-10346 will be fixed
+        #self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
+        self.assertRaises(ValueError, math.acosh, 0)
+        self.assertRaises(ValueError, math.acosh, -1)
+        self.assertEqual(math.acosh(INF), INF)
+        self.assertRaises(ValueError, math.acosh, NINF)
+        self.assertTrue(math.isnan(math.acosh(NAN)))
+
+        class MyFF:
+            def __float__(self):
+                return 6
+        # TODO uncomment when GR-10346 will be fixed
+        #self.ftest('acos(MyFloat())', math.acosh(MyFF()), 0.9272952180016123)
+        self.assertRaises(ValueError, math.acosh, MyFloat())
+
     def testIsfinite(self):
         self.assertTrue(math.isfinite(0.0))
         self.assertTrue(math.isfinite(-0.0))

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

@@ -43,6 +43,7 @@
 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.function.builtins.PythonUnaryBuiltinNode;
 import com.oracle.graal.python.nodes.truffle.PythonArithmeticTypes;
 import com.oracle.graal.python.runtime.exception.PythonErrorType;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
@@ -874,6 +875,45 @@ protected AcosNode create() {
         }
     }
 
+    @Builtin(name = "acosh", fixedNumOfArguments = 1, doc = "Return the inverse hyperbolic cosine of x.")
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @ImportStatic(MathGuards.class)
+    @GenerateNodeFactory
+    public abstract static class AcoshNode extends PythonUnaryBuiltinNode {
+
+        public abstract double executeObject(Object value);
+        
+        @Specialization
+        public double acoshInt(long value,
+                @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
+            return acoshDouble(value, doNotFit);
+        }
+        
+        @Specialization
+        public double acoshDouble(double value,
+                @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
+            if (doNotFit.profile(value < 1 )) {
+                throw raise(ValueError, "math domain error");
+            }
+            return Math.log(value + Math.sqrt(value*value - 1.0));
+        }
+        
+        @Specialization(guards = "!isNumber(value)")
+        public double acosh(Object value,
+                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode dispatchFloat,
+                        @Cached("create()") AcoshNode acoshNode) {
+            Object result = dispatchFloat.executeObject(value);
+            if (result == PNone.NO_VALUE) {
+                throw raise(TypeError, "must be real number, not %p", value);
+            }
+            return acoshNode.executeObject(result);
+        }
+
+        protected AcoshNode create() {
+            return MathModuleBuiltinsFactory.AcoshNodeFactory.create(new PNode[0]);
+        }
+    }
+    
     @Builtin(name = "cos", fixedNumOfArguments = 1)
     @GenerateNodeFactory
     public abstract static class CosNode extends PythonBuiltinNode {