passagemath-m4ri-m4rie 10.8.1rc0__cp312-cp312-win_amd64.whl

passagemath_m4ri_m4rie/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie
+
+from sage.all__sagemath_m4ri_m4rie import *

passagemath_m4ri_m4rie-10.8.1rc0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.12.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-ki67ldfq\\cp312-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-vv', '--custom-patch', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-ki67ldfq\\cp312-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-ki67ldfq\\cp312-win_amd64\\built_wheel\\passagemath_m4ri_m4rie-10.8.1rc0-cp312-cp312-win_amd64.whl']

passagemath_m4ri_m4rie-10.8.1rc0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: passagemath-m4ri-m4rie
+Version: 10.8.1rc0
+Summary: passagemath: Linear Algebra with m4ri and m4rie
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/x-rst
+Requires-Dist: cysignals!=1.12.4; sys_platform == "win32"
+Requires-Dist: cysignals!=1.12.0,>=1.11.2
+Requires-Dist: memory_allocator<0.2
+Requires-Dist: passagemath-environment==10.8.1rc0
+Requires-Dist: passagemath-categories==10.8.1rc0
+Requires-Dist: passagemath-modules==10.8.1rc0
+Provides-Extra: test
+Requires-Dist: passagemath-repl; extra == "test"
+Requires-Dist: passagemath-pari; extra == "test"
+
+=================================================
+ passagemath: Linear Algebra with m4ri and m4rie
+=================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-m4ri-m4rie``
+provides modules that depend on the libraries
+`m4ri <https://bitbucket.org/malb/m4ri/src/master/>`_,
+`m4rie <https://bitbucket.org/malb/m4rie/src/master/>`_.
+
+
+What is included
+----------------
+
+- `Dense matrices over GF(2) using the M4RI library <https://passagemath.org/docs/latest/html/en/reference/matrices/sage/matrix/matrix_mod2_dense.html>`__
+
+- `Dense matrices over GF(2**e) for e from 2 to 16 using the M4RIE library <https://passagemath.org/docs/latest/html/en/reference/matrices/sage/matrix/matrix_gf2e_dense.html>`__
+
+- `Vectors with elements in GF(2) <https://passagemath.org/docs/latest/html/en/reference/modules/sage/modules/vector_mod2_dense.html>`__

passagemath_m4ri_m4rie-10.8.1rc0.dist-info/RECORD

