X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_utils.py;h=7c6c581329dd64aaa8f3d958e00b2f9eb3221fcb;hb=f38e111cd026f1ecdab6dd2d2ed194a8745252a8;hp=2402d9f0e5f6d1b174690688b8f9b2d7f17eba61;hpb=c41c7f2a94370c11d478dbdb22e77cfa30298eb2;p=sage.d.git

diff --git a/mjo/eja/eja_utils.py b/mjo/eja/eja_utils.py
index 2402d9f..7c6c581 100644
--- a/mjo/eja/eja_utils.py
+++ b/mjo/eja/eja_utils.py
@@ -54,7 +54,9 @@ def _all2list(x):
     SETUP::
 
         sage: from mjo.eja.eja_utils import _all2list
-        sage: from mjo.octonions import Octonions, OctonionMatrixAlgebra
+        sage: from mjo.hurwitz import (QuaternionMatrixAlgebra,
+        ....:                          Octonions,
+        ....:                          OctonionMatrixAlgebra)
 
     EXAMPLES::
 
@@ -86,6 +88,13 @@ def _all2list(x):
         sage: _all2list(OctonionMatrixAlgebra(1).one())
         [1, 0, 0, 0, 0, 0, 0, 0]
 
+    ::
+
+        sage: _all2list(QuaternionAlgebra(QQ, -1, -1).one())
+        [1, 0, 0, 0]
+        sage: _all2list(QuaternionMatrixAlgebra(1).one())
+        [1, 0, 0, 0]
+
     ::
 
         sage: V1 = VectorSpace(QQ,2)
@@ -129,8 +138,8 @@ def gram_schmidt(v, inner_product=None):
     """
     Perform Gram-Schmidt on the list ``v`` which are assumed to be
     vectors over the same base ring. Returns a list of orthonormalized
-    vectors over the smallest extention ring containing the necessary
-    roots.
+    vectors over the same base ring, which means that your base ring
+    needs to contain the appropriate roots.
 
     SETUP::
 
@@ -138,11 +147,21 @@ def gram_schmidt(v, inner_product=None):
 
     EXAMPLES:
 
+    If you start with an orthonormal set, you get it back. We can use
+    the rationals here because we don't need any square roots::
+
+        sage: v1 = vector(QQ, (1,0,0))
+        sage: v2 = vector(QQ, (0,1,0))
+        sage: v3 = vector(QQ, (0,0,1))
+        sage: v = [v1,v2,v3]
+        sage: gram_schmidt(v) == v
+        True
+
     The usual inner-product and norm are default::
 
-        sage: v1 = vector(QQ,(1,2,3))
-        sage: v2 = vector(QQ,(1,-1,6))
-        sage: v3 = vector(QQ,(2,1,-1))
+        sage: v1 = vector(AA,(1,2,3))
+        sage: v2 = vector(AA,(1,-1,6))
+        sage: v3 = vector(AA,(2,1,-1))
         sage: v = [v1,v2,v3]
         sage: u = gram_schmidt(v)
         sage: all( u_i.inner_product(u_i).sqrt() == 1 for u_i in u )
@@ -159,11 +178,11 @@ def gram_schmidt(v, inner_product=None):
     orthonormal with respect to that (and not the usual inner
     product)::
 
-        sage: v1 = vector(QQ,(1,2,3))
-        sage: v2 = vector(QQ,(1,-1,6))
-        sage: v3 = vector(QQ,(2,1,-1))
+        sage: v1 = vector(AA,(1,2,3))
+        sage: v2 = vector(AA,(1,-1,6))
+        sage: v3 = vector(AA,(2,1,-1))
         sage: v = [v1,v2,v3]
-        sage: B = matrix(QQ, [ [6, 4, 2],
+        sage: B = matrix(AA, [ [6, 4, 2],
         ....:                  [4, 5, 4],
         ....:                  [2, 4, 9] ])
         sage: ip = lambda x,y: (B*x).inner_product(y)
@@ -181,18 +200,18 @@ def gram_schmidt(v, inner_product=None):
     This Gram-Schmidt routine can be used on matrices as well, so long
     as an appropriate inner-product is provided::
 
-        sage: E11 = matrix(QQ, [ [1,0],
+        sage: E11 = matrix(AA, [ [1,0],
         ....:                    [0,0] ])
-        sage: E12 = matrix(QQ, [ [0,1],
+        sage: E12 = matrix(AA, [ [0,1],
         ....:                    [1,0] ])
-        sage: E22 = matrix(QQ, [ [0,0],
+        sage: E22 = matrix(AA, [ [0,0],
         ....:                    [0,1] ])
-        sage: I = matrix.identity(QQ,2)
+        sage: I = matrix.identity(AA,2)
         sage: trace_ip = lambda X,Y: (X*Y).trace()
         sage: gram_schmidt([E11,E12,I,E22], inner_product=trace_ip)
         [
-        [1 0]  [          0 1/2*sqrt(2)]  [0 0]
-        [0 0], [1/2*sqrt(2)           0], [0 1]
+        [1 0]  [                  0 0.7071067811865475?]  [0 0]
+        [0 0], [0.7071067811865475?                   0], [0 1]
         ]
 
     It even works on Cartesian product spaces whose factors are vector
@@ -221,16 +240,23 @@ def gram_schmidt(v, inner_product=None):
 
     Ensure that zero vectors don't get in the way::
 
-        sage: v1 = vector(QQ,(1,2,3))
-        sage: v2 = vector(QQ,(1,-1,6))
-        sage: v3 = vector(QQ,(0,0,0))
+        sage: v1 = vector(AA,(1,2,3))
+        sage: v2 = vector(AA,(1,-1,6))
+        sage: v3 = vector(AA,(0,0,0))
         sage: v = [v1,v2,v3]
         sage: len(gram_schmidt(v)) == 2
         True
     """
     if inner_product is None:
         inner_product = lambda x,y: x.inner_product(y)
-    norm = lambda x: inner_product(x,x).sqrt()
+    def norm(x):
+        ip = inner_product(x,x)
+        # Don't expand the given field; the inner-product's codomain
+        # is already correct. For example QQ(2).sqrt() returns sqrt(2)
+        # in SR, and that will give you weird errors about symbolics
+        # when what's really going wrong is that you're trying to
+        # orthonormalize in QQ.
+        return ip.parent()(ip.sqrt())
 
     v = list(v) # make a copy, don't clobber the input