passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

cypari2/pari_instance.pyx

@@ -0,0 +1,1438 @@
+# sage_setup: distribution = sagemath-pari
+r"""
+Interface to the PARI library
+*****************************
+
+AUTHORS:
+
+- William Stein (2006-03-01): updated to work with PARI 2.2.12-beta
+
+- William Stein (2006-03-06): added newtonpoly
+
+- Justin Walker: contributed some of the function definitions
+
+- Gonzalo Tornaria: improvements to conversions; much better error
+  handling.
+
+- Robert Bradshaw, Jeroen Demeyer, William Stein (2010-08-15):
+  Upgrade to PARI 2.4.3 (:trac:`9343`)
+
+- Jeroen Demeyer (2011-11-12): rewrite various conversion routines
+  (:trac:`11611`, :trac:`11854`, :trac:`11952`)
+
+- Peter Bruin (2013-11-17): split off this file from gen.pyx
+  (:trac:`15185`)
+
+- Jeroen Demeyer (2014-02-09): upgrade to PARI 2.7 (:trac:`15767`)
+
+- Jeroen Demeyer (2014-09-19): upgrade to PARI 2.8 (:trac:`16997`)
+
+- Jeroen Demeyer (2015-03-17): automatically generate methods from
+  ``pari.desc`` (:trac:`17631` and :trac:`17860`)
+
+- Luca De Feo (2016-09-06): Separate Sage-specific components from
+  generic C-interface in ``Pari`` (:trac:`20241`)
+
+Examples:
+
+>>> import cypari2
+>>> pari = cypari2.Pari()
+>>> pari('5! + 10/x')
+(120*x + 10)/x
+>>> pari('intnum(x=0,13,sin(x)+sin(x^2) + x)')
+85.6215190762676
+>>> f = pari('x^3 - 1')
+>>> v = f.factor(); v
+[x - 1, 1; x^2 + x + 1, 1]
+>>> v[0]   # indexing is 0-based unlike in GP.
+[x - 1, x^2 + x + 1]~
+>>> v[1]
+[1, 1]~
+
+For most functions, you can call the function as method of ``pari``
+or you can first create a :class:`Gen` object and then call the
+function as method of that. In other words, the following two commands
+do the same:
+
+>>> pari('x^3 - 1').factor()
+[x - 1, 1; x^2 + x + 1, 1]
+>>> pari.factor('x^3 - 1')
+[x - 1, 1; x^2 + x + 1, 1]
+
+Arithmetic operations cause all arguments to be converted to PARI:
+
+>>> type(pari(1) + 1)
+<... 'cypari2.gen.Gen'>
+>>> type(1 + pari(1))
+<... 'cypari2.gen.Gen'>
+
+Guide to real precision in the PARI interface
+=============================================
+
+In the PARI interface, "real precision" refers to the precision of real
+numbers, so it is the floating-point precision. This is a non-trivial
+issue, since there are various interfaces for different things.
+
+Internal representation of floating-point numbers in PARI
+---------------------------------------------------------
+
+Real numbers in PARI have a precision associated to them, which is
+always a multiple of the CPU wordsize. So, it is a multiple of 32
+of 64 bits. When converting a ``float`` from Python to PARI, the
+``float`` has 53 bits of precision which is rounded up to 64 bits
+in PARI:
+
+>>> x = 1.0
+>>> pari(x)
+1.00000000000000
+>>> pari(x).bitprecision()
+64
+
+It is possible to change the precision of a PARI object with the
+:meth:`Gen.bitprecision` method:
+
+>>> p = pari(1.0)
+>>> p.bitprecision()
+64
+>>> p = p.bitprecision(100)
+>>> p.bitprecision()   # Rounded up to a multiple of the wordsize
+128
+
+Beware that these extra bits are just bogus. For example, this will not
+magically give a more precise approximation of ``math.pi``:
+
+>>> import math
+>>> p = pari(math.pi)
+>>> pari("Pi") - p
+1.225148... E-16
+>>> p = p.bitprecision(1000)
+>>> pari("Pi") - p
+1.225148... E-16
+
+Another way to create numbers with many bits is to use a string with
+many digits:
+
+>>> p = pari("3.1415926535897932384626433832795028842")
+>>> p.bitprecision()
+128
+
+.. _pari_output_precision:
+
+Output precision for printing
+-----------------------------
+
+Even though PARI reals have a precision, not all significant bits are
+printed by default. The maximum number of digits when printing a PARI
+real can be set using the methods
+:meth:`Pari.set_real_precision_bits` or
+:meth:`Pari.set_real_precision`.
+Note that this will also change the input precision for strings,
+see :ref:`pari_input_precision`.
+
+We create a very precise approximation of pi and see how it is printed
+in PARI:
+
+>>> pi = pari.pi(precision=1024)
+
+The default precision is 15 digits:
+
+>>> pi
+3.14159265358979
+
+With a different precision, we see more digits. Note that this does not
+affect the object ``pi`` at all, it only affects how it is printed:
+
+>>> _ = pari.set_real_precision(50)
+>>> pi
+3.1415926535897932384626433832795028841971693993751
+
+Back to the default:
+
+>>> _ = pari.set_real_precision(15)
+>>> pi
+3.14159265358979
+
+.. _pari_input_precision:
+
+Input precision for function calls
+----------------------------------
+
+When we talk about precision for PARI functions, we need to distinguish
+three kinds of calls:
+
+1. Using the string interface, for example ``pari("sin(1)")``.
+
+2. Using the library interface with *exact* inputs, for example
+   ``pari.sin(1)``.
+
+3. Using the library interface with *inexact* inputs, for example
+   ``pari.sin(1.0)``.
+
+In the first case, the relevant precision is the one set by the methods
+:meth:`Pari.set_real_precision_bits` or
+:meth:`Pari.set_real_precision`:
+
+>>> pari.set_real_precision_bits(150)
+>>> pari("sin(1)")
+0.841470984807896506652502321630298999622563061
+>>> pari.set_real_precision_bits(53)
+>>> pari("sin(1)")
+0.841470984807897
+
+In the second case, the precision can be given as the argument
+``precision`` in the function call, with a default of 53 bits.
+The real precision set by
+:meth:`Pari.set_real_precision_bits` or
+:meth:`Pari.set_real_precision` does not affect the call
+(but it still affects printing).
+
+As explained before, the precision increases to a multiple of the
+wordsize (and you should not assume that the extra bits are meaningful):
+
+>>> a = pari.sin(1, precision=180); a
+0.841470984807897
+>>> a.bitprecision()
+192
+>>> b = pari.sin(1, precision=40); b
+0.841470984807897
+>>> b.bitprecision()
+64
+>>> c = pari.sin(1); c
+0.841470984807897
+>>> c.bitprecision()
+64
+>>> pari.set_real_precision_bits(90)
+>>> print(a); print(b); print(c)
+0.841470984807896506652502322
+0.8414709848078965067
+0.8414709848078965067
+
+In the third case, the precision is determined only by the inexact
+inputs and the ``precision`` argument is ignored:
+
+>>> pari.sin(1.0, precision=180).bitprecision()
+64
+>>> pari.sin(1.0, precision=40).bitprecision()
+64
+>>> pari.sin("1.0000000000000000000000000000000000000").bitprecision()
+128
+
+Tests:
+
+Check that the documentation is generated correctly:
+
+>>> from inspect import getdoc
+>>> getdoc(pari.Pi)
+'The constant :math:`\\pi` ...'
+
+Check that output from PARI's print command is actually seen by
+Python (:trac:`9636`):
+
+>>> pari('print("test")')
+test
+
+Verify that ``nfroots()`` (which has an unusual signature with a
+non-default argument following a default argument) works:
+
+>>> pari.nfroots(x='x^4 - 1')
+[-1, 1]...
+>>> pari.nfroots(pari.nfinit('t^2 + 1'), "x^4 - 1")
+[-1, 1, Mod(-t, t^2 + 1), Mod(t, t^2 + 1)]...
+
+Reset default precision for the following tests:
+
+>>> pari.set_real_precision_bits(53)
+
+Test the trashcan mechanism (without the trashcan, this would cause
+a stack overflow):
+
+>>> pari.allocatemem(2**27, silent=True)
+>>> L = [pari(i) for i in range(2**20)]
+>>> x = pari.Pi()
+>>> del L
+>>> del x
+
+Test that interrupts work properly:
+
+>>> pari.allocatemem(8000000, 2**29)
+PARI stack size set to 8000000 bytes, maximum size set to ...
+>>> from cysignals.alarm import alarm, AlarmInterrupt
+>>> for i in range(1, 11):
+...     try:
+...         alarm(i/11.0)
+...         pari.binomial(2**100, 2**22)
+...     except AlarmInterrupt:
+...         pass
+
+Test that changing the stack size using ``default`` works properly:
+
+>>> pari.default("parisizemax", 2**23)
+>>> pari = cypari2.Pari()  # clear stack
+>>> a = pari(1)
+>>> pari.default("parisizemax", 2**29)
+>>> a + a
+2
+>>> pari.default("parisizemax")
+536870912
+"""
+
+# ****************************************************************************
+# 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/
+# ****************************************************************************
+
+import sys
+from libc.stdio cimport *
+cimport cython
+
+from cysignals.signals cimport sig_check, sig_on, sig_off, sig_error
+
+from .string_utils cimport to_string, to_bytes
+from .paridecl cimport *
+from .paripriv cimport *
+from .gen cimport Gen, objtogen
+from .stack cimport (new_gen, new_gen_noclear, clear_stack,
+                     set_pari_stack_size, before_resize, after_resize)
+from .handle_error cimport _pari_init_error_handling
+from .closure cimport _pari_init_closure
+
+
+#################################################################
+# conversions between various real precision models
+#################################################################
+
+def prec_bits_to_dec(long prec_in_bits):
+    r"""
+    Convert from precision expressed in bits to precision expressed in
+    decimal.
+
+    Examples:
+
+    >>> from cypari2.pari_instance import prec_bits_to_dec
+    >>> prec_bits_to_dec(53)
+    15
+    >>> [(32*n, prec_bits_to_dec(32*n)) for n in range(1, 9)]
+    [(32, 9), (64, 19), (96, 28), (128, 38), (160, 48), (192, 57), (224, 67), (256, 77)]
+    """
+    return nbits2ndec(prec_in_bits)
+
+
+def prec_dec_to_bits(long prec_in_dec):
+    r"""
+    Convert from precision expressed in decimal to precision expressed
+    in bits.
+
+    Examples:
+
+    >>> from cypari2.pari_instance import prec_dec_to_bits
+    >>> prec_dec_to_bits(15)
+    50
+    >>> [(n, prec_dec_to_bits(n)) for n in range(10, 100, 10)]
+    [(10, 34), (20, 67), (30, 100), (40, 133), (50, 167), (60, 200), (70, 233), (80, 266), (90, 299)]
+    """
+    cdef double log_10 = 3.32192809488736
+    return int(prec_in_dec*log_10 + 1.0)  # Add one to round up
+
+
+cpdef long prec_words_to_bits(long prec_in_words) noexcept:
+    r"""
+    Deprecated internal function. Used (incorrectly) in sagemath < 10.5.
+
+    Convert from pari real precision expressed in words to precision
+    expressed in bits. Note: this adjusts for the two codewords of a
+    pari real, and is architecture-dependent.
+
+    Examples:
+
+    >>> from cypari2.pari_instance import prec_words_to_bits
+    >>> import sys
+    >>> import warnings
+    >>> warnings.simplefilter("ignore")
+    >>> bitness = '64' if sys.maxsize > (1 << 32) else '32'
+    >>> prec_words_to_bits(10) == (256 if bitness == '32' else 512)
+    True
+
+    >>> ans32 = [(3, 32), (4, 64), (5, 96), (6, 128), (7, 160), (8, 192), (9, 224)]
+    >>> ans64 = [(3, 64), (4, 128), (5, 192), (6, 256), (7, 320), (8, 384), (9, 448)] # 64-bit
+    >>> [(n, prec_words_to_bits(n)) for n in range(3, 10)] == (ans32 if bitness == '32' else ans64)
+    True
+    """
+    from warnings import warn
+    warn("'prec_words_to_bits` in cypari2 is internal and deprecated",
+         DeprecationWarning)
+    # see user's guide to the pari library, page 10
+    return (prec_in_words - 2) * BITS_IN_LONG
+
+
+cpdef long default_bitprec() noexcept:
+    r"""
+    Return the default precision in bits.
+
+    Examples:
+
+    >>> from cypari2.pari_instance import default_bitprec
+    >>> default_bitprec()
+    64
+    """
+    return DEFAULT_BITPREC
+
+
+def prec_words_to_dec(long prec_in_words):
+    r"""
+    Deprecated internal function.
+
+    Convert from precision expressed in words to precision expressed in
+    decimal. Note: this adjusts for the two codewords of a pari real,
+    and is architecture-dependent.
+
+    Examples:
+
+    >>> from cypari2.pari_instance import prec_words_to_dec
+    >>> import sys
+    >>> import warnings
+    >>> warnings.simplefilter("ignore")
+    >>> bitness = '64' if sys.maxsize > (1 << 32) else '32'
+    >>> prec_words_to_dec(5) == (28 if bitness == '32' else 57)
+    True
+
+    >>> ans32 = [(3, 9), (4, 19), (5, 28), (6, 38), (7, 48), (8, 57), (9, 67)]
+    >>> ans64 = [(3, 19), (4, 38), (5, 57), (6, 77), (7, 96), (8, 115), (9, 134)]
+    >>> [(n, prec_words_to_dec(n)) for n in range(3, 10)] == (ans32 if bitness == '32' else ans64)
+    True
+    """
+    from warnings import warn
+    warn("'prec_words_to_dec` in cypari2 is internal and deprecated",
+         DeprecationWarning)
+    return prec_bits_to_dec(prec_words_to_bits(prec_in_words))
+
+
+# Callbacks from PARI to print stuff using sys.stdout.write() instead
+# of C library functions like puts().
+cdef PariOUT python_pariOut
+
+cdef void python_putchar(char c) noexcept:
+    cdef char s[2]
+    s[0] = c
+    s[1] = 0
+    try:
+        # avoid string conversion if possible
+        sys.stdout.buffer.write(s)
+    except AttributeError:
+        sys.stdout.write(to_string(s))
+    # Let PARI think the last character was a newline,
+    # so it doesn't print one when an error occurs.
+    pari_set_last_newline(1)
+
+cdef void python_puts(const char* s) noexcept:
+    try:
+        # avoid string conversion if possible
+        sys.stdout.buffer.write(s)
+    except AttributeError:
+        sys.stdout.write(to_string(s))
+    pari_set_last_newline(1)
+
+cdef void python_flush() noexcept:
+    sys.stdout.flush()
+
+include 'auto_instance.pxi'
+
+
+cdef class Pari(Pari_auto):
+    def __cinit__(self):
+        r"""
+        (Re)-initialize the PARI library.
+
+        Tests:
+
+        >>> from cypari2.pari_instance import Pari
+        >>> Pari.__new__(Pari)
+        Interface to the PARI C library
+        >>> pari = Pari()
+        >>> pari("print('hello')")
+        """
+        # PARI is already initialized, nothing to do...
+        if avma:
+            return
+
+        # Take 1MB as minimal stack. Use maxprime=0, which PARI will
+        # internally increase to some small value like 65537.
+        # (see function initprimes in src/language/forprime.c)
+        pari_init_opts(1000000 * sizeof(long), 0, INIT_DFTm)
+        after_resize()
+
+        # Disable PARI's stack overflow checking which is incompatible
+        # with multi-threading.
+        pari_stackcheck_init(NULL)
+
+        _pari_init_error_handling()
+        _pari_init_closure()
+
+        # Set printing functions
+        global pariOut, pariErr
+
+        pariOut = &python_pariOut
+        pariOut.putch = python_putchar
+        pariOut.puts = python_puts
+        pariOut.flush = python_flush
+
+        # Use 53 bits as default precision
+        self.set_real_precision_bits(53)
+
+        # Disable pretty-printing
+        GP_DATA.fmt.prettyp = 0
+
+        # This causes PARI/GP to use output independent of the terminal
+        # (which is what we want for the PARI library interface).
+        GP_DATA.flags = gpd_TEST
+
+        # Ensure that Galois groups are represented in a sane way,
+        # see the polgalois section of the PARI users manual.
+        global new_galois_format
+        new_galois_format = 1
+
+        # By default, factor() should prove primality of returned
+        # factors. This not only influences the factor() function, but
+        # also many functions indirectly using factoring.
+        global factor_proven
+        factor_proven = 1
+
+        # Monkey-patch default(parisize) and default(parisizemax)
+        ep = pari_is_default("parisize")
+        if ep:
+            ep.value = <void*>patched_parisize
+        ep = pari_is_default("parisizemax")
+        if ep:
+            ep.value = <void*>patched_parisizemax
+
+    def __init__(self, size_t size=8000000, size_t sizemax=0, unsigned long maxprime=500000):
+        """
+        (Re)-Initialize the PARI system.
+
+        INPUT:
+
+        - ``size`` -- (default: 8000000) the number of bytes for the
+          initial PARI stack (see notes below)
+
+        - ``sizemax`` -- the maximal number of bytes for the
+          dynamically increasing PARI stack. The default ``0`` means
+          to use the same value as ``size`` (see notes below)
+
+        - ``maxprime`` -- (default: 500000) limit on the primes in the
+          precomputed prime number table which is used for sieving
+          algorithms
+
+        When the PARI system is already initialized, the PARI stack is only
+        grown if ``size`` is greater than the current stack, and the table
+        of primes is only computed if ``maxprime`` is larger than the current
+        bound.
+
+        Examples:
+
+        >>> from cypari2.pari_instance import Pari
+        >>> pari = Pari()
+        >>> pari2 = Pari(10**7)
+        >>> pari2
+        Interface to the PARI C library
+        >>> pari2 is pari
+        False
+        >>> pari2.PARI_ZERO == pari.PARI_ZERO
+        True
+        >>> pari2 = Pari(10**6)
+        >>> pari.stacksize(), pari2.stacksize()
+        (10000000, 10000000)
+
+        >>> Pari().default("primelimit")
+        500000
+        >>> Pari(maxprime=20000).default("primelimit")
+        20000
+
+        For more information about how precision works in the PARI
+        interface, see :mod:`cypari2.pari_instance`.
+
+        .. NOTE::
+
+            PARI has a "real" stack size (``size``) and a "virtual"
+            stack size (``sizemax``). The idea is that the real stack
+            will be used if possible, but that the stack might be
+            increased up to ``sizemax`` bytes. Therefore, it is not a
+            problem to set ``sizemax`` to a large value. On the other
+            hand, it also makes no sense to set this to a value larger
+            than what your system can handle.
+
+        .. NOTE::
+
+           Normally, all results from PARI computations end up on the
+           PARI stack. CyPari2 tries to keep everything on the PARI
+           stack. However, if over half of the PARI stack space is used,
+           all live objects on the PARI stack are copied to the PARI
+           heap (they become so-called clones).
+        """
+        # Increase (but don't decrease) size and sizemax to the
+        # requested value
+        size = max(size, pari_mainstack.rsize)
+        sizemax = max(max(size, pari_mainstack.vsize), sizemax)
+        set_pari_stack_size(size, sizemax)
+
+        # Increase the table of primes if needed
+        GP_DATA.primelimit = maxprime
+        self.init_primes(maxprime)
+
+        # Initialize some constants
+        self.PARI_ZERO = new_gen_noclear(gen_0)
+        self.PARI_ONE = new_gen_noclear(gen_1)
+        self.PARI_TWO = new_gen_noclear(gen_2)
+
+        IF HAVE_PLOT_SVG:
+            # If we are running under IPython, setup for displaying SVG plots.
+            if "IPython" in sys.modules:
+                pari_set_plot_engine(get_plot_ipython)
+
+    def debugstack(self):
+        r"""
+        Print the internal PARI variables ``top`` (top of stack), ``avma``
+        (available memory address, think of this as the stack pointer),
+        ``bot`` (bottom of stack).
+        """
+        # We deliberately use low-level functions to minimize the
+        # chances that something goes wrong here (for example, if we
+        # are out of memory).
+        printf("top =  %p\navma = %p\nbot =  %p\nsize = %lu\n",
+               <void*>pari_mainstack.top,
+               <void*>avma,
+               <void*>pari_mainstack.bot,
+               <unsigned long>pari_mainstack.rsize)
+        fflush(stdout)
+
+    def __repr__(self):
+        return "Interface to the PARI C library"
+
+    def __hash__(self):
+        return 907629390
+
+    def set_debug_level(self, level):
+        """
+        Set the debug PARI C library variable.
+        """
+        self.default('debug', int(level))
+
+    def get_debug_level(self):
+        """
+        Set the debug PARI C library variable.
+        """
+        return int(self.default('debug'))
+
+    def set_real_precision_bits(self, n):
+        """
+        Sets the PARI default real precision in bits.
+
+        This is used both for creation of new objects from strings and
+        for printing. It determines the number of digits in which real
+        numbers numbers are printed. It also determines the precision
+        of objects created by parsing strings (e.g. pari('1.2')), which
+        is *not* the normal way of creating new PARI objects using
+        cypari. It has *no* effect on the precision of computations
+        within the PARI library.
+
+        .. seealso:: :meth:`set_real_precision` to set the
+           precision in decimal digits.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.set_real_precision_bits(200)
+        >>> pari('1.2')
+        1.20000000000000000000000000000000000000000000000000000000000
+        >>> pari.set_real_precision_bits(53)
+        """
+        cdef bytes strn = to_bytes(n)
+        sig_on()
+        sd_realbitprecision(strn, d_SILENT)
+        clear_stack()
+
+    def get_real_precision_bits(self):
+        """
+        Return the current PARI default real precision in bits.
+
+        This is used both for creation of new objects from strings and
+        for printing. It determines the number of digits in which real
+        numbers numbers are printed. It also determines the precision
+        of objects created by parsing strings (e.g. pari('1.2')), which
+        is *not* the normal way of creating new PARI objects using
+        cypari. It has *no* effect on the precision of computations
+        within the PARI library.
+
+        .. seealso:: :meth:`get_real_precision` to get the
+           precision in decimal digits.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.get_real_precision_bits()
+        53
+        """
+        sig_on()
+        r = itos(sd_realbitprecision(NULL, d_RETURN))
+        clear_stack()
+        return r
+
+    def set_real_precision(self, long n):
+        """
+        Sets the PARI default real precision in decimal digits.
+
+        This is used both for creation of new objects from strings and for
+        printing. It is the number of digits *IN DECIMAL* in which real
+        numbers are printed. It also determines the precision of objects
+        created by parsing strings (e.g. pari('1.2')), which is *not* the
+        normal way of creating new PARI objects in CyPari2. It has *no*
+        effect on the precision of computations within the pari library.
+
+        Returns the previous PARI real precision.
+
+        .. seealso:: :meth:`set_real_precision_bits` to set the
+           precision in bits.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.set_real_precision(60)
+        15
+        >>> pari('1.2')
+        1.20000000000000000000000000000000000000000000000000000000000
+        >>> pari.set_real_precision(15)
+        60
+        """
+        old = self.get_real_precision()
+        self.set_real_precision_bits(prec_dec_to_bits(n))
+        return old
+
+    def get_real_precision(self):
+        """
+        Returns the current PARI default real precision.
+
+        This is used both for creation of new objects from strings and for
+        printing. It is the number of digits *IN DECIMAL* in which real
+        numbers are printed. It also determines the precision of objects
+        created by parsing strings (e.g. pari('1.2')), which is *not* the
+        normal way of creating new PARI objects in CyPari2. It has *no*
+        effect on the precision of computations within the pari library.
+
+        .. seealso:: :meth:`get_real_precision_bits` to get the
+           precision in bits.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.get_real_precision()
+        15
+        """
+        cdef long r
+        sig_on()
+        r = itos(sd_realprecision(NULL, d_RETURN))
+        sig_off()
+        return r
+
+    def set_series_precision(self, long n):
+        global precdl
+        precdl = n
+
+    def get_series_precision(self):
+        return precdl
+
+    def version(self):
+        """
+        Return the PARI version as tuple with 3 or 4 components:
+        (major, minor, patch) or (major, minor, patch, VCSversion).
+
+        Examples:
+
+        >>> from cypari2 import Pari
+        >>> Pari().version() >= (2, 9, 0)
+        True
+        """
+        return tuple(Pari_auto.version(self))
+
+    def complex(self, re, im):
+        """
+        Create a new complex number, initialized from re and im.
+        """
+        cdef Gen t0 = objtogen(re)
+        cdef Gen t1 = objtogen(im)
+        sig_on()
+        return new_gen(mkcomplex(t0.g, t1.g))
+
+    def __call__(self, s):
+        """
+        Create the PARI object obtained by evaluating s using PARI.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari(0)
+        0
+        >>> pari([2,3,5])
+        [2, 3, 5]
+
+        >>> a = pari(1); a, a.type()
+        (1, 't_INT')
+        >>> a = pari('1/2'); a, a.type()
+        (1/2, 't_FRAC')
+
+        >>> s = pari(u'"éàèç"')
+        >>> s.type()
+        't_STR'
+
+        Some commands are just executed without returning a value:
+
+        >>> pari("dummy = 0; kill(dummy)")
+        >>> print(pari("dummy = 0; kill(dummy)"))
+        None
+
+        See :func:`objtogen` for more examples.
+        """
+        cdef Gen g = objtogen(s)
+        if g.g is gnil:
+            return None
+        return g
+
+    cpdef Gen zero(self):
+        """
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.zero()
+        0
+        """
+        return self.PARI_ZERO
+
+    cpdef Gen one(self):
+        """
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.one()
+        1
+        """
+        return self.PARI_ONE
+
+    def new_with_bits_prec(self, s, long precision):
+        r"""
+        pari.new_with_bits_prec(self, s, precision) creates s as a PARI
+        Gen with (at most) precision *bits* of precision.
+        """
+        # TODO: deprecate
+        cdef unsigned long old_prec
+        old_prec = GP_DATA.fmt.sigd
+        precision = prec_bits_to_dec(precision)
+        if not precision:
+            precision = old_prec
+        self.set_real_precision(precision)
+        x = objtogen(s)
+        self.set_real_precision(old_prec)
+        return x
+
+    ############################################################
+    # Initialization
+    ############################################################
+
+    def stacksize(self):
+        r"""
+        Return the current size of the PARI stack, which is `10^6`
+        by default.  However, the stack size is automatically
+        increased when needed up to the given maximum stack size.
+
+        .. SEEALSO::
+
+            - :meth:`stacksizemax` to get the maximum stack size
+            - :meth:`allocatemem` to change the current or maximum
+              stack size
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.stacksize()
+        8000000
+        >>> pari.allocatemem(2**18, silent=True)
+        >>> pari.stacksize()
+        262144
+        """
+        return pari_mainstack.size
+
+    def stacksizemax(self):
+        r"""
+        Return the maximum size of the PARI stack, which is determined
+        at startup in terms of available memory. Usually, the PARI
+        stack size is (much) smaller than this maximum but the stack
+        will be increased up to this maximum if needed.
+
+        .. SEEALSO::
+
+            - :meth:`stacksize` to get the current stack size
+            - :meth:`allocatemem` to change the current or maximum
+              stack size
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.allocatemem(2**18, 2**26, silent=True)
+        >>> pari.stacksizemax()
+        67108864
+        """
+        return pari_mainstack.vsize
+
+    def allocatemem(self, size_t s=0, size_t sizemax=0, *, silent=False):
+        r"""
+        Change the PARI stack space to the given size ``s`` (or double
+        the current size if ``s`` is `0`) and change the maximum stack
+        size to ``sizemax``.
+
+        PARI tries to use only its current stack (the size which is set
+        by ``s``), but it will increase its stack if needed up to the
+        maximum size which is set by ``sizemax``.
+
+        The PARI stack is never automatically shrunk.  You can use the
+        command ``pari.allocatemem(10^6)`` to reset the size to `10^6`,
+        which is the default size at startup.  Note that the results of
+        computations using cypari are copied to the Python heap, so they
+        take up no space in the PARI stack. The PARI stack is cleared
+        after every computation.
+
+        It does no real harm to set this to a small value as the PARI
+        stack will be automatically enlarged when we run out of memory.
+
+        INPUT:
+
+        - ``s`` - an integer (default: 0).  A non-zero argument is the
+          size in bytes of the new PARI stack.  If `s` is zero, double
+          the current stack size.
+
+        - ``sizemax`` - an integer (default: 0).  A non-zero argument
+          is the maximum size in bytes of the PARI stack.  If
+          ``sizemax`` is 0, the maximum of the current maximum and
+          ``s`` is taken.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.allocatemem(10**7, 10**7)
+        PARI stack size set to 10000000 bytes, maximum size set to 100...
+        >>> pari.allocatemem()  # Double the current size
+        PARI stack size set to 20000000 bytes, maximum size set to 200...
+        >>> pari.stacksize()
+        20000000
+        >>> pari.allocatemem(10**6)
+        PARI stack size set to 1000000 bytes, maximum size set to 200...
+
+        The following computation will automatically increase the PARI
+        stack size:
+
+        >>> a = pari('2^100000000')
+
+        ``a`` is now a Python variable on the Python heap and does not
+        take up any space on the PARI stack.  The PARI stack is still
+        large because of the computation of ``a``:
+
+        >>> pari.stacksize() > 10**6
+        True
+
+        Setting a small maximum size makes this fail:
+
+        >>> pari.allocatemem(10**6, 2**22)
+        PARI stack size set to 1000000 bytes, maximum size set to 4194304
+        >>> a = pari('2^100000000')
+        Traceback (most recent call last):
+        ...
+        PariError: _^s: the PARI stack overflows (current size: 1000000; maximum size: 4194304)
+        You can use pari.allocatemem() to change the stack size and try again
+
+        Tests:
+
+        Do the same without using the string interface and starting
+        from a very small stack size:
+
+        >>> pari.allocatemem(1, 2**26)
+        PARI stack size set to 1024 bytes, maximum size set to 67108864
+        >>> a = pari(2)**100000000
+        >>> pari.stacksize() > 10**6
+        True
+
+        We do not allow ``sizemax`` less than ``s``:
+
+        >>> pari.allocatemem(10**7, 10**6)
+        Traceback (most recent call last):
+        ...
+        ValueError: the maximum size (10000000) should be at least the stack size (1000000)
+        """
+        if s == 0:
+            s = pari_mainstack.size * 2
+            if s < pari_mainstack.size:
+                raise OverflowError("cannot double stack size")
+        elif s < 1024:
+            s = 1024  # arbitrary minimum size
+        if sizemax == 0:
+            # For the default sizemax, use the maximum of current
+            # sizemax and the given size s.
+            if pari_mainstack.vsize > s:
+                sizemax = pari_mainstack.vsize
+            else:
+                sizemax = s
+        elif sizemax < s:
+            raise ValueError("the maximum size ({}) should be at least the stack size ({})".format(s, sizemax))
+        set_pari_stack_size(s, sizemax)
+        if not silent:
+            print("PARI stack size set to {} bytes, maximum size set to {}".
+                  format(self.stacksize(), self.stacksizemax()))
+
+    @staticmethod
+    def pari_version():
+        """
+        Return a string describing the version of PARI/GP.
+
+        >>> from cypari2 import Pari
+        >>> Pari.pari_version()
+        'GP/PARI CALCULATOR Version ...'
+        """
+        return to_string(PARIVERSION)
+
+    def init_primes(self, unsigned long M):
+        """
+        Recompute the primes table including at least all primes up to M
+        (but possibly more).
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.init_primes(200000)
+
+        We make sure that ticket :trac:`11741` has been fixed:
+
+        >>> pari.init_primes(2**30)
+        Traceback (most recent call last):
+        ...
+        ValueError: Cannot compute primes beyond 436273290
+        """
+        # Hardcoded bound in PARI sources (language/forprime.c)
+        if M > 436273289:
+            raise ValueError("Cannot compute primes beyond 436273290")
+
+        if M <= maxprime():
+            return
+        sig_on()
+        initprimetable(M)
+        sig_off()
+
+    def primes(self, n=None, end=None):
+        """
+        Return a pari vector containing the first `n` primes, the primes
+        in the interval `[n, end]`, or the primes up to `end`.
+
+        INPUT:
+
+        Either
+
+        - ``n`` -- integer
+
+        or
+
+        - ``n`` -- list or tuple `[a, b]` defining an interval of primes
+
+        or
+
+        - ``n, end`` -- start and end point of an interval of primes
+
+        or
+
+        - ``end`` -- end point for the list of primes
+
+        OUTPUT: a PARI list of prime numbers
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.primes(3)
+        [2, 3, 5]
+        >>> pari.primes(10)
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+        >>> pari.primes(20)
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]
+        >>> len(pari.primes(1000))
+        1000
+        >>> pari.primes(11,29)
+        [11, 13, 17, 19, 23, 29]
+        >>> pari.primes((11,29))
+        [11, 13, 17, 19, 23, 29]
+        >>> pari.primes(end=29)
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+        >>> pari.primes(10**30, 10**30 + 100)
+        [1000000000000000000000000000057, 1000000000000000000000000000099]
+
+        Tests:
+
+        >>> pari.primes(0)
+        []
+        >>> pari.primes(-1)
+        []
+        >>> pari.primes(end=1)
+        []
+        >>> pari.primes(end=-1)
+        []
+        >>> pari.primes(3,2)
+        []
+        """
+        cdef Gen t0, t1
+        if end is None:
+            t0 = objtogen(n)
+            sig_on()
+            return new_gen(primes0(t0.g))
+        elif n is None:
+            t0 = self.PARI_TWO  # First prime
+        else:
+            t0 = objtogen(n)
+        t1 = objtogen(end)
+        sig_on()
+        return new_gen(primes_interval(t0.g, t1.g))
+
+    euler = Pari_auto.Euler
+    pi = Pari_auto.Pi
+
+    def polchebyshev(self, long n, v=None):
+        """
+        Chebyshev polynomial of the first kind of degree `n`,
+        in the variable `v`.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.polchebyshev(7)
+        64*x^7 - 112*x^5 + 56*x^3 - 7*x
+        >>> pari.polchebyshev(7, 'z')
+        64*z^7 - 112*z^5 + 56*z^3 - 7*z
+        >>> pari.polchebyshev(0)
+        1
+        """
+        sig_on()
+        return new_gen(polchebyshev1(n, get_var(v)))
+
+    def factorial_int(self, long n):
+        """
+        Return the factorial of the integer n as a PARI gen.
+        Give result as an integer.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.factorial_int(0)
+        1
+        >>> pari.factorial_int(1)
+        1
+        >>> pari.factorial_int(5)
+        120
+        >>> pari.factorial_int(25)
+        15511210043330985984000000
+        """
+        sig_on()
+        return new_gen(mpfact(n))
+
+    def polsubcyclo(self, long n, long d, v=None):
+        r"""
+        polsubcyclo(n, d, v=x): return the pari list of polynomial(s)
+        defining the sub-abelian extensions of degree `d` of the
+        cyclotomic field `\QQ(\zeta_n)`, where `d`
+        divides `\phi(n)`.
+
+        Examples::
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+
+            >>> pari.polsubcyclo(8, 4)
+            [x^4 + 1]
+            >>> pari.polsubcyclo(8, 2, 'z')
+            [z^2 + 2, z^2 - 2, z^2 + 1]
+            >>> pari.polsubcyclo(8, 1)
+            [x - 1]
+            >>> pari.polsubcyclo(8, 3)
+            []
+        """
+        cdef Gen plist
+        sig_on()
+        plist = new_gen(polsubcyclo(n, d, get_var(v)))
+        if typ(plist.g) != t_VEC:
+            return self.vector(1, [plist])
+        else:
+            return plist
+
+    def setrand(self, seed):
+        """
+        Sets PARI's current random number seed.
+
+        INPUT:
+
+        - ``seed`` -- either a strictly positive integer or a GEN of
+          type ``t_VECSMALL`` as output by ``getrand()``
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.setrand(50)
+        >>> a = pari.getrand()
+        >>> pari.setrand(a)
+        >>> a == pari.getrand()
+        True
+
+        Tests:
+
+        Check that invalid inputs are handled properly:
+
+        >>> pari.setrand("foobar")
+        Traceback (most recent call last):
+        ...
+        PariError: incorrect type in setrand (t_POL)
+        """
+        cdef Gen t0 = objtogen(seed)
+        sig_on()
+        setrand(t0.g)
+        sig_off()
+
+    def vector(self, long n, entries=None):
+        """
+        vector(long n, entries=None): Create and return the length n PARI
+        vector with given list of entries.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.vector(5, [1, 2, 5, 4, 3])
+        [1, 2, 5, 4, 3]
+        >>> pari.vector(2, ['x', 1])
+        [x, 1]
+        >>> pari.vector(2, ['x', 1, 5])
+        Traceback (most recent call last):
+        ...
+        IndexError: length of entries (=3) must equal n (=2)
+        """
+        # TODO: deprecate
+        v = self._empty_vector(n)
+        if entries is not None:
+            if len(entries) != n:
+                raise IndexError(f"length of entries (={len(entries)}) must equal n (={n})")
+            for i, x in enumerate(entries):
+                v[i] = x
+        return v
+
+    cdef Gen _empty_vector(self, long n):
+        cdef Gen v
+        sig_on()
+        v = new_gen(zerovec(n))
+        return v
+
+    def matrix(self, long m, long n, entries=None):
+        """
+        matrix(long m, long n, entries=None): Create and return the m x n
+        PARI matrix with given list of entries.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.matrix(3, 3, range(9))
+        [0, 1, 2; 3, 4, 5; 6, 7, 8]
+        """
+        cdef long i, j, k
+        cdef Gen x
+
+        sig_on()
+        A = new_gen(zeromatcopy(m, n))
+        if entries is not None:
+            if len(entries) != m * n:
+                raise IndexError("len of entries (=%s) must be %s*%s=%s" % (len(entries), m, n, m*n))
+            k = 0
+            for i in range(m):
+                for j in range(n):
+                    sig_check()
+                    x = objtogen(entries[k])
+                    set_gcoeff(A.g, i+1, j+1, x.ref_target())
+                    A.cache((i, j), x)
+                    k += 1
+        return A
+
+    def genus2red(self, P, p=None):
+        r"""
+        Let `P` be a polynomial with integer coefficients.
+        Determines the reduction of the (proper, smooth) genus 2
+        curve `C/\QQ`, defined by the hyperelliptic equation `y^2 = P`.
+        The special syntax ``genus2red([P,Q])`` is also allowed, where
+        the polynomials `P` and `Q` have integer coefficients, to
+        represent the model `y^2 + Q(x)y = P(x)`.
+
+        If the second argument `p` is specified, it must be a prime.
+        Then only the local information at `p` is computed and returned.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> x = pari('x')
+        >>> pari.genus2red([-5*x**5, x**3 - 2*x**2 - 2*x + 1])
+        [1416875, [2, -1; 5, 4; 2267, 1], ..., [[2, [2, [Mod(1, 2)]], []], [5, [1, []], ["[V] page 156", [3]]], [2267, [2, [Mod(432, 2267)]], ["[I{1-0-0}] page 170", []]]]]
+        >>> pari.genus2red([-5*x**5, x**3 - 2*x**2 - 2*x + 1],2267)
+        [2267, Mat([2267, 1]), ..., [2267, [2, [Mod(432, 2267)]], ["[I{1-0-0}] page 170", []]]]
+        """
+        cdef Gen t0 = objtogen(P)
+        if p is None:
+            sig_on()
+            return new_gen(genus2red(t0.g, NULL))
+        cdef Gen t1 = objtogen(p)
+        sig_on()
+        return new_gen(genus2red(t0.g, t1.g))
+
+    def List(self, x=None):
+        """
+        Create an empty list or convert `x` to a list.
+
+        Examples:
+
+        >>> import cypari2
+        >>> pari = cypari2.Pari()
+        >>> pari.List(range(5))
+        List([0, 1, 2, 3, 4])
+        >>> L = pari.List()
+        >>> L
+        List([])
+        >>> L.listput(42, 1)
+        42
+        >>> L
+        List([42])
+        >>> L.listinsert(24, 1)
+        24
+        >>> L
+        List([24, 42])
+        """
+        if x is None:
+            sig_on()
+            return new_gen(mklist())
+        cdef Gen t0 = objtogen(x)
+        sig_on()
+        return new_gen(gtolist(t0.g))
+
+
+cdef long get_var(v) except -2:
+    """
+    Convert ``v`` into a PARI variable number.
+
+    If ``v`` is a PARI object, return the variable number of
+    ``variable(v)``. If ``v`` is ``None``, return -1.
+    Otherwise, treat ``v`` as a string and return the number of
+    the variable named ``v``.
+
+    OUTPUT: a PARI variable number (varn) or -1 if there is no
+    variable number.
+
+    .. WARNING::
+
+        You can easily create variables with garbage names using
+        this function. This can actually be used as a feature, if
+        you want variable names which cannot be confused with
+        ordinary user variables.
+
+    Examples:
+
+    We test this function using ``Pol()`` which calls this function:
+
+    >>> import cypari2
+    >>> pari = cypari2.Pari()
+    >>> pari("[1,0]").Pol()
+    x
+    >>> pari("[2,0]").Pol('x')
+    2*x
+    >>> pari("[Pi,0]").Pol('!@#$%^&')
+    3.14159265358979*!@#$%^&
+
+    We can use ``varhigher()`` and ``varlower()`` to create
+    temporary variables without a name. The ``"xx"`` below is just a
+    string to display the variable, it doesn't create a variable
+    ``"xx"``:
+
+    >>> xx = pari.varhigher("xx")
+    >>> pari("[x,0]").Pol(xx)
+    x*xx
+
+    Indeed, this is not the same as:
+
+    >>> pari("[x,0]").Pol("xx")
+    Traceback (most recent call last):
+    ...
+    PariError: incorrect priority in gtopoly: variable x <= xx
+    """
+    if v is None:
+        return -1
+    cdef long varno
+    if isinstance(v, Gen):
+        sig_on()
+        varno = gvar((<Gen>v).g)
+        sig_off()
+        if varno < 0:
+            return -1
+        else:
+            return varno
+    cdef bytes s = to_bytes(v)
+    sig_on()
+    varno = fetch_user_var(s)
+    sig_off()
+    return varno
+
+
+# Monkey-patched versions of default(parisize) and default(parisizemax)
+# which call before_resize() and after_resize().
+# The monkey-patching is set up in PariInstance.__cinit__
+cdef GEN patched_parisize(const char* v, long flag) noexcept:
+    # Cast to `int(*)() noexcept` to avoid exception handling
+    if (<int(*)() noexcept>before_resize)():
+        sig_error()
+    return sd_parisize(v, flag)
+
+
+cdef GEN patched_parisizemax(const char* v, long flag) noexcept:
+    # Cast to `int(*)() noexcept` to avoid exception handling
+    if (<int(*)() noexcept>before_resize)():
+        sig_error()
+    return sd_parisizemax(v, flag)
+
+
+IF HAVE_PLOT_SVG:
+    cdef void get_plot_ipython(PARI_plot* T) noexcept:
+        # Values copied from src/graph/plotsvg.c in PARI sources
+        T.width = 480
+        T.height = 320
+        T.hunit = 3
+        T.vunit = 3
+        T.fwidth = 9
+        T.fheight = 12
+
+        T.draw = draw_ipython
+
+    cdef void draw_ipython(PARI_plot *T, GEN w, GEN x, GEN y) noexcept:
+        global avma
+        cdef pari_sp av = avma
+        cdef char* svg = rect2svg(w, x, y, T)
+        from IPython.core.display import SVG, display
+        display(SVG(svg))
+        avma = av