eja: fix gram_schmidt doctests.

diff --git a/mjo/eja/eja_utils.py b/mjo/eja/eja_utils.py
index d4e9990ecc6749057905d3b1d5ac700bd34cdc71..0b2d2a315989949c2431641c8f82dea9b576f9b8 100644 (file)
--- a/mjo/eja/eja_utils.py
+++ b/mjo/eja/eja_utils.py
@@ -129,8 +129,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 +138,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 +169,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 +191,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,9 +231,9 @@ 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