Convert PARI objects to Sage types

sage.libs.pari.convert_sage.gen_to_sage(z, locals=None)

Convert a PARI gen to a Sage/Python object.

INPUT:

  • z – PARI gen

  • locals – optional dictionary used in fallback cases that involve sage_eval()

OUTPUT:

One of the following depending on the PARI type of z

  • a Integer if z is an integer (type t_INT)

  • a Rational if z is a rational (type t_FRAC)

  • a RealNumber if z is a real number (type t_REAL). The precision will be equivalent.

  • a NumberFieldElement_quadratic or a ComplexNumber if z is a complex number (type t_COMPLEX). The former is used when the real and imaginary parts are integers or rationals and the latter when they are floating point numbers. In that case The precision will be the maximal precision of the real and imaginary parts.

  • a Python list if z is a vector or a list (type t_VEC, t_COL)

  • a Python string if z is a string (type t_STR)

  • a Python list of Python integers if z is a small vector (type t_VECSMALL)

  • a matrix if z is a matrix (type t_MAT)

  • a padic element (type t_PADIC)

  • a Infinity if z is an infinity (type t_INF)

EXAMPLES:

sage: from sage.libs.pari.convert_sage import gen_to_sage

Converting an integer:

sage: z = pari('12'); z
12
sage: z.type()
't_INT'
sage: a = gen_to_sage(z); a
12
sage: a.parent()
Integer Ring

sage: gen_to_sage(pari('7^42'))
311973482284542371301330321821976049

Converting a rational number:

sage: z = pari('389/17'); z
389/17
sage: z.type()
't_FRAC'
sage: a = gen_to_sage(z); a
389/17
sage: a.parent()
Rational Field

sage: gen_to_sage(pari('5^30 / 3^50'))
931322574615478515625/717897987691852588770249

Converting a real number:

sage: pari.set_real_precision(70)
15
sage: z = pari('1.234'); z
1.234000000000000000000000000000000000000000000000000000000000000000000
sage: a = gen_to_sage(z); a
1.234000000000000000000000000000000000000000000000000000000000000000000000000
sage: a.parent()
Real Field with 256 bits of precision
sage: pari.set_real_precision(15)
70
sage: a = gen_to_sage(pari('1.234')); a
1.23400000000000000
sage: a.parent()
Real Field with 64 bits of precision

For complex numbers, the parent depends on the PARI type:

sage: z = pari('(3+I)'); z
3 + I
sage: z.type()
't_COMPLEX'
sage: a = gen_to_sage(z); a
i + 3
sage: a.parent()
Number Field in i with defining polynomial x^2 + 1 with i = 1*I

sage: z = pari('(3+I)/2'); z
3/2 + 1/2*I
sage: a = gen_to_sage(z); a
1/2*i + 3/2
sage: a.parent()
Number Field in i with defining polynomial x^2 + 1 with i = 1*I

sage: z = pari('1.0 + 2.0*I'); z
1.00000000000000 + 2.00000000000000*I
sage: a = gen_to_sage(z); a
1.00000000000000000 + 2.00000000000000000*I
sage: a.parent()
Complex Field with 64 bits of precision

sage: z = pari('1 + 1.0*I'); z
1 + 1.00000000000000*I
sage: a = gen_to_sage(z); a
1.00000000000000000 + 1.00000000000000000*I
sage: a.parent()
Complex Field with 64 bits of precision

sage: z = pari('1.0 + 1*I'); z
1.00000000000000 + I
sage: a = gen_to_sage(z); a
1.00000000000000000 + 1.00000000000000000*I
sage: a.parent()
Complex Field with 64 bits of precision

Converting polynomials:

sage: f = pari('(2/3)*x^3 + x - 5/7 + y')
sage: f.type()
't_POL'

sage: R.<x,y> = QQ[]
sage: gen_to_sage(f, {'x': x, 'y': y})
2/3*x^3 + x + y - 5/7
sage: parent(gen_to_sage(f, {'x': x, 'y': y}))
Multivariate Polynomial Ring in x, y over Rational Field

sage: x,y = SR.var('x,y')
sage: gen_to_sage(f, {'x': x, 'y': y})
2/3*x^3 + x + y - 5/7
sage: parent(gen_to_sage(f, {'x': x, 'y': y}))
Symbolic Ring

sage: gen_to_sage(f)
Traceback (most recent call last):
...
NameError: name 'x' is not defined

Converting vectors:

sage: z1 = pari('[-3, 2.1, 1+I]'); z1
[-3, 2.10000000000000, 1 + I]
sage: z2 = pari('[1.0*I, [1,2]]~'); z2
[1.00000000000000*I, [1, 2]]~
sage: z1.type(), z2.type()
('t_VEC', 't_COL')
sage: a1 = gen_to_sage(z1)
sage: a2 = gen_to_sage(z2)
sage: type(a1), type(a2)
(<... 'list'>, <... 'list'>)
sage: [parent(b) for b in a1]
[Integer Ring,
 Real Field with 64 bits of precision,
 Number Field in i with defining polynomial x^2 + 1 with i = 1*I]