@@ -0,0 +1,31 @@
+passagemath_m4ri_m4rie/__init__.py,sha256=iRfLnZs3v4u5SwObgolyWr6miv2UqImJqhQOhkkrHDA,94
+passagemath_m4ri_m4rie-10.8.1rc0.dist-info/DELVEWHEEL,sha256=OyLZs-GfH4471B6R_oOGGktshFnXI6DSfFZsMiaLtSw,444
+passagemath_m4ri_m4rie-10.8.1rc0.dist-info/METADATA,sha256=jwhBZPsybUatdR3NtD2i_vcpY5yiDrXR6coeD-yZRHg,5186
+passagemath_m4ri_m4rie-10.8.1rc0.dist-info/RECORD,,
+passagemath_m4ri_m4rie-10.8.1rc0.dist-info/top_level.txt,sha256=VYtehKnlOP033PAdgMHCtjdtvRhdEkQ1-gXJRPdVaOM,29
+passagemath_m4ri_m4rie-10.8.1rc0.dist-info/WHEEL,sha256=4SIlGrTWEevUMa-6zmQ9aBHcYatnnG9aOHYILIJiCXU,102
+passagemath_m4ri_m4rie.libs/libgd-3-c61e7774529134604ac795e62efaf403.dll,sha256=YwbA1innVct8Ixz51WZ4phPdTitjxXGtQSZrP8POhzA,1029367
+passagemath_m4ri_m4rie.libs/libgmp-10-794009e46893ff9a2414ad67e43fe75c.dll,sha256=eUAJ5GiT_5okFK1n5D_nXGqBOQjLrnzSAz4fr2uGCVk,3004991
+passagemath_m4ri_m4rie.libs/libiconv-2-ff31fa811f9c07cc7fdaa68c9e8bca3a.dll,sha256=_zH6gR-cB8x_2qaMnovKOntP324KB5pYF16li6E5x64,1136529
+passagemath_m4ri_m4rie.libs/libm4ri-2-9729666b38684339900e7e99b07c3429.dll,sha256=icnY62fxgNsZE4pnY7Sf32JRliHXBMOuJnEP7Qu6uy8,881994
+passagemath_m4ri_m4rie.libs/libm4rie-1-0fdffa6c128e9dab0da9764b26814f9c.dll,sha256=vOxsLHa0eRoCor7Bfbm-ejLLAZvIPVfAnCYjvEkh95w,2295991
+passagemath_m4ri_m4rie.libs/libpng16-16-435fb9547382c2a0ae933c65b9ae2dff.dll,sha256=5jLcBMxD92fXX7OuIr4Uz3C3JO2vW1gv09mTEzNsae0,1159070
+passagemath_m4ri_m4rie.libs/zlib1-fc169cee00e737ab1f0556b1f633363b.dll,sha256=_Bac7gDnN6sfBVax9jM2O8UmNLdj7hgnc_UyaQZt_7M,396070
+sage/all__sagemath_m4ri_m4rie.py,sha256=aRCLJjC8-R-Y7tdCGntbjUmD65xKi3ecqS1OCRiBw-8,374
+sage/libs/all__sagemath_m4ri_m4rie.py,sha256=L-17t91PRczBYPsQIj9LZALGVC4J78DQme9qg1zio_E,49
+sage/libs/m4ri.pxd,sha256=JVvhBpqVlRSCT5wAOiS7b2hVj9GCoPq5cj46hjfxaHU,5444
+sage/libs/m4rie.pxd,sha256=DsJxIv5ENOYSZvld2PGnj2hgBrgPMCkh3_R0Ebdn6kw,6632
+sage/matrix/all__sagemath_m4ri_m4rie.py,sha256=L-17t91PRczBYPsQIj9LZALGVC4J78DQme9qg1zio_E,49
+sage/matrix/matrix_gf2e_dense.cp312-win_amd64.pyd,sha256=LkpssqEKmaESfqsap6d71Rontutk3bTtDTyDqMGSOds,195072
+sage/matrix/matrix_gf2e_dense.pxd,sha256=Hfve_Glya4MAMcK78FSs8aMsPHLNuY1Qk7tdEFQuQZ8,592
+sage/matrix/matrix_gf2e_dense.pyx,sha256=aR17tglB0wNr8vrChFIg8cMtSa29YtaAF2SLLOCI4Jg,57966
+sage/matrix/matrix_mod2_dense.cp312-win_amd64.pyd,sha256=adE1fx40Axp9cW7cQVYiFwtUNC5vsGjVYJNtMCq4OLc,283136
+sage/matrix/matrix_mod2_dense.pxd,sha256=VsOtqaInYPWTGG8DgOc5I5FfSSmD2mnwuH-my4qI8Ms,524
+sage/matrix/matrix_mod2_dense.pyx,sha256=rJ3f4xqhBGjdR00ijX2QB3jyEu2JBAJFwjxq7_WjE0E,94053
+sage/modules/all__sagemath_m4ri_m4rie.py,sha256=L-17t91PRczBYPsQIj9LZALGVC4J78DQme9qg1zio_E,49
+sage/modules/numpy_util.cp312-win_amd64.pyd,sha256=YCV6QrukZPLk2CaitQpp8yOv00-RVuEHOMF45gU1F_A,179200
+sage/modules/numpy_util.pxd,sha256=YdZcgoaja4Ht4_Taz0vBQt4Bg3zlekCmIHTsAj9V4rI,493
+sage/modules/numpy_util.pyx,sha256=rVEfRaSoseNmJrmHqeVojJ8MNy4eLXJOFFSsyDW-BAg,4699
+sage/modules/vector_mod2_dense.cp312-win_amd64.pyd,sha256=H_gUDi77QbnBKYYbBjiE5PvYCkhdXjl1PuWTCa6vO00,107008
+sage/modules/vector_mod2_dense.pxd,sha256=yo5evcgW0iC-tMJsl2-9Rz32XDVMgYB0sVbkTRFYywQ,321
+sage/modules/vector_mod2_dense.pyx,sha256=hQJ8zWolq0AzPDBXaQet6lJPxTfbW4WNB043lBqWAZg,16481

