Merge pull request #99 from videlec

Support for pari 2.13.0

Author: videlec

.travis.yml

@@ -18,14 +18,18 @@ env:
   - PARI_VERSION=pari-2.9.5
     URLDIR=OLD/2.9
   - PARI_VERSION=pari-2.11.0
-    URLDIR=unix
+    URLDIR=OLD/2.11
   - PARI_VERSION=pari-2.11.1
-    URLDIR=unix
+    URLDIR=OLD/2.11
   - PARI_VERSION=pari-2.11.2
-    URLDIR=unix
+    URLDIR=OLD/2.11
   - PARI_VERSION=pari-2.11.3
+    URLDIR=OLD/2.11
+  - PARI_VERSION=pari-2.11.4
+    URLDIR=OLD/2.11
+  - PARI_VERSION=pari-2.13.0
     URLDIR=unix
-  - PARI_VERSION=pari-2.12.0.alpha
+  - PARI_VERSION=pari-2.12.1.beta
     URLDIR=unstable
   - PARI_VERSION=snapshot
     URLDIR=snapshots

Makefile

@@ -14,6 +14,8 @@ install:
 
 check:
 	ulimit -s 8192; $(PYTHON) -u tests/rundoctest.py
+	ulimit -s 8192; $(PYTHON) tests/test_integers.py
+	ulimit -s 8192; $(PYTHON) tests/test_backward.py
 
 dist:
 	chmod go+rX-w -R .

autogen/args.py

@@ -15,7 +15,7 @@
 from __future__ import unicode_literals
 
 # Some replacements for reserved words
-replacements = {'char': 'character'}
+replacements = {'char': 'character', 'return': 'return_value'}
 
 class PariArgument(object):
     """
@@ -339,6 +339,29 @@ def c_convert_code(self):
         s += "            {name} = precdl  # Global PARI series precision\n"
         return s.format(name=self.name)
 
+class PariArgumentGENPointer(PariArgumentObject):
+    default = "NULL"
+    def _typerepr(self):
+        return "GEN*"
+    def ctype(self):
+        return "GEN*"
+    def convert_code(self):
+        """
+        Conversion to NULL or Gen
+        """
+        s  = "        cdef bint _have_{name} = ({name} is not None)\n"
+        s += "        if _have_{name}:\n"
+        s += "            raise NotImplementedError(\"optional argument {name} not available\")\n"
+        return s.format(name=self.name)
+    def c_convert_code(self):
+        """
+        Conversion Gen -> GEN
+        """
+        s  = "        cdef GEN * {tmp} = NULL\n"
+        return s.format(name=self.name, tmp=self.tmpname)
+    def call_code(self):
+        return self.tmpname
+
 
 pari_arg_types = {
         'G': PariArgumentGEN,
@@ -351,9 +374,9 @@ def c_convert_code(self):
         'p': PariArgumentPrec,
         'b': PariArgumentBitprec,
         'P': PariArgumentSeriesPrec,
+        '&': PariArgumentGENPointer,
 
     # Codes which are known but not actually supported yet
-        '&': None,
         'V': None,
         'I': None,
         'E': None,

autogen/doc.py

@@ -263,12 +263,7 @@ def get_raw_doc(function):
         <BLANKLINE>
         @[label se:cos]
         Cosine of @[dollar]x@[dollar].
-        <BLANKLINE>
-        <BLANKLINE>
-        The library syntax is @[startcode]GEN @[startbold]gcos@[endbold](GEN x, long prec)@[endcode].
-        <BLANKLINE>
-        <BLANKLINE>
-        <BLANKLINE>
+        ...
         >>> get_raw_doc("abcde")
         Traceback (most recent call last):
         ...

autogen/parser.py

@@ -21,7 +21,7 @@
 from .paths import pari_share
 
 paren_re = re.compile(r"[(](.*)[)]")
-argname_re = re.compile(r"[ {]*([A-Za-z_][A-Za-z0-9_]*)")
+argname_re = re.compile(r"[ {]*&?([A-Za-z_][A-Za-z0-9_]*)")
 
 def read_pari_desc():
     """
@@ -35,9 +35,12 @@ def read_pari_desc():
 
         >>> from autogen.parser import read_pari_desc
         >>> D = read_pari_desc()
