Ticket #7723: trac_7723-generic_multiply.patch

sage/matrix/action.pyx

@@ -135 +135 @@
         """
         cdef Matrix A = g #<Matrix>g
         cdef Matrix B = s #<Matrix>s
-        if A._parent._base is not self._codomain._base:
-            A = A.change_ring(self._codomain._base)
-        if B._parent._base is not self._codomain._base:
-            B = B.change_ring(self._codomain._base)
-        if self.fix_sparseness:
-            if B.is_sparse_c():
-                B = B.dense_matrix()
-            else:
-                A = A.dense_matrix()
-        prod = A._matrix_times_matrix_(B)
+        prod = A._generic_matrix_times_matrix_(B, self._codomain)
         if A.subdivisions is not None or B.subdivisions is not None:
             Asubs = A.get_subdivisions()
             Bsubs = B.get_subdivisions()

sage/matrix/matrix0.pyx

@@ -40 +40 @@
 from   sage.structure.element    cimport ModuleElement, Element, RingElement, Vector
 from   sage.structure.mutability cimport Mutability
 from   sage.misc.misc_c cimport normalize_index
+from sage.structure.parent cimport Parent
 
 from sage.rings.ring cimport CommutativeRing
 from sage.rings.ring import is_Ring
@@ -3442 +3443 @@
                 ans.set_unsafe(r, c, (<RingElement>self.get_unsafe(r, c))._mul_(x))
         return ans
 
+    cdef sage.structure.element.Matrix _generic_matrix_times_matrix_(self,
+                                           sage.structure.element.Matrix right,
+                                           Parent codomain):
+        r"""
+        Return the product of two matrices.
+
+        The matrices may have different parents, but are guaranteed to
+        have a multiplication codomain (e.g. they have conforming
+        shape).  The output should be the product of the matrices in
+        the ``codomain`` given.
+
+        By default:
+         - Change base ring to that of codomain
+         - If sparsity differs, make the sparse matrix dense
+         - Call ``_matrix_times_matrix``
+
+        Specific matrix implementations might override this to provide faster
+        operations (in particular, perform sparse-dense multiplication).
+        """
+        cdef sage.structure.element.Matrix A = self, B = right
+        cdef bint left_sparse = self.is_sparse_c()
+        cdef bint right_sparse = right.is_sparse_c()
+        base = codomain._base
+        
+        if A._parent._base is not base:
+            A = A.change_ring(codomain._base)
+        if B._parent._base is not base:
+            B = B.change_ring(codomain._base)
+        if (left_sparse == 0) != (right_sparse == 0):
+            if left_sparse:
+                A = A.dense_matrix()
+            else:
+                B = B.dense_matrix()
+        return A._matrix_times_matrix_(B)
+
     cdef sage.structure.element.Matrix _matrix_times_matrix_(self, sage.structure.element.Matrix right):
         r"""
         Return the product of two matrices.
+
+        The matrices should both the same base ring and either both
+        should be dense or both sparse.
         
         EXAMPLE of matrix times matrix over same base ring: We multiply
         matrices over `\QQ[x,y]`.

sage/structure/element.pxd

@@ -119 +119 @@
     cdef Vector _matrix_times_vector_(matrix_left, Vector vector_right)    # OK to override, AND call directly    
     cdef Matrix _matrix_times_matrix_(left, Matrix right)                  # OK to override, AND call directly
 
+    cdef Matrix _generic_matrix_times_matrix_(left, Matrix right, Parent codomain) # OK to override, AND call directly
+
     cdef bint is_sparse_c(self)
     cdef bint is_dense_c(self)
         

sage/structure/element.pyx

@@ -2001 +2001 @@
     cdef Matrix _matrix_times_matrix_(left, Matrix right):
         raise TypeError
     
-    
+    cdef Matrix _generic_matrix_times_matrix_(left, Matrix right, Parent codomain):
+        raise TypeError    
 
 def is_Matrix(x):
     return IS_INSTANCE(x, Matrix)