passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

sage/libs/linkages/padics/unram_shared.pxi

@@ -0,0 +1,247 @@
+# sage_setup: distribution = sagemath-pari
+# sage.doctest: needs sage.libs.ntl
+cimport cython
+
+
+@cython.binding(True)
+def frobenius_unram(self, arithmetic=True):
+    """
+    Return the image of this element under the Frobenius automorphism
+    applied to its parent.
+
+    INPUT:
+
+    - ``self`` -- an element of an unramified extension
+    - ``arithmetic`` -- whether to apply the arithmetic Frobenius (acting
+      by raising to the `p`-th power on the residue field). If ``False`` is
+      provided, the image of geometric Frobenius (raising to the `(1/p)`-th
+      power on the residue field) will be returned instead.
+
+    EXAMPLES::
+
+        sage: R.<a> = Zq(5^4,3)
+        sage: a.frobenius()
+        (a^3 + a^2 + 3*a) + (3*a + 1)*5 + (2*a^3 + 2*a^2 + 2*a)*5^2 + O(5^3)
+        sage: f = R.defining_polynomial()
+        sage: f(a)
+        O(5^3)
+        sage: f(a.frobenius())
+        O(5^3)
+        sage: for i in range(4): a = a.frobenius()
+        sage: a
+        a + O(5^3)
+
+        sage: R.<a> = Zq(5^4,3)
+        sage: a.frobenius(arithmetic=False)
+        (3*a^3 + 3*a^2 + a) + (a^3 + 4*a^2 + a + 4)*5 + (3*a^2 + 2*a + 3)*5^2 + O(5^3)
+
+        sage: K.<a> = Qq(7^3,4)
+        sage: b = (a+1)/7
+        sage: c = b.frobenius(); c
+        (3*a^2 + 5*a + 1)*7^-1 + (6*a^2 + 6*a + 6) + (4*a^2 + 3*a + 4)*7 + (6*a^2 + a + 6)*7^2 + O(7^3)
+        sage: c.frobenius().frobenius()
+        (a + 1)*7^-1 + O(7^3)
+
+    An error will be raised if the parent of ``self`` is a ramified extension::
+
+        sage: x = polygen(ZZ, 'x')
+        sage: K.<a> = Qp(5).extension(x^2 - 5)
+        sage: a.frobenius()
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: Frobenius automorphism only implemented for unramified extensions
+
+    TESTS:
+
+    We check that :issue:`23575` is resolved::
+
+        sage: x = R.random_element()
+        sage: x.frobenius(arithmetic=false).frobenius() == x
+        True
+    """
+    if self == 0:
+        return self
+    R = self.parent()
+    p = R.prime()
+    a = R.gen()
+    frob_a = R._frob_gen(arithmetic)
+    ppow = self.valuation()
+    unit = self.unit_part()
+    coefs = unit.expansion()
+    ans = 0
+
+    # Xavier's implementation based on Horner scheme
+    for i in range(R.f()-1, -1, -1):
+        update = 0
+        for j in range(len(coefs)-1, -1, -1):
+            update *= p
+            try:
+                update += coefs[j][i]
+            except IndexError:
+                pass
+        ans *= frob_a
+        ans += update
+    return ans << ppow
+
+
+@cython.binding(True)
+def norm_unram(self, base=None):
+    r"""
+    Return the absolute or relative norm of this element.
+
+    .. WARNING::
+
+        This is not the `p`-adic absolute value.  This is a
+        field theoretic norm down to a ground ring.  If you want the
+        `p`-adic absolute value, use the ``abs()`` function instead.
+
+    INPUT:
+
+    - ``base`` -- a subfield of the parent `L` of this element; the norm is the
+      relative norm from ``L`` to ``base``. Defaults to the absolute norm down
+      to `\QQ_p` or `\ZZ_p`.
+
+    EXAMPLES::
+
+        sage: R = ZpCR(5,5)
+        sage: S.<x> = R[]
+        sage: f = x^5 + 75*x^3 - 15*x^2 +125*x - 5
+        sage: W.<w> = R.ext(f)
+        sage: ((1+2*w)^5).norm()
+        1 + 5^2 + O(5^5)
+        sage: ((1+2*w)).norm()^5
+        1 + 5^2 + O(5^5)
+
+    TESTS::
+
+        sage: R = ZpCA(5,5)
+        sage: S.<x> = ZZ[]
+        sage: f = x^5 + 75*x^3 - 15*x^2 +125*x - 5
+        sage: W.<w> = R.ext(f)
+        sage: ((1+2*w)^5).norm()
+        1 + 5^2 + O(5^5)
+        sage: ((1+2*w)).norm()^5
+        1 + 5^2 + O(5^5)
+        sage: R = ZpFM(5,5)
+        sage: S.<x> = ZZ[]
+        sage: f = x^5 + 75*x^3 - 15*x^2 +125*x - 5
+        sage: W.<w> = R.ext(f)
+        sage: ((1+2*w)^5).norm()
+        1 + 5^2
+        sage: ((1+2*w)).norm()^5
+        1 + 5^2
+
+    TESTS:
+
+    Check that :issue:`11586` has been resolved::
+
+        sage: R.<x> = QQ[]
+        sage: f = x^2 + 3*x + 1
+        sage: M.<a> = Qp(7).extension(f)
+        sage: M(7).norm()
+        7^2 + O(7^22)
+        sage: b = 7*a + 35
+        sage: b.norm()
+        4*7^2 + 7^3 + O(7^22)
+        sage: b*b.frobenius()
+        4*7^2 + 7^3 + O(7^22)
+
+    Check that :issue:`31845` is fixed::
+
+        sage: R.<a> = Zq(4)
+        sage: (a - a).norm()
+        O(2^20)
+    """
+    if base is not None:
+        if base is self.parent():
+            return self
+        else:
+            raise NotImplementedError
+    if self._is_exact_zero():
+        return self.parent().ground_ring()(0)
+    elif self._is_inexact_zero():
+        return self.parent().ground_ring()(0, self.valuation())
+    if self.valuation() == 0:
+        return self.parent().ground_ring()(self.matrix_mod_pn().det())
+    else:
+        if self.parent().e() == 1:
+            norm_of_uniformizer = self.parent().ground_ring().uniformizer_pow(self.parent().degree())
+        else:
+            norm_of_uniformizer = (-1)**self.parent().degree() * self.parent().defining_polynomial()[0]
+        return self.parent().ground_ring()(self.unit_part().matrix_mod_pn().det()) * norm_of_uniformizer**self.valuation()
+
+
+@cython.binding(True)
+def trace_unram(self, base=None):
+    r"""
+    Return the absolute or relative trace of this element.
+
+    If ``base`` is given then ``base`` must be a subfield of the
+    parent `L` of ``self``, in which case the trace is the relative
+    trace from `L` to ``base``.
+
+    In all other cases, the trace is the absolute trace down to
+    `\QQ_p` or `\ZZ_p`.
+
+    EXAMPLES::
+
+        sage: R = ZpCR(5,5)
+        sage: S.<x> = R[]
+        sage: f = x^5 + 75*x^3 - 15*x^2 +125*x - 5
+        sage: W.<w> = R.ext(f)
+        sage: a = (2+3*w)^7
+        sage: b = (6+w^3)^5
+        sage: a.trace()
+        3*5 + 2*5^2 + 3*5^3 + 2*5^4 + O(5^5)
+        sage: a.trace() + b.trace()
+        4*5 + 5^2 + 5^3 + 2*5^4 + O(5^5)
+        sage: (a+b).trace()
+        4*5 + 5^2 + 5^3 + 2*5^4 + O(5^5)
+
+    TESTS::
+
+        sage: R = ZpCA(5,5)
+        sage: S.<x> = ZZ[]
+        sage: f = x^5 + 75*x^3 - 15*x^2 +125*x - 5
+        sage: W.<w> = R.ext(f)
+        sage: a = (2+3*w)^7
+        sage: b = (6+w^3)^5
+        sage: a.trace()
+        3*5 + 2*5^2 + 3*5^3 + 2*5^4 + O(5^5)
+        sage: a.trace() + b.trace()
+        4*5 + 5^2 + 5^3 + 2*5^4 + O(5^5)
+        sage: (a+b).trace()
+        4*5 + 5^2 + 5^3 + 2*5^4 + O(5^5)
+        sage: R = ZpFM(5,5)
+        sage: S.<x> = R[]
+        sage: f = x^5 + 75*x^3 - 15*x^2 +125*x - 5
+        sage: W.<w> = R.ext(f)
+        sage: a = (2+3*w)^7
+        sage: b = (6+w^3)^5
+        sage: a.trace()
+        3*5 + 2*5^2 + 3*5^3 + 2*5^4
+        sage: a.trace() + b.trace()
+        4*5 + 5^2 + 5^3 + 2*5^4
+        sage: (a+b).trace()
+        4*5 + 5^2 + 5^3 + 2*5^4
+
+    Check that :issue:`31845` is fixed::
+
+        sage: R.<a> = Zq(4)
+        sage: (a - a).trace()
+        O(2^20)
+    """
+    if base is not None:
+        if base is self.parent():
+            return self
+        else:
+            raise NotImplementedError
+    if self._is_exact_zero():
+        return self.parent().ground_ring()(0)
+    elif self._is_inexact_zero():
+        return self.parent().ground_ring()(0, self.precision_absolute())
+    if self.valuation() >= 0:
+        return self.parent().ground_ring()(self.matrix_mod_pn().trace())
+    else:
+        shift = -self.valuation()
+        return self.parent().ground_ring()((self * self.parent().prime() ** shift).matrix_mod_pn().trace()) / self.parent().prime()**shift

