passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

sage/libs/pari/convert_sage_complex_double.pyx

@@ -0,0 +1,132 @@
+# sage_setup: distribution = sagemath-pari
+# sage.doctest: needs sage.rings.complex_double
+
+from cysignals.signals cimport sig_on, sig_off
+
+from sage.libs.gsl.complex cimport *
+
+from cypari2.paridecl cimport *
+from cypari2.convert cimport new_gen_from_double, new_t_COMPLEX_from_double
+
+
+cpdef ComplexDoubleElement pari_to_cdf(Gen g):
+    """
+    Create a CDF element from a PARI ``gen``.
+
+    EXAMPLES::
+
+        sage: CDF(pari("Pi"))  # indirect doctest
+        3.141592653589793
+        sage: CDF(pari("1 + I/2"))
+        1.0 + 0.5*I
+
+    TESTS:
+
+    Check that we handle PARI errors gracefully, see :issue:`17329`::
+
+        sage: CDF(-151.386325246 + 992.34771962*I).zeta()                               # needs sage.symbolic
+        Traceback (most recent call last):
+        ...
+        PariError: overflow in t_REAL->double conversion
+        sage: CDF(pari(x^2 + 5))                                                        # needs sage.symbolic
+        Traceback (most recent call last):
+        ...
+        PariError: incorrect type in gtofp (t_POL)
+    """
+    cdef ComplexDoubleElement z = ComplexDoubleElement.__new__(ComplexDoubleElement)
+    sig_on()
+    if typ(g.g) == t_COMPLEX:
+        z._complex = gsl_complex_rect(gtodouble(gel(g.g, 1)), gtodouble(gel(g.g, 2)))
+    else:
+        z._complex = gsl_complex_rect(gtodouble(g.g), 0.0)
+    sig_off()
+    return z
+
+
+cpdef Gen new_gen_from_complex_double_element(ComplexDoubleElement self):
+    """
+    Return PARI version of ``self``, as ``t_COMPLEX`` or ``t_REAL``.
+
+    EXAMPLES::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import new_gen_from_complex_double_element
+        sage: new_gen_from_complex_double_element(CDF(1,0))
+        1.00000000000000
+        sage: new_gen_from_complex_double_element(CDF(0,1))
+        1.00000000000000*I
+        sage: new_gen_from_complex_double_element(CDF(1,1))
+        1.00000000000000 + 1.00000000000000*I
+    """
+    if not GSL_IMAG(self._complex):
+        return new_gen_from_double(GSL_REAL(self._complex))
+    else:
+        return new_t_COMPLEX_from_double(GSL_REAL(self._complex), GSL_IMAG(self._complex))
+
+
+cpdef ComplexDoubleElement complex_double_element_eta(ComplexDoubleElement self, int flag):
+    """
+    TESTS::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import complex_double_element_eta
+        sage: a = CDF(1,1)
+        sage: complex_double_element_eta(a, 0)
+        0.9981290699259585
+        sage: complex_double_element_eta(a, 1)
+        0.7420487758365647 + 0.1988313702299107*I
+    """
+    return pari_to_cdf(new_gen_from_complex_double_element(self).eta(flag))
+
+
+cpdef ComplexDoubleElement complex_double_element_agm(ComplexDoubleElement self, right):
+    """
+    TESTS::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import complex_double_element_agm
+        sage: complex_double_element_agm(CDF(1, 1), CDF(2, 2))
+        1.4567910310469068 + 1.4567910310469068*I
+    """
+    return pari_to_cdf(new_gen_from_complex_double_element(self).agm(right))
+
+
+cpdef ComplexDoubleElement complex_double_element_dilog(ComplexDoubleElement self):
+    """
+    TESTS::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import complex_double_element_dilog
+        sage: complex_double_element_dilog(CDF(1, 1))
+        0.6168502750680849 + 1.4603621167531196*I
+    """
+    return pari_to_cdf(new_gen_from_complex_double_element(self).dilog())
+
+
+cpdef ComplexDoubleElement complex_double_element_gamma(ComplexDoubleElement self):
+    """
+    TESTS::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import complex_double_element_gamma
+        sage: complex_double_element_gamma(CDF(1, 1))
+        0.49801566811835607 - 0.15494982830181067*I
+    """
+    return pari_to_cdf(new_gen_from_complex_double_element(self).gamma())
+
+
+cpdef ComplexDoubleElement complex_double_element_gamma_inc(ComplexDoubleElement self, t):
+    """
+    TESTS::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import complex_double_element_gamma_inc
+        sage: complex_double_element_gamma_inc(CDF(1, 1), CDF(2, 2))
+        0.054695987717541285 - 0.04676800059213122*I
+    """
+    return pari_to_cdf(new_gen_from_complex_double_element(self).incgam(t))
+
+
+cpdef ComplexDoubleElement complex_double_element_zeta(ComplexDoubleElement self):
+    """
+    TESTS::
+
+        sage: from sage.libs.pari.convert_sage_complex_double import complex_double_element_zeta
+        sage: complex_double_element_zeta(CDF(1, 2))
+        0.5981655697623818 - 0.35185474521784527*I
+    """
+    return pari_to_cdf(new_gen_from_complex_double_element(self).zeta())

