Ticket #3969: 3969-fast-matmod2-hash-rebased.patch

a/sage/matrix/matrix_mod2_dense.pyx

@@ -145 +145 @@
-    """
-    m4ri_destroy_all_codes()
-
+    
+
-cdef class Matrix_mod2_dense(matrix_dense.Matrix_dense):   # dense or sparse
-    r"""
-    Dense matrix over GF(2).
@@ -273 +275 @@
-
-    def __hash__(self):
-        """
+        The has of a matrix is computed as $\oplus i*a_i$ where the $a_i$ are 
+        the flattened entries in a matrix (by row, then by column). 
+        
-        EXAMPLE:
-            sage: B = random_matrix(GF(2),3,3)
-            sage: B.set_immutable()
@@ -280 +285 @@
-            {[0 1 0]
-            [0 1 1]
-            [0 0 0]: 0}
-            sage: A = matrix(GF(2),2,2)
-            sage: A.set_immutable()
-            sage: hex(hash(A))
-            '0xdeadbeed' # 64-bit
-            '-0x21524113' # 32-bit
+            sage: M = random_matrix(GF(2), 123, 321)
+            sage: M.set_immutable()
+            sage: MZ = M.change_ring(ZZ)
+            sage: MZ.set_immutable()
+            sage: hash(M) == hash(MZ)
+            True
+            sage: MS = M.sparse_matrix()
+            sage: MS.set_immutable()
+            sage: hash(M) == hash(MS)
+            True
-            
-        TEST:
-            sage: A = matrix(GF(2),2,0)
@@ -297 +308 @@
-            0
-            
-        """
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-        if self._nrows == 0 or self._ncols == 0:
-            return 0
-
+        cdef unsigned long i, j, truerow
+        cdef unsigned long start, shift
+        cdef word row_xor
+        cdef word end_mask = ~(((<word>1)<<(RADIX - self._ncols%RADIX))-1)
+        cdef word top_mask, bot_mask
+        cdef word cur
+        cdef word* row
+        
+        # running_xor is the xor of all words in the matrix, as if the rows
+        # in the matrix were written out consecutively, without regard to 
+        # word boundaries. 
+        cdef word running_xor = 0
+        # running_parity is the number of extra words that must be xor'd.
+        cdef unsigned long running_parity = 0
+        
+        
-        for i from 0 <= i < self._entries.nrows:
+
+            # All this shifting and masking is because the
+            # rows are word-aligned. 
-            truerow = self._entries.rowswap[i]
-
-
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    cdef set_unsafe(self, Py_ssize_t i, Py_ssize_t j, value):
-        mzd_write_bit(self._entries, i, j, int(value))
@@ -1332 +1403 @@
-        gdFree(buf)
-        return unpickle_matrix_mod2_dense_v1, (r,c, data, size)
-
+
+# Used for hashing
+cdef int i, k
+cdef unsigned long parity_table[256]
+for i from 0 <= i < 256:
+    parity_table[i] = 1 & ((i) ^ (i>>1) ^ (i>>2) ^ (i>>3) ^ 
+                           (i>>4) ^ (i>>5) ^ (i>>6) ^ (i>>7))
+                           
+# gmp's ULONG_PARITY may use special 
+# assembly instructions, could be faster
+cpdef inline unsigned long parity(word a):
+    """
+    Returns the parity of the number of bits in a. 
+    
+    EXAMPLES: 
+        sage: from sage.matrix.matrix_mod2_dense import parity
+        sage: parity(1)
+        1L
+        sage: parity(3)
+        0L
+        sage: parity(0x10000101011)
+        1L
+    """
+    if sizeof(word) == 8:
+        a ^= a >> 32
+    a ^= a >> 16
+    a ^= a >> 8
+    return parity_table[a & 0xFF]
+
+cdef inline unsigned long parity_mask(word a):
+    return -parity(a)
+
+
-def unpickle_matrix_mod2_dense_v1(r, c, data, size):
-    r"""
-    Deserialize a matrix encoded in the string \code{s}.