sage/libs/pari/__init__.py

@@ -0,0 +1,210 @@
+# sage_setup: distribution = sagemath-pari
+# sage.doctest: needs sage.rings.real_mpfr
+"""
+Interface between Sage and PARI
+
+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 and conversion between Sage and 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 from Sage to PARI, the precision is rounded
+up to the nearest multiple of the wordsize::
+
+    sage: x = 1.0
+    sage: x.precision()
+    53
+    sage: pari(x)
+    1.00000000000000
+    sage: pari(x).bitprecision()
+    64
+
+With a higher precision::
+
+    sage: x = RealField(100).pi()
+    sage: x.precision()
+    100
+    sage: pari(x).bitprecision()
+    128
+
+When converting back to Sage, the precision from PARI is taken::
+
+    sage: x = RealField(100).pi()
+    sage: y = pari(x).sage()
+    sage: y
+    3.1415926535897932384626433832793333156
+    sage: parent(y)
+    Real Field with 128 bits of precision
+
+So ``pari(x).sage()`` is definitely not equal to ``x`` since it has
+28 bogus bits.
+
+Therefore, some care must be taken when juggling reals back and forth
+between Sage and PARI. The correct way of avoiding this is to convert
+``pari(x).sage()`` back into a domain with the right precision. This has
+to be done by the user (or by Sage functions that use PARI library
+functions). For instance, if we want to use the PARI library to compute
+``sqrt(pi)`` with a precision of 100 bits::
+
+    sage: # needs sage.symbolic
+    sage: R = RealField(100)
+    sage: s = R(pi); s
+    3.1415926535897932384626433833
+    sage: p = pari(s).sqrt()
+    sage: x = p.sage(); x    # wow, more digits than I expected!
+    1.7724538509055160272981674833410973484
+    sage: x.prec()           # has precision 'improved' from 100 to 128?
+    128
+    sage: x == RealField(128)(pi).sqrt()  # sadly, no!
+    False
+    sage: R(x)               # x should be brought back to precision 100
+    1.7724538509055160272981674833
+    sage: R(x) == s.sqrt()
+    True
+
+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`.
+
+We create a very precise approximation of pi and see how it is printed
+in PARI::
+
+    sage: pi = pari(RealField(1000).pi())
+
+The default precision is 15 digits::
+
+    sage: pi
+    3.14159265358979
+
+With a different precision::
+
+    sage: _ = pari.set_real_precision(50)
+    sage: pi
+    3.1415926535897932384626433832795028841971693993751
+
+Back to the default::
+
+    sage: _ = pari.set_real_precision(15)
+    sage: pi
+    3.14159265358979
+
+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(1).sin()``.
+
+3. Using the library interface with inexact inputs, for example
+   ``pari(1.0).sin()``.
+
+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`::
+
+    sage: pari.set_real_precision_bits(150)
+    sage: pari("sin(1)")
+    0.841470984807896506652502321630298999622563061
+    sage: pari.set_real_precision_bits(53)
+    sage: 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` is irrelevant.
+
+In these examples, we convert to Sage to ensure that PARI's real
+precision is not used when printing the numbers. As explained before,
+this artificially increases the precision to a multiple of the
+wordsize. ::
+
+    sage: s = pari(1).sin(precision=180).sage(); print(s); print(parent(s))
+    0.841470984807896506652502321630298999622563060798371065673
+    Real Field with 192 bits of precision
+    sage: s = pari(1).sin(precision=40).sage(); print(s); print(parent(s))
+    0.841470984807896507
+    Real Field with 64 bits of precision
+    sage: s = pari(1).sin().sage(); print(s); print(parent(s))
+    0.841470984807896507
+    Real Field with 64 bits of precision
+
+In the third case, the precision is determined only by the inexact
+inputs and the ``precision`` argument is ignored::
+
+    sage: pari(1.0).sin(precision=180).sage()
+    0.841470984807896507
+    sage: pari(1.0).sin(precision=40).sage()
+    0.841470984807896507
+    sage: pari(RealField(100).one()).sin().sage()
+    0.84147098480789650665250232163029899962
+
+Elliptic curve functions
+------------------------
+
+An elliptic curve given with exact `a`-invariants is considered an
+exact object. Therefore, you should set the precision for each method
+call individually::
+
+    sage: e = pari([0,0,0,-82,0]).ellinit()
+    sage: eta1 = e.elleta(precision=50)[0]
+    sage: eta1.sage()
+    3.6054636014326520859158205642077267748
+    sage: eta1 = e.elleta(precision=150)[0]
+    sage: eta1.sage()
+    3.605463601432652085915820564207726774810268996598024745444380641429820491740 # 64-bit
+    3.605463601432652085915820564207726774810268996598024745444380641430          # 32-bit
+"""
+
+from cypari2 import Pari
+
+from sage.ext.memory import init_memory_functions
+
+
+def _get_pari_instance():
+    """
+    TESTS::
+
+        sage: pari  # indirect doctest
+        Interface to the PARI C library
+    """
+    stack_initial = 1024 * 1024
+    stack_max = 1024 * stack_initial
+    P = Pari(stack_initial, stack_max)
+
+    # pari_init_opts() overrides MPIR's memory allocation functions,
+    # so we need to reset them.
+    init_memory_functions()
+
+    # PARI sets debugmem=1 by default but we do not want those warning
+    # messages in Sage.
+    P.default("debugmem", 0)
+
+    # Make sure pari doesn't use threads, regardless of how it was compiled.
+    # Threads cause some doctest failures (memory issues). Those could probably
+    # be solved without disabling threads. But that would require figuring out
+    # some sensible values for `threadsizemax`. See
+    # https://pari.math.u-bordeaux.fr/dochtml/html/GP_defaults.html
+    P.default("nbthreads", 1)
+
+    return P
+
+
+pari = _get_pari_instance()