sage/libs/pari/convert_sage_matrix.pyx

@@ -0,0 +1,106 @@
+# sage_setup: distribution = sagemath-pari
+# sage.doctest: needs sage.modules
+
+from cypari2.gen cimport Gen
+from cypari2.types cimport (GEN, typ, t_INT, t_FRAC, t_REAL, t_COMPLEX,
+                            t_INTMOD, t_PADIC, t_INFINITY, t_VEC, t_COL,
+                            t_VECSMALL, t_MAT, t_STR,
+                            lg, precp)
+from cypari2.paridecl cimport *
+
+from sage.matrix.args cimport (MatrixArgs, MA_ENTRIES_SEQ_SEQ,
+                               MA_ENTRIES_SEQ_FLAT, MA_ENTRIES_CALLABLE,
+                               MA_ENTRIES_UNKNOWN, MA_ENTRIES_SCALAR)
+
+from .convert_sage cimport gen_to_sage
+
+
+def gen_to_sage_matrix(Gen z, locals=None):
+    cdef GEN g = z.g
+    nc = lg(g) - 1
+    nr = 0 if nc == 0 else lg(gel(g,1)) - 1
+    ma = MatrixArgs.__new__(MatrixArgs)
+    ma.nrows = nr
+    ma.ncols = nc
+    ma.entries = [gen_to_sage(z[i,j], locals) for i in range(nr) for j in range(nc)]
+    return ma.matrix()
+
+
+def pari_typ_to_entries_type(MatrixArgs self):
+    """
+    Determine the ``entries_type`` of a :class:`sage.matrix.args.MatrixArgs`
+    with PARI entries.
+
+    This will modify the entries.
+
+    TESTS:
+
+    ``MA_ENTRIES_SEQ_SEQ``::
+
+        sage: from sage.libs.pari.convert_sage import pari_typ_to_entries_type
+        sage: from sage.matrix.args import MatrixArgs
+        sage: ma = MatrixArgs(QQ, entries=pari("[1,2;3,4]"))
+        sage: 0x10_03 == pari_typ_to_entries_type(ma)
+        True
+
+    ``MA_ENTRIES_SEQ_FLAT``::
+
+        sage: ma = MatrixArgs(QQ, entries=pari("[1,2]"))
+        sage: 0x10_04 == pari_typ_to_entries_type(ma)
+        True
+        sage: ma = MatrixArgs(QQ, entries=pari(vector([1,2])))
+        sage: 0x10_04 == pari_typ_to_entries_type(ma)
+        True
+        sage: ma = MatrixArgs(QQ, entries=pari(matrix(2, range(4))[0]))
+        sage: 0x10_04 == pari_typ_to_entries_type(ma)
+        True
+
+    ``MA_ENTRIES_CALLABLE``::
+
+        sage: ma = MatrixArgs(QQ, entries=pari(lambda x: x))
+        sage: 0x13_06 == pari_typ_to_entries_type(ma)
+        True
+
+    ``MA_ENTRIES_SCALAR``::
+
+        sage: ma = MatrixArgs(QQ, entries=pari(1/2))
+        sage: 0x17_02 == pari_typ_to_entries_type(ma)
+        True
+
+    ``MA_ENTRIES_UNKNOWN``::
+
+        sage: ma = MatrixArgs(QQ, entries=pari('"2"'))
+        sage: 0 == pari_typ_to_entries_type(ma)
+        True
+
+    A second call gives an error::
+
+        sage: ma = MatrixArgs(QQ, entries=pari("[1,2]"))
+        sage: 0x10_04 == pari_typ_to_entries_type(ma)
+        True
+        sage: 0x10_04 == pari_typ_to_entries_type(ma)
+        Traceback (most recent call last):
+        ...
+        ValueError: entries are not a PARI generator
+    """
+    if not isinstance(self.entries, Gen):
+        raise ValueError("entries are not a PARI generator")
+    cdef long t = typ((<Gen>self.entries).g)
+    if t == t_MAT:
+        R = self.base
+        if R is None:
+            self.entries = self.entries.Col().sage()
+        else:
+            self.entries = [[R(x) for x in v]
+                            for v in self.entries.mattranspose()]
+        return MA_ENTRIES_SEQ_SEQ
+    elif t in [t_VEC, t_COL, t_VECSMALL, t_LIST]:
+        self.entries = self.entries.sage()
+        return MA_ENTRIES_SEQ_FLAT
+    elif t == t_CLOSURE:
+        return MA_ENTRIES_CALLABLE
+    elif t == t_STR:
+        return MA_ENTRIES_UNKNOWN
+    else:
+        self.entries = self.entries.sage()
+        return MA_ENTRIES_SCALAR

