passagemath-linbox 10.6.43__cp313-cp313-macosx_13_0_arm64.whl

sage/geometry/integral_points_integer_dense.pyx

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-linbox
+# cython: wraparound=False, boundscheck=False
+
+from sage.modules.vector_integer_dense cimport Vector_integer_dense as VectorClass
+from sage.matrix.matrix_integer_dense cimport Matrix_integer_dense as MatrixClass
+
+include "integral_points.pxi"

sage/libs/all__sagemath_linbox.py

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

sage/libs/iml.pxd

@@ -0,0 +1,10 @@
+# sage_setup: distribution = sagemath-linbox
+from sage.libs.gmp.types cimport mpz_t
+
+cdef extern from "iml.h":
+    cdef enum SOLU_POS:
+        LeftSolu
+        RightSolu
+
+    cdef long nullspaceMP(long n, long m, const mpz_t *A, mpz_t * *mp_N_pass)
+    cdef void nonsingSolvLlhsMM(SOLU_POS solupos, long n, long m, mpz_t *mp_A, mpz_t *mp_B, mpz_t *mp_N, mpz_t mp_D)

sage/libs/linbox/__init__.py

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

sage/libs/linbox/conversion.pxd

@@ -0,0 +1,185 @@
+# sage_setup: distribution = sagemath-linbox
+r"""
+Inline conversions between LinBox and Sage
+
+Each LinBox type has a corresponding Sage types and we use the following
+conventions for conversion functions
+
+- ``new_linbox_XXX`` : create a new linbox object
+- ``new_sage_XXX``   : create a new Sage object
+- ``set_linbox_XXX`` : set the entries of the linbox object
+- ``set_sage_XXX``   : set the entries of the Sage object
+
+For matrices that uses a flint datastructure, see the lower level conversions
+in the module ``linbox_flint_interface``.
+"""
+#*****************************************************************************
+#       Copyright (C) 2007 Martin Albrecht
+#       Copyright (C) 2008 Clement Pernet
+#       Copyright (C) 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.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+
+from libcpp.vector cimport vector as cppvector
+
+from sage.libs.gmp.mpz cimport mpz_set
+
+from sage.libs.linbox.givaro cimport Modular_uint64, ZRing, Integer
+from sage.libs.linbox.linbox cimport SparseMatrix_Modular_uint64, SparseMatrix_integer, DenseVector_integer
+
+from sage.matrix.matrix_modn_sparse cimport Matrix_modn_sparse
+from sage.matrix.matrix_integer_sparse cimport Matrix_integer_sparse
+
+from sage.modules.vector_modn_sparse cimport c_vector_modint
+from sage.modules.vector_integer_dense cimport Vector_integer_dense
+from sage.modules.vector_integer_sparse cimport mpz_vector,  mpz_vector_get_entry, mpz_vector_set_entry
+
+########################################
+# algorithm for solving linear systems #
+########################################
+
+ctypedef enum linbox_specifier:
+    METHOD_DEFAULT              # no specification
+    METHOD_DENSE_ELIMINATION     # DenseElimination
+    METHOD_SPARSE_ELIMINATION   # SparseElimination
+    METHOD_BLACKBOX             # Blackbox
+    METHOD_WIEDEMANN            # Wiedeman
+    ERROR
+
+cdef inline linbox_specifier get_method(str algo) except ERROR:
+    if algo is None or algo == "default":
+        return METHOD_DEFAULT
+    elif algo == "dense_elimination" or \
+         algo == "linbox_dense_elimination" or \
+         algo == "LinBox::DenseElimination":
+        return METHOD_DENSE_ELIMINATION
+    elif algo == "sparse_elimination" or \
+         algo == "linbox_sparse_elimination" or \
+         algo == "LinBox::SparseElimination":
+        return METHOD_SPARSE_ELIMINATION
+    elif algo == "blackbox" or \
+         algo == "linbox_blackbox" or \
+         algo == "LinBox::Blackbox":
+        return METHOD_BLACKBOX
+    elif algo == 'wiedemann' or \
+         algo == "linbox_wiedemann" or \
+         algo == "LinBox::Wiedeman":
+        return METHOD_WIEDEMANN
+    else:
+        raise ValueError("unknown algorithm")
+
+################################################
+# matrix_modn_sparse (sparse matrix over Z/nZ) #
+################################################
+
+cdef inline void set_linbox_matrix_modn_sparse(SparseMatrix_Modular_uint64& A, Matrix_modn_sparse m) noexcept:
+    r"""
+    Set the entries of a LinBox matrix from a Sage matrix.
+
+    INPUT:
+
+    - ``A`` -- LinBox matrix
+    - ``m`` -- Sage matrix
+    """
+    cdef c_vector_modint * row
+    cdef size_t i, j
+    for i in range(<size_t> m._nrows):
+        row = m.rows + i
+        for j in range(<size_t> row.num_nonzero):
+            A.setEntry(i, row.positions[j], row.entries[j])
+
+cdef inline SparseMatrix_Modular_uint64 * new_linbox_matrix_modn_sparse(Modular_uint64 &F, Matrix_modn_sparse m) noexcept:
+    r"""
+    Return a new LinBox matrix from a Sage matrix.
+
+    Such matrix has to be deallocated with a "del" statement.
+
+    INPUT:
+
+    - ``F`` -- LinBox field
+    - ``m`` -- Sage matrix
+    """
+    cdef SparseMatrix_Modular_uint64 * A = new SparseMatrix_Modular_uint64(F, <size_t> m._nrows, <size_t> m._ncols)
+    set_linbox_matrix_modn_sparse(A[0], m)
+    return A
+
+#########################
+# matrix_integer_sparse #
+#########################
+
+cdef inline void set_linbox_matrix_integer_sparse(SparseMatrix_integer& A, Matrix_integer_sparse m) noexcept:
+    r"""
+    Set the entries of a LinBox matrix from a Sage matrix.
+
+    INPUT:
+
+    - ``A`` -- LinBox matrix
+    - ``m`` -- Sage matrix
+    """
+    cdef size_t i, j, k
+    cdef mpz_vector * v
+    cdef Integer t
+    for i in range(<size_t> m._nrows):
+        v = m._matrix + i
+        for k in range(<size_t> v.num_nonzero):
+            j = v.positions[k]
+            mpz_set(t.get_mpz(), v.entries[k])
+            A.setEntry(i, j, t)
+
+cdef inline SparseMatrix_integer * new_linbox_matrix_integer_sparse(ZRing &ZZ, Matrix_integer_sparse m) noexcept:
+    r"""
+    Return a new LinBox matrix from a Sage matrix.
+
+    Suc matrix has to be deallocated with a "del" statement.
+
+    INPUT:
+
+    - ``m`` -- Sage matrix
+    """
+    cdef SparseMatrix_integer * A = new SparseMatrix_integer(ZZ, <size_t> m._nrows, <size_t> m._ncols)
+    set_linbox_matrix_integer_sparse(A[0], m)
+    return A
+
+########################
+# vector integer dense #
+########################
+
+cdef inline DenseVector_integer * new_linbox_vector_integer_dense(ZRing &ZZ, Vector_integer_dense v) noexcept:
+    r"""
+    Return a new linbox vector from a sage one.
+
+    INPUT:
+
+    - ``v`` -- a Sage dense integer vector
+    """
+    cdef cppvector[Integer] * vec = new cppvector[Integer](<size_t> v._degree)
+    cdef size_t i
+    for i in range(<size_t> v._degree):
+        mpz_set(vec[0][i].get_mpz(), v._entries[i])
+
+    cdef DenseVector_integer * V = new DenseVector_integer(ZZ, vec[0])
+    del vec
+
+    return V
+
+cdef inline Vector_integer_dense new_sage_vector_integer_dense(P, DenseVector_integer &v):
+    r"""
+    Return a new Sage vector from a LinBox one.
+
+    INPUT:
+
+    - ``P`` -- parent for the Sage vector
+    - ``v`` -- linbox vector
+    """
+    cdef Vector_integer_dense res = P()
+    cdef size_t i
+    for i in range(<size_t> res._degree):
+        mpz_set(res._entries[i], v.getEntry(i).get_mpz_const())
+
+    return res