sage/libs/pari/all.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2 import PariError
+from cypari2.gen import Gen as pari_gen
+
+from sage.libs.pari import pari

sage/libs/pari/convert_flint.pxd

@@ -0,0 +1,14 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2.types cimport GEN
+from cypari2.gen cimport Gen
+from sage.libs.flint.types cimport fmpz_t, fmpz_mat_t, fmpq_t, fmpq_mat_t
+
+cdef GEN _new_GEN_from_fmpz_t(fmpz_t value) noexcept
+cdef GEN _new_GEN_from_fmpz_mat_t(fmpz_mat_t B) noexcept
+cdef GEN _new_GEN_from_fmpz_mat_t_rotate90(fmpz_mat_t B) noexcept
+cdef Gen integer_matrix(fmpz_mat_t B, bint rotate)
+
+cdef GEN _new_GEN_from_fmpq_t(fmpq_t value) noexcept
+cdef GEN _new_GEN_from_fmpq_mat_t(fmpq_mat_t B) noexcept
+cdef GEN _new_GEN_from_fmpq_mat_t_rotate90(fmpq_mat_t B) noexcept
+cdef Gen rational_matrix(fmpq_mat_t B, bint rotate)

sage/libs/pari/convert_flint.pyx

@@ -0,0 +1,159 @@
+# sage_setup: distribution = sagemath-pari
+"""
+Convert PARI objects to/from Flint objects
+
+Utility function to convert PARI ``GEN``s to/from flint types.
+
+AUTHORS:
+
+- Luca De Feo (2016-09-06): Separate Sage-specific components from
+  generic C-interface in ``Pari`` (:issue:`20241`)
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2016 Luca De Feo <luca.defeo@polytechnique.edu>
+#
+# 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/
+# ****************************************************************************
+
+from cysignals.signals cimport sig_on
+
+from sage.libs.flint.fmpz cimport COEFF_IS_MPZ, COEFF_TO_PTR, fmpz_is_one
+from sage.libs.flint.fmpq cimport fmpq_numref, fmpq_denref
+from sage.libs.flint.fmpz_mat cimport fmpz_mat_nrows, fmpz_mat_ncols, fmpz_mat_entry
+from sage.libs.flint.fmpq_mat cimport fmpq_mat_nrows, fmpq_mat_ncols, fmpq_mat_entry
+
+from cypari2.paridecl cimport *
+from cypari2.stack cimport new_gen
+from sage.libs.pari.convert_gmp cimport _new_GEN_from_mpz_t
+
+
+cdef inline GEN _new_GEN_from_fmpz_t(fmpz_t value) noexcept:
+    r"""
+    Create a new PARI ``t_INT`` from a ``fmpz_t``.
+
+    For internal use only; this directly uses the PARI stack.
+    One should call ``sig_on()`` before and ``sig_off()`` after.
+    """
+    if COEFF_IS_MPZ(value[0]):
+        return _new_GEN_from_mpz_t(COEFF_TO_PTR(value[0]))
+    else:
+        return stoi(value[0])
+
+
+cdef inline GEN _new_GEN_from_fmpq_t(fmpq_t value) noexcept:
+    r"""
+    Create a new PARI ``t_RAT`` from a ``fmpq_t``.
+
+    For internal use only; this directly uses the PARI stack.
+    One should call ``sig_on()`` before and ``sig_off()`` after.
+    """
+    cdef GEN num = _new_GEN_from_fmpz_t(fmpq_numref(value))
+    if fmpz_is_one(fmpq_denref(value)):
+        return num
+    cdef GEN denom = _new_GEN_from_fmpz_t(fmpq_denref(value))
+    return mkfrac(num, denom)
+
+
+cdef GEN _new_GEN_from_fmpz_mat_t(fmpz_mat_t B) noexcept:
+    r"""
+    Create a new PARI ``t_MAT`` with ``nr`` rows and ``nc`` columns
+    from a ``fmpz_mat_t``.
+
+    For internal use only; this directly uses the PARI stack.
+    One should call ``sig_on()`` before and ``sig_off()`` after.
+    """
+    cdef GEN x
+    cdef GEN A = zeromatcopy(fmpz_mat_nrows(B), fmpz_mat_ncols(B))
+    cdef Py_ssize_t i, j
+    for i in range(fmpz_mat_nrows(B)):
+        for j in range(fmpz_mat_ncols(B)):
+            x = _new_GEN_from_fmpz_t(fmpz_mat_entry(B, i, j))
+            set_gcoeff(A, i+1, j+1, x)  # A[i+1, j+1] = x (using 1-based indexing)
+    return A
+
+
+cdef GEN _new_GEN_from_fmpq_mat_t(fmpq_mat_t B) noexcept:
+    cdef GEN x
+    cdef GEN A = zeromatcopy(fmpq_mat_nrows(B), fmpq_mat_ncols(B))
+    cdef Py_ssize_t i, j
+    for i in range(fmpq_mat_nrows(B)):
+        for j in range(fmpq_mat_ncols(B)):
+            x = _new_GEN_from_fmpq_t(fmpq_mat_entry(B, i, j))
+            set_gcoeff(A, i+1, j+1, x)  # A[i+1, j+1] = x (using 1-based indexing)
+    return A
+
+cdef GEN _new_GEN_from_fmpz_mat_t_rotate90(fmpz_mat_t B) noexcept:
+    r"""
+    Create a new PARI ``t_MAT`` with ``nr`` rows and ``nc`` columns
+    from a ``fmpz_mat_t`` and rotate the matrix 90 degrees
+    counterclockwise.  So the resulting matrix will have ``nc`` rows
+    and ``nr`` columns.
+
+    For internal use only; this directly uses the PARI stack.
+    One should call ``sig_on()`` before and ``sig_off()`` after.
+    """
+    cdef GEN x
+    cdef GEN A = zeromatcopy(fmpz_mat_ncols(B), fmpz_mat_nrows(B))
+    cdef Py_ssize_t i, j
+    for i in range(fmpz_mat_nrows(B)):
+        for j in range(fmpz_mat_ncols(B)):
+            x = _new_GEN_from_fmpz_t(fmpz_mat_entry(B, i, fmpz_mat_ncols(B) - j - 1))
+            set_gcoeff(A, j+1, i+1, x)  # A[j+1, i+1] = x (using 1-based indexing)
+    return A
+
+
+cdef GEN _new_GEN_from_fmpq_mat_t_rotate90(fmpq_mat_t B) noexcept:
+    r"""
+    Create a new PARI ``t_MAT`` with ``nr`` rows and ``nc`` columns
+    from a ``fmpq_mat_t`` and rotate the matrix 90 degrees
+    counterclockwise.  So the resulting matrix will have ``nc`` rows
+    and ``nr`` columns.
+
+    For internal use only; this directly uses the PARI stack.
+    One should call ``sig_on()`` before and ``sig_off()`` after.
+    """
+    cdef GEN x
+    cdef GEN A = zeromatcopy(fmpq_mat_ncols(B), fmpq_mat_nrows(B))
+    cdef Py_ssize_t i, j
+    for i in range(fmpq_mat_nrows(B)):
+        for j in range(fmpq_mat_ncols(B)):
+            x = _new_GEN_from_fmpq_t(fmpq_mat_entry(B, i, fmpq_mat_ncols(B) - j - 1))
+            set_gcoeff(A, j+1, i+1, x)  # A[j+1, i+1] = x (using 1-based indexing)
+    return A
+
+
+cdef Gen integer_matrix(fmpz_mat_t B, bint rotate):
+    """
+    EXAMPLES::
+
+        sage: matrix(ZZ,2,[1..6]).__pari__()   # indirect doctest                       # needs sage.libs.pari sage.modules
+        [1, 2, 3; 4, 5, 6]
+    """
+    cdef GEN g
+    sig_on()
+    if rotate:
+        g = _new_GEN_from_fmpz_mat_t_rotate90(B)
+    else:
+        g = _new_GEN_from_fmpz_mat_t(B)
+    return new_gen(g)
+
+
+cdef Gen rational_matrix(fmpq_mat_t B, bint rotate):
+    """
+    EXAMPLES::
+
+        sage: matrix(QQ, 2, [1/2, 2/3, 3/4, 4/5]).__pari__()  # indirect doctest        # needs sage.libs.pari sage.modules
+        [1/2, 2/3; 3/4, 4/5]
+    """
+    cdef GEN g
+    sig_on()
+    if rotate:
+        g = _new_GEN_from_fmpq_mat_t_rotate90(B)
+    else:
+        g = _new_GEN_from_fmpq_mat_t(B)
+    return new_gen(g)

sage/libs/pari/convert_gmp.pxd

@@ -0,0 +1,14 @@
+# sage_setup: distribution = sagemath-pari
+from cypari2.types cimport GEN
+from cypari2.gen cimport Gen
+from sage.libs.gmp.types cimport mpz_t, mpq_t, mpz_ptr, mpq_ptr
+
+cdef Gen new_gen_from_mpz_t(mpz_t value)
+cdef GEN _new_GEN_from_mpz_t(mpz_t value) noexcept
+cdef Gen new_gen_from_mpq_t(mpq_t value)
+cdef GEN _new_GEN_from_mpq_t(mpq_t value) noexcept
+cdef Gen new_gen_from_padic(long ordp, long relprec, mpz_t prime, mpz_t p_pow, mpz_t unit)
+cdef GEN _new_GEN_from_mpq_t_matrix(mpq_t** B, long nr, long nc) noexcept
+cdef Gen rational_matrix(mpq_t** B, long nr, long nc)
+cdef void INT_to_mpz(mpz_ptr value, GEN g) noexcept
+cdef void INTFRAC_to_mpq(mpq_ptr value, GEN g) noexcept