Add some functions to Matrix_nmod_dense

Author: roed314

src/sage/matrix/docs.py

@@ -392,11 +392,11 @@ class derived from Matrix). They can be either sparse or dense, and
        * cdef _list -- list of underlying elements (need not be a copy)
        * cdef _dict -- sparse dictionary of underlying elements
        * cdef _add_ -- add two matrices with identical parents
-       * _matrix_times_matrix_c_impl -- multiply two matrices with compatible dimensions and
+       * _matrix_times_matrix_ -- multiply two matrices with compatible dimensions and
                                         identical base rings (both sparse or both dense)
        * cpdef _richcmp_ -- compare two matrices with identical parents
-       * cdef _lmul_c_impl -- multiply this matrix on the right by a scalar, i.e., self * scalar
-       * cdef _rmul_c_impl -- multiply this matrix on the left by a scalar, i.e., scalar * self
+       * cdef _lmul_ -- multiply this matrix on the right by a scalar, i.e., self * scalar
+       * cdef _rmul_ -- multiply this matrix on the left by a scalar, i.e., scalar * self
        * __copy__
        * __neg__
 

src/sage/matrix/matrix_nmod_dense.pyx

@@ -12,15 +12,16 @@ from cpython.sequence cimport *
 from cysignals.signals cimport sig_str, sig_off
 
 from sage.structure.sage_object cimport SageObject
+from sage.structure.element cimport Element, Matrix
 from sage.libs.flint.nmod_mat cimport *
 
 from .args cimport SparseEntry, MatrixArgs_init
 
 import sage.matrix.matrix_space as matrix_space
-
+from sage.rings.finite_rings.integer_mod cimport IntegerMod_int, IntegerMod_int64
 
 cdef class Matrix_nmod_dense(Matrix_dense):
-    def __cinit__(self, parent, entries=None, bint coerce=True):
+    def __cinit__(self, parent, *args, **kwds):
         self._modulus = parent._base._pyx_order
         sig_str("FLINT exception")
         nmod_mat_init(self._matrix, self._nrows, self._ncols, self._modulus.int64)
@@ -42,7 +43,10 @@ cdef class Matrix_nmod_dense(Matrix_dense):
         nmod_mat_print_pretty(self._matrix)
 
     cdef set_unsafe(self, Py_ssize_t i, Py_ssize_t j, object x):
-        self.set_unsafe_si(i, j, x.ivalue)
+        if self._modulus.element_class() is IntegerMod_int:
+            self.set_unsafe_si(i, j, (<IntegerMod_int>x).ivalue)
+        else:
+            self.set_unsafe_si(i, j, (<IntegerMod_int64>x).ivalue)
 
     cdef void set_unsafe_si(self, Py_ssize_t i, Py_ssize_t j, long value):
         nmod_mat_set_entry(self._matrix, i, j, value)
@@ -68,9 +72,37 @@ cdef class Matrix_nmod_dense(Matrix_dense):
             P = self._parent
         else:
             P = matrix_space.MatrixSpace(self._parent._base, nrows, ncols, sparse=False)
-        cdef Matrix_nmod_dense ans = Matrix_nmod_dense.__new__(Matrix_nmod_dense, P, None, None, None)
+        cdef Matrix_nmod_dense ans = Matrix_nmod_dense.__new__(Matrix_nmod_dense, P)
         return ans
 
+    cpdef _add_(self, _right):
+        cdef Matrix_nmod_dense right = _right
+        cdef Matrix_nmod_dense M = self._new(self._nrows, self._ncols)
+        nmod_mat_add(M._matrix, self._matrix, right._matrix)
+        return M
+
+    cpdef _sub_(self, _right):
+        cdef Matrix_nmod_dense right = _right
+        cdef Matrix_nmod_dense M = self._new(self._nrows, self._ncols)
+        nmod_mat_sub(M._matrix, self._matrix, right._matrix)
+        return M
+
+    cdef Matrix _matrix_times_matrix_(left, Matrix _right):
+        if left._ncols != _right._nrows:
+            raise IndexError("Number of columns of self must equal number of rows of right.")
+        cdef Matrix_nmod_dense right = _right
+        cdef Matrix_nmod_dense M = left._new(left._nrows, right._ncols)
+        nmod_mat_mul(M._matrix, left._matrix, right._matrix)
+        return M
+
+    cpdef _lmul_(self, Element right):
+        cdef Matrix_nmod_dense M = self._new(self._nrows, self._ncols)
+        print("Hello")
+        if self._modulus.element_class() is IntegerMod_int:
+            nmod_mat_scalar_mul(M._matrix, self._matrix, (<IntegerMod_int?>right).ivalue)
+        else:
+            nmod_mat_scalar_mul(M._matrix, self._matrix, (<IntegerMod_int64?>right).ivalue)
+        return M
 
     def strong_echelon_form(self):
         if self._nrows >= self._ncols: