matrix_algebra: add _entry_algebra_element_to_vector() method.

diff --git a/mjo/hurwitz.py b/mjo/hurwitz.py
index e2800345cf550b3f6970fa62592c0d43a1e85531..cad89ca177cbdcfbc065682d4a64af43aad6917a 100644 (file)
--- a/mjo/hurwitz.py
+++ b/mjo/hurwitz.py
@@ -627,6 +627,32 @@ class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra):
             entry_algebra = QuaternionAlgebra(scalars,-1,-1)
         super().__init__(n, entry_algebra, scalars, **kwargs)
 
+    def _entry_algebra_element_to_vector(self, entry):
+        r"""
+
+        SETUP::
+
+            sage: from mjo.hurwitz import QuaternionMatrixAlgebra
+
+        EXAMPLES::
+
+            sage: A = QuaternionMatrixAlgebra(2)
+            sage: u = A.entry_algebra().one()
+            sage: A._entry_algebra_element_to_vector(u)
+            (1, 0, 0, 0)
+            sage: i,j,k = A.entry_algebra().gens()
+            sage: A._entry_algebra_element_to_vector(i)
+            (0, 1, 0, 0)
+            sage: A._entry_algebra_element_to_vector(j)
+            (0, 0, 1, 0)
+            sage: A._entry_algebra_element_to_vector(k)
+            (0, 0, 0, 1)
+
+        """
+        from sage.modules.free_module import VectorSpace
+        d = len(self.entry_algebra_gens())
+        V = VectorSpace(self.entry_algebra().base_ring(), d)
+        return V(entry.coefficient_tuple())
 
 class ComplexMatrixAlgebra(HurwitzMatrixAlgebra):
     r"""
@@ -707,3 +733,24 @@ class ComplexMatrixAlgebra(HurwitzMatrixAlgebra):
             from sage.rings.all import QQbar
             entry_algebra = QQbar
         super().__init__(n, entry_algebra, scalars, **kwargs)
+
+    def _entry_algebra_element_to_vector(self, entry):
+        r"""
+
+        SETUP::
+
+            sage: from mjo.hurwitz import ComplexMatrixAlgebra
+
+        EXAMPLES::
+
+            sage: A = ComplexMatrixAlgebra(2, QQbar, QQ)
+            sage: A._entry_algebra_element_to_vector(QQbar(1))
+            (1, 0)
+            sage: A._entry_algebra_element_to_vector(QQbar(I))
+            (0, 1)
+
+        """
+        from sage.modules.free_module import VectorSpace
+        d = len(self.entry_algebra_gens())
+        V = VectorSpace(self.entry_algebra().base_ring(), d)
+        return V((entry.real(), entry.imag()))

diff --git a/mjo/matrix_algebra.py b/mjo/matrix_algebra.py
index 84aa8d28bb3de9e6797b9b0a209eb96c3a14dc22..8491f277d5cc81b955c6ddaed0298549d15aa779 100644 (file)
--- a/mjo/matrix_algebra.py
+++ b/mjo/matrix_algebra.py
@@ -240,6 +240,81 @@ class MatrixAlgebra(CombinatorialFreeModule):
         """
         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 VectorSpace
+        d = len(self.entry_algebra_gens())
+        V = VectorSpace(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