X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=cea1476f1eef34df7db63a231c9b1ff54efe5224;hb=26ca01fdf8ab74e5cc443e83d96843a5bc272871;hp=2a5e624cf4730e8296373d5fe542bbc78d31666e;hpb=09ef15bb469b45f6491c71b44dc7d50a8f2c6fe3;p=sage.d.git

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index 2a5e624..cea1476 100644
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -5,7 +5,7 @@ are used in optimization, and have some additional nice methods beyond
 what can be supported in a general Jordan Algebra.
 """
 
-from itertools import repeat
+from itertools import izip, repeat
 
 from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
 from sage.categories.magmatic_algebras import MagmaticAlgebras
@@ -409,7 +409,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
             # assign a[r] goes out-of-bounds.
             a.append(1) # corresponds to x^r
 
-        return sum( a[k]*(t**k) for k in range(len(a)) )
+        return sum( a[k]*(t**k) for k in xrange(len(a)) )
 
 
     def inner_product(self, x, y):
@@ -491,7 +491,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
 
         """
         M = list(self._multiplication_table) # copy
-        for i in range(len(M)):
+        for i in xrange(len(M)):
             # M had better be "square"
             M[i] = [self.monomial(i)] + M[i]
         M = [["*"] + list(self.gens())] + M
@@ -799,8 +799,8 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra):
     """
     def __init__(self, n, field=QQ, **kwargs):
         V = VectorSpace(field, n)
-        mult_table = [ [ V.gen(i)*(i == j) for j in range(n) ]
-                       for i in range(n) ]
+        mult_table = [ [ V.gen(i)*(i == j) for j in xrange(n) ]
+                       for i in xrange(n) ]
 
         fdeja = super(RealCartesianProductEJA, self)
         return fdeja.__init__(field, mult_table, rank=n, **kwargs)
@@ -930,13 +930,15 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
             # with had entries in a nice field.
             return super(MatrixEuclideanJordanAlgebra, self)._charpoly_coeff(i)
         else:
-            n = self.natural_basis_space().nrows()
+            # If we didn't unembed first, this number would be wrong
+            # by a power-of-two factor for complex/quaternion matrices.
+            n = self.real_unembed(self.natural_basis_space().zero()).nrows()
             field = self.base_ring().base_ring() # yeeeeaaaahhh
             J = self.__class__(n, field, False)
             (_,x,_,_) = J._charpoly_matrix_system()
             p = J._charpoly_coeff(i)
             # p might be missing some vars, have to substitute "optionally"
-            pairs = zip(x.base_ring().gens(), self._basis_normalizers)
+            pairs = izip(x.base_ring().gens(), self._basis_normalizers)
             substitutions = { v: v*c for (v,c) in pairs }
             return p.subs(substitutions)
 
@@ -962,9 +964,9 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
         V = VectorSpace(field, dimension**2)
         W = V.span_of_basis( _mat2vec(s) for s in basis )
         n = len(basis)
-        mult_table = [[W.zero() for j in range(n)] for i in range(n)]
-        for i in range(n):
-            for j in range(n):
+        mult_table = [[W.zero() for j in xrange(n)] for i in xrange(n)]
+        for i in xrange(n):
+            for j in xrange(n):
                 mat_entry = (basis[i]*basis[j] + basis[j]*basis[i])/2
                 mult_table[i][j] = W.coordinate_vector(_mat2vec(mat_entry))
 
@@ -1020,24 +1022,16 @@ class RealMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
     @staticmethod
     def real_embed(M):
         """
-        Embed the matrix ``M`` into a space of real matrices.
-
-        The matrix ``M`` can have entries in any field at the moment:
-        the real numbers, complex numbers, or quaternions. And although
-        they are not a field, we can probably support octonions at some
-        point, too. This function returns a real matrix that "acts like"
-        the original with respect to matrix multiplication; i.e.
-
-          real_embed(M*N) = real_embed(M)*real_embed(N)
-
+        The identity function, for embedding real matrices into real
+        matrices.
         """
         return M
 
-
     @staticmethod
     def real_unembed(M):
         """
-        The inverse of :meth:`real_embed`.
+        The identity function, for unembedding real matrices from real
+        matrices.
         """
         return M
 
@@ -1735,9 +1729,9 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra):
     """
     def __init__(self, n, field=QQ, **kwargs):
         V = VectorSpace(field, n)
-        mult_table = [[V.zero() for j in range(n)] for i in range(n)]
-        for i in range(n):
-            for j in range(n):
+        mult_table = [[V.zero() for j in xrange(n)] for i in xrange(n)]
+        for i in xrange(n):
+            for j in xrange(n):
                 x = V.gen(i)
                 y = V.gen(j)
                 x0 = x[0]