-        >>> D["cos"] == { 'class': 'basic',
+        >>> Dcos = D["cos"]
+        >>> if "description" in Dcos: _ = Dcos.pop("description")
+        >>> Dcos.pop("doc").startswith('cosine of $x$.')
+        True
+        >>> Dcos == { 'class': 'basic',
         ...   'cname': 'gcos',
-        ...   'doc': 'cosine of $x$.',
         ...   'function': 'cos',
         ...   'help': 'cos(x): cosine of x.',
         ...   'prototype': 'Gp',
@@ -101,6 +104,10 @@ def parse_prototype(proto, help, initial_args=[]):
         >>> help = 'qfbred(x,{flag=0},{d},{isd},{sd})'
         >>> parse_prototype(proto, help)
         ([GEN x, long flag=0, GEN d=NULL, GEN isd=NULL, GEN sd=NULL], GEN)
+        >>> proto = "GD&"
+        >>> help = "sqrtint(x,{&r})"
+        >>> parse_prototype(proto, help)
+        ([GEN x, GEN* r=NULL], GEN)
         >>> parse_prototype("lp", "foo()", [str("TEST")])
         (['TEST', prec precision=0], long)
     """

cypari2/gen.pyx

@@ -134,11 +134,14 @@ cdef extern from *:
     #endif
 
     #if PARI_VERSION_CODE >= PARI_VERSION(2, 12, 0)
-    #define nfbasis(x, yptr, p) nfbasis(mkvec2(x, p), yptr)
+    #define old_nfbasis(x, yptr, p) nfbasis(mkvec2(x, p), yptr)
+    #else
+    #define old_nfbasis nfbasis
     #endif
     """
     GEN new_nf_nfzk(GEN nf, GEN rnfeq)
     GEN new_nfeltup(GEN nf, GEN x, GEN zknf)
+    GEN old_nfbasis(GEN x, GEN * y, GEN p)
 
 
 cdef class Gen(Gen_base):
@@ -2611,24 +2614,6 @@ cdef class Gen(Gen_base):
         """
         return self.new_ref(gel(self.fixGEN(), 2))
 
-    def precision(x, long n=-1):
-        """
-        Change the precision of `x` to be `n`, where `n` is an integer.
-        If `n` is omitted, output the real precision of `x`.
-
-        INPUT:
-
-        -  ``x`` - gen
-
-        -  ``n`` - (optional) int
-
-        OUTPUT: gen
-        """
-        if n <= 0:
-            return precision(x.g)
-        sig_on()
-        return new_gen(precision0(x.g, n))
-
     def round(x, bint estimate=False):
         """
         round(x,estimate=False): If x is a real number, returns x rounded
@@ -3686,6 +3671,19 @@ cdef class Gen(Gen_base):
         [1, 1/10000000019*x]
         >>> pari(f).nfbasis(fa=[2,p])              # Equivalent with the above
         [1, 1/10000000019*x]
+
+        The following alternative syntax closer to PARI/GP can be used
+
+        >>> pari.nfbasis([f, 1])
+        [1, x]
+        >>> pari.nfbasis(f)
+        [1, 1/10000000019*x]
+        >>> pari.nfbasis([f, 10**6])
+        [1, x]
+        >>> pari.nfbasis([f, "[2,2; %s,2]"%p])
+        [1, 1/10000000019*x]
+        >>> pari.nfbasis([f, [2,p]])
+        [1, 1/10000000019*x]
         """
         cdef Gen t0
         cdef GEN g0
@@ -3697,7 +3695,7 @@ cdef class Gen(Gen_base):
         else:
             g0 = NULL
         sig_on()
-        return new_gen(nfbasis(self.g, NULL, g0))
+        return new_gen(old_nfbasis(self.g, NULL, g0))
 
     def nfbasis_d(self, long flag=0, fa=None):
         """
@@ -3731,7 +3729,7 @@ cdef class Gen(Gen_base):
         else:
             g0 = NULL
         sig_on()
-        ans = nfbasis(self.g, &disc, g0)
+        ans = old_nfbasis(self.g, &disc, g0)
         return new_gens2(ans, disc)
 
     def nfbasistoalg_lift(nf, x):
@@ -4115,38 +4113,6 @@ cdef class Gen(Gen_base):
         sig_on()
         return new_gen(factorpadic(self.g, t0.g, r))
 
-    def poldegree(self, var=None):
-        """
-        Return the degree of this polynomial.
-        """
-        sig_on()
-        n = poldegree(self.g, get_var(var))
-        sig_off()
-        return n
-
-    def polisirreducible(self):
-        """
-        f.polisirreducible(): Returns True if f is an irreducible
-        non-constant polynomial, or False if f is reducible or constant.
-        """
-        sig_on()
-        t = polisirreducible(self.g)
-        clear_stack()
-        return t != 0
-
-    def polroots(self, unsigned long precision=0):
-        """
-        Complex roots of the given polynomial using Schonhage's method,
-        as modified by Gourdon.
-        """
-        sig_on()
-        return new_gen(cleanroots(self.g, prec_bits_to_words(precision)))
-
-    def rnfisnorm(self, T, long flag=0):
-        cdef Gen t0 = objtogen(T)
-        sig_on()
-        return new_gen(rnfisnorm(t0.g, self.g, flag))
-
     def ncols(self):
         """
         Return the number of columns of self.
@@ -4699,20 +4665,14 @@ cpdef Gen objtogen(s):
 
     Conversion from reals uses the real's own precision:
 
-    >>> a = pari(1.2); a, a.type()
-    (1.20000000000000, 't_REAL')
-    >>> import sys
-    >>> bitness = '64' if sys.maxsize > (1 << 32) else '32'
-    >>> a.precision() == (4 if bitness == '32' else 3)
-    True
+    >>> a = pari(1.2); a, a.type(), a.bitprecision()
+    (1.20000000000000, 't_REAL', 64)
 
     Conversion from strings uses the current PARI real precision.
     By default, this is 64 bits:
 
-    >>> a = pari('1.2'); a, a.type()
-    (1.20000000000000, 't_REAL')
-    >>> a.precision() == (4 if bitness == '32' else 3)
-    True
+    >>> a = pari('1.2'); a, a.type(), a.bitprecision()
+    (1.20000000000000, 't_REAL', 64)
 
     Unicode and bytes work fine:
 
@@ -4725,11 +4685,10 @@ cpdef Gen objtogen(s):
 
     >>> pari.set_real_precision(35)  # precision in decimal digits
     15
-    >>> a = pari('1.2'); a, a.type()
-    (1.2000000000000000000000000000000000, 't_REAL')
-    >>> bitness = '64' if sys.maxsize > (1 << 32) else '32'
-    >>> a.precision() == (6 if bitness == '32' else 4)
-    True
+    >>> a = pari('Pi'); a, a.type(), a.bitprecision()
+    (3.1415926535897932384626433832795029, 't_REAL', 128)
+    >>> a = pari('1.2'); a, a.type(), a.bitprecision()
+    (1.2000000000000000000000000000000000, 't_REAL', 128)
 
     Set the precision to 15 digits for the remaining tests:
 

cypari2/pari_instance.pyx

@@ -491,7 +491,8 @@ cdef class Pari(Pari_auto):
 
         # Take 1MB as minimal stack. Use maxprime=0, which PARI will
         # internally increase to some small value like 65537.
-        pari_init_opts(1000000, 0, INIT_DFTm)
+        # (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
@@ -557,7 +558,7 @@ cdef class Pari(Pari_auto):
 
         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 is ``maxprime`` is larger than the current
+        of primes is only computed if ``maxprime`` is larger than the current
         bound.
 
         Examples:
@@ -575,6 +576,11 @@ cdef class Pari(Pari_auto):
         >>> 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`.
 
@@ -603,6 +609,7 @@ cdef class Pari(Pari_auto):
         set_pari_stack_size(size, sizemax)
 
         # Increase the table of primes if needed
+        GP_DATA.primelimit = maxprime
         self.init_primes(maxprime)
 
         # Initialize some constants
@@ -1042,15 +1049,15 @@ cdef class Pari(Pari_auto):
         >>> pari = cypari2.Pari()
         >>> pari.init_primes(200000)
 
-        We make sure that ticket :trac:`11741` has been fixed::
+        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
+        >>> pari.init_primes(2**30)
+        Traceback (most recent call last):
+        ...
+        ValueError: Cannot compute primes beyond 436273290
         """
-        # Hardcoded bound in PARI sources
-        if M > 436273290:
+        # Hardcoded bound in PARI sources (language/forprime.c)
+        if M > 436273289:
             raise ValueError("Cannot compute primes beyond 436273290")
 
         if M <= maxprime():