passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

cypari2/paripriv.pxd

@@ -0,0 +1,34 @@
+# distutils: libraries = gmp pari
+"""
+Declarations for private functions from PARI
+
+Ideally, we shouldn't use these, but for technical reasons, we have to.
+"""
+
+from .types cimport *
+
+cdef extern from "pari/paripriv.h":
+    int t_FF_FpXQ, t_FF_Flxq, t_FF_F2xq
+
+    int gpd_QUIET, gpd_TEST, gpd_EMACS, gpd_TEXMACS
+
+    struct pariout_t:
+        char format  # e,f,g
+        long fieldw  # 0 (ignored) or field width
+        long sigd    # -1 (all) or number of significant digits printed
+        int sp       # 0 = suppress whitespace from output
+        int prettyp  # output style: raw, prettyprint, etc
+        int TeXstyle
+
+    struct gp_data:
+        pariout_t *fmt
+        unsigned long flags
+        ulong primelimit    # deprecated
+
+    extern gp_data* GP_DATA
+
+# In older versions of PARI, this is declared in the private
+# non-installed PARI header file "anal.h". More recently, this is
+# declared in "paripriv.h". Since a double declaration does not hurt,
+# we declare it here regardless.
+cdef extern const char* closure_func_err()

cypari2/pycore_long.h

@@ -0,0 +1,98 @@
+#include "Python.h"
+#include <stdbool.h>
+
+#if PY_VERSION_HEX >= 0x030C00A5
+#define ob_digit(o)  (((PyLongObject*)o)->long_value.ob_digit)
+#else
+#define ob_digit(o)  (((PyLongObject*)o)->ob_digit)
+#endif
+
+#if PY_VERSION_HEX >= 0x030C00A7
+// taken from cpython:Include/internal/pycore_long.h @ 3.12
+
+/* Long value tag bits:
+ * 0-1: Sign bits value = (1-sign), ie. negative=2, positive=0, zero=1.
+ * 2: Reserved for immortality bit
+ * 3+ Unsigned digit count
+ */
+#define SIGN_MASK 3
+#define SIGN_ZERO 1
+#define SIGN_NEGATIVE 2
+#define NON_SIZE_BITS 3
+
+static inline bool
+_PyLong_IsZero(const PyLongObject *op)
+{
+    return (op->long_value.lv_tag & SIGN_MASK) == SIGN_ZERO;
+}
+
+static inline bool
+_PyLong_IsNegative(const PyLongObject *op)
+{
+    return (op->long_value.lv_tag & SIGN_MASK) == SIGN_NEGATIVE;
+}
+
+static inline bool
+_PyLong_IsPositive(const PyLongObject *op)
+{
+    return (op->long_value.lv_tag & SIGN_MASK) == 0;
+}
+
+static inline Py_ssize_t
+_PyLong_DigitCount(const PyLongObject *op)
+{
+    assert(PyLong_Check(op));
+    return op->long_value.lv_tag >> NON_SIZE_BITS;
+}
+
+#define TAG_FROM_SIGN_AND_SIZE(sign, size) ((1 - (sign)) | ((size) << NON_SIZE_BITS))
+
+static inline void
+_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size)
+{
+    assert(size >= 0);
+    assert(-1 <= sign && sign <= 1);
+    assert(sign != 0 || size == 0);
+    op->long_value.lv_tag = TAG_FROM_SIGN_AND_SIZE(sign, (size_t)size);
+}
+
+#else
+// fallback for < 3.12
+
+static inline bool
+_PyLong_IsZero(const PyLongObject *op)
+{
+    return Py_SIZE(op) == 0;
+}
+
+static inline bool
+_PyLong_IsNegative(const PyLongObject *op)
+{
+    return Py_SIZE(op) < 0;
+}
+
+static inline bool
+_PyLong_IsPositive(const PyLongObject *op)
+{
+    return Py_SIZE(op) > 0;
+}
+
+static inline Py_ssize_t
+_PyLong_DigitCount(const PyLongObject *op)
+{
+    Py_ssize_t size = Py_SIZE(op);
+    return size < 0 ? -size : size;
+}
+
+static inline void
+_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size)
+{
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION < 9)
+// The function Py_SET_SIZE is defined starting with python 3.9.
+    Py_SIZE(op) = size;
+#else
+    Py_SET_SIZE(op, sign < 0 ? -size : size);
+#endif
+}
+
+#endif

cypari2/pycore_long.pxd

