Wrap arcsin from numpy, elemwise.

theano/scalar/basic.py

@@ -2037,6 +2037,25 @@ class Sin(UnaryScalarOp):
 sin = Sin(upgrade_to_float, name='sin')
 
 
+class Arcsin(UnaryScalarOp):
+    def impl(self, x):
+        return numpy.arcsin(x)
+
+    def grad(self, (x,), (gz,)):
+        if gz.type in complex_types:
+            raise NotImplementedError()
+        if x.type in float_types:
+            return gz / sqrt(numpy.cast[x.type](1) - sqr(x)),
+        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 = asin(%(x)s);" % locals()
+arcsin = Arcsin(upgrade_to_float, name='arcsin')
+
+
 class Tan(UnaryScalarOp):
     def impl(self, x):
         return numpy.tan(x)

theano/tensor/basic.py

@@ -2576,6 +2576,11 @@ def sin(a):
     """sine of a"""
 
 
+@_scal_elemwise_with_nfunc('arcsin', 1, 1)
+def arcsin(a):
+    """arcsine of a"""
+
+
 @_scal_elemwise_with_nfunc('tan', 1, 1)
 def tan(a):
     """tangent of a"""

theano/tensor/inplace.py

-
 from basic import _scal_elemwise #, _transpose_inplace
 from theano import scalar as scal
 import elemwise
@@ -152,6 +151,10 @@ def arccos_inplace(a):
 def sin_inplace(a):
     """sine of `a` (inplace on `a`)"""
 
+@_scal_inplace
+def arcsin_inplace(a):
+    """arcsine of `a` (inplace on `a`)"""
+
 @_scal_inplace
 def tan_inplace(a):
     """tangent of `a` (inplace on `a`)"""

theano/tensor/tests/test_basic.py

@@ -1035,6 +1035,9 @@ _grad_broadcast_unary_arccos = dict(normal = (rand_ranged(-1.+1e-7, 1-1e-7, (2,
                                   #empty = (numpy.asarray([]),),
                                   )
 
+_good_broadcast_unary_arcsin = _good_broadcast_unary_arccos
+
+_grad_broadcast_unary_arcsin = _grad_broadcast_unary_arccos
 
 SinTester = makeBroadcastTester(op = tensor.sin,
                                   expected = numpy.sin,
@@ -1046,6 +1049,17 @@ SinInplaceTester = makeBroadcastTester(op = inplace.sin_inplace,
                                          grad = _grad_broadcast_unary_wide,
                                          inplace = True)
 
+ArcsinTester = makeBroadcastTester(op = tensor.arcsin,
+                                  expected = numpy.arcsin,
+                                  good = _good_broadcast_unary_arcsin,
+                                  grad = _grad_broadcast_unary_arcsin)
+
+ArcsinInplaceTester = makeBroadcastTester(op = inplace.arcsin_inplace,
+                                         expected = numpy.arcsin,
+                                         good = _good_broadcast_unary_arcsin,
+                                         grad = _grad_broadcast_unary_arcsin,
+                                         inplace = True)
+
 CosTester = makeBroadcastTester(op = tensor.cos,
                                   expected = numpy.cos,
                                   good = _good_broadcast_unary_wide,