passagemath-iml 10.6.46__cp310-cp310-musllinux_1_2_aarch64.whl

passagemath_iml/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-iml
+
+from sage.all__sagemath_iml import *

passagemath_iml-10.6.46.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: passagemath-iml
+Version: 10.6.46
+Summary: passagemath: Linear Algebra with IML
+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: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+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.10
+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: passagemath-environment~=10.6.46.0
+Requires-Dist: passagemath-categories~=10.6.46.0
+Requires-Dist: passagemath-flint~=10.6.46.0
+Requires-Dist: passagemath-modules~=10.6.46.0
+Provides-Extra: test
+Requires-Dist: passagemath-repl; extra == "test"
+
+======================================
+ passagemath: Linear Algebra with IML
+======================================
+
+`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-iml``
+provides modules that depend on the library
+`IML <https://cs.uwaterloo.ca/~astorjoh/iml.html>`_.

passagemath_iml-10.6.46.dist-info/RECORD

@@ -0,0 +1,18 @@
+passagemath_iml/__init__.py,sha256=NdO4g5bk11MJItshkI4te7taUE-Jn-7HzocKeHLETRQ,80
+passagemath_iml.libs/libflint-edf7fb90.so.22.0.0,sha256=MD3YZou85hLe1nME9zmMO9rgpWntwei2_yI19VNhFGo,12776233
+passagemath_iml.libs/libgcc_s-2d945d6c.so.1,sha256=NdOgO2If8roY3PSnJ81CsBa1rjMvN_uWPCo_V0ThwEY,203337
+passagemath_iml.libs/libgfortran-67378ab2.so.5.0.0,sha256=A91Op_3ABLyRZ8zL3gXSHIQx8Ole8PHTFZ3TMRbmGxs,1738025
+passagemath_iml.libs/libgmp-28992bcb.so.10.5.0,sha256=chvEgOPn69KHFEAC4oKOFhJ2LjYfSTYlyAEyFvE1hJg,668217
+passagemath_iml.libs/libiml-7e8f179c.so.0.1.1,sha256=6v-Mg2s6sS4oxRv2mAWy1WzqVxj6ECUnahrtt053p3c,594137
+passagemath_iml.libs/libmpfr-1fc8ea36.so.6.2.2,sha256=6QZDznN7C9yVcv5AG5GpXZWrvxsAw1kqTlkqECWjLIQ,931889
+passagemath_iml.libs/libopenblasp-r0-503f0c35.3.29.so,sha256=9TXSi3fPF12lvTfJcZfd4EzbsJAUcTs8M7j0Hau7RKk,23179593
+sage/all__sagemath_iml.py,sha256=JkCUqCbgv_BfDU5GkGqRvZ2D9YxOqr5UDA1MndDmGXc,62
+sage/libs/all__sagemath_iml.py,sha256=Fxq15-6XT5V8u-vDT34I88lKPruA0VGDT3bqpmULCg8,42
+sage/libs/iml.pxd,sha256=5JdoculaJjo2Z1Z8sGzo-5ZHRQXELsTDdf-16kjCWBQ,363
+sage/matrix/all__sagemath_iml.py,sha256=Fxq15-6XT5V8u-vDT34I88lKPruA0VGDT3bqpmULCg8,42
+sage/matrix/matrix_integer_iml.cpython-310-aarch64-linux-gnu.so,sha256=yk98d5amAHfs2uAjYAFmR1PKnTmE6Lpkty28qPITvjU,595145
+sage/matrix/matrix_integer_iml.pyx,sha256=b97lePKykguBEaks3FdfzN3IUNlZo3S_CtbAJMQQ0X4,9236
+passagemath_iml-10.6.46.dist-info/METADATA,sha256=CkeweII4HPcO0NcaiizVCcM8CcscsaYC8HP8x60wn1E,4406
+passagemath_iml-10.6.46.dist-info/WHEEL,sha256=qvx19vD_zYvGQFVzkH0wrT4tVIal9wOVogYGQfy9ymw,113
+passagemath_iml-10.6.46.dist-info/top_level.txt,sha256=ka1mTeqr1T6DIwrqKXQw4y_4AOqEQ6B83AVk3UnUO8w,22
+passagemath_iml-10.6.46.dist-info/RECORD,,

