from sage.matrix.constructor import matrix
from sage.modules.free_module_element import vector
+def _scale(x, alpha):
+ r"""
+ Scale the vector, matrix, or cartesian-product-of-those-things
+ ``x`` by ``alpha``.
+
+ This works around the inability to scale certain elements of
+ Cartesian product spaces, as reported in
+
+ https://trac.sagemath.org/ticket/31435
+
+ ..WARNING:
+
+ This will do the wrong thing if you feed it a tuple or list.
+
+ SETUP::
+
+ sage: from mjo.eja.eja_utils import _scale
+
+ EXAMPLES::
+
+ sage: v = vector(QQ, (1,2,3))
+ sage: _scale(v,2)
+ (2, 4, 6)
+ sage: m = matrix(QQ, [[1,2],[3,4]])
+ sage: M = cartesian_product([m.parent(), m.parent()])
+ sage: _scale(M((m,m)), 2)
+ ([2 4]
+ [6 8], [2 4]
+ [6 8])
+
+ """
+ if hasattr(x, 'cartesian_factors'):
+ P = x.parent()
+ return P(tuple( _scale(x_i, alpha)
+ for x_i in x.cartesian_factors() ))
+ else:
+ return x*alpha
+
+
def _all2list(x):
r"""
Flatten a vector, matrix, or cartesian product of those things
R = v[0].base_ring()
- # Define a scaling operation that can be used on tuples.
- # Oh and our "zero" needs to belong to the right space.
- scale = lambda x,alpha: x*alpha
+ # Our "zero" needs to belong to the right space for sum() to work.
zero = v[0].parent().zero()
- if hasattr(v[0], 'cartesian_factors'):
- P = v[0].parent()
- scale = lambda x,alpha: P(tuple( x_i*alpha
- for x_i in x.cartesian_factors() ))
+ sc = lambda x,a: a*x
+ if hasattr(v[0], 'cartesian_factors'):
+ # Only use the slow implementation if necessary.
+ sc = _scale
def proj(x,y):
- return scale(x, (inner_product(x,y)/inner_product(x,x)))
+ return sc(x, (inner_product(x,y)/inner_product(x,x)))
# First orthogonalize...
for i in range(1,len(v)):
# them here because then our subalgebra would have a bigger field
# than the superalgebra.
for i in range(len(v)):
- v[i] = scale(v[i], ~norm(v[i]))
+ v[i] = sc(v[i], ~norm(v[i]))
return v