Ticket #12841: trac_12841_m4rie_new_version.patch

File trac_12841_m4rie_new_version.patch, 8.9 KB (added by malb, 9 years ago)
  • sage/libs/m4rie.pxd

    # HG changeset patch
    # User Martin Albrecht <martinralbrecht@googlemail.com>
    # Date 1326300377 -3600
    # Node ID 62b283ab0192cdaf62719e332ec700528aaadece
    # Parent  ba3a0fe5a10da1f31070c6e80128530bc8440173
    #12841: adapted to new M4RIE version
    
    diff --git a/sage/libs/m4rie.pxd b/sage/libs/m4rie.pxd
    a b  
    1818
    1919    void gf2e_free(gf2e *ff)
    2020
    21 #cdef extern from "m4rie/gf2e_matrix.h":
     21#cdef extern from "m4rie/mzed.h":
    2222    ctypedef struct mzed_t:
    2323        mzd_t *x
    2424        gf2e *finite_field
     
    8787
    8888    void mzed_print(const_mzed_t *M)
    8989 
    90     mzed_t *mzed_invert_travolta(mzed_t *A, mzed_t *B)
     90    mzed_t *mzed_invert_newton_john(mzed_t *A, mzed_t *B)
    9191
    9292    # TODO: not implemented yet in m4rie
    9393    double mzed_density(mzed_t *A, int res)
     
    9595    # TODO: not implemented yet in m4rie
    9696    double _mzed_density(mzed_t *A, int res, size_t r, size_t c)
    9797
    98 #cdef extern from "m4rie/travolta.h":
    99     size_t mzed_echelonize_travolta(mzed_t *, size_t)
     98#cdef extern from "m4rie/newton_john.h":
     99    size_t mzed_echelonize_newton_john(mzed_t *, size_t)
    100100
    101     mzed_t *mzed_mul_travolta(mzed_t *, mzed_t *, mzed_t *)
     101    mzed_t *mzed_mul_newton_john(mzed_t *, mzed_t *, mzed_t *)
    102102
    103103#cdef extern from "m4rie/echelonform.h":
    104104    size_t mzed_echelonize(mzed_t *, size_t)
     
    110110
    111111    size_t _mzed_strassen_cutoff(mzed_t *C, mzed_t *A, mzed_t *B)
    112112
    113 #cdef extern from "m4rie/bitslice.h":
     113#cdef extern from "m4rie/mzd_slice.h":
    114114
    115115    int __M4RIE_MAX_KARATSUBA_DEGREE
    116116
  • sage/matrix/matrix_mod2e_dense.pxd

    diff --git a/sage/matrix/matrix_mod2e_dense.pxd b/sage/matrix/matrix_mod2e_dense.pxd
    a b  
    1212    cdef object _one
    1313    cdef object _zero
    1414
    15     cpdef Matrix_mod2e_dense _multiply_travolta(Matrix_mod2e_dense self, Matrix_mod2e_dense right)
     15    cpdef Matrix_mod2e_dense _multiply_newton_john(Matrix_mod2e_dense self, Matrix_mod2e_dense right)
    1616    cpdef Matrix_mod2e_dense _multiply_karatsuba(Matrix_mod2e_dense self, Matrix_mod2e_dense right)
    1717    cpdef Matrix_mod2e_dense _multiply_strassen(Matrix_mod2e_dense self, Matrix_mod2e_dense right, cutoff=*)
  • sage/matrix/matrix_mod2e_dense.pyx

    diff --git a/sage/matrix/matrix_mod2e_dense.pyx b/sage/matrix/matrix_mod2e_dense.pyx
    a b  
    1212  represented as ``[0xxx|0xxx|0xxx|0xxx|...]``. This representation is
    1313  wrapped as :class:`Matrix_mod2e_dense` in Sage.
    1414
    15   Multiplication and elimination both use "Travolta" tables. These
     15  Multiplication and elimination both use "Newton-John" tables. These
    1616  tables are simply all possible multiples of a given row in a matrix
    1717  such that a scale+add operation is reduced to a table lookup +
    18   add. On top of Travolta multiplication M4RIE implements
     18  add. On top of Newton-John multiplication M4RIE implements
    1919  asymptotically fast Strassen-Winograd multiplication. Elimination
    2020  uses simple Gaussian elimination which requires `O(n^3)` additions
    2121  but only `O(n^2 * 2^e)` multiplications.
     
    430430            sage: K.<a> = GF(2^3)
    431431            sage: A = random_matrix(K, 51, 50)
    432432            sage: B = random_matrix(K, 50, 52)
    433             sage: A*B == A._multiply_travolta(B) # indirect doctest
     433            sage: A*B == A._multiply_newton_john(B) # indirect doctest
    434434            True
    435435
    436436            sage: K.<a> = GF(2^5)
    437437            sage: A = random_matrix(K, 10, 50)
    438438            sage: B = random_matrix(K, 50, 12)
    439             sage: A*B == A._multiply_travolta(B)
     439            sage: A*B == A._multiply_newton_john(B)
    440440            True
    441441
    442442            sage: K.<a> = GF(2^7)
     
    458458        _sig_off
    459459        return ans
    460460
    461     cpdef Matrix_mod2e_dense _multiply_travolta(Matrix_mod2e_dense self, Matrix_mod2e_dense right):
     461    cpdef Matrix_mod2e_dense _multiply_newton_john(Matrix_mod2e_dense self, Matrix_mod2e_dense right):
    462462        """
    463         Return A*B using Travolta tables.
     463        Return A*B using Newton-John tables.
    464464
    465465        We can write classical cubic multiplication (``C=A*B``) as::
    466466
     
    474474        ``e * B[j]`` is computed more than once for any ``e`` in the finite
    475475        field. Instead, we compute all possible
    476476        multiples of ``B[j]`` and re-use this data in the inner loop.
    477         This is what is called a "Travolta" table in M4RIE.
     477        This is what is called a "Newton-John" table in M4RIE.
    478478
    479479        INPUT:
    480480
     
    485485            sage: K.<a> = GF(2^2)
    486486            sage: A = random_matrix(K, 50, 50)
    487487            sage: B = random_matrix(K, 50, 50)
    488             sage: A._multiply_travolta(B) == A._multiply_classical(B) # indirect doctest
     488            sage: A._multiply_newton_john(B) == A._multiply_classical(B) # indirect doctest
    489489            True
    490490
    491491            sage: K.<a> = GF(2^4)
    492492            sage: A = random_matrix(K, 50, 50)
    493493            sage: B = random_matrix(K, 50, 50)
    494             sage: A._multiply_travolta(B) == A._multiply_classical(B)
     494            sage: A._multiply_newton_john(B) == A._multiply_classical(B)
    495495            True
    496496
    497497            sage: K.<a> = GF(2^8)
    498498            sage: A = random_matrix(K, 50, 50)
    499499            sage: B = random_matrix(K, 50, 50)
    500             sage: A._multiply_travolta(B) == A._multiply_classical(B)
     500            sage: A._multiply_newton_john(B) == A._multiply_classical(B)
    501501            True
    502502
    503503            sage: K.<a> = GF(2^10)
    504504            sage: A = random_matrix(K, 50, 50)
    505505            sage: B = random_matrix(K, 50, 50)
    506             sage: A._multiply_travolta(B) == A._multiply_classical(B)
     506            sage: A._multiply_newton_john(B) == A._multiply_classical(B)
    507507            True
    508508        """
    509509        if self._ncols != right._nrows:
     
    516516            return ans
    517517
    518518        _sig_on
    519         ans._entries = mzed_mul_travolta(ans._entries, self._entries, (<Matrix_mod2e_dense>right)._entries)
     519        ans._entries = mzed_mul_newton_john(ans._entries, self._entries, (<Matrix_mod2e_dense>right)._entries)
    520520        _sig_off
    521521        return ans
    522522
     
    550550
    551551        TESTS::
    552552
    553             sage: K.<a> = GF(2^5)
     553            sage: K.<a> = GF(2^10)
    554554            sage: A = random_matrix(K, 50, 50)
    555555            sage: B = random_matrix(K, 50, 50)
    556556            sage: A._multiply_karatsuba(B) == A._multiply_classical(B)
    557557            Traceback (most recent call last):
    558558            ...
    559             NotImplementedError: Karatsuba multiplication is only implemented for matrices over GF(2^e) with e <= 4.
     559            NotImplementedError: Karatsuba multiplication is only implemented for matrices over GF(2^e) with e <= 8.
    560560        """
    561561        if self._ncols != right._nrows:
    562562            raise ArithmeticError("left ncols must match right nrows")
     
    577577
    578578    cpdef Matrix_mod2e_dense _multiply_strassen(Matrix_mod2e_dense self, Matrix_mod2e_dense right, cutoff=0):
    579579        """
    580         Winograd-Strassen matrix multiplication with Travolta
     580        Winograd-Strassen matrix multiplication with Newton-John
    581581        multiplication as base case.
    582582
    583583        INPUT:
    584584
    585585        - ``right`` - a matrix
    586586        - ``cutoff`` - row or column dimension to switch over to
    587           Travolta multiplication (default: 64)
     587          Newton-John multiplication (default: 64)
    588588
    589589        EXAMPLES::
    590590
     
    877877
    878878        - ``algorithm`` - one of the following
    879879          - ``heuristic`` - let M4RIE decide (default)
    880           - ``travolta`` - use travolta table based algorithm
     880          - ``newton_john`` - use newton_john table based algorithm
    881881          - ``ple`` - use PLE decomposition
    882882          - ``naive`` - use naive cubic Gaussian elimination (M4RIE implementation)
    883883          - ``builtin`` - use naive cubic Gaussian elimination (Sage implementation)
     
    904904            sage: MS = MatrixSpace(K,m,n)
    905905            sage: A = random_matrix(K, 3, 5)
    906906
    907             sage: copy(A).echelon_form('travolta')
     907            sage: copy(A).echelon_form('newton_john')
    908908            [          1           0           0         a^2     a^2 + 1]
    909909            [          0           1           0         a^2           1]
    910910            [          0           0           1 a^2 + a + 1       a + 1]
     
    940940            r =  mzed_echelonize_naive(self._entries, full)
    941941            _sig_off
    942942           
    943         elif algorithm == 'travolta':
     943        elif algorithm == 'newton_john':
    944944            _sig_on
    945             r =  mzed_echelonize_travolta(self._entries, full)
     945            r =  mzed_echelonize_newton_john(self._entries, full)
    946946            _sig_off
    947947           
    948948        elif algorithm == 'ple':
     
    10141014        A = Matrix_mod2e_dense.__new__(Matrix_mod2e_dense, self._parent, 0, 0, 0)
    10151015       
    10161016        if self._nrows and self._nrows == self._ncols:
    1017             mzed_invert_travolta(A._entries, self._entries)
     1017            mzed_invert_newton_john(A._entries, self._entries)
    10181018
    10191019        return A
    10201020