sage: [parent(b) for b in a2]
[Complex Field with 64 bits of precision, <... 'list'>]

sage: z = pari('Vecsmall([1,2,3,4])')
sage: z.type()
't_VECSMALL'
sage: a = gen_to_sage(z); a
[1, 2, 3, 4]
sage: type(a)
<... 'list'>
sage: [parent(b) for b in a]
[<... 'int'>, <... 'int'>, <... 'int'>, <... 'int'>]

Matrices:

sage: z = pari('[1,2;3,4]')
sage: z.type()
't_MAT'
sage: a = gen_to_sage(z); a
[1 2]
[3 4]
sage: a.parent()
Full MatrixSpace of 2 by 2 dense matrices over Integer Ring

Conversion of p-adics:

sage: z = pari('569 + O(7^8)'); z
2 + 4*7 + 4*7^2 + 7^3 + O(7^8)
sage: a = gen_to_sage(z); a
2 + 4*7 + 4*7^2 + 7^3 + O(7^8)
sage: a.parent()
7-adic Field with capped relative precision 8

Conversion of infinities:

sage: gen_to_sage(pari('oo'))
+Infinity
sage: gen_to_sage(pari('-oo'))
-Infinity

Conversion of strings:

sage: s = pari('"foo"').sage(); s
'foo'
sage: type(s)
<class 'str'>
sage.libs.pari.convert_sage.new_gen_from_integer(self)
sage.libs.pari.convert_sage.new_gen_from_rational(self)
sage.libs.pari.convert_sage.pari_divisors_small(self)

Return the list of divisors of this number using PARI divisorsu.

See also

This method is better used through sage.rings.integer.Integer.divisors().

EXAMPLES:

sage: from sage.libs.pari.convert_sage import pari_divisors_small
sage: pari_divisors_small(4)
[1, 2, 4]

The integer must fit into an unsigned long:

sage: pari_divisors_small(-4)
Traceback (most recent call last):
...
AssertionError
sage: pari_divisors_small(2**65)
Traceback (most recent call last):
...
AssertionError
sage.libs.pari.convert_sage.pari_is_prime(p)

Return whether p is a prime.

The caller must ensure that p.value fits in a long.

EXAMPLES:

sage: from sage.libs.pari.convert_sage import pari_is_prime
sage: pari_is_prime(2)
True
sage: pari_is_prime(3)
True
sage: pari_is_prime(1)
False
sage: pari_is_prime(4)
False

Its recommended to use sage.rings.integer.Integer.is_prime(), which checks overflow. The following is incorrect, because the number does not fit into a long:

sage: pari_is_prime(2**64 + 2)
True
sage.libs.pari.convert_sage.pari_is_prime_power(q, get_data)

Return whether q is a prime power.

The caller must ensure that q.value fits in a long.

OUTPUT:

If get_data return a tuple of the prime and the exponent. Otherwise return a boolean.

EXAMPLES:

sage: from sage.libs.pari.convert_sage import pari_is_prime_power
sage: pari_is_prime_power(2, False)
True
sage: pari_is_prime_power(2, True)
(2, 1)
sage: pari_is_prime_power(4, False)
True
sage: pari_is_prime_power(4, True)
(2, 2)
sage: pari_is_prime_power(6, False)
False
sage: pari_is_prime_power(6, True)
(6, 0)

Its recommended to use sage.rings.integer.Integer.is_prime_power(), which checks overflow. The following is incorrect, because the number does not fit into a long:

sage: pari_is_prime_power(2**64 + 2, False)
True
sage.libs.pari.convert_sage.pari_maxprime()

Return to which limit PARI has computed the primes.

EXAMPLES:

sage: from sage.libs.pari.convert_sage import pari_maxprime
sage: a = pari_maxprime()
sage: res = prime_range(2, 2*a)
sage: b = pari_maxprime()
sage: b >= 2*a
True
sage.libs.pari.convert_sage.pari_prime_range(c_start, c_stop, py_ints=False)

Return a list of all primes between start and stop - 1, inclusive.

sage.libs.pari.convert_sage.pari_typ_to_entries_type(self)

Determine the entries_type of a sage.matrix.args.MatrixArgs with PARI entries.

This will modify the entries.

sage.libs.pari.convert_sage.set_integer_from_gen(self, x)

EXAMPLES:

sage: [Integer(pari(x)) for x in [1, 2^60, 2., GF(3)(1), GF(9,'a')(2)]]
[1, 1152921504606846976, 2, 1, 2]
sage: Integer(pari(2.1)) # indirect doctest
Traceback (most recent call last):
...
TypeError: Attempt to coerce non-integral real number to an Integer
sage.libs.pari.convert_sage.set_rational_from_gen(self, x)

EXAMPLES:

sage: [Rational(pari(x)) for x in [1, 1/2, 2^60, 2., GF(3)(1), GF(9,'a')(2)]]
[1, 1/2, 1152921504606846976, 2, 1, 2]
sage: Rational(pari(2.1)) # indirect doctest
Traceback (most recent call last):
...
TypeError: Attempt to coerce non-integral real number to an Integer