EXAMPLES::
- sage: M = MatrixAlgebra(QQbar,RDF,2)
+ sage: M = MatrixAlgebra(2, QQbar,RDF)
sage: A = M.monomial((0,0,1)) + 4*M.monomial((0,1,1))
sage: A
+-----+-----+
EXAMPLES::
- sage: MatrixAlgebra(ZZ,ZZ,2).zero()
+ sage: MatrixAlgebra(2,ZZ,ZZ).zero()
+---+---+
| 0 | 0 |
+---+---+
| 0 | 0 |
+---+---+
+ TESTS::
+
+ sage: MatrixAlgebra(0,ZZ,ZZ).zero()
+ 0
+
"""
- return table(self.rows(), frame=True)._repr_()
+ if self.nrows() == 0 or self.ncols() == 0:
+ # Otherwise we get a crash or a blank space, depending
+ # on how hard we work for it.
+ return self.parent().entry_algebra().zero().__repr__()
+
+ return table(rs, frame=True)._repr_()
def list(self):
EXAMPLES::
- sage: A = MatrixAlgebra(ZZ,ZZ,2)
+ sage: A = MatrixAlgebra(2,ZZ,ZZ)
sage: A([[1,2],[3,4]]).list()
[1, 2, 3, 4]
EXAMPLES::
- sage: M = MatrixAlgebra(ZZ,ZZ,2)([[1,2],[3,4]])
+ sage: M = MatrixAlgebra(2,ZZ,ZZ)([[1,2],[3,4]])
sage: M[0,0]
1
sage: M[0,1]
sage: entries = MatrixSpace(ZZ,2)
sage: scalars = ZZ
- sage: M = MatrixAlgebra(entries, scalars, 2)
+ sage: M = MatrixAlgebra(2, entries, scalars)
sage: I = entries.one()
sage: Z = entries.zero()
sage: M([[I,Z],[Z,I]]).trace()
sage: set_random_seed()
sage: entries = QuaternionAlgebra(QQ,-1,-1)
- sage: M = MatrixAlgebra(entries, QQ, 3)
+ sage: M = MatrixAlgebra(3, entries, QQ)
sage: M.random_element().matrix_space() == M
True
The existence of a unit element is determined dynamically::
- sage: MatrixAlgebra(ZZ,ZZ,2).one()
+ sage: MatrixAlgebra(2,ZZ,ZZ).one()
+---+---+
| 1 | 0 |
+---+---+
"""
Element = MatrixAlgebraElement
- def __init__(self, entry_algebra, scalars, n, prefix="A", **kwargs):
+ def __init__(self, n, entry_algebra, scalars, prefix="A", **kwargs):
category = MagmaticAlgebras(scalars).FiniteDimensional()
category = category.WithBasis()
if "Unital" in entry_algebra.category().axioms():
category = category.Unital()
entry_one = entry_algebra.one()
- self.one = lambda: sum( (self.monomial((i,i,entry_one))
- for i in range(self.nrows()) ),
- self.zero() )
+ self.one = lambda: self.sum( (self.monomial((i,i,entry_one))
+ for i in range(self.nrows()) ) )
if "Associative" in entry_algebra.category().axioms():
category = category.Associative()
# sticking a "1" in each position doesn't give us a basis for
# the space. We actually need to stick each of e0, e1, ... (a
# basis for the entry algebra itself) into each position.
- I = range(n)
- J = range(n)
self._entry_algebra = entry_algebra
- entry_basis = entry_algebra.gens()
+
+ # Needs to make the (overridden) method call when, for example,
+ # the entry algebra is the complex numbers and its gens() method
+ # lies to us.
+ entry_basis = self.entry_algebra_gens()
basis_indices = [(i,j,e) for i in range(n)
for j in range(n)
- for e in entry_algebra.gens()]
+ for e in entry_basis]
super().__init__(scalars,
basis_indices,
"""
return self._entry_algebra
+ def entry_algebra_gens(self):
+ r"""
+ Return a tuple of the generators of (that is, a basis for) the
+ entries of this matrix algebra.
+
+ This can be overridden in subclasses to work around the
+ inconsistency in the ``gens()`` methods of the various
+ entry algebras.
+ """
+ return self.entry_algebra().gens()
+
+ def _entry_algebra_element_to_vector(self, entry):
+ r"""
+ Return a vector representation (of length equal to the cardinality
+ of :meth:`entry_algebra_gens`) of the given ``entry``.
+
+ This can be overridden in subclasses to work around the fact that
+ real numbers, complex numbers, quaternions, et cetera, all require
+ different incantations to turn them into a vector.
+
+ It only makes sense to "guess" here in the superclass when no
+ subclass that overrides :meth:`entry_algebra_gens` exists. So
+ if you have a special subclass for your annoying entry algebra,
+ override this with the correct implementation there instead of
+ adding a bunch of awkward cases to this superclass method.
+
+ SETUP::
+
+ sage: from mjo.hurwitz import Octonions
+ sage: from mjo.matrix_algebra import MatrixAlgebra
+
+ EXAMPLES:
+
+ Real numbers::
+
+ sage: A = MatrixAlgebra(1, AA, QQ)
+ sage: A._entry_algebra_element_to_vector(AA(17))
+ (17)
+
+ Octonions::
+
+ sage: A = MatrixAlgebra(1, Octonions(), QQ)
+ sage: e = A.entry_algebra_gens()
+ sage: A._entry_algebra_element_to_vector(e[0])
+ (1, 0, 0, 0, 0, 0, 0, 0)
+ sage: A._entry_algebra_element_to_vector(e[1])
+ (0, 1, 0, 0, 0, 0, 0, 0)
+ sage: A._entry_algebra_element_to_vector(e[2])
+ (0, 0, 1, 0, 0, 0, 0, 0)
+ sage: A._entry_algebra_element_to_vector(e[3])
+ (0, 0, 0, 1, 0, 0, 0, 0)
+ sage: A._entry_algebra_element_to_vector(e[4])
+ (0, 0, 0, 0, 1, 0, 0, 0)
+ sage: A._entry_algebra_element_to_vector(e[5])
+ (0, 0, 0, 0, 0, 1, 0, 0)
+ sage: A._entry_algebra_element_to_vector(e[6])
+ (0, 0, 0, 0, 0, 0, 1, 0)
+ sage: A._entry_algebra_element_to_vector(e[7])
+ (0, 0, 0, 0, 0, 0, 0, 1)
+
+ Sage matrices::
+
+ sage: MS = MatrixSpace(QQ,2)
+ sage: A = MatrixAlgebra(1, MS, QQ)
+ sage: A._entry_algebra_element_to_vector(MS([[1,2],[3,4]]))
+ (1, 2, 3, 4)
+
+ """
+ if hasattr(entry, 'to_vector'):
+ return entry.to_vector()
+
+ from sage.modules.free_module import FreeModule
+ d = len(self.entry_algebra_gens())
+ V = FreeModule(self.entry_algebra().base_ring(), d)
+
+ if hasattr(entry, 'list'):
+ # sage matrices
+ return V(entry.list())
+
+ # This works in AA, and will crash if it doesn't know what to
+ # do, and that's fine because then I don't know what to do
+ # either.
+ return V((entry,))
+
+
+
def nrows(self):
return self._nrows
ncols = nrows
sage: e = O.gens()
sage: e[2]*e[1]
-e3
- sage: A = MatrixAlgebra(O,QQ,2)
+ sage: A = MatrixAlgebra(2,O,QQ)
sage: A.product_on_basis( (0,0,e[2]), (0,0,e[1]) )
+-----+---+
| -e3 | 0 |
(i,j,e1) = mon1
(k,l,e2) = mon2
if j == k:
- # If e1*e2 has a negative sign in front of it,
- # then (i,l,e1*e2) won't be a monomial!
- p = e1*e2
- if (i,l,p) in self.indices():
- return self.monomial((i,l,p))
- else:
- return -self.monomial((i,l,-p))
+ # There's no reason to expect e1*e2 to itself be a monomial,
+ # so we have to do some manual conversion to get one.
+ p = self._entry_algebra_element_to_vector(e1*e2)
+
+ # We have to convert alpha_g because a priori it lives in the
+ # base ring of the entry algebra.
+ R = self.base_ring()
+ return self.sum_of_terms( (((i,l,g), R(alpha_g))
+ for (alpha_g, g)
+ in zip(p, self.entry_algebra_gens()) ),
+ distinct=True)
else:
return self.zero()
SETUP::
- sage: from mjo.matrix_algebra import MatrixAlgebra
+ sage: from mjo.hurwitz import ComplexMatrixAlgebra
EXAMPLES::
- sage: A = MatrixAlgebra(QQbar, ZZ, 2)
- sage: A.from_list([[0,I],[-I,0]])
+ sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+ sage: M = A.from_list([[0,I],[-I,0]])
+ sage: M
+----+---+
| 0 | I |
+----+---+
| -I | 0 |
+----+---+
+ sage: M.to_vector()
+ (0, 0, 0, 1, 0, -1, 0, 0)
"""
nrows = len(entries)
# Octonions(AA).
return self.entry_algebra().from_vector(e_ij.to_vector())
- return sum( (self.monomial( (i,j, convert(entries[i][j])) )
- for i in range(nrows)
- for j in range(ncols) ),
- self.zero() )
+ def entry_to_element(i,j,entry):
+ # Convert an entry at i,j to a matrix whose only non-zero
+ # entry is i,j and corresponds to the entry.
+ p = self._entry_algebra_element_to_vector(entry)
+
+ # We have to convert alpha_g because a priori it lives in the
+ # base ring of the entry algebra.
+ R = self.base_ring()
+ return self.sum_of_terms( (((i,j,g), R(alpha_g))
+ for (alpha_g, g)
+ in zip(p, self.entry_algebra_gens()) ),
+ distinct=True)
+
+ return self.sum( entry_to_element(i,j,entries[i][j])
+ for j in range(ncols)
+ for i in range(nrows) )
+
def _element_constructor_(self, elt):
if elt in self:
projects / sage.d.git / blobdiff