@@ -0,0 +1,9 @@
+from cpython.longintrepr cimport py_long, digit
+
+cdef extern from "pycore_long.h":
+    digit* ob_digit(py_long o)
+    bint _PyLong_IsZero(py_long o)
+    bint _PyLong_IsNegative(py_long o)
+    bint _PyLong_IsPositive(py_long o)
+    Py_ssize_t _PyLong_DigitCount(py_long o)
+    void _PyLong_SetSignAndDigitCount(py_long o, int sign, Py_ssize_t size)

cypari2/stack.pxd

@@ -0,0 +1,27 @@
+# sage_setup: distribution = sagemath-pari
+
+from .types cimport GEN, pari_sp
+from .gen cimport Gen_base, Gen
+
+
+cdef Gen new_gen(GEN x)
+cdef new_gens2(GEN x, GEN y)
+cdef Gen new_gen_noclear(GEN x)
+cdef Gen clone_gen(GEN x)
+cdef Gen clone_gen_noclear(GEN x)
+
+cdef void clear_stack() noexcept
+cdef void reset_avma() noexcept
+
+cdef void remove_from_pari_stack(Gen self) noexcept
+cdef int move_gens_to_heap(pari_sp lim) except -1
+
+cdef int before_resize() except -1
+cdef int set_pari_stack_size(size_t size, size_t sizemax) except -1
+cdef void after_resize() noexcept
+
+
+cdef class DetachGen:
+    cdef source
+
+    cdef GEN detach(self) except NULL

cypari2/stack.pyx