passagemath_m4ri_m4rie-10.8.1rc0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

passagemath_m4ri_m4rie-10.8.1rc0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+
+passagemath_m4ri_m4rie
+sage

sage/all__sagemath_m4ri_m4rie.py

@@ -0,0 +1,11 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie
+# start delvewheel patch
+def _delvewheel_patch_1_12_0():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'passagemath_m4ri_m4rie.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_12_0()
+del _delvewheel_patch_1_12_0
+# end delvewheel patch

sage/libs/all__sagemath_m4ri_m4rie.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie

sage/libs/m4ri.pxd

@@ -0,0 +1,198 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie
+# distutils: extra_compile_args = -std=c++14
+# distutils: language = c++
+
+cdef extern from "m4ri/m4ri.h":
+    ctypedef int rci_t
+    ctypedef int wi_t
+    ctypedef unsigned long long m4ri_word "word"
+    ctypedef int BIT
+
+    ctypedef struct mzd_t:
+        rci_t nrows
+        rci_t ncols
+        wi_t width
+
+    ctypedef struct mzp_t:
+        rci_t *values
+        rci_t size
+
+    cdef int m4ri_radix
+
+    ##############
+    # Maintenance
+    ##############
+
+    # builds all gray codes up to a certain size
+    cdef void m4ri_build_all_codes()
+    cdef void m4ri_destroy_all_codes()
+
+    ##############
+    # Constructors
+    ##############
+
+    # create empty matrix
+    cdef mzd_t *mzd_init(rci_t , rci_t)
+
+    # create the identity permutation
+    cdef mzp_t *mzp_init(rci_t)
+
+    # free memory for the matrix
+    cdef void mzd_free(mzd_t *)
+
+    # free memory for the permutation
+    cdef void mzp_free(mzp_t *)
+
+    # filled uniformly random
+    cdef void mzd_randomize(mzd_t *)
+
+    # identity matrix if i%2
+    cdef void mzd_set_ui(mzd_t *, unsigned int )
+
+    # [A],[B] -> [AB]
+    cdef mzd_t *mzd_concat(mzd_t *, mzd_t *, mzd_t *)
+
+    # [A],[B] -> | A |
+    #            | B |
+    cdef mzd_t *mzd_stack(mzd_t *, mzd_t *, mzd_t *)
+
+    # returns a submatrix from a
+    cdef mzd_t *mzd_submatrix(mzd_t *, mzd_t *, rci_t lowr, rci_t lowc, rci_t highr, rci_t highc)
+
+    # return a matrix window to A
+    cdef mzd_t *mzd_init_window(mzd_t *, rci_t lowr, rci_t lowc, rci_t highr, rci_t highc)
+
+    cdef void mzd_free_window(mzd_t *)
+
+    # deep copy
+    cdef mzd_t *mzd_copy(mzd_t *, mzd_t *)
+
+    # printing
+    cdef void mzd_print(mzd_t *)
+
+    ##############
+    # Bit Level IO
+    ##############
+
+    # set BIT
+    cdef void mzd_write_bit( mzd_t *m, rci_t row, rci_t col, BIT value)
+
+    # get BIT
+    cdef BIT mzd_read_bit( mzd_t *m, rci_t row, rci_t col )
+
+    # get BITs (n<=64)
+    cdef m4ri_word mzd_read_bits( mzd_t *m, rci_t row, rci_t col, int n)
+
+    #####################
+    # Row/Column Based IO
+    #####################
+
+    cdef m4ri_word *mzd_row(mzd_t *, rci_t)
+
+    cdef void mzd_row_swap(mzd_t *, rci_t, rci_t)
+
+    cdef void mzd_col_swap(mzd_t *, rci_t, rci_t)
+
+    cdef void mzd_row_clear_offset(mzd_t *m, rci_t, rci_t)
+
+    cdef void mzd_row_add_offset(mzd_t *m, rci_t, rci_t, rci_t)
+
+    ############
+    # Arithmetic
+    ############
+
+    # matrix addition
+    cdef mzd_t *mzd_add(mzd_t *, mzd_t *, mzd_t *)
+
+    # naive cubic matrix multiply
+    cdef mzd_t *mzd_mul_naive(mzd_t *, mzd_t *, mzd_t *)
+
+    # naive cubic matrix multiply (b is pre-transposed)
+    cdef mzd_t *_mzd_mul_naive(mzd_t *, mzd_t *, mzd_t *, int)
+
+    # matrix multiply using Gray codes
+    cdef mzd_t *mzd_mul_m4rm(mzd_t *, mzd_t *, mzd_t *, int k)
+
+    # matrix multiply using Gray codes (transposed)
+    cdef mzd_t *mzd_mul_m4rm_t(mzd_t *, mzd_t *, mzd_t *, int k)
+
+    # matrix multiply and addition using Gray codes: C = C + AB
+    cdef mzd_t *mzd_addmul_m4rm(mzd_t *, mzd_t *, mzd_t *, int k)
+
+    # matrix multiplication via Strassen's formula
+    cdef mzd_t *mzd_mul(mzd_t *, mzd_t *, mzd_t *, int cutoff)
+
+    # C = C + AB via Strassen's formula
+    cdef mzd_t *mzd_addmul(mzd_t *, mzd_t *, mzd_t *, int cutoff)
+
+    # equality testing
+    cdef int mzd_equal(mzd_t *, mzd_t *)
+
+    # returns -1,0,1
+    cdef int mzd_cmp(mzd_t *, mzd_t *)
+
+    # transpose
+    cdef mzd_t *mzd_transpose(mzd_t *, mzd_t *)
+
+    # density with given resolution
+    cdef double mzd_density(mzd_t *, int resolution)
+
+    ########################
+    # LAPACK Level Functions
+    ########################
+
+    # cubic Gaussian elimination
+    cdef int mzd_echelonize_naive(mzd_t *, int full)
+
+    # row echelon form using Gray codes
+    cdef int mzd_echelonize_m4ri(mzd_t *m, int full, int k)
+
+    # reduced row echelon form from upper triangular form
+    cdef void mzd_top_echelonize_m4ri(mzd_t *m, int k)
+
+    # heuristic choice of algorithms
+    cdef int mzd_echelonize(mzd_t *m, int full)
+
+    # matrix inversion using Gray codes
+    cdef mzd_t *mzd_inv_m4ri(mzd_t *dst, mzd_t *src, int k)
+
+    # asymptotically fast PLUQ factorization
+    cdef long mzd_pluq(mzd_t *A, mzp_t *P, mzp_t *Q, int cutoff)
+
+    # PLUQ factorization using Gray codes
+    cdef long _mzd_pluq_russian(mzd_t *A, mzp_t *P, mzp_t *Q, int k)
+
+    # cubic PLUQ factorization
+    cdef long _mzd_pluq_naive(mzd_t *A, mzp_t *P, mzp_t *Q)
+
+    # asymptotically fast PLS factorization
+    cdef long mzd_ple(mzd_t *A, mzp_t *P, mzp_t *Q, int cutoff)
+
+    # PLS factorization using Gray codes
+    cdef long _mzd_ple_russian(mzd_t *A, mzp_t *P, mzp_t *Q, int k)
+
+    # cubic PLS factorization
+    cdef long _mzd_ple_naive(mzd_t *A, mzp_t *P, mzp_t *Q)
+
+    # reduced row echelon form using PLUQ factorization
+    cdef long mzd_echelonize_pluq(mzd_t *A, int full)
+
+    # reduced row echelon form using PLUQ factorization
+    cdef mzd_t *mzd_kernel_left_pluq(mzd_t *A, int cutoff)
+
+    # system solving
+    cdef int mzd_solve_left(mzd_t *A, mzd_t *B, int cutoff, int inconsistency_check)
+
+    ########################
+    # Bit operations
+    ########################
+
+    cdef m4ri_word __M4RI_LEFT_BITMASK(int)
+
+    cdef m4ri_word m4ri_swap_bits(m4ri_word)
+
+    ##################################
+    # Internal Functions for Debugging
+    ##################################
+
+    cdef void mzd_clear_bits(mzd_t *m, int x, int y, int n)

