passagemath-sirocco 10.8.1a1__cp314-cp314-macosx_13_0_x86_64.whl

passagemath_sirocco/__init__.py

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

passagemath_sirocco-10.8.1a1.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: passagemath-sirocco
+Version: 10.8.1a1
+Summary: passagemath: Certified root continuation with sirocco
+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.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: passagemath-modules==10.8.1.alpha1
+Provides-Extra: test
+Requires-Dist: passagemath-combinat; extra == "test"
+Requires-Dist: passagemath-graphs; extra == "test"
+Requires-Dist: passagemath-groups; extra == "test"
+Requires-Dist: passagemath-polyhedra; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+Requires-Dist: passagemath-schemes; extra == "test"
+
+==================================================================================
+ passagemath: Certified root continuation with sirocco
+==================================================================================
+
+`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-sirocco`` provides a Cython interface
+to the `sirocco <https://github.com/miguelmarco/SIROCCO2>`_ library for computing
+topologically certified root continuation of bivariate polynomials.
+
+
+What is included
+----------------
+
+* `sage.libs.sirocco <https://github.com/passagemath/passagemath/blob/main/src/sage/libs/sirocco.pyx>`_
+
+
+Examples
+--------
+
+::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-sirocco[test]" ipython
+
+    In [1]: from passagemath_sirocco import *
+
+    In [2]: from sage.libs.sirocco import contpath
+
+    In [3]: pol = list(map(RR,[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+
+    In [4]: contpath(2, pol, RR(0), RR(0))
+    Out[4]:
+    [(0.0, 0.0, 0.0),
+     (0.3535533905932738, -0.12500000000000003, 0.0),
+     (0.7071067811865476, -0.5000000000000001, 0.0),
+     (1.0, -1.0, 0.0)]

passagemath_sirocco-10.8.1a1.dist-info/RECORD

@@ -0,0 +1,12 @@
+passagemath_sirocco-10.8.1a1.dist-info/RECORD,,
+passagemath_sirocco-10.8.1a1.dist-info/WHEEL,sha256=0b5LPYpZuejuC45Qy8kskxCl_dBB2BB2HJGLhdQK0sg,155
+passagemath_sirocco-10.8.1a1.dist-info/top_level.txt,sha256=WaBfhxtou-FhXK710boiIi1wnus0aQ5K02SO4T3yCrg,26
+passagemath_sirocco-10.8.1a1.dist-info/METADATA,sha256=mCzMaVx6b-Yh-d0UlByTZpWDk1AKWUAxzFxkJiSwqGU,5355
+passagemath_sirocco/__init__.py,sha256=13fj3jvtMS6cIdUTHWR6olfV09gKD0e2Wi5JIMSxNik,88
+passagemath_sirocco/.dylibs/libgmp.10.dylib,sha256=3gZLlmh46b7M66MbRtnJRyeyZTWVot1LFBCkoybABUA,488712
+passagemath_sirocco/.dylibs/libmpfr.6.dylib,sha256=OIhUMaY-7wDA4oIMu2xb9oBWQwoQt-eRlelpay9g6m4,465224
+passagemath_sirocco/.dylibs/libsirocco.0.0.0.dylib,sha256=QePj41ApE_cGG2XI-CzNp8T3cUAsHv1dq2EojAM0RII,236856
+sage/all__sagemath_sirocco.py,sha256=DETVlVgWYtPIsdw2wOM9oqCp-RfID9ymRYZCbm70-io,188
+sage/libs/sirocco.cpython-314-darwin.so,sha256=oGSwqfYVTRIda55HQhCQf2BUmofY_C5PvdTSaRM1vuU,133176
+sage/libs/sirocco.pyx,sha256=7YNwWX3wbNUoa2V6_OE9IjaVcdhCfdy5_4lO6Sgvv7E,11095
+sage/libs/all__sagemath_sirocco.py,sha256=BnLb9I-8oMsUKI5uRle_hxp92wdAAez3PgwDyMK-KRc,46

passagemath_sirocco-10.8.1a1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: false
+Tag: cp314-cp314-macosx_13_0_x86_64
+Generator: delocate 0.13.1.dev42+ga0af70b54
+

passagemath_sirocco-10.8.1a1.dist-info/top_level.txt

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

sage/all__sagemath_sirocco.py

@@ -0,0 +1,9 @@
+# sage_setup: distribution = sagemath-sirocco
+# delvewheel: patch
+
+try:
+    from sage.all__sagemath_schemes import *
+except ImportError:
+    pass
+
+from sage.all__sagemath_modules import *

sage/libs/all__sagemath_sirocco.py

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

sage/libs/sirocco.pyx

@@ -0,0 +1,288 @@
+# cython: boundscheck=False, wraparound=False
+# distutils: libraries = sirocco
+# distutils: language = c++
+# sage_setup: distribution = sagemath-sirocco
+
+r"""
+Cython wrapper for sirocco library
+
+This is used to call the sirocco library directly from Python.
+
+AUTHORS:
+
+- Miguel Marco (2016-07-19): initial version.
+"""
+
+from cysignals.signals cimport sig_on, sig_off
+from cysignals.memory cimport check_allocarray, sig_free as free
+
+from sage.libs.mpfr cimport *
+from sage.rings.real_mpfr cimport RealNumber
+from sage.rings.real_mpfr import RealField
+
+cdef extern from "sirocco.h":
+    mpfr_t* homotopyPath_mp(int degree, mpfr_t *_coef, mpfr_t _y0R, mpfr_t _y0I, int prec)
+    double* homotopyPath(int degree, double *_coef, double _y0R, double _y0I)
+    mpfr_t* homotopyPath_mp_comps(int degree, mpfr_t *_coef, mpfr_t _y0R, mpfr_t _y0I, int prec, int nothercomps, int *degreescomps, mpfr_t *_coefscomps)
+    double* homotopyPath_comps(int degree, double *_coef, double _y0R, double _y0I, int nothercomps, int *degreescomps, double *_coefscomps)
+
+
+cpdef list[list] contpath_mp(int deg, list values, RealNumber y0r, RealNumber y0i, int prec) noexcept:
+    """
+    Mimics :func:`contpath`, but with the following differences:
+
+    - The floating point numbers can be arbitrary precision RealNumbers.
+
+    - A extra argument is needed, indicating the bits of precision used
+      in the computations.
+
+    EXAMPLES::
+
+        sage: from sage.libs.sirocco import contpath_mp   # optional - sirocco
+        sage: from sage.rings.real_mpfr import RR
+        sage: pol = list(map(RR, [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        sage: contpath_mp(2, pol, RR(0), RR(0), 53)   # optional - sirocco # abs tol 1e-15
+        [(0.000000000000000, 0.000000000000000, 0.000000000000000),
+         (0.500000000000000, -0.250000000000000, 0.000000000000000),
+         (1.00000000000000, -1.00000000000000, 0.000000000000000)]
+    """
+    cdef mpfr_t* cvalues = <mpfr_t*> check_allocarray(len(values), sizeof(mpfr_t))
+    cdef mpfr_t* rop
+    cdef int i, j
+    cdef mpfr_t y0R
+    cdef mpfr_t y0I
+
+    for j in range(len(values)):
+        mpfr_init2(cvalues[j], prec)
+        mpfr_set(cvalues[j], (<RealNumber>values[j]).value, MPFR_RNDN)
+
+    sig_on()
+    mpfr_init2(y0R, prec)
+    mpfr_set(y0R, (<RealNumber>y0r).value, MPFR_RNDN)
+    mpfr_init2(y0I, prec)
+    mpfr_set(y0I, (<RealNumber>y0i).value, MPFR_RNDN)
+    rop = homotopyPath_mp(deg, cvalues, y0R, y0I, prec)
+    sig_off()
+
+    for j in range(len(values)):
+        mpfr_clear(cvalues[j])
+    free(cvalues)
+
+    if rop == NULL:
+        raise ValueError("libsirocco could not guarantee one step")
+
+    cdef int n = mpfr_get_si(rop[0], MPFR_RNDN)
+    cdef list l = []
+    cdef list inner
+    cdef RealNumber RN
+    field = RealField(prec)
+    for i in range(n):
+        inner = []
+        for j in range(3*i+1, 3*(i+1)+1):
+            RN = <RealNumber> RealNumber.__new__(RealNumber, field)
+            mpfr_set(RN.value, rop[j], MPFR_RNDN)
+            mpfr_clear(rop[j])
+            inner.append(RN)
+        l.append(tuple(inner))
+    free(rop)
+    return l
+
+cpdef list[list] contpath_mp_comps(int deg, list values, RealNumber y0r, RealNumber y0i, int prec, list otherdegs, list othercoefs) noexcept:
+    """
+    Mimics :func:`contpath`, but with the following differences:
+
+    - The floating point numbers can be arbitrary precision RealNumbers.
+
+    - A extra argument is needed, indicating the bits of precision used
+      in the computations.
+
+    EXAMPLES::
+
+        sage: from sage.libs.sirocco import contpath_mp_comps   # optional - sirocco
+        sage: from sage.rings.real_mpfr import RR
+        sage: pol = list(map(RR,[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        sage: fac = list(map(RR,[0, 0, 0.1, 0.2, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        sage: contpath_mp_comps(2, pol, RR(0), RR(0), 53, [2], fac)   # optional - sirocco # abs tol 1e-15
+        [(0.000000000000000, 0.000000000000000, 0.000000000000000),
+         (0.125000000000000, -0.0156250000000000, 0.000000000000000),
+         (0.250000000000000, -0.0625000000000000, 0.000000000000000),
+         (0.375000000000000, -0.140625000000000, 0.000000000000000),
+         (0.500000000000000, -0.250000000000000, 0.000000000000000),
+         (0.625000000000000, -0.390625000000000, 0.000000000000000),
+         (0.750000000000000, -0.562500000000000, 0.000000000000000),
+         (0.875000000000000, -0.765625000000000, 0.000000000000000),
+         (1.00000000000000, -1.00000000000000, 0.000000000000000)]
+    """
+
+    cdef mpfr_t* cvalues = <mpfr_t*> check_allocarray(len(values), sizeof(mpfr_t))
+    cdef mpfr_t* cothercoefs = <mpfr_t*> check_allocarray(len(othercoefs), sizeof(mpfr_t))
+    cdef int* cotherdegs = <int*> check_allocarray(len(otherdegs), sizeof(int))
+    cdef mpfr_t* rop
+    cdef int i, j
+    cdef mpfr_t y0R
+    cdef mpfr_t y0I
+
+    for j in range(len(values)):
+        mpfr_init2(cvalues[j], prec)
+        mpfr_set(cvalues[j], (<RealNumber>values[j]).value, MPFR_RNDN)
+
+    for j in range(len(othercoefs)):
+        mpfr_init2(cothercoefs[j], prec)
+        mpfr_set(cothercoefs[j], (<RealNumber>othercoefs[j]).value, MPFR_RNDN)
+
+    for j in range(len(otherdegs)):
+        cotherdegs[j] = int(otherdegs[j])
+    sig_on()
+    mpfr_init2(y0R, prec)
+    mpfr_set(y0R, (<RealNumber>y0r).value, MPFR_RNDN)
+    mpfr_init2(y0I, prec)
+    mpfr_set(y0I, (<RealNumber>y0i).value, MPFR_RNDN)
+    rop = homotopyPath_mp_comps(deg, cvalues, y0R, y0I, prec, int(len(otherdegs)), cotherdegs, cothercoefs)
+    sig_off()
+    for j in range(len(values)):
+        mpfr_clear(cvalues[j])
+    free(cvalues)
+    for j in range(len(othercoefs)):
+        mpfr_clear(cothercoefs[j])
+    free(cothercoefs)
+    free(cotherdegs)
+    if rop == NULL:
+        raise ValueError("libsirocco could not guarantee one step")
+    cdef int n = mpfr_get_si(rop[0], MPFR_RNDN)
+    cdef list l = []
+    cdef list inner
+    cdef RealNumber RN
+    field = RealField(prec)
+    for i in range(n):
+        inner = []
+        for j in range(3*i+1, 3*(i+1)+1):
+            RN = <RealNumber> RealNumber.__new__(RealNumber, field)
+            mpfr_set(RN.value, rop[j], MPFR_RNDN)
+            mpfr_clear(rop[j])
+            inner.append(RN)
+        l.append(tuple(inner))
+    free(rop)
+    return l
+
+
+cpdef list[list] contpath(int deg, list values, double y0r, double y0i) noexcept:
+    """
+    INPUT:
+
+    - An integer, representing the degree of the polynomial
+
+    - A list of floating point numbers. Each four consecutive elements
+      of this list represent the interval corresponding to a coefficient.
+      Coefficients are listed in increasing deglex order, and inside each
+      coefficients, the four numbers represent the lower real, upper real,
+      lower imaginary and real imaginary limits of the interval.
+
+    - A float representing the real part of the initial root approximation
+
+    - A float representing the imaginary part of the initial root.
+
+    OUTPUT:
+
+    A list of tuples. Each tuple represents the `x` value (between 0 and 1)
+    and the real and imaginary parts of the `y` value of a vertex in
+    the piecewise linear approximation of the path tracked by the root.
+
+    EXAMPLES::
+
+        sage: from sage.libs.sirocco import contpath   # optional - sirocco
+        sage: from sage.rings.real_mpfr import RR
+        sage: pol = list(map(RR,[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        sage: contpath(2, pol, RR(0), RR(0))  # optional - sirocco # abs tol 1e-15
+        [(0.0, 0.0, 0.0),
+         (0.3535533905932738, -0.12500000000000003, 0.0),
+         (0.7071067811865476, -0.5000000000000001, 0.0),
+         (1.0, -1.0, 0.0)]
+    """
+    cdef double* rop
+    cdef double* c_values = <double*> check_allocarray(len(values), sizeof(double))
+    cdef int i
+    for i, v in enumerate(values):
+        c_values[i] = values[i]
+    cdef double y0R = y0r
+    cdef double y0I = y0i
+    sig_on()
+    rop = homotopyPath(deg, c_values, y0R, y0I)
+    sig_off()
+    if rop == NULL:
+        raise ValueError("libsirocco could not guarantee one step")
+    cdef int n = int(rop[0])
+    cdef list l = [0] * n
+    for i in range(n):
+        l[i] = (rop[3*i+1], rop[3*i+2], rop[3*i+3])
+    free(rop)
+    free(c_values)
+    return l
+
+cpdef list[list] contpath_comps(int deg, list values, double y0r, double y0i, list otherdegrees, list othercoefs) noexcept:
+    """
+    INPUT:
+
+    - An integer, representing the degree of the polynomial
+
+    - A list of floating point numbers. Each four consecutive elements
+      of this list represent the interval corresponding to a coefficient.
+      Coefficients are listed in increasing deglex order, and inside each
+      coefficients, the four numbers represent the lower real, upper real,
+      lower imaginary and real imaginary limits of the interval.
+
+    - A float representing the real part of the initial root approximation
+
+    - A float representing the imaginary part of the initial root.
+
+    OUTPUT:
+
+    A list of tuples. Each tuple represents the `x` value (between 0 and 1)
+    and the real and imaginary parts of the `y` value of a vertex in
+    the piecewise linear approximation of the path tracked by the root.
+
+    EXAMPLES::
+
+        sage: from sage.libs.sirocco import contpath_comps   # optional - sirocco
+        sage: from sage.rings.real_mpfr import RR
+        sage: pol = list(map(RR,[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        sage: fac = list(map(RR,[0, 0, 0.1, 0.2, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        sage: contpath_comps(2, pol, RR(0), RR(0), [2], fac)   # optional - sirocco # abs tol 1e-15
+        [(0.0, 0.0, 0.0),
+         (0.125, -0.015625, 0.0),
+         (0.25, -0.0625, 0.0),
+         (0.375, -0.140625, 0.0),
+         (0.5, -0.25, 0.0),
+         (0.625, -0.390625, 0.0),
+         (0.75, -0.5625, 0.0),
+         (0.875, -0.765625, 0.0),
+         (1.0, -1.0, 0.0)]
+    """
+    cdef double* rop
+    cdef double* c_values = <double*> check_allocarray(len(values), sizeof(double))
+    cdef int* c_otherdegrees = <int*> check_allocarray(len(otherdegrees), sizeof(int))
+    cdef double* c_othercoefs = <double*> check_allocarray(len(othercoefs), sizeof(double))
+    cdef int i
+    for i, v in enumerate(values):
+        c_values[i] = values[i]
+
+    for i, v in enumerate(otherdegrees):
+        c_otherdegrees[i] = otherdegrees[i]
+    for i, v in enumerate(othercoefs):
+        c_othercoefs[i] = othercoefs[i]
+
+    cdef double y0R = y0r
+    cdef double y0I = y0i
+    sig_on()
+    rop = homotopyPath_comps(deg, c_values, y0R, y0I, int(len(otherdegrees)), c_otherdegrees, c_othercoefs)
+    sig_off()
+    if rop == NULL:
+        raise ValueError("libsirocco could not guarantee one step")
+    cdef int n = int(rop[0])
+    cdef list l = [0] * n
+    for i in range(n):
+        l[i] = (rop[3*i+1], rop[3*i+2], rop[3*i+3])
+    free(rop)
+    free(c_values)
+    free(c_otherdegrees)
+    free(c_othercoefs)
+    return l