passagemath_iml-10.6.46.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-musllinux_1_2_aarch64
+

passagemath_iml-10.6.46.dist-info/top_level.txt

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

sage/all__sagemath_iml.py

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-iml
+# delvewheel: patch

sage/libs/all__sagemath_iml.py

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

sage/libs/iml.pxd

@@ -0,0 +1,10 @@
+# sage_setup: distribution = sagemath-iml
+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/matrix/all__sagemath_iml.py

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

sage/matrix/matrix_integer_iml.pyx

@@ -0,0 +1,316 @@
+# sage_setup: distribution = sagemath-iml
+# distutils: libraries = iml
+# sage.doctest: needs sage.libs.iml
+
+from cysignals.signals cimport sig_check, sig_on, sig_str, sig_off
+from cysignals.memory cimport sig_malloc, sig_free, check_allocarray
+
+from sage.libs.flint.fmpz cimport *
+from sage.libs.flint.fmpz_mat cimport *
+from sage.libs.gmp.mpz cimport *
+from sage.matrix.matrix_integer_dense cimport Matrix_integer_dense
+from sage.misc.verbose import verbose
+from sage.rings.integer cimport Integer
+
+
+########## iml -- integer matrix library ###########
+from sage.libs.iml cimport *
+
+
+def _rational_kernel_iml(Matrix_integer_dense self):
+    """
+    Return the rational (left) kernel of this matrix.
+
+    OUTPUT:
+
+    A matrix ``K`` such that ``self * K = 0``, and the number of columns of
+    K equals the nullity of ``self``.
+
+    EXAMPLES::
+
+        sage: from sage.matrix.matrix_integer_iml import _rational_kernel_iml
+        sage: m = matrix(ZZ, 5, 5, [1+i+i^2 for i in range(25)])
+        sage: _rational_kernel_iml(m)
+        [ 1  3]
+        [-3 -8]
+        [ 3  6]
+        [-1  0]
+        [ 0 -1]
+
+        sage: V1 = _rational_kernel_iml(m).column_space().change_ring(QQ)
+        sage: V2 = m._rational_kernel_flint().column_space().change_ring(QQ)
+        sage: assert V1 == V2
+    """
+    if self._nrows == 0 or self._ncols == 0:
+        return self.matrix_space(self._ncols, 0).zero_matrix()
+
+    cdef long dim
+    cdef unsigned long i,j,k
+    cdef mpz_t *mp_N
+    time = verbose('computing null space of %s x %s matrix using IML' % (self._nrows, self._ncols))
+    cdef mpz_t * m = fmpz_mat_to_mpz_array(self._matrix)
+    sig_on()
+    dim = nullspaceMP(self._nrows, self._ncols, m, &mp_N)
+    sig_off()
+    # Now read the answer as a matrix.
+    cdef Matrix_integer_dense M
+    M = self._new(self._ncols, dim)
+    k = 0
+    for i in range(self._ncols):
+        for j in range(dim):
+            fmpz_set_mpz(fmpz_mat_entry(M._matrix, i, j), mp_N[k])
+            k += 1
+    mpz_array_clear(m, self._nrows * self._ncols)
+    mpz_array_clear(mp_N, dim * self._ncols)
+    verbose("finished computing null space", time)
+    return M
+
+
+def _invert_iml(Matrix_integer_dense self, use_nullspace=False, check_invertible=True):
+    """
+    Invert this matrix using IML. The output matrix is an integer
+    matrix and a denominator.
+
+    INPUT:
+
+    - ``self`` -- an invertible matrix
+
+    - ``use_nullspace`` -- boolean (default: ``False``); whether to
+      use nullspace algorithm, which is slower, but doesn't require
+      checking that the matrix is invertible as a precondition
+
+    - ``check_invertible`` -- boolean (default: ``True``); whether to
+      check that the matrix is invertible
+
+    OUTPUT: `A`, `d` such that ``A*self == d``
+
+    - ``A`` -- a matrix over ZZ
+
+    - ``d`` -- integer
+
+    ALGORITHM: Uses IML's `p`-adic nullspace function.
+
+    EXAMPLES::
+
+        sage: from sage.matrix.matrix_integer_iml import _invert_iml
+        sage: a = matrix(ZZ,3,[1,2,5, 3,7,8, 2,2,1])
+        sage: b, d = _invert_iml(a); b,d
+        (
+        [  9  -8  19]
+        [-13   9  -7]
+        [  8  -2  -1], 23
+        )
+        sage: a*b
+        [23  0  0]
+        [ 0 23  0]
+        [ 0  0 23]
+
+    AUTHORS:
+
+    - William Stein
+    """
+    if self._nrows != self._ncols:
+        raise TypeError("self must be a square matrix.")
+
+    P = self.parent()
+    time = verbose('computing inverse of %s x %s matrix using IML' % (self._nrows, self._ncols))
+    if use_nullspace:
+        A = self.augment(P.identity_matrix())
+        K = A._rational_kernel_iml()
+        d = -K[self._nrows,0]
+        if K.ncols() != self._ncols or d == 0:
+            raise ZeroDivisionError("input matrix must be nonsingular")
+        B = K[:self._nrows]
+        verbose("finished computing inverse using IML", time)
+        return B, d
+    else:
+        if check_invertible and self.rank() != self._nrows:
+            raise ZeroDivisionError("input matrix must be nonsingular")
+        return _solve_iml(self, P.identity_matrix(), right=True)
+
+
+def _solve_iml(Matrix_integer_dense self, Matrix_integer_dense B, right=True):
+    """
+    Let A equal ``self`` be a square matrix. Given B return an integer
+    matrix C and an integer d such that ``self`` ``C*A == d*B`` if right is
+    False or ``A*C == d*B`` if right is True.
+
+    OUTPUT:
+
+    - ``C`` -- integer matrix
+
+    - ``d`` -- integer denominator
+
+    EXAMPLES::
+
+        sage: from sage.matrix.matrix_integer_iml import _solve_iml
+        sage: A = matrix(ZZ,4,4,[0, 1, -2, -1, -1, 1, 0, 2, 2, 2, 2, -1, 0, 2, 2, 1])
+        sage: B = matrix(ZZ,3,4, [-1, 1, 1, 0, 2, 0, -2, -1, 0, -2, -2, -2])
+        sage: C, d = _solve_iml(A, B, right=False); C
+        [  6 -18 -15  27]
+        [  0  24  24 -36]
+        [  4 -12  -6  -2]
+
+    ::
+
+        sage: d
+        12
+
+    ::
+
+        sage: C*A == d*B
+        True
+
+    ::
+
+        sage: A = matrix(ZZ,4,4,[0, 1, -2, -1, -1, 1, 0, 2, 2, 2, 2, -1, 0, 2, 2, 1])
+        sage: B = matrix(ZZ,4,3, [-1, 1, 1, 0, 2, 0, -2, -1, 0, -2, -2, -2])
+        sage: C, d = _solve_iml(A, B)
+        sage: C
+        [ 12  40  28]
+        [-12  -4  -4]
+        [ -6 -25 -16]
+        [ 12  34  16]
+
+    ::
+
+        sage: d
+        12
+
+    ::
+
+        sage: A*C == d*B
+        True
+
+    Test wrong dimensions::
+
+        sage: A = random_matrix(ZZ, 4, 4)
+        sage: B = random_matrix(ZZ, 2, 3)
+        sage: _solve_iml(B, A)
+        Traceback (most recent call last):
+        ...
+        ValueError: self must be a square matrix
+        sage: _solve_iml(A, B, right=False)
+        Traceback (most recent call last):
+        ...
+        ArithmeticError: B's number of columns must match self's number of rows
+        sage: _solve_iml(A, B, right=True)
+        Traceback (most recent call last):
+        ...
+        ArithmeticError: B's number of rows must match self's number of columns
+
+    Check that this can be interrupted properly (:issue:`15453`)::
+
+        sage: A = random_matrix(ZZ, 2000, 2000)
+        sage: B = random_matrix(ZZ, 2000, 2000)
+        sage: t0 = walltime()
+        sage: alarm(2); _solve_iml(A, B)  # long time
+        Traceback (most recent call last):
+        ...
+        AlarmInterrupt
+        sage: t = walltime(t0)
+        sage: t < 10 or t
+        True
+
+    ALGORITHM: Uses IML.
+
+    AUTHORS:
+
+    - Martin Albrecht
+    """
+    cdef unsigned long i, j, k
+    cdef mpz_t *mp_N
+    cdef mpz_t mp_D
+    cdef Matrix_integer_dense M
+    cdef Integer D
+
+    if self._nrows != self._ncols:
+        # This is *required* by the IML function we call below.
+        raise ValueError("self must be a square matrix")
+
+    if self._nrows == 1:
+        return B, self[0,0]
+
+    cdef SOLU_POS solu_pos
+
+    if right:
+        if self._ncols != B._nrows:
+            raise ArithmeticError("B's number of rows must match self's number of columns")
+
+        n = self._ncols
+        m = B._ncols
+
+        P = self.matrix_space(n, m)
+        if self._nrows == 0 or self._ncols == 0:
+            return P.zero_matrix(), Integer(1)
+
+        if m == 0 or n == 0:
+            return self.new_matrix(nrows = n, ncols = m), Integer(1)
+
+        solu_pos = RightSolu
+
+    else: # left
+        if self._nrows != B._ncols:
+            raise ArithmeticError("B's number of columns must match self's number of rows")
+
+        n = self._ncols
+        m = B._nrows
+
+        P = self.matrix_space(m, n)
+        if self._nrows == 0 or self._ncols == 0:
+            return P.zero_matrix(), Integer(1)
+
+        if m == 0 or n == 0:
+            return self.new_matrix(nrows = m, ncols = n), Integer(1)
+
+        solu_pos = LeftSolu
+
+    sig_check()
+    verbose("Initializing mp_N and mp_D")
+    mp_N = <mpz_t *> sig_malloc( n * m * sizeof(mpz_t) )
+    for i in range(n * m):
+        mpz_init(mp_N[i])
+    mpz_init(mp_D)
+    verbose("Done with initializing mp_N and mp_D")
+    cdef mpz_t * mself = fmpz_mat_to_mpz_array(self._matrix)
+    cdef mpz_t * mB = fmpz_mat_to_mpz_array(B._matrix)
+    try:
+        verbose('Calling solver n = %s, m = %s' % (n,m))
+        sig_on()
+        nonsingSolvLlhsMM(solu_pos, n, m, mself, mB, mp_N, mp_D)
+        sig_off()
+        M = self._new(P.nrows(), P.ncols())
+        k = 0
+        for i from 0 <= i < M._nrows:
+            for j from 0 <= j < M._ncols:
+                fmpz_set_mpz(fmpz_mat_entry(M._matrix,i,j), mp_N[k])
+                k += 1
+        D = Integer.__new__(Integer)
+        mpz_set(D.value, mp_D)
+        return M, D
+    finally:
+        mpz_clear(mp_D)
+        mpz_array_clear(mself, self.nrows() * self.ncols())
+        mpz_array_clear(mB, B.nrows() * B.ncols())
+        mpz_array_clear(mp_N, n*m)
+
+
+cdef inline mpz_t * fmpz_mat_to_mpz_array(fmpz_mat_t m) except? NULL:
+    cdef mpz_t * entries = <mpz_t *>check_allocarray(fmpz_mat_nrows(m), sizeof(mpz_t) * fmpz_mat_ncols(m))
+    cdef size_t i, j
+    cdef size_t k = 0
+    sig_on()
+    for i in range(fmpz_mat_nrows(m)):
+        for j in range(fmpz_mat_ncols(m)):
+            mpz_init(entries[k])
+            fmpz_get_mpz(entries[k], fmpz_mat_entry(m, i, j))
+            k += 1
+    sig_off()
+    return entries
+
+
+cdef inline void mpz_array_clear(mpz_t * a, size_t length) noexcept:
+    cdef size_t i
+    for i in range(length):
+        mpz_clear(a[i])
+    sig_free(a)