sage/libs/m4rie.pxd

@@ -0,0 +1,206 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie
+# distutils: extra_compile_args = -std=c++14
+##############################################################################
+#       Copyright (C) 2010 Martin Albrecht <martinralbrecht@googlemail.com>
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+##############################################################################
+
+from sage.libs.m4ri cimport mzd_t, m4ri_word, mzp_t
+
+
+cdef extern from "m4rie/m4rie.h":
+    ctypedef struct gf2e:
+        int degree
+        m4ri_word minpoly
+
+        m4ri_word *pow_gen
+        m4ri_word *red
+
+        m4ri_word (*inv)(gf2e *ff, m4ri_word a)
+        m4ri_word (*mul)(gf2e *ff, m4ri_word a, m4ri_word b)
+
+    gf2e *gf2e_init(m4ri_word minpoly)
+    void gf2e_free(gf2e *ff)
+
+#cdef extern from "m4rie/mzed.h":
+    ctypedef struct mzed_t:
+        mzd_t *x
+        gf2e *finite_field
+        int nrows
+        int ncols
+        int w
+
+    ctypedef int const_int "const int"
+    ctypedef size_t const_size_t "const size_t"
+    ctypedef mzed_t const_mzed_t "const mzed_t"
+
+    mzed_t *mzed_init(gf2e *, size_t m, size_t n)
+
+    void mzed_free(mzed_t *)
+
+    int mzed_read_elem(const_mzed_t *M, const_size_t row, const_size_t col)
+
+    void mzed_write_elem(mzed_t *, const_size_t row, const_size_t col, const_int elem)
+
+    void mzed_set_ui(mzed_t *A, m4ri_word value)
+
+    mzed_t *mzed_copy(mzed_t *o, const_mzed_t *i)
+
+    int mzed_cmp(mzed_t *l, mzed_t *r)
+
+    mzed_t *mzed_randomize(mzed_t *)
+
+    mzed_t *mzed_add(mzed_t *, mzed_t *, mzed_t *)
+
+    size_t mzed_echelonize_naive(mzed_t *, size_t)
+
+    void mzed_add_elem(mzed_t *a, const_size_t row, const_size_t col, const_int elem)
+
+    void mzed_add_multiple_of_row(mzed_t *A, size_t ar, mzed_t *B, size_t br, m4ri_word x, size_t start_col)
+
+    void mzed_rescale_row(mzed_t *A, size_t r, size_t c, m4ri_word x)
+
+    void mzed_row_swap(mzed_t *M, const_size_t rowa, const_size_t rowb)
+
+    void mzed_copy_row(mzed_t* B, size_t i, const_mzed_t* A, size_t j)
+
+    void mzed_col_swap(mzed_t *M, const_size_t cola, const_size_t colb)
+
+    void mzed_row_add(mzed_t *M, const_size_t sourcerow, const_size_t destrow)
+
+    size_t mzed_first_zero_row(mzed_t *A)
+
+    int mzed_is_zero(mzed_t *A)
+
+    void mzed_row_clear_offset(mzed_t *M, const_size_t row, const_size_t coloffset)
+
+    mzed_t *mzed_concat(mzed_t *C, const_mzed_t *A, const_mzed_t *B)
+
+    mzed_t *mzed_stack(mzed_t *C, const_mzed_t *A, const_mzed_t *B)
+
+    mzed_t *mzed_submatrix(mzed_t *S, const_mzed_t *M, size_t lowr, size_t lowc, size_t highr, size_t highc)
+
+    mzed_t *mzed_mul(mzed_t *C, const_mzed_t *A, const_mzed_t *B)
+
+    mzed_t *mzed_mul_naive(mzed_t *C, const_mzed_t *A, const_mzed_t *B)
+
+    mzed_t *mzed_mul_scalar(mzed_t *C, m4ri_word a, const_mzed_t *B)
+
+    # TODO: not implemented yet in m4rie
+    mzed_t *mzed_transpose(mzed_t *DST, const_mzed_t *A )
+
+    void mzed_print(const_mzed_t *M)
+
+    mzed_t *mzed_invert_newton_john(mzed_t *A, mzed_t *B)
+
+    # TODO: not implemented yet in m4rie
+    double mzed_density(mzed_t *A, int res)
+
+    # TODO: not implemented yet in m4rie
+    double _mzed_density(mzed_t *A, int res, size_t r, size_t c)
+
+#cdef extern from "m4rie/newton_john.h":
+    size_t mzed_echelonize_newton_john(mzed_t *, size_t)
+
+    mzed_t *mzed_mul_newton_john(mzed_t *, mzed_t *, mzed_t *)
+
+#cdef extern from "m4rie/echelonform.h":
+    size_t mzed_echelonize(mzed_t *, size_t)
+
+    size_t mzed_echelonize_ple(mzed_t *, size_t)
+
+    int mzed_ple(mzed_t *A, mzp_t *P, mzp_t *Q)
+
+#cdef extern from "m4rie/strassen.h":
+    mzed_t *mzed_mul_strassen(mzed_t *, mzed_t *, mzed_t *, size_t cutoff)
+
+    size_t _mzed_strassen_cutoff(mzed_t *C, mzed_t *A, mzed_t *B)
+
+#cdef extern from "m4rie/mzd_slice.h":
+
+    int __M4RIE_MAX_KARATSUBA_DEGREE
+
+    ctypedef struct mzd_slice_t:
+        mzd_t *x[16]
+        gf2e *finite_field
+        int nrows
+        int ncols
+        int depth
+
+    mzd_slice_t *mzd_slice_init(gf2e *ff, size_t m, size_t n)
+
+    void mzd_slice_free(mzd_slice_t *A)
+
+    mzed_t *mzed_cling(mzed_t *A, mzd_slice_t *Z)
+
+    mzd_slice_t *mzed_slice(mzd_slice_t *A, mzed_t *Z)
+
+    mzd_slice_t *mzd_slice_concat(mzd_slice_t *C, mzd_slice_t *A, mzd_slice_t *B)
+
+    mzd_slice_t *mzd_slice_stack(mzd_slice_t *C, mzd_slice_t *A, mzd_slice_t *B)
+
+    mzd_slice_t *mzd_slice_submatrix(mzd_slice_t *S, mzd_slice_t *A, size_t lowr, size_t lowc, size_t highr, size_t highc)
+
+    mzd_slice_t *mzd_slice_init_window(mzd_slice_t *A, size_t lowr, size_t lowc, size_t highr, size_t highc)
+
+    void mzd_slice_free_window(mzd_slice_t *A)
+
+    mzd_slice_t *_mzd_slice_add(mzd_slice_t *C, mzd_slice_t *A, mzd_slice_t *B)
+
+    mzd_slice_t *mzd_slice_add(mzd_slice_t *C, mzd_slice_t *A, mzd_slice_t *B)
+
+    void mzd_slice_randomize(mzd_slice_t *A)
+
+    mzd_slice_t *mzd_slice_copy(mzd_slice_t *B, mzd_slice_t *A)
+
+    void mzd_slice_set_ui(mzd_slice_t *A, m4ri_word value)
+
+    m4ri_word mzd_slice_read_elem(mzd_slice_t *A, size_t row, size_t col)
+
+    void mzd_slice_add_elem(mzd_slice_t *A, size_t row, size_t col, m4ri_word elem)
+
+    void mzd_slice_write_elem(mzd_slice_t *A, size_t row, size_t col, m4ri_word elem)
+
+    int mzd_slice_cmp(mzd_slice_t *A, mzd_slice_t *B)
+
+    int mzd_slice_is_zero(mzd_slice_t *A)
+
+    void mzd_slice_rescale_row(mzd_slice_t *A, size_t r, size_t c, m4ri_word x)
+
+    void mzd_slice_row_swap(mzd_slice_t *A, size_t rowa, size_t rowb)
+
+    void mzd_slice_copy_row(mzd_slice_t* B, size_t i, mzd_slice_t* A, size_t j)
+
+    void mzd_slice_col_swap(mzd_slice_t *A, size_t cola, size_t colb)
+
+    void mzd_slice_row_add(mzd_slice_t *A, size_t sourcerow, size_t destrow)
+
+    void mzd_slice_row_clear_offset(mzd_slice_t *A, size_t row, size_t coloffset)
+
+    void mzd_slice_print(mzd_slice_t *A)
+
+    mzd_slice_t *_mzed_slice2(mzd_slice_t *A, mzed_t *Z)
+
+    mzd_slice_t *mzed_slice2(mzd_slice_t *A, mzed_t *Z)
+
+    mzd_slice_t *_mzed_slice4(mzd_slice_t *A, mzed_t *Z)
+
+    mzed_t *_mzed_cling2(mzed_t *A, mzd_slice_t *Z)
+
+    mzed_t* mzed_cling2(mzed_t *A, mzd_slice_t *Z)
+
+    mzed_t *_mzed_cling4(mzed_t *A, mzd_slice_t *Z)
+
+    mzed_t* mzed_cling4(mzed_t *A, mzd_slice_t *Z)
+
+    mzed_t *mzed_mul_karatsuba(mzed_t *C, mzed_t *A, mzed_t *B)
+
+    mzed_t *mzed_addmul_karatsuba(mzed_t *C, mzed_t *A, mzed_t *B)
+
+    mzed_t *_mzed_mul_karatsuba(mzed_t *C, mzed_t *A, mzed_t *B)
+
+    mzd_slice_t *_mzd_slice_mul_karatsuba2(mzd_slice_t *C, mzd_slice_t *A, mzd_slice_t *B)
+
+    mzd_slice_t *_mzd_slice_mul_karatsuba3(mzd_slice_t *C, mzd_slice_t *A, mzd_slice_t *B)

sage/matrix/all__sagemath_m4ri_m4rie.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie

sage/matrix/matrix_gf2e_dense.pxd

@@ -0,0 +1,14 @@
+# sage_setup: distribution = sagemath-m4ri-m4rie
+from sage.libs.m4rie cimport mzed_t
+from sage.libs.m4ri cimport m4ri_word
+from sage.matrix.matrix_dense cimport Matrix_dense
+
+
+cdef class Matrix_gf2e_dense(Matrix_dense):
+    cdef mzed_t *_entries
+    cdef object _one
+    cdef object _zero
+
+    cpdef Matrix_gf2e_dense _multiply_newton_john(Matrix_gf2e_dense self, Matrix_gf2e_dense right)
+    cpdef Matrix_gf2e_dense _multiply_karatsuba(Matrix_gf2e_dense self, Matrix_gf2e_dense right)
+    cpdef Matrix_gf2e_dense _multiply_strassen(Matrix_gf2e_dense self, Matrix_gf2e_dense right, cutoff=*)