from sage.functions.other import sqrt
+from sage.structure.element import is_Matrix
from sage.matrix.constructor import matrix
from sage.modules.free_module_element import vector
+def _charpoly_sage_input(s):
+ r"""
+ Helper function that you can use on the string output from sage
+ to convert a charpoly coefficient into the corresponding input
+ to be cached.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_algebra import JordanSpinEJA
+ sage: from mjo.eja.eja_utils import _charpoly_sage_input
+
+ EXAMPLES::
+
+ sage: J = JordanSpinEJA(4,QQ)
+ sage: a = J._charpoly_coefficients()
+ sage: a[0]
+ X1^2 - X2^2 - X3^2 - X4^2
+ sage: _charpoly_sage_input(str(a[0]))
+ 'X[0]**2 - X[1]**2 - X[2]**2 - X[3]**2'
+
+ """
+ import re
+
+ exponent_out = r"\^"
+ exponent_in = r"**"
+
+ digit_out = r"X([0-9]+)"
+
+ def replace_digit(m):
+ # m is a match object
+ return "X[" + str(int(m.group(1)) - 1) + "]"
+
+ s = re.sub(exponent_out, exponent_in, s)
+ return re.sub(digit_out, replace_digit, s)
+
+
def _scale(x, alpha):
r"""
Scale the vector, matrix, or cartesian-product-of-those-things
[3, 4, 1, 0, 0, 0, 0, 0, 0, 0]
"""
- if hasattr(x, 'list') and hasattr(x, 'to_vector'):
- # This avoids calling to_vector() on a matrix algebra with
- # e.g. quaternions where the returned vector is of the wrong
- # length (three instead of four) because the quaternions don't
- # know how many generators they have.
- return _all2list(x.list())
-
if hasattr(x, 'to_vector'):
# This works on matrices of e.g. octonions directly, without
# first needing to convert them to a list of octonions and
# then recursing down into the list. It also avoids the wonky
# list(x) when x is an element of a CFM. I don't know what it
- # returns but it aint the coordinates. This will fall through
- # to the iterable case the next time around.
- return _all2list(x.to_vector())
+ # returns but it aint the coordinates. We don't recurse
+ # because vectors can only contain ring elements as entries.
+ return x.to_vector().list()
+
+ if is_Matrix(x):
+ # This sucks, but for performance reasons we don't want to
+ # call _all2list recursively on the contents of a matrix
+ # when we don't have to (they only contain ring elements
+ # as entries)
+ return x.list()
try:
xl = list(x)
# Avoid the retardation of list(QQ(1)) == [1].
return [x]
- return sum(list( map(_all2list, xl) ), [])
+ return sum( map(_all2list, xl) , [])