got rid of UncomputableOp (no longer necessary)

theano/gof/op.py

@@ -609,59 +609,6 @@ class Op(utils.object2, PureOp, CLinkerOp):
         rval.lazy = False
         return rval
 
-class UncomputableOp(Op):
-    """
-        An Op representing an expression that cannot be computed.
-        theano.function checks that the subgraph it implements
-        does not contain these ops, and that optimization does not
-        introduce any such ops.
-        theano.tensor.grad checks the graphs it returns to ensure
-        they do not contain these ops.
-    """
-
-    def __init__(self, exc, msg=""):
-        """
-        exc: the exception type to raise if a subgraph contains
-             this op.
-        msg: the message to include in the exception.
-        """
-
-        self.exc = exc
-        self.msg = msg
-
-    def __eq__(self, other):
-        return type(self) == type(other)
-
-    def __hash__(self):
-        return hash((type(self)))
-
-    def __str__(self):
-        return "Uncomputable{%s,%s}"%(self.exc,self.msg)
-
-    def make_node(self,x):
-        if x is None:
-            x = graph.Constant(theano.gof.type.generic,None)
-        return graph.Apply(self, [x], [x.type()] )
-
-    def perform(self, node, inputs, out_storage):
-        """ This should never be called"""
-        raise AssertionError("A BadGradOp should never be compiled, "+\
-                "and certainly not executed.")
-        #Note: essentially, this op should just be NaNs_like(inputs[0])
-        #but 0 * BadGradOp(x) + y optimizes to just y
-        #so until we develop a way of symbolically representing a variable
-        #that is always NaN and implement the logic for 0 * NaN = NaN, etc.
-        #the only way we can guarantee correctness of a theano function
-        #is to guarantee that its initial subgraph contained no BadGradOps
-
-    def raise_exc(self):
-        raise self.exc(self.msg)
-
-def raise_if_uncomputable(node):
-    if node is not None:
-        if isinstance(node.op, UncomputableOp):
-            node.op.raise_exc()
-
 def get_test_value(v):
     """
     Extract test value from `v`. Raises AttributeError if there is none.