merge

__init__.py

 
 import gof
+import base_tensor
+import tensor
+import sparse
+import compile
+import gradient
+import opt
+
 from base_tensor import *
 from tensor import *
 from compile import *
-#from sparse import *
 from opt import *
 from gradient import *
 

_test_tensor.py

@@ -647,6 +647,7 @@ class t_gemm(unittest.TestCase):
     def setUp(self):
         numpy.random.seed(44)
         _approx_eq.debug = 0
+        Gemm.debug = False
 
     @staticmethod
     def _gemm(z,a,x,y,b):
@@ -681,6 +682,7 @@ class t_gemm(unittest.TestCase):
         cmp_linker(copy(z), a, x, y, b, gof.link.PerformLinker)
 
     def test0a(self): 
+        Gemm.debug = True
         try:
             g = gemm([1.], 1., [1.], [1.], 1.)
         except ValueError, e:
@@ -723,5 +725,52 @@ class t_gemm(unittest.TestCase):
     def test12(self): self.cmp(self.rand(3,4), -1.0,
             self.rand(3,5), self.rand(5,4), -1.0)
 
+    def test_destroy_map0(self):
+        """test that only first input can be overwritten"""
+        Z = astensor(self.rand(2,2))
+        try:
+            gemm(Z, 1.0, Z, Z, 1.0)
+        except ValueError, e:
+            if e[0] == Gemm.E_z_uniq:
+                return
+        self.fail()
+    def test_destroy_map1(self):
+        """test that only first input can be overwritten"""
+        Z = astensor(self.rand(2,2))
+        A = astensor(self.rand(2,2))
+        try:
+            gemm(Z, 1.0, A, Z.T, 1.0)
+        except ValueError, e:
+            if e[0] == Gemm.E_z_uniq:
+                return
+        self.fail()
+    def test_destroy_map2(self):
+        """test that only first input can be overwritten"""
+        Z = astensor(self.rand(2,2))
+        A = astensor(self.rand(2,2))
+        try:
+            gemm(Z, 1.0, Z.T, A, 1.0)
+        except ValueError, e:
+            if e[0] == Gemm.E_z_uniq:
+                return
+        self.fail()
+    def test_destroy_map3(self):
+        """test that only first input can be overwritten"""
+        Z = astensor(self.rand(2,2))
+        A = astensor(self.rand(2,2))
+        try:
+            gemm(Z, 1.0, Z, A, 1.0)
+        except ValueError, e:
+            if e[0] == Gemm.E_z_uniq:
+                return
+        self.fail()
+
+    def test_destroy_map4(self):
+        """test that dot args can be aliased"""
+        Z = astensor(self.rand(2,2))
+        A = astensor(self.rand(2,2))
+        eval_outputs([gemm(Z, 1.0, A, A, 1.0)])
+        eval_outputs([gemm(Z, 1.0, A, A.T, 1.0)])
+
 if __name__ == '__main__':
     unittest.main()

gof/result.py

@@ -56,7 +56,9 @@ class ResultBase(object):
     __slots__ = ['_role', '_data', 'state', '_name', '_hash_id']
 
     def __init__(self, role=None, name=None):
-        self._role = role
+        self._role = None
+        if role is not None:
+            self.role = role
         self._data = [None]
         self.state = Empty
         self.name = name
@@ -98,6 +100,9 @@ class ResultBase(object):
             if _index != index:
                 raise ValueError("Result %s was already mapped to a different index." % self)
             return # because _owner is owner and _index == index
+        #TODO: this doesn't work because many bits of code set the role before
+        # owner.outputs.  Op.__init__ should do this I think. -JSB
+        #assert owner.outputs[index] is self
         self._role = role
 
     role = property(__get_role, __set_role)
@@ -331,6 +336,9 @@ class PythonResult(ResultBase):
         rval.data = copy.copy(self.data)
         return rval
 
-    
+def python_result(data, **kwargs):
+    rval = PythonResult(**kwargs)
+    rval.data = data
+    return rval
 
 

tensor.py

@@ -366,6 +366,13 @@ class Gemm(_Op):
     nout=1
     E_rank = 'gemm only works for rank 2'
     E_scalar = 'gemm requires scalar argument'
+    E_z_uniq = 'argument z not unique in argument list'
+    debug = False
+    def __init__(self, *args, **kwargs):
+        _Op.__init__(self, *args, **kwargs)
+        z, a, x, y, b = self.inputs
+        if z in self.inputs[1:]:
+            raise ValueError(Gemm.E_z_uniq, self.inputs)
     def destroy_map(self):
         return {self.out:[self.inputs[0]]}
     def propagate_broadcastable(self, bz, ba, bx, by, bb):