eja: drop custom gram_schmidt() routine that isn't noticeably faster.

[sage.d.git] / mjo / eja / eja_subalgebra.py

diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py
index 0f641416366ef7ee72d4703e070c69e2d60e30a9..c372e50072c73a50281dd45d07eec62a62848277 100644 (file)
--- a/mjo/eja/eja_subalgebra.py
+++ b/mjo/eja/eja_subalgebra.py
@@ -2,7 +2,6 @@ from sage.matrix.constructor import matrix
 
 from mjo.eja.eja_algebra import FiniteDimensionalEuclideanJordanAlgebra
 from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
-from mjo.eja.eja_utils import gram_schmidt
 
 class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensionalEuclideanJordanAlgebraElement):
     """
@@ -132,16 +131,17 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         # because it's the maximal set of powers that could possibly
         # be independent (by a dimension argument).
         powers = [ elt**k for k in range(V.dimension()) ]
+        power_vectors = [ p.to_vector() for p in powers ]
+        P = matrix(field, power_vectors)
 
         if orthonormalize_basis == False:
             # In this case, we just need to figure out which elements
             # of the "powers" list are redundant... First compute the
             # vector subspace spanned by the powers of the given
             # element.
-            power_vectors = [ p.to_vector() for p in powers ]
 
             # Figure out which powers form a linearly-independent set.
-            ind_rows = matrix(field, power_vectors).pivot_rows()
+            ind_rows = P.pivot_rows()
 
             # Pick those out of the list of all powers.
             superalgebra_basis = tuple(map(powers.__getitem__, ind_rows))
@@ -153,9 +153,16 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         else:
             # If we're going to orthonormalize the basis anyway, we
             # might as well just do Gram-Schmidt on the whole list of
-            # powers. The redundant ones will get zero'd out.
-            superalgebra_basis = gram_schmidt(powers)
-            basis_vectors = [ b.to_vector() for b in superalgebra_basis ]
+            # powers. The redundant ones will get zero'd out. If this
+            # looks like a roundabout way to orthonormalize, it is.
+            # But converting everything from algebra elements to vectors
+            # to matrices and then back again turns out to be about
+            # as fast as reimplementing our own Gram-Schmidt that
+            # works in an EJA.
+            G,_ = P.gram_schmidt(orthonormal=True)
+            basis_vectors = [ g for g in G.rows() if not g.is_zero() ]
+            superalgebra_basis = [ self._superalgebra.from_vector(b)
+                                   for b in basis_vectors ]
 
         W = V.span_of_basis( V.from_vector(v) for v in basis_vectors )
         n = len(superalgebra_basis)