sage/libs/linbox/fflas.pxd

@@ -0,0 +1,189 @@
+# sage_setup: distribution = sagemath-linbox
+# Issue #33153: fflas-ffpack-2.4.3 is missing a return value in one of
+# its functions and runs afoul of -Werror=return-type. Compounding the
+# problem on openSUSE tumbleweed, the CFLAGS in python's sysconfig
+# contain -Werror=return-type and wind up being used to compile this
+# extension. To avoid a compilation failure on that platform, we
+# temporarily append "-Wno-error=return-type" to those flags.
+#
+# distutils: extra_compile_args = FFLASFFPACK_CFLAGS -Wno-error=return-type
+#
+# distutils: include_dirs = FFLASFFPACK_INCDIR
+# distutils: libraries = FFLASFFPACK_LIBRARIES
+# distutils: library_dirs = FFLASFFPACK_LIBDIR
+# distutils: extra_link_args = FFLASFFPACK_LIBEXTRA
+# distutils: language = c++ 
+
+from sage.libs.linbox.givaro cimport Modular_double, Modular_float, Dense, Sparse
+from sage.libs.linbox.givaro cimport givvector, Poly1Dom
+from libcpp.vector cimport vector
+from libcpp cimport bool
+ctypedef Poly1Dom[Modular_double, Dense] PolynomialRing_Modular_double
+ctypedef Poly1Dom[Modular_float, Dense] PolynomialRing_Modular_float
+
+ctypedef givvector[Modular_double.Element] ModDoubleDensePolynomial
+ctypedef givvector[Modular_float.Element] ModFloatDensePolynomial
+
+cdef extern from "fflas-ffpack/fflas-ffpack.h" namespace "FFLAS":
+    ctypedef enum FFLAS_TRANSPOSE:
+        FflasNoTrans
+        FflasTrans
+
+    ctypedef enum FFLAS_SIDE:
+        FflasRight
+
+    # double
+    Modular_double.Element* fgemv (Modular_double F, FFLAS_TRANSPOSE transA,
+             size_t nrows, size_t ncols,
+             Modular_double.Element alpha, Modular_double.Element* A,
+             size_t lda, Modular_double.Element* X, size_t incX,
+             Modular_double.Element beta, Modular_double.Element* Y,
+             size_t incY)
+
+    Modular_double.Element* fgemm (Modular_double F,
+             FFLAS_TRANSPOSE transA, FFLAS_TRANSPOSE transB,
+             size_t nrowsA, size_t ncolsB, size_t ncolsA,
+             Modular_double.Element alpha, Modular_double.Element* A,
+             size_t A_stride, Modular_double.Element* B, int B_stride,
+             Modular_double.Element beta, Modular_double.Element* C,
+             size_t C_stride)
+
+    Modular_double.Element* pfgemm (Modular_double F,
+             FFLAS_TRANSPOSE transA, FFLAS_TRANSPOSE transB,
+             size_t nrowsA, size_t ncolsB, size_t ncolsA,
+             Modular_double.Element alpha, Modular_double.Element* A,
+             size_t A_stride, Modular_double.Element* B, int B_stride,
+             Modular_double.Element beta, Modular_double.Element* C,
+             size_t C_stride, size_t numthreads)
+
+    # float
+    Modular_float.Element* fgemv (Modular_float F, FFLAS_TRANSPOSE transA,
+             size_t nrows, size_t ncols,
+             Modular_float.Element alpha, Modular_float.Element* A,
+             size_t lda, Modular_float.Element* X, size_t incX,
+             Modular_float.Element beta, Modular_float.Element* Y,
+             size_t incY)
+
+    Modular_float.Element* fgemm (Modular_float F,
+             FFLAS_TRANSPOSE transA, FFLAS_TRANSPOSE transB,
+             size_t nrowsA, size_t ncolsB, size_t ncolsA,
+             Modular_float.Element alpha, Modular_float.Element* A,
+             size_t A_stride, Modular_float.Element* B, int B_stride,
+             Modular_float.Element beta, Modular_float.Element* C,
+             size_t C_stride)
+
+    Modular_float.Element* pfgemm (Modular_float F,
+             FFLAS_TRANSPOSE transA, FFLAS_TRANSPOSE transB,
+             size_t nrowsA, size_t ncolsB, size_t ncolsA,
+             Modular_float.Element alpha, Modular_float.Element* A,
+             size_t A_stride, Modular_float.Element* B, int B_stride,
+             Modular_float.Element beta, Modular_float.Element* C,
+             size_t C_stride, size_t numthreads)
+
+cdef extern from "fflas-ffpack/fflas-ffpack.h" namespace "FFPACK":
+    # double
+    bint IsSingular (Modular_double F,
+                     size_t nrows, size_t ncols, Modular_double.Element* A,
+                     size_t A_stride)
+
+    Modular_double.Element* Invert (Modular_double F, size_t order,
+                                    Modular_double.Element* A, size_t A_stride, int nullity)
+
+    Modular_double.Element Det (Modular_double F, Modular_double.Element& d, size_t n,
+                                Modular_double.Element* A, size_t A_stride)
+
+    Modular_double.Element pDet (Modular_double F, Modular_double.Element& d, size_t n,
+                                Modular_double.Element* A, size_t A_stride, size_t numthreads)
+
+    int Rank (Modular_double,
+              size_t nrows, size_t ncols,
+              Modular_double.Element *A, size_t lda)
+
+    int pRank (Modular_double,
+              size_t nrows, size_t ncols,
+              Modular_double.Element *A, size_t lda, size_t numthreads)
+
+    size_t ReducedRowEchelonForm (Modular_double F, size_t a, size_t b,
+                                  Modular_double.Element* matrix,
+                                  size_t s, size_t* P, size_t* Q)
+
+    size_t pReducedRowEchelonForm (Modular_double F, size_t a, size_t b,
+                                  Modular_double.Element* matrix,
+                                  size_t s, size_t* P, size_t* Q, bool transform, size_t numthreads)
+
+    Modular_double.Element* Solve (Modular_double F, size_t M,
+           Modular_double.Element* A, size_t lda,
+           Modular_double.Element* x, int incx,
+           Modular_double.Element* b, int incb)
+
+    Modular_double.Element* pSolve (Modular_double F, size_t M,
+           Modular_double.Element* A, size_t lda,
+           Modular_double.Element* x, int incx,
+           Modular_double.Element* b, int incb, size_t numthreads)
+
+    void applyP (Modular_double F,
+                 FFLAS_SIDE s, FFLAS_TRANSPOSE tr,
+                 size_t nr, size_t foo, size_t r,
+                 Modular_double.Element* matrix, size_t nc, size_t* Q)
+
+    void MinPoly ( Modular_double& F,
+                   vector[Modular_double.Element] minP, size_t N,
+                   Modular_double.Element*A, size_t lda)
+
+    void CharPoly ( PolynomialRing_Modular_double& R,
+                    ModDoubleDensePolynomial& charp, size_t N,
+                    Modular_double.Element* A, size_t lda)
+
+    # float
+
+    bint IsSingular (Modular_float F,
+                     size_t nrows, size_t ncols, Modular_float.Element* A,
+                     size_t A_stride)
+
+    Modular_float.Element* Invert (Modular_float F, size_t order,
+                                   Modular_float.Element* A, size_t A_stride, int nullity)
+
+    Modular_float.Element Det (Modular_float F, Modular_float.Element& d, size_t n,
+                               Modular_float.Element* A, size_t A_stride)
+
+    Modular_float.Element pDet (Modular_float F, Modular_float.Element& d, size_t n,
+                               Modular_float.Element* A, size_t A_stride, size_t numthreads)
+
+    int Rank (Modular_float,
+              size_t nrows, size_t ncols,
+              Modular_float.Element *A, size_t lda)
+
+    int pRank (Modular_float,
+              size_t nrows, size_t ncols,
+              Modular_float.Element *A, size_t lda, size_t numthreads)
+
+    size_t ReducedRowEchelonForm (Modular_float F, size_t a, size_t b,
+                                  Modular_float.Element* matrix,
+                                  size_t s, size_t* P, size_t* Q)
+
+    size_t pReducedRowEchelonForm (Modular_float F, size_t a, size_t b,
+                                  Modular_float.Element* matrix,
+                                  size_t s, size_t* P, size_t* Q, bool transform, size_t numthreads)
+
+    Modular_float.Element* Solve (Modular_float F, size_t M,
+           Modular_float.Element* A, size_t lda,
+           Modular_float.Element* x, int incx,
+           Modular_float.Element* b, int incb)
+
+    Modular_float.Element* pSolve (Modular_float F, size_t M,
+           Modular_float.Element* A, size_t lda,
+           Modular_float.Element* x, int incx,
+           Modular_float.Element* b, int incb, size_t numthreads)
+
+    void applyP (Modular_float F,
+                 FFLAS_SIDE s, FFLAS_TRANSPOSE tr,
+                 size_t nr, size_t foo, size_t r,
+                 Modular_float.Element* matrix, size_t nc, size_t* Q)
+
+    void MinPoly ( Modular_float F,
+                   vector[Modular_float.Element] minP, size_t N,
+                   Modular_float.Element* A, size_t lda)
+
+    void CharPoly ( PolynomialRing_Modular_float& F,
+                    ModFloatDensePolynomial& charp, size_t N,
+                    Modular_float.Element* A, size_t lda )

