passagemath-linbox 10.6.43__cp313-cp313-macosx_13_0_arm64.whl

sage/libs/linbox/linbox.pxd

@@ -0,0 +1,219 @@
+# sage_setup: distribution = sagemath-linbox
+# distutils: extra_compile_args = LINBOX_CFLAGS -std=gnu++14
+# distutils: include_dirs = LINBOX_INCDIR
+# distutils: libraries = LINBOX_LIBRARIES
+# distutils: library_dirs = LINBOX_LIBDIR
+# distutils: extra_link_args = LINBOX_LIBEXTRA
+# distutils: language = c++
+
+from libc.stdint cimport uint32_t, uint64_t
+from libcpp.vector cimport vector as cppvector
+
+from sage.libs.linbox.givaro cimport *
+
+cdef extern from "linbox/matrix/dense-matrix.h":
+    ## template <class _Field, class _blasRep=typename Vector<_Field>::Dense >
+    ## class DenseMatrix ;
+    ##
+    ## template <class _Field>
+    ## using DenseMatrix = DenseMatrix<_Field> ;
+    cdef cppclass DenseMatrix_integer "LinBox::DenseMatrix<Givaro::ZRing<Givaro::Integer>>":
+        ctypedef ZRing Field
+        ctypedef Integer Element
+        DenseMatrix_integer(Field &F, size_t m, size_t n)
+        size_t rowdim()
+        size_t coldim()
+        void setEntry(size_t i, size_t j, Element &a)
+        Element &getEntry(size_t i, size_t j)
+        Field& field()
+
+        ostream& write(ostream&)
+
+    cdef cppclass DenseMatrix_Modular_double "LinBox::DenseMatrix<Givaro::Modular<double>>":
+        ctypedef Modular_double Field
+        ctypedef double Element
+        DenseMatrix_Modular_double(Field F, size_t m, size_t n)
+        void setEntry(size_t i, size_t j, Element& a)
+        Element &getEntry(size_t i, size_t j)
+
+        ostream& write(ostream&)
+
+    cdef cppclass DenseMatrix_Modular_float "LinBox::DenseMatrix<Givaro::Modular<float>>":
+        ctypedef Modular_float Field
+        ctypedef float Element
+        DenseMatrix_Modular_float(Field F, size_t m, size_t n)
+        void setEntry(size_t i, size_t j, Element& a)
+        Element &getEntry(size_t i, size_t j)
+
+        ostream& write(ostream&)
+
+cdef extern from "linbox/matrix/sparse-matrix.h":
+    ## template<class _Field, class _Storage = SparseMatrixFormat::SparseSeq >
+    ## class SparseMatrix ;
+    cdef cppclass SparseMatrix_integer "LinBox::SparseMatrix<Givaro::ZRing<Givaro::Integer>>":
+        ctypedef ZRing Field
+        ctypedef Integer Element
+        SparseMatrix_integer(Field &F, size_t m, size_t n)
+        size_t rowdim()
+        size_t coldim()
+        void setEntry(size_t i, size_t j, Element &a)
+        Element &getEntry(size_t i, size_t j)
+        Field& field()
+
+        ostream& write(ostream&)
+
+    cdef cppclass SparseMatrix_Modular_uint64 "LinBox::SparseMatrix<Givaro::Modular<uint64_t>, LinBox::SparseMatrixFormat::SparseSeq>":
+        ctypedef Modular_uint64 Field
+        ctypedef uint64_t Element
+        SparseMatrix_Modular_uint64(Field &F, size_t m, size_t n)
+        SparseMatrix_Modular_uint64(SparseMatrix_Modular_uint64&)
+        size_t rowdim()
+        size_t coldim()
+        void setEntry(size_t i, size_t j, Element &a)
+        Element &getEntry(size_t i, size_t j)
+        Field& field()
+
+        ostream& write(ostream&)
+
+cdef extern from "linbox/polynomial/dense-polynomial.h":
+    ## template<class Field>
+    ## class DensePolynomial : public Givaro::Poly1FactorDom<Field, Givaro::Dense>::Element
+    cdef cppclass DensePolynomial_integer "LinBox::DensePolynomial<Givaro::ZRing<Givaro::Integer>>":
+        ctypedef ZRing BaseRing
+        ctypedef Integer BaseRingElement
+        DensePolynomial_integer(BaseRing &F)
+        DensePolynomial_integer(BaseRing &F, size_t s)
+        BaseRingElement& operator[](size_t i)
+        size_t size()
+
+cdef extern from "linbox/ring/polynomial-ring.h":
+    ## template <class BaseRing, class StorageTag= Givaro::Dense>
+    ## class PolynomialRing : public Givaro::Poly1FactorDom<BaseRing,StorageTag>
+    cdef cppclass PolynomialRing_integer "LinBox::PolynomialRing<Givaro::ZRing<Givaro::Integer>, Givaro::Dense>":
+        ctypedef DensePolynomial_integer Element
+        ctypedef DensePolynomial_integer Polynomial
+
+cdef extern from "linbox/vector/vector.h":
+    cdef cppclass DenseVector_integer "LinBox::DenseVector<Givaro::ZRing<Givaro::Integer>>":
+        ctypedef ZRing Field
+        ctypedef Integer Element
+        DenseVector_integer (Field &F)
+        DenseVector_integer (Field &F, long& m)
+        DenseVector_integer (Field &F, cppvector[Integer]&)
+        size_t size()
+        void resize(size_t)
+        void resize(size_t n, const Element&)
+        void push_back(Element&)
+        void clear()
+        void reserve(const size_t&)
+        void setEntry(size_t i, Element&)
+        Element& getEntry(size_t i)
+
+cdef extern from "linbox/matrix/matrix-domain.h":
+    ## template <class Field_ >
+    ## class MatrixDomain : public MVProductDomain<Field_> {
+    cdef cppclass MatrixDomain_integer "LinBox::MatrixDomain<Givaro::ZRing<Givaro::Integer>>":
+        MatrixDomain_integer(ZRing&)
+        DenseMatrix_integer& mul(DenseMatrix_integer ans,
+                                      DenseMatrix_integer left,
+                                      DenseMatrix_integer right)
+
+cdef extern from "linbox/solutions/methods.h" namespace "LinBox":
+    cdef struct HybridSpecifier:
+        pass
+    cdef struct BlackboxSpecifier:
+        pass
+    cdef struct EliminationSpecifier:
+        pass
+    cdef struct WiedemannTraits:
+        pass
+    cdef struct DenseEliminationTraits:
+        pass
+    cdef struct SparseEliminationTraits:
+        pass
+
+    cdef cppclass Method:
+        ctypedef HybridSpecifier Hybrid
+        ctypedef BlackboxSpecifier Blackbox
+        ctypedef EliminationSpecifier Elimination
+        ctypedef WiedemannTraits Wiedemann
+        ctypedef DenseEliminationTraits DenseElimination
+        ctypedef SparseEliminationTraits SparseElimination
+
+cdef extern from "linbox/solutions/charpoly.h" namespace "LinBox":
+    PolynomialRing_integer.Element& charpoly (PolynomialRing_integer.Element&, DenseMatrix_integer&)
+    PolynomialRing_integer.Element& charpoly (PolynomialRing_integer.Element&, SparseMatrix_integer&)
+
+cdef extern from "linbox/solutions/minpoly.h" namespace "LinBox":
+    PolynomialRing_integer.Element& minpoly (PolynomialRing_integer.Element&, DenseMatrix_integer&)
+    PolynomialRing_integer.Element& minpoly (PolynomialRing_integer.Element&, SparseMatrix_integer&)
+
+cdef extern from "linbox/algorithms/gauss.h":
+    cdef cppclass GaussDomain_Modular_uint64 "LinBox::GaussDomain<Givaro::Modular<uint64_t>>":
+        ctypedef Modular_uint64 Field
+        ctypedef uint64_t Element
+        GaussDomain_Modular_uint64(Field &)
+        unsigned long& InPlaceLinearPivoting(unsigned long &rank,
+                                             Element& determinant,
+                                             SparseMatrix_Modular_uint64 &A,
+                                             unsigned long Ni,
+                                             unsigned long Nj)
+
+cdef extern from "linbox/solutions/echelon.h" namespace "LinBox":
+    size_t rowEchelon (DenseMatrix_Modular_float&, const DenseMatrix_Modular_float&)
+    size_t rowEchelonize (DenseMatrix_Modular_float&)
+    size_t reducedRowEchelon (DenseMatrix_Modular_float&, const DenseMatrix_Modular_float&)
+    size_t reducedRowEchelonize (DenseMatrix_Modular_float&)
+    size_t colEchelon (DenseMatrix_Modular_float&, const DenseMatrix_Modular_float&)
+    size_t colEchelonize (DenseMatrix_Modular_float&)
+    size_t reducedColEchelon (DenseMatrix_Modular_float&, const DenseMatrix_Modular_float&)
+    size_t reducedColEchelonize (DenseMatrix_Modular_float&)
+
+    size_t rowEchelon (DenseMatrix_Modular_double&, const DenseMatrix_Modular_double&)
+    size_t rowEchelonize (DenseMatrix_Modular_double&)
+    size_t reducedRowEchelon (DenseMatrix_Modular_double&, const DenseMatrix_Modular_double&)
+    size_t reducedRowEchelonize (DenseMatrix_Modular_double&)
+    size_t colEchelon (DenseMatrix_Modular_double&, const DenseMatrix_Modular_double&)
+    size_t colEchelonize (DenseMatrix_Modular_double&)
+    size_t reducedColEchelon (DenseMatrix_Modular_double&, const DenseMatrix_Modular_double&)
+    size_t reducedColEchelonize (DenseMatrix_Modular_double&)
+
+cdef extern from "linbox/solutions/rank.h" namespace "LinBox":
+    unsigned long & rank (unsigned long&, DenseMatrix_integer)
+    unsigned long & rank (unsigned long&, SparseMatrix_integer)
+
+cdef extern from "linbox/solutions/det.h" namespace "LinBox":
+    Integer& det (Integer&, DenseMatrix_integer)
+    Integer& det (Integer&, SparseMatrix_integer)
+
+cdef extern from "linbox/solutions/solve.h" namespace "LinBox":
+    # integer solve
+
+    DenseVector_integer& solve (DenseVector_integer &,
+                                Integer &,
+                                SparseMatrix_integer &,
+                                DenseVector_integer &,
+                                Method.DenseElimination) except +
+
+    DenseVector_integer& solve (DenseVector_integer &,
+                                Integer &,
+                                SparseMatrix_integer &,
+                                DenseVector_integer &,
+                                Method.SparseElimination) except +
+
+    DenseVector_integer& solve (DenseVector_integer &,
+                                Integer &,
+                                SparseMatrix_integer &,
+                                DenseVector_integer &,
+                                Method.Blackbox) except +
+
+    DenseVector_integer& solve (DenseVector_integer &,
+                                Integer &,
+                                SparseMatrix_integer &,
+                                DenseVector_integer &,
+                                Method.Wiedemann) except +
+
+    DenseVector_integer& solve (DenseVector_integer &,
+                                Integer &,
+                                SparseMatrix_integer &,
+                                DenseVector_integer &)