@@ -0,0 +1,278 @@
+# sage_setup: distribution = sagemath-pari
+"""
+Memory management for Gens on the PARI stack or the heap
+********************************************************
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2016 Luca De Feo <luca.defeo@polytechnique.edu>
+#       Copyright (C) 2018 Jeroen Demeyer <J.Demeyer@UGent.be>
+#
+# 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/
+# ****************************************************************************
+
+cimport cython
+
+from cpython.ref cimport PyObject, _Py_REFCNT
+from cpython.exc cimport PyErr_SetString
+
+from cysignals.signals cimport (sig_on, sig_off, sig_block, sig_unblock,
+                                sig_error)
+
+from .gen cimport Gen, Gen_new
+from .paridecl cimport (avma, pari_mainstack, gnil, gcopy,
+                        is_universal_constant, is_on_stack,
+                        isclone, gclone, gclone_refc,
+                        paristack_setsize)
+
+from warnings import warn
+
+
+cdef extern from *:
+    int sig_on_count "cysigs.sig_on_count"
+    int block_sigint "cysigs.block_sigint"
+
+
+# Singleton object to denote the top of the PARI stack
+cdef Gen top_of_stack = Gen_new(gnil, NULL)
+
+# Pointer to the Gen on the bottom of the PARI stack. This is the first
+# element of the Gen linked list. If the linked list is empty, this
+# equals top_of_stack. This pointer is *not* refcounted, so it does not
+# prevent the stackbottom object from being deallocated. In that case,
+# we update stackbottom in Gen.__dealloc__
+cdef PyObject* stackbottom = <PyObject*>top_of_stack
+
+
+cdef void remove_from_pari_stack(Gen self) noexcept:
+    global avma, stackbottom
+    if <PyObject*>self is not stackbottom:
+        print("ERROR: removing wrong instance of Gen")
+        print(f"Expected: {<object>stackbottom}")
+        print(f"Actual:   {self}")
+    if sig_on_count and not block_sigint:
+        PyErr_SetString(SystemError, "calling remove_from_pari_stack() inside sig_on()")
+        sig_error()
+    if self.sp() != avma:
+        if avma > self.sp():
+            print("ERROR: inconsistent avma when removing Gen from PARI stack")
+            print(f"Expected: 0x{self.sp():x}")
+            print(f"Actual:   0x{avma:x}")
+        else:
+            warn(f"cypari2 leaked {self.sp() - avma} bytes on the PARI stack",
+                 RuntimeWarning, stacklevel=2)
+    n = self.next
+    stackbottom = <PyObject*>n
+    self.next = None
+    reset_avma()
+
+
+cdef inline Gen Gen_stack_new(GEN x):
+    """
+    Allocate and initialize a new instance of ``Gen`` wrapping
+    a GEN on the PARI stack.
+    """
+    global stackbottom
+    # n = <Gen>stackbottom must be done BEFORE calling Gen_new()
+    # since Gen_new may invoke gc.collect() which would mess up
+    # the PARI stack.
+    n = <Gen>stackbottom
+    z = Gen_new(x, <GEN>avma)
+    z.next = n
+    stackbottom = <PyObject*>z
+    sz = z.sp()
+    sn = n.sp()
+    if sz > sn:
+        raise SystemError(f"objects on PARI stack in invalid order (first: 0x{sz:x}; next: 0x{sn:x})")
+    return z
+
+
+cdef void reset_avma() noexcept:
+    """
+    Reset PARI stack pointer to remove unused stuff from the PARI stack.
+
+    Note that the actual data remains on the stack. Therefore, it is
+    safe to use as long as no further PARI functions are called.
+    """
+    # NOTE: this can be called with an exception set (the error handler
+    # does that)!
+    global avma
+    avma = (<Gen>stackbottom).sp()
+
+
+cdef void clear_stack() noexcept:
+    """
+    Call ``sig_off()`` and clean the PARI stack.
+    """
+    sig_off()
+    reset_avma()
+
+
+cdef int move_gens_to_heap(pari_sp lim) except -1:
+    """
+    Move some/all Gens from the PARI stack to the heap.
+
+    If lim == -1, move everything. Otherwise, keep moving as long as
+    avma <= lim.
+    """
+    while avma <= lim and stackbottom is not <PyObject*>top_of_stack:
+        current = <Gen>stackbottom
+        sig_on()
+        current.g = gclone(current.g)
+        sig_block()
+        remove_from_pari_stack(current)
+        sig_unblock()
+        sig_off()
+        # The .address attribute can only be updated now because it is
+        # needed in remove_from_pari_stack(). This means that the object
+        # is temporarily in an inconsistent state but this does not
+        # matter since .address is normally not used.
+        #
+        # The more important .g attribute is updated correctly before
+        # remove_from_pari_stack(). Therefore, the object can be used
+        # normally regardless of what happens to the PARI stack.
+        current.address = current.g
+
+
+cdef int before_resize() except -1:
+    """
+    Prepare for resizing the PARI stack
+
+    This must be called before reallocating the PARI stack
+    """
+    move_gens_to_heap(-1)
+    if top_of_stack.sp() != pari_mainstack.top:
+        raise RuntimeError("cannot resize PARI stack here")
+
+
+cdef int set_pari_stack_size(size_t size, size_t sizemax) except -1:
+    """
+    Safely set the PARI stack size
+    """
+    before_resize()
+    sig_on()
+    paristack_setsize(size, sizemax)
+    sig_off()
+    after_resize()
+
+
+cdef void after_resize() noexcept:
+    """
+    This must be called after reallocating the PARI stack
+    """
+    top_of_stack.address = <GEN>pari_mainstack.top
+
+
+cdef Gen new_gen(GEN x):
+    """
+    Create a new ``Gen`` from a ``GEN``. Except if `x` is ``gnil``, then
+    return ``None`` instead.
+
+    Also call ``sig_off``() and clear the PARI stack.
+    """
+    sig_off()
+    if x is gnil:
+        reset_avma()
+        return None
+    return new_gen_noclear(x)
+
+
+cdef new_gens2(GEN x, GEN y):
+    """
+    Create a 2-tuple of new ``Gen``s from 2 ``GEN``s.
+
+    Also call ``sig_off``() and clear the PARI stack.
+    """
+    sig_off()
+    global avma
+    av = avma
+    g1 = new_gen_noclear(x)
+    # Restore avma in case that remove_from_pari_stack() was called
+    avma = av
+    g2 = new_gen_noclear(y)
+    return (g1, g2)
+
+
+cdef Gen new_gen_noclear(GEN x):
+    """
+    Create a new ``Gen`` from a ``GEN``.
+    """
+    if not is_on_stack(x):
+        reset_avma()
+        if is_universal_constant(x):
+            return Gen_new(x, NULL)
+        elif isclone(x):
+            gclone_refc(x)
+            return Gen_new(x, x)
+        raise SystemError("new_gen() argument not on PARI stack, not on PARI heap and not a universal constant")
+
+    z = Gen_stack_new(x)
+
+    # If we used over half of the PARI stack, move all Gens to the heap
+    if (pari_mainstack.top - avma) >= pari_mainstack.size // 2:
+        if sig_on_count == 0:
+            try:
+                move_gens_to_heap(-1)
+            except MemoryError:
+                pass
+
+    return z
+
+
+cdef Gen clone_gen(GEN x):
+    x = gclone(x)
+    clear_stack()
+    return Gen_new(x, x)
+
+
+cdef Gen clone_gen_noclear(GEN x):
+    x = gclone(x)
+    return Gen_new(x, x)
+
+
+@cython.no_gc
+cdef class DetachGen:
+    """
+    Destroy a :class:`Gen` but keep the ``GEN`` which is inside it.
+
+    The typical usage is as follows:
+
+    1. Creates the ``DetachGen`` object from a :class`Gen`.
+
+    2. Removes all other references to that :class:`Gen`.
+
+    3. Call the ``detach`` method to retrieve the ``GEN`` (or a copy of
+       it if the original was not on the stack).
+    """
+    def __init__(self, s):
+        self.source = s
+
+    cdef GEN detach(self) except NULL:
+        src = <Gen?>self.source
+
+        # Whatever happens, delete self.source
+        self.source = None
+
+        # Delete src safely, keeping it available as GEN
+        cdef GEN res = src.g
+        if is_on_stack(res):
+            # Verify that we hold the only reference to src
+            if _Py_REFCNT(<PyObject*>src) != 1:
+                raise SystemError("cannot detach a Gen which is still referenced")
+        elif is_universal_constant(res):
+            pass
+        else:
+            # Make a copy to the PARI stack
+            res = gcopy(res)
+
+        # delete src but do not change avma
+        global avma
+        cdef pari_sp av = avma
+        avma = src.sp()  # Avoid a warning when deallocating
+        del src
+        avma = av
+        return res

cypari2/string_utils.pxd

@@ -0,0 +1,29 @@
+# sage_setup: distribution = sagemath-pari
+
+cdef extern from *:
+    int PY_MAJOR_VERSION
+
+cpdef bytes to_bytes(s)
+cpdef unicode to_unicode(s)
+
+cpdef inline to_string(s):
+    r"""
+    Converts a bytes and unicode ``s`` to a string.
+
+    String means bytes in Python2 and unicode in Python3
+
+    Examples:
+
+    >>> from cypari2.string_utils import to_string
+    >>> s1 = to_string(b'hello')
+    >>> s2 = to_string('hello')
+    >>> s3 = to_string(u'hello')
+    >>> type(s1) == type(s2) == type(s3) == str
+    True
+    >>> s1 == s2 == s3 == 'hello'
+    True
+    """
+    if PY_MAJOR_VERSION <= 2:
+        return to_bytes(s)
+    else:
+        return to_unicode(s)

cypari2/string_utils.pyx

@@ -0,0 +1,65 @@
+# sage_setup: distribution = sagemath-pari
+r"""
+Conversion functions for bytes/unicode
+"""
+
+import sys
+encoding = sys.getfilesystemencoding()
+
+
+cpdef bytes to_bytes(s):
+    """
+    Converts bytes and unicode ``s`` to bytes.
+
+    Examples:
+
+    >>> from cypari2.string_utils import to_bytes
+    >>> s1 = to_bytes(b'hello')
+    >>> s2 = to_bytes('hello')
+    >>> s3 = to_bytes(u'hello')
+    >>> type(s1) is type(s2) is type(s3) is bytes
+    True
+    >>> s1 == s2 == s3 == b'hello'
+    True
+
+    >>> type(to_bytes(1234)) is bytes
+    True
+    >>> int(to_bytes(1234))
+    1234
+    """
+    cdef int convert
+    for convert in range(2):
+        if convert:
+            s = str(s)
+        if isinstance(s, bytes):
+            return <bytes> s
+        elif isinstance(s, unicode):
+            return (<unicode> s).encode(encoding)
+    raise AssertionError(f"str() returned {type(s)}")
+
+
+cpdef unicode to_unicode(s):
+    r"""
+    Converts bytes and unicode ``s`` to unicode.
+
+    Examples:
+
+    >>> from cypari2.string_utils import to_unicode
+    >>> s1 = to_unicode(b'hello')
+    >>> s2 = to_unicode('hello')
+    >>> s3 = to_unicode(u'hello')
+    >>> type(s1) is type(s2) is type(s3) is type(u"")
+    True
+    >>> s1 == s2 == s3 == u'hello'
+    True
+
+    >>> print(to_unicode(1234))
+    1234
+    >>> type(to_unicode(1234)) is type(u"")
+    True
+    """
+    if isinstance(s, bytes):
+        return (<bytes> s).decode(encoding)
+    elif isinstance(s, unicode):
+        return <unicode> s
+    return unicode(s)

cypari2/types.pxd

@@ -0,0 +1,147 @@
+# sage_setup: distribution = sagemath-pari
+"""
+Declarations for types used by PARI
+
+This includes both the C types as well as the PARI types (and a few
+macros for dealing with those).
+
+It is important that the functionality in this file does not call any
+PARI library functions. The reason is that we want to allow just using
+these types (for example, to define a Cython extension type) without
+linking to PARI. This file should consist only of typedefs and macros
+from PARI's include files.
+"""
+
+# ****************************************************************************
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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/
+# ****************************************************************************
+
+cdef extern from "pari/pari.h":
+    ctypedef unsigned long ulong "pari_ulong"
+
+    ctypedef long* GEN
+    ctypedef char* byteptr
+    ctypedef unsigned long pari_sp
+    ctypedef unsigned long pari_prime
+
+    # PARI types
+    enum:
+        t_INT
+        t_REAL
+        t_INTMOD
+        t_FRAC
+        t_FFELT
+        t_COMPLEX
+        t_PADIC
+        t_QUAD
+        t_POLMOD
+        t_POL
+        t_SER
+        t_RFRAC
+        t_QFR
+        t_QFI
+        t_VEC
+        t_COL
+        t_MAT
+        t_LIST
+        t_STR
+        t_VECSMALL
+        t_CLOSURE
+        t_ERROR
+        t_INFINITY
+
+    int BITS_IN_LONG
+    int LOWDEFAULTPREC
+    long DEFAULTPREC       # 64 bits precision
+    long MEDDEFAULTPREC    # 128 bits precision
+    long BIGDEFAULTPREC    # 192 bits precision
+
+    ulong CLONEBIT
+
+    long    typ(GEN x)
+    long    settyp(GEN x, long s)
+    long    isclone(GEN x)
+    long    setisclone(GEN x)
+    long    unsetisclone(GEN x)
+    long    lg(GEN x)
+    long    setlg(GEN x, long s)
+    long    signe(GEN x)
+    long    setsigne(GEN x, long s)
+    long    lgefint(GEN x)
+    long    setlgefint(GEN x, long s)
+    long    expo(GEN x)
+    long    setexpo(GEN x, long s)
+    long    valp(GEN x)
+    long    setvalp(GEN x, long s)
+    long    precp(GEN x)
+    long    setprecp(GEN x, long s)
+    long    varn(GEN x)
+    long    setvarn(GEN x, long s)
+    long    evaltyp(long x)
+    long    evallg(long x)
+    long    evalvarn(long x)
+    long    evalsigne(long x)
+    long    evalprecp(long x)
+    long    evalvalp(long x)
+    long    evalexpo(long x)
+    long    evallgefint(long x)
+
+    ctypedef struct PARI_plot:
+        long width
+        long height
+        long hunit
+        long vunit
+        long fwidth
+        long fheight
+        void (*draw)(PARI_plot *T, GEN w, GEN x, GEN y)
+
+    ctypedef struct entree:
+        const char *name
+        ulong valence
+        void *value
+        long menu
+        const char *code
+        const char *help
+        void *pvalue
+        long arity
+        ulong hash
+        entree *next
+
+    # Various structures that we don't interface but which need to be
+    # declared, such that Cython understands the declarations of
+    # functions using these types.
+    struct bb_group
+    struct bb_field
+    struct bb_ring
+    struct bb_algebra
+    struct qfr_data
+    struct nfmaxord_t
+    struct forcomposite_t
+    struct forpart_t
+    struct forprime_t
+    struct forvec_t
+    struct gp_context
+    struct nfbasic_t
+    struct pariFILE
+    struct pari_mt
+    struct pari_stack
+    struct pari_thread
+    struct pari_timer
+    struct GENbin
+    struct hashentry
+    struct hashtable
+
+    # These are actually defined in cypari.h but we put them here to
+    # prevent Cython from reordering the includes.
+    GEN set_gel(GEN x, long n, GEN z)              # gel(x, n) = z
+    GEN set_gmael(GEN x, long i, long j, GEN z)    # gmael(x, i, j) = z
+    GEN set_gcoeff(GEN x, long i, long j, GEN z)   # gcoeff(x, i, j) = z
+    GEN set_uel(GEN x, long n, ulong z)            # uel(x, n) = z
+
+
+# It is important that this gets included *after* all PARI includes
+cdef extern from "cypari.h":
+    pass

passagemath_pari-10.6.32.data/data/etc/jupyter/nbconfig/notebook.d/gp-mode.json

@@ -0,0 +1,5 @@
+{
+  "load_extensions": {
+    "gp-mode/main": true
+  }
+}