X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_utils.py;h=803ec636520515543c873ecc59669475a0048a3c;hb=ee9ac102b8b392793466c13039a6e50b1e3c4c01;hp=29edf5b8a339b073e1426a12a98a6143e7af5069;hpb=667e0df9c07589c03616ad8cf42eebe5c86de50b;p=sage.d.git

diff --git a/mjo/eja/eja_utils.py b/mjo/eja/eja_utils.py
index 29edf5b..803ec63 100644
--- a/mjo/eja/eja_utils.py
+++ b/mjo/eja/eja_utils.py
@@ -10,12 +10,10 @@ def _all2list(x):
     if hasattr(x, 'list'):
         # Easy case...
         return x.list()
-    if hasattr(x, 'cartesian_factors'):
-        # If it's a formal cartesian product space element, then
-        # we also know what to do...
-        return sum(( x_i.list() for x_i in x ), [])
     else:
-        # But what if it's a tuple or something else?
+        # But what if it's a tuple or something else? This has to
+        # handle cartesian products of cartesian products, too; that's
+        # why it's recursive.
         return sum( map(_all2list,x), [] )
 
 def _mat2vec(m):
@@ -110,9 +108,6 @@ def gram_schmidt(v, inner_product=None):
         inner_product = lambda x,y: x.inner_product(y)
     norm = lambda x: inner_product(x,x).sqrt()
 
-    def proj(x,y):
-        return (inner_product(x,y)/inner_product(x,x))*x
-
     v = list(v) # make a copy, don't clobber the input
 
     # Drop all zero vectors before we start.
@@ -124,10 +119,26 @@ def gram_schmidt(v, inner_product=None):
 
     R = v[0].base_ring()
 
+    # Define a scaling operation that can be used on tuples.
+    # Oh and our "zero" needs to belong to the right space.
+    scale = lambda x,alpha: x*alpha
+    zero = v[0].parent().zero()
+    if hasattr(v[0], 'cartesian_factors'):
+        P = v[0].parent()
+        scale = lambda x,alpha: P(tuple( x_i*alpha
+                                         for x_i in x.cartesian_factors() ))
+
+
+    def proj(x,y):
+        return scale(x, (inner_product(x,y)/inner_product(x,x)))
+
     # First orthogonalize...
     for i in range(1,len(v)):
         # Earlier vectors can be made into zero so we have to ignore them.
-        v[i] -= sum( proj(v[j],v[i]) for j in range(i) if not v[j].is_zero() )
+        v[i] -= sum( (proj(v[j],v[i])
+                      for j in range(i)
+                      if not v[j].is_zero() ),
+                     zero )
 
     # And now drop all zero vectors again if they were "orthogonalized out."
     v = [ v_i for v_i in v if not v_i.is_zero() ]
@@ -136,6 +147,6 @@ def gram_schmidt(v, inner_product=None):
     # them here because then our subalgebra would have a bigger field
     # than the superalgebra.
     for i in range(len(v)):
-        v[i] = v[i] / norm(v[i])
+        v[i] = scale(v[i], ~norm(v[i]))
 
     return v