sage/libs/linbox/linbox_flint_interface.pxd

@@ -0,0 +1,18 @@
+# sage_setup: distribution = sagemath-linbox
+
+from sage.libs.flint.types cimport fmpz_t, fmpz_mat_t, fmpz_poly_t
+
+# set C <- A * B
+cdef void linbox_fmpz_mat_mul(fmpz_mat_t C, fmpz_mat_t A, fmpz_mat_t B) noexcept
+
+# set cp to the characteristic polynomial of A
+cdef void linbox_fmpz_mat_charpoly(fmpz_poly_t cp, fmpz_mat_t A) noexcept
+
+# set mp to the minimal polynomial of A
+cdef void linbox_fmpz_mat_minpoly(fmpz_poly_t mp, fmpz_mat_t A) noexcept
+
+# return the rank of A
+cdef size_t linbox_fmpz_mat_rank(fmpz_mat_t A) noexcept
+
+# set det to the determinant of A
+cdef void linbox_fmpz_mat_det(fmpz_t det, fmpz_mat_t A) noexcept

sage/libs/linbox/linbox_flint_interface.pyx

@@ -0,0 +1,192 @@
+# sage_setup: distribution = sagemath-linbox
+# distutils: libraries = LINBOX_LIBRARIES
+# distutils: library_dirs = LINBOX_LIBDIR
+# distutils: extra_link_args = LINBOX_LIBEXTRA
+r"""
+Interface between flint matrices and linbox
+
+This module only contains C++ code (and the interface is fully C
+compatible). It basically contains what used to be in the LinBox
+source code under interfaces/sage/linbox-sage.C written by M. Albrecht
+and C. Pernet. The functions available are:
+
+- ``void  linbox_fmpz_mat_mul(fmpz_mat_t C, fmpz_mat_t A, fmpz_mat_t B)``: set
+  ``C`` to be the result of the multiplication ``A * B``
+
+- ``void linbox_fmpz_mat_charpoly(fmpz_poly_t cp, fmpz_mat_t A)``: set ``cp``
+  to be the characteristic polynomial of the square matrix ``A``
+
+- ``void  linbox_fmpz_mat_minpoly(fmpz_poly_t mp, fmpz_mat_t A)``: set ``mp``
+  to be the minimal polynomial of the square matrix ``A``
+
+- ``size_t linbox_fmpz_mat_rank(fmpz_mat_t A)``: return the rank of the
+  matrix ``A``
+
+- ``void linbox_fmpz_mat_det(fmpz_t det, fmpz_mat_t A)``: set ``det`` to the
+  determinant of the square matrix ``A``
+"""
+# ****************************************************************************
+#       Copyright (C) 2007 Martin Albrecht
+#       Copyright (C) 2008 Clement Pernet
+#       Copyright (C) 2017-2018 Vincent Delecroix
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.libs.gmp.types cimport mpz_t
+from sage.libs.flint.types cimport fmpz_t
+from sage.libs.flint.fmpz cimport fmpz_get_mpz, fmpz_set_mpz
+from sage.libs.flint.fmpz_mat cimport fmpz_mat_entry, fmpz_mat_nrows, fmpz_mat_ncols
+from sage.libs.flint.fmpz_poly cimport fmpz_poly_fit_length, _fmpz_poly_set_length
+from sage.libs.flint.fmpz_poly_sage cimport fmpz_poly_set_coeff_mpz
+
+cimport sage.libs.linbox.givaro as givaro
+cimport sage.libs.linbox.linbox as linbox
+from sage.libs.linbox.linbox cimport PolynomialRing_integer
+
+
+cdef void fmpz_mat_get_linbox(linbox.DenseMatrix_integer& A, fmpz_mat_t m) noexcept:
+    r"""
+    Set the entries of A from m (no allocation performed).
+
+    NOTE: this function does not appear in the Cython header
+    (the .pxd file) in order to keep the header C-compatible
+    """
+    cdef size_t i,j
+    cdef givaro.Integer t
+
+    for i in range(fmpz_mat_nrows(m)):
+        for j in range(fmpz_mat_ncols(m)):
+            fmpz_get_mpz(t.get_mpz(), fmpz_mat_entry(m, i, j))
+            A.setEntry(i, j, t)
+
+
+cdef void fmpz_mat_set_linbox(fmpz_mat_t m, linbox.DenseMatrix_integer& A) noexcept:
+    r"""
+    Set the entries of m from A (no allocation performed).
+
+    NOTE: this function does not appear in the Cython header
+    (the .pxd file) in order to keep the header C-compatible
+    """
+    cdef size_t i,j
+    for i in range(A.rowdim()):
+        for j in range(A.coldim()):
+            fmpz_set_mpz(fmpz_mat_entry(m, i, j), A.getEntry(i, j).get_mpz_const())
+
+
+cdef void fmpz_poly_set_linbox(fmpz_poly_t p, PolynomialRing_integer.Element& q) noexcept:
+    r"""
+    Set the entries of the polynomial p from q (no allocation performed).
+
+    NOTE: this function does not appear in the Cython header
+    (the .pxd file) in order to keep the header C-compatible
+    """
+    cdef size_t i
+    cdef mpz_t tmp
+
+    fmpz_poly_fit_length(p, q.size())
+
+    for i in range(q.size()):
+        tmp = q[i].get_mpz_const()
+        fmpz_poly_set_coeff_mpz(p, i, tmp)
+
+    _fmpz_poly_set_length(p, q.size())
+
+
+cdef void linbox_fmpz_mat_mul(fmpz_mat_t C, fmpz_mat_t A, fmpz_mat_t B) noexcept:
+    r"""
+    Set C to be A * B.
+    """
+    cdef givaro.ZRing ZZ
+    cdef linbox.DenseMatrix_integer *LBA
+    cdef linbox.DenseMatrix_integer *LBB
+    cdef linbox.DenseMatrix_integer *LBC
+    cdef linbox.MatrixDomain_integer * MD
+
+    LBA = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(A), fmpz_mat_ncols(A))
+    fmpz_mat_get_linbox(LBA[0], A)
+
+    LBB = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(B), fmpz_mat_ncols(B))
+    fmpz_mat_get_linbox(LBB[0], B)
+
+    LBC = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(A), fmpz_mat_ncols(B))
+
+    MD = new linbox.MatrixDomain_integer(ZZ)
+    MD.mul(LBC[0], LBA[0], LBB[0])
+
+    del MD
+
+    fmpz_mat_set_linbox(C, LBC[0])
+
+
+cdef void linbox_fmpz_mat_charpoly(fmpz_poly_t cp, fmpz_mat_t A) noexcept:
+    r"""
+    Set cp to the characteristic polynomial of A.
+    """
+    cdef givaro.ZRing ZZ
+    cdef linbox.DenseMatrix_integer * LBA
+    cdef linbox.DensePolynomial_integer * m_A
+
+    LBA = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(A), fmpz_mat_ncols(A))
+    fmpz_mat_get_linbox(LBA[0], A)
+    m_A = new linbox.DensePolynomial_integer(ZZ, fmpz_mat_nrows(A))
+    linbox.charpoly(m_A[0], LBA[0])
+    fmpz_poly_set_linbox(cp, m_A[0])
+
+    del LBA
+    del m_A
+
+
+cdef void linbox_fmpz_mat_minpoly(fmpz_poly_t mp, fmpz_mat_t A) noexcept:
+    r"""
+    Set mp to the minimal polynomial of A.
+    """
+    cdef givaro.ZRing ZZ
+    cdef linbox.DenseMatrix_integer * LBA
+    cdef linbox.DensePolynomial_integer * m_A
+
+    LBA = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(A), fmpz_mat_ncols(A))
+    m_A = new linbox.DensePolynomial_integer(ZZ)
+    fmpz_mat_get_linbox(LBA[0], A)
+    linbox.minpoly(m_A[0], LBA[0])
+    fmpz_poly_set_linbox(mp, m_A[0])
+
+    del LBA
+    del m_A
+
+
+cdef size_t linbox_fmpz_mat_rank(fmpz_mat_t A) noexcept:
+    r"""
+    Return the rank of A
+    """
+    cdef givaro.ZRing ZZ
+    cdef linbox.DenseMatrix_integer * LBA
+    cdef size_t r = 0
+
+    LBA = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(A), fmpz_mat_ncols(A))
+    fmpz_mat_get_linbox(LBA[0], A)
+    linbox.rank(r, LBA[0])
+
+    del LBA
+
+    return r
+
+
+cdef void linbox_fmpz_mat_det(fmpz_t det, fmpz_mat_t A) noexcept:
+    r"""
+    Set det to the determinant of A.
+    """
+    cdef givaro.ZRing ZZ
+    cdef linbox.DenseMatrix_integer * LBA
+    cdef givaro.Integer d
+
+    LBA = new linbox.DenseMatrix_integer(ZZ, fmpz_mat_nrows(A), fmpz_mat_ncols(A))
+    fmpz_mat_get_linbox(LBA[0], A)
+    linbox.det(d, LBA[0])
+    fmpz_set_mpz(det, d.get_mpz_const())
+
+    del LBA

sage/libs/m4ri.pxd

@@ -0,0 +1,198 @@
+# sage_setup: distribution = sagemath-linbox
+# 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)