X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_utils.py;h=803ec636520515543c873ecc59669475a0048a3c;hb=21fa036e86711c6c28b6d89af2b1bfe4ceb24b29;hp=b6e0c7d38eaf1d9114973bba4f5ad0674cb8a8a2;hpb=6d875d564f6d962f855c520c21cf539bdd4a3c1d;p=sage.d.git

diff --git a/mjo/eja/eja_utils.py b/mjo/eja/eja_utils.py
index b6e0c7d..803ec63 100644
--- a/mjo/eja/eja_utils.py
+++ b/mjo/eja/eja_utils.py
@@ -2,6 +2,20 @@ from sage.functions.other import sqrt
 from sage.matrix.constructor import matrix
 from sage.modules.free_module_element import vector
 
+def _all2list(x):
+    r"""
+    Flatten a vector, matrix, or cartesian product of those things
+    into a long list.
+    """
+    if hasattr(x, 'list'):
+        # Easy case...
+        return x.list()
+    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):
         return vector(m.base_ring(), m.list())
 
@@ -94,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.
@@ -108,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() ]
@@ -120,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