sage/libs/linbox/givaro.pxd

@@ -0,0 +1,109 @@
+# sage_setup: distribution = sagemath-linbox
+# distutils: extra_compile_args = GIVARO_CFLAGS
+# distutils: include_dirs = GIVARO_INCDIR
+# distutils: libraries = GIVARO_LIBRARIES FFLASFFPACK_LIBRARIES
+# distutils: library_dirs = GIVARO_LIBDIR
+# distutils: language = c++
+
+from libc.stdint cimport uint32_t, uint64_t
+
+from sage.libs.gmp.types cimport (mpz_t, mpz_srcptr, mpz_ptr,
+                                  mpq_t, mpq_srcptr, mpq_ptr)
+
+cdef extern from "<iostream>" namespace "std":
+    cdef cppclass ostream:
+        ostream& write(const char*, int) except +
+
+cdef extern from "gmp++/gmp++.h" namespace "Givaro":
+    cdef cppclass Integer:
+        Integer()
+        Integer(int32_t)
+        Integer(int64_t)
+        Integer(uint32_t)
+        Integer(uint64_t)
+        Integer(Integer&)
+
+        mpz_ptr get_mpz()
+        mpz_srcptr get_mpz_const()
+
+cdef extern from "givaro/givcategory.h" namespace "Givaro":
+    cdef cppclass Sporadic:
+        pass
+    cdef cppclass Dense:
+        pass
+    cdef cppclass Sparse:
+        pass
+
+cdef extern from "givaro/zring.h":
+    ## template<class _Element> class ZRing
+    cdef cppclass ZRing "Givaro::ZRing<Givaro::Integer>":
+        ctypedef Integer Element
+        Element zero
+        Element one
+        Element mone
+
+cdef extern from "givaro/modular-integral.h":
+    cdef cppclass Modular_uint64 "Givaro::Modular<uint64_t>":
+        ctypedef uint64_t Element
+        Modular_uint64(int modulus)
+
+        Element init(Element res, int v)
+        Element inv(Element x, Element y)
+        Element neg(Element x, Element y)
+        Element mul(Element r, Element x, Element y)
+        Element mulin(Element x, Element y)
+        Element addin(Element x, Element y)
+        Element invin(Element y)
+        Element negin(Element y)
+        int characteristic(int c)
+        bint isZero(Element x)
+
+        ostream& write(ostream&)
+
+cdef extern from "givaro/modular-floating.h":
+    cdef cppclass Modular_double "Givaro::Modular<double>":
+        ctypedef double Element
+        Modular_double(int modulus)
+
+        Element init(Element res, int v)
+        Element init(Element res, double v)
+        Element inv(Element x, Element y)
+        Element neg(Element x, Element y)
+        Element mul(Element r, Element x, Element y)
+        Element mulin(Element x, Element y)
+        Element addin(Element x, Element y)
+        Element invin(Element y)
+        Element negin(Element y)
+        int characteristic(int c)
+        bint isZero(Element x)
+
+        ostream& write(ostream&)
+
+    cdef cppclass Modular_float "Givaro::Modular<float>":
+        ctypedef float Element
+        Modular_float(int modulus)
+
+        Element init(Element res, int v)
+        Element init(Element res, float v)
+        Element inv(Element x, Element y)
+        Element neg(Element x, Element y)
+        Element mul(Element r, Element x, Element y)
+        Element mulin(Element x, Element y)
+        Element addin(Element x, Element y)
+        Element invin(Element y)
+        Element negin(Element y)
+        int characteristic(int c)
+        bint isZero(Element x)
+
+        ostream& write(ostream&)
+
+cdef extern from "givaro/givpoly1.h" namespace "Givaro":
+    ## template < typename T, typename A=std::allocator<T> >
+    ## class givvector : public __GIV_STANDARD_VECTOR<T,A>
+    cdef cppclass givvector [T,ALLOCATOR=*]:
+        T& operator[](size_t i)
+        size_t size()
+
+    ## template<class Domain, class StorageTag=Dense> class Poly1Dom
+    cdef cppclass Poly1Dom[Domain,StorageClass=*]:
+        Poly1Dom(Domain&)