Wrap arccosh from numpy, elemwise.

theano/scalar/basic.py

@@ -2116,6 +2116,25 @@ class Cosh(UnaryScalarOp):
 cosh = Cosh(upgrade_to_float, name='cosh')
 
 
+class ArcCosh(UnaryScalarOp):
+    def impl(self, x):
+        return numpy.arccosh(x)
+
+    def grad(self, (x, ), (gz, )):
+        if x.type in complex_types:
+            raise NotImplementedError()
+        if x.type in float_types:
+            return gz / sqrt(sqr(x) - numpy.cast[x.type](1)),
+        else:
+            return None,
+
+    def c_code(self, node, name, (x, ), (z, ), sub):
+        if node.inputs[0].type in complex_types:
+            raise NotImplementedError('type not supported', type)
+        return "%(z)s = acosh(%(x)s);" % locals()
+arccosh = ArcCosh(upgrade_to_float, name='arccosh')
+
+
 class Sinh(UnaryScalarOp):
     """
     sinh(x) = (exp(x) - exp(-x)) / 2

theano/tensor/basic.py

@@ -2585,6 +2585,7 @@ def arcsin(a):
 def tan(a):
     """tangent of a"""
 
+
 @_scal_elemwise_with_nfunc('arctan', 1, 1)
 def arctan(a):
     """arctangent of a"""
@@ -2595,6 +2596,11 @@ def cosh(a):
     """hyperbolic cosine of a"""
 
 
+@_scal_elemwise_with_nfunc('arccosh', 1, 1)
+def arccosh(a):
+    """hyperbolic arc cosine of a"""
+
+
 @_scal_elemwise_with_nfunc('sinh', 1, 1)
 def sinh(a):
     """hyperbolic sine of a"""

theano/tensor/inplace.py

@@ -167,6 +167,10 @@ def arctan_inplace(a):
 def cosh_inplace(a):
     """hyperbolic cosine of `a` (inplace on `a`)"""
 
+@_scal_inplace
+def arccosh_inplace(a):
+    """hyperbolic arc cosine of `a` (inplace on `a`)"""
+
 @_scal_inplace
 def sinh_inplace(a):
     """hyperbolic sine of `a` (inplace on `a`)"""

theano/tensor/tests/test_basic.py

@@ -1069,6 +1069,8 @@ CosInplaceTester = makeBroadcastTester(op = inplace.cos_inplace,
                                          good = _good_broadcast_unary_wide,
                                          grad = _grad_broadcast_unary_wide,
                                          inplace = True)
+
+
 ArccosTester = makeBroadcastTester(op = tensor.arccos,
                                   expected = numpy.arccos,
                                   good = _good_broadcast_unary_arccos,
@@ -1107,8 +1109,6 @@ ArctanTester = makeBroadcastTester(op = tensor.tan,
                                    good = _good_broadcast_unary_wide,
                                    grad = _grad_broadcast_unary_wide,
                                    grad_rtol=tan_grad_rtol)
-
-
 ArctanInplaceTester = makeBroadcastTester(op = inplace.tan_inplace,
                                           expected = numpy.tan,
                                           good = _good_broadcast_unary_wide,
@@ -1127,6 +1127,25 @@ CoshInplaceTester = makeBroadcastTester(op = inplace.cosh_inplace,
                                           grad = _grad_broadcast_unary_normal,
                                           inplace = True)
 
+
+_good_broadcast_unary_arccosh = dict(normal = (rand_ranged(1, 1000, (2, 3)),),
+                                     integers = (randint_ranged(1, 1000, (2, 3)),),
+                                     complex = (randc128_ranged(1, 1000, (2, 3)),),
+                                     empty = (numpy.asarray([]),),)
+_grad_broadcast_unary_arccosh = dict(normal = (rand_ranged(1, 1000, (2, 3)),),)
+
+
+ArccoshTester = makeBroadcastTester(op = tensor.arccosh,
+                                    expected = numpy.arccosh,
+                                    good = _good_broadcast_unary_arccosh,
+                                    grad = _grad_broadcast_unary_arccosh)
+ArccoshInplaceTester = makeBroadcastTester(op = inplace.arccosh_inplace,
+                                           expected = numpy.arccosh,
+                                           good = _good_broadcast_unary_arccosh,
+                                           grad = _grad_broadcast_unary_arccosh,
+                                           inplace = True)
+
+
 SinhTester = makeBroadcastTester(op = tensor.sinh,
                                    expected = numpy.sinh,
                                    good = _good_broadcast_unary_normal,