sage/libs/pari/convert_sage_real_double.pxd

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2.gen cimport Gen
+from sage.rings.real_double cimport RealDoubleElement
+
+cpdef Gen new_gen_from_real_double_element(RealDoubleElement self)

sage/libs/pari/convert_sage_real_double.pyx

@@ -0,0 +1,14 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2.convert cimport new_gen_from_double
+
+cpdef Gen new_gen_from_real_double_element(RealDoubleElement self):
+    """
+    Return a PARI representation of ``self``.
+
+    EXAMPLES::
+
+        sage: from sage.libs.pari.convert_sage_real_double import new_gen_from_real_double_element
+        sage: new_gen_from_real_double_element(RDF(-2.5))
+        -2.50000000000000
+    """
+    return new_gen_from_double(self._value)

sage/libs/pari/convert_sage_real_mpfr.pxd

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2.gen cimport Gen
+
+from sage.rings.real_mpfr cimport RealNumber
+
+cpdef Gen new_gen_from_real_mpfr_element(RealNumber self)
+cpdef bint set_real_mpfr_element_from_gen(RealNumber self, Gen x) noexcept

sage/libs/pari/convert_sage_real_mpfr.pyx

@@ -0,0 +1,108 @@
+# sage_setup: distribution = sagemath-pari
+# sage.doctest: needs sage.rings.real_mpfr
+
+from cypari2.stack cimport new_gen
+from cypari2.paridecl cimport *
+from cysignals.signals cimport sig_on
+
+from sage.libs.gmp.mpz cimport *
+from sage.libs.mpfr cimport *
+from sage.libs.mpfr.types cimport mpfr_prec_t
+from sage.rings.real_mpfr cimport RealField_class, RealField
+
+
+cpdef Gen new_gen_from_real_mpfr_element(RealNumber self):
+
+    # This uses interfaces of MPFR and PARI which are documented
+    # (and not marked subject-to-change).  It could be faster
+    # by using internal interfaces of MPFR, which are documented
+    # as subject-to-change.
+
+    if mpfr_nan_p(self.value) or mpfr_inf_p(self.value):
+        raise ValueError('cannot convert NaN or infinity to Pari float')
+
+    # wordsize for PARI
+    cdef unsigned long wordsize = sizeof(long)*8
+
+    cdef mpfr_prec_t prec
+    prec = (<RealField_class>self._parent)._prec
+
+    # We round up the precision to the nearest multiple of wordsize.
+    cdef int rounded_prec
+    rounded_prec = nbits2prec(self.prec())
+
+    # Yes, assigning to self works fine, even in Cython.
+    if rounded_prec > prec:
+        self = RealField(rounded_prec)(self)
+
+    cdef mpz_t mantissa
+    cdef mp_exp_t exponent
+    cdef GEN pari_float
+
+    sig_on()
+    if mpfr_zero_p(self.value):
+        pari_float = real_0_bit(-rounded_prec)
+    else:
+        # Now we can extract the mantissa, and it will be normalized
+        # (the most significant bit of the most significant word will be 1).
+        mpz_init(mantissa)
+        exponent = mpfr_get_z_exp(mantissa, self.value)
+
+        # Create a PARI REAL
+        pari_float = cgetr(rounded_prec)
+        pari_float[1] = evalexpo(exponent + rounded_prec - 1) + evalsigne(mpfr_sgn(self.value))
+        mpz_export(&pari_float[2], NULL, 1, wordsize // 8, 0, 0, mantissa)
+        mpz_clear(mantissa)
+
+    return new_gen(pari_float)
+
+
+cpdef bint set_real_mpfr_element_from_gen(RealNumber self, Gen x) noexcept:
+    r"""
+    EXAMPLES::
+
+        sage: rt2 = sqrt(pari('2.0'))
+        sage: rt2
+        1.41421356237310
+        sage: rt2.sage()
+        1.41421356237309505
+        sage: rt2.sage().prec()
+        64
+        sage: pari(rt2.sage()) == rt2
+        True
+        sage: for i in range(100, 200):
+        ....:     assert(sqrt(pari(i)) == pari(sqrt(pari(i)).sage()))
+        sage: (-3.1415).__pari__().sage()
+        -3.14150000000000000
+    """
+    cdef GEN g = x.g
+
+    if typ((<Gen>x).g) != t_REAL:
+        return False
+
+    cdef int sgn
+    sgn = signe(g)
+
+    if sgn == 0:
+        mpfr_set_ui(self.value, 0, MPFR_RNDN)
+        return True
+
+    cdef int wordsize = 8 * sizeof(long)
+
+    cdef mpz_t mantissa
+    mpz_init(mantissa)
+    mpz_import(mantissa, lg(g) - 2, 1, wordsize/8, 0, 0, &g[2])
+
+    cdef mp_exp_t exponent = expo(g)
+
+    # Round to nearest for best results when setting a low-precision
+    # MPFR from a high-precision GEN
+    mpfr_set_z(self.value, mantissa, MPFR_RNDN)
+    mpfr_mul_2si(self.value, self.value, exponent - wordsize * (lg(g) - 2) + 1, MPFR_RNDN)
+
+    if sgn < 0:
+        mpfr_neg(self.value, self.value, MPFR_RNDN)
+
+    mpz_clear(mantissa)
+
+    return True

sage/libs/pari/misc.pxd

@@ -0,0 +1,4 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2.gen cimport Gen
+
+cdef Gen new_t_POL_from_int_star(int* vals, unsigned long length, long varnum)

sage/libs/pari/misc.pyx

@@ -0,0 +1,26 @@
+# sage_setup: distribution = sagemath-pari
+from cysignals.signals cimport sig_on
+from cypari2.paridecl cimport *
+from cypari2.stack cimport new_gen
+
+
+cdef Gen new_t_POL_from_int_star(int* vals, unsigned long length, long varnum):
+    """
+    Convert an array of ints to a PARI polynomial.
+
+    Note that ``length = degree + 1``, so that recognizing 0 is easier.
+    """
+    cdef GEN z
+    cdef unsigned long i
+
+    sig_on()
+    z = cgetg(length + 2, t_POL)
+    if length == 0:
+        # Polynomial is zero
+        z[1] = evalvarn(varnum) + evalsigne(0)
+    else:
+        z[1] = evalvarn(varnum) + evalsigne(1)
+        for i in range(length):
+            set_gel(z, i+2, stoi(vals[i]))
+
+    return new_gen(z)