ported ScalarFromTensor and fixed grad tests

_test_gradient.py

@@ -238,50 +238,5 @@ class _test_grad_sources_inputs(unittest.TestCase):
         self.failUnless(g[a1.inputs[1]] == 11)
 
 
-class _test_grad(unittest.TestCase):
-    class O(gof.op.Op):
-        def __init__(self):
-            self.gval0 = gof.generic()
-            self.gval1 = gof.generic()
-        def make_node(self):
-            inputs = [gof.generic(),gof.generic()]
-            outputs = [gof.generic(),gof.generic()]
-            return gof.Apply(self, inputs, outputs)
-        def grad(self, (x0,x1), (gz0,gz1)):
-            return self.gval0, self.gval1
-
-    def test_1param(self):
-        """grad: Test passing a single result param"""
-        o = _test_grad.O()
-        a1 = o.make_node()
-        self.failUnless(o.gval0 is grad(a1.outputs[0], a1.inputs[0]))
-
-    def test_Nparam(self):
-        """grad: Test passing multiple result params"""
-        o = _test_grad.O()
-        a1 = o.make_node()
-        g0,g1 = grad(a1.outputs[0], a1.inputs)
-        self.failUnless(o.gval0 is g0)
-        self.failUnless(o.gval1 is g1)
-
-    def test_1None_rval(self):
-        """grad: Test returning a single None from grad"""
-        o = _test_grad.O()
-        a1 = o.make_node()
-        self.failUnless(None is grad(a1.outputs[0], a1.outputs[1]))
-        self.failUnless(None is grad(a1.outputs[0], 'wtf'))
-    def test_NNone_rval(self):
-        """grad: Test returning some Nones from grad"""
-        o = _test_grad.O()
-        a1 = o.make_node()
-        g0,g1,g2 = grad(a1.outputs[0], a1.inputs + ['wtf'])
-        self.failUnless(o.gval0 is g0)
-        self.failUnless(o.gval1 is g1)
-        self.failUnless(None is g2)
-
-
-
-
-
 if __name__ == '__main__':
     unittest.main()

_test_tensor.py

@@ -1506,46 +1506,50 @@ class T_tensorfromscalar(unittest.TestCase):
 #         self.failUnless(t.data == 1.0)
 #         self.failUnless(t.data is not tt.data)
 
+
 class _test_grad(unittest.TestCase):
     class O(gof.op.Op):
         def __init__(self):
-            self.inputs = [scalar('a'),scalar('c')]
-            self.outputs = [scalar('b'),scalar('d')]
             self.gval0 = scalar('e')
             self.gval1 = scalar('f')
+        def make_node(self):
+            inputs = [scalar('a'),scalar('c')]
+            outputs = [scalar('b'),scalar('d')]
+            return gof.Apply(self, inputs, outputs)
         def grad(self, (x0,x1), (gz0,gz1)):
             return self.gval0, self.gval1
 
     def test_1param(self):
         """grad: Test passing a single result param"""
-        a1 = _test_grad.O()
-        self.failUnless(a1.gval0 is grad(a1.outputs[0], a1.inputs[0]))
+        o = _test_grad.O()
+        a1 = o.make_node()
+        self.failUnless(o.gval0 is grad(a1.outputs[0], a1.inputs[0]))
 
     def test_Nparam(self):
         """grad: Test passing multiple result params"""
-        a1 = _test_grad.O()
+        o = _test_grad.O()
+        a1 = o.make_node()
         g0,g1 = grad(a1.outputs[0], a1.inputs)
-        self.failUnless(a1.gval0 is g0)
-        self.failUnless(a1.gval1 is g1)
+        self.failUnless(o.gval0 is g0)
+        self.failUnless(o.gval1 is g1)
 
     def test_1None_rval(self):
         """grad: Test returning a single None from grad"""
-        a1 = _test_grad.O()
+        o = _test_grad.O()
+        a1 = o.make_node()
         self.failUnless(None is grad(a1.outputs[0], a1.outputs[1]))
         self.failUnless(None is grad(a1.outputs[0], 'wtf'))
     def test_NNone_rval(self):
         """grad: Test returning some Nones from grad"""
-        a1 = _test_grad.O()
+        o = _test_grad.O()
+        a1 = o.make_node()
         g0,g1,g2 = grad(a1.outputs[0], a1.inputs + ['wtf'])
-        self.failUnless(a1.gval0 is g0)
-        self.failUnless(a1.gval1 is g1)
+        self.failUnless(o.gval0 is g0)
+        self.failUnless(o.gval1 is g1)
         self.failUnless(None is g2)
 
 
 
-
-
-
 if __name__ == '__main__':
     unittest.main()
 #    suite = unittest.TestLoader()

tensor.py

@@ -348,6 +348,9 @@ class _tensor_py_operators:
     def __getslice__(self, *args):
         args = slice(*args),
         return Subtensor(args)(self, *Subtensor.collapse(args, lambda entry: isinstance(entry, Result)))
+    
+    #COPYING
+    def copy(self): return tensor_copy(self)
 
     def __iter__(self): 
         # This prevents accidental iteration via builtin.sum(self)
@@ -388,16 +391,18 @@ class TensorFromScalar(Op):
 tensor_from_scalar = TensorFromScalar()
 
 class ScalarFromTensor(Op):
-    def __init__(self, s, **kwargs):
-        assert isinstance(s, Tensor)
-        Op.__init__(self, **kwargs)
-        self.inputs = [s]
-        self.outputs = [scal.Scalar(s.dtype)]
-    def perform(self):
-        self.outputs[0].data = self.inputs[0].data
+    def make_node(self, t):
+        assert isinstance(t.type, scal.Tensor)
+        assert t.type.broadcastable == ()
+        return Apply(self,
+                     [s],
+                     [scal.Scalar(dtype = s.type.dtype).make_result()])
+    def perform(self, node, (s, ), (out, )):
+        out[0] = s.flatten()[0]
     def grad(self, (s,), (dt,)):
         return [TensorFromScalar(dt)]
-scalar_from_tensor = gof.op.constructor(ScalarFromTensor)
+scalar_from_tensor = ScalarFromTensor()
+
 
 ##########################
 # Unary Operations