Ticket #9640: 9640old.patch

File 9640old.patch, 85.5 KB (added by jdemeyer, 11 years ago)

Old patch for reference

  • module_list.py

    # HG changeset patch
    # User Jeroen Demeyer <jdemeyer@cage.ugent.be>
    # Date 1281989171 -7200
    # Node ID f902c841cbfb392d51d313b2849771f8abd5086b
    # Parent  37fb7c004f83b1ca4f933033edb43ce7a9621ad6
    [mq]: 9640
    
    diff -r 37fb7c004f83 -r f902c841cbfb module_list.py
    a b  
    531531              sources = ["sage/libs/pari/gen.pyx"],
    532532              libraries = ['pari', 'gmp']),
    533533   
     534    Extension('sage.libs.pari.pari_err',
     535              sources = ["sage/libs/pari/pari_err.pyx", "sage/libs/pari/except_from_c.c"],
     536              libraries = ['pari']),
     537   
    534538    Extension('sage.libs.ratpoints',
    535539              sources = ["sage/libs/ratpoints.pyx"],
    536540              depends = [SAGE_ROOT + '/local/include/ratpoints.h'],
  • sage/libs/pari/all.py

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/all.py
    a b  
    66
    77allocatemem = pari.allocatemem
    88
    9 PariError = _gen.PariError
    109
    1110from gen import (prec_dec_to_words, prec_dec_to_bits,
    1211                 prec_bits_to_words, prec_bits_to_dec,
    1312                 prec_words_to_bits, prec_words_to_dec)
     13
     14from pari_err import PariError
  • sage/libs/pari/decl.pxi

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/decl.pxi
    a b  
    8181    GEN     gen_1
    8282    GEN     gen_2
    8383    GEN     ghalf
    84     GEN     gi
    8584    GEN     gen_0
    8685    GEN     gnil
     86    int (*cb_pari_handle_exception)(long numerr) except 0
     87
     88    # parierr.h
     89
     90    char *errmessage[]
     91    int user     # User error
     92    int errpile  # Out of memory
     93    int noer     # Number of errors
    8794
    8895    # level1.h (incomplete!)
    8996   
     
    16071614    long *   int_precW(long * xp)
    16081615    long *   int_nextW(long * xp)
    16091616
     1617
    16101618cdef extern:   # paristio.h
    16111619    ctypedef struct PariOUT:
    16121620        void (*putch)(char)
  • sage/libs/pari/gen.pxd

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/gen.pxd
    a b  
    4141    cdef integer_matrix(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc, bint permute_for_hnf)
    4242    cdef GEN rational_matrix_GEN(self, mpq_t** B, Py_ssize_t nr, Py_ssize_t nc) except <GEN>0
    4343    cdef rational_matrix(self, mpq_t** B, Py_ssize_t nr, Py_ssize_t nc)
    44 
    45    
    46    
    47    
  • sage/libs/pari/gen.pyx

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/gen.pyx
    a b  
    152152from sage.structure.element cimport ModuleElement, RingElement, Element
    153153from sage.structure.parent cimport Parent
    154154from sage.misc.randstate cimport randstate, current_randstate
     155from sage.libs.pari.pari_err import PariError
     156from sage.libs.pari.pari_err cimport handle_pari_exception
     157from sage.libs.pari.pari_err cimport _pari_catch
    155158
    156159from sage.misc.misc_c import is_64_bit
    157160
     
    164167    cdef void ZZ_to_t_INT( GEN *g, mpz_t value )
    165168    cdef void QQ_to_t_FRAC( GEN *g, mpq_t value )
    166169
     170
    167171# Make sure we don't use mpz_t_offset before initializing it by
    168172# putting in a value that's likely to provoke a segmentation fault,
    169173# rather than silently corrupting memory.
     
    173177cdef PariInstance pari_instance, P
    174178pari_instance = PariInstance(16000000, 500000)
    175179P = pari_instance   # shorthand notation
     180# Also a copy of PARI accessible from external pure python code.
     181pari = pari_instance
    176182
    177183# so Galois groups are represented in a sane way
    178184# See the polgalois section of the PARI users manual.
     
    350356    """
    351357    return prec_bits_to_dec(prec_words_to_bits(prec_in_words))
    352358
    353 # Also a copy of PARI accessible from external pure python code.
    354 pari = pari_instance
    355359
    356360# temp variables
    357361cdef GEN t0,t1,t2,t3,t4
     
    456460        return sage.libs.pari.gen_py.pari, (s,)
    457461
    458462    cpdef ModuleElement _add_(self, ModuleElement right):
    459         _sig_on
     463        _sig_on; _pari_catch()
    460464        return P.new_gen(gadd(self.g, (<gen>right).g))
    461465
    462466    def _add_unsafe(gen self, gen right):
     
    485489        return w
    486490   
    487491    cpdef ModuleElement _sub_(self, ModuleElement right):
    488         _sig_on
     492        _sig_on; _pari_catch()
    489493        return P.new_gen(gsub(self.g, (<gen> right).g))
    490494
    491495    def _sub_unsafe(gen self, gen right):
     
    514518        return w
    515519
    516520    cpdef RingElement _mul_(self, RingElement right):   
    517         _sig_on
     521        _sig_on; _pari_catch()
    518522        return P.new_gen(gmul(self.g, (<gen>right).g))
    519523
    520524    def _mul_unsafe(gen self, gen right):
     
    543547        return w
    544548
    545549    cpdef RingElement _div_(self, RingElement right):   
    546         _sig_on
     550        _sig_on; _pari_catch()
    547551        return P.new_gen(gdiv(self.g, (<gen>right).g))
    548552
    549553    def _div_unsafe(gen self, gen right):
     
    588592            sage: n._add_one()
    589593            x^3 + 1
    590594        """
    591         _sig_on
     595        _sig_on; _pari_catch()
    592596        return P.new_gen(gaddsg(1, self.g))
    593597
    594598    def _mod(gen self, gen other):
    595         _sig_on
     599        _sig_on; _pari_catch()
    596600        return P.new_gen(gmod(self.g, other.g))
    597601
    598602    def __mod__(self, other):
     
    603607    def __pow__(self, n, m):
    604608        t0GEN(self)
    605609        t1GEN(n)
    606         _sig_on
     610        _sig_on; _pari_catch()
    607611        # Note: the prec parameter here has no effect when t0,t1 are
    608612        # real; the precision of the result is the minimum of the
    609613        # precisions of t0 and t1.  In any case the 3rd parameter to
     
    611615        return P.new_gen(gpow(t0, t1, prec))
    612616
    613617    def __neg__(gen self):
    614         _sig_on
     618        _sig_on; _pari_catch()
    615619        return P.new_gen(gneg(self.g))
    616620
    617621    def __xor__(gen self, n):
     
    619623              "in Python, and has the wrong precedence."
    620624
    621625    def __rshift__(gen self, long n):
    622         _sig_on
     626        _sig_on; _pari_catch()
    623627        return P.new_gen(gshift(self.g, -n))
    624628
    625629    def __lshift__(gen self, long n):
    626         _sig_on       
     630        _sig_on; _pari_catch()       
    627631        return P.new_gen(gshift(self.g, n))
    628632
    629633    def __invert__(gen self):
    630         _sig_on       
     634        _sig_on; _pari_catch()       
    631635        return P.new_gen(ginv(self.g))
    632636
    633637    ###########################################
     
    636640    #def __getattr__(self, attr):
    637641    def getattr(self, attr):
    638642        t0GEN(str(self) + '.' + str(attr))
    639         _sig_on
     643        _sig_on; _pari_catch()
    640644        return self.new_gen(t0)
    641645
    642646    def __getitem__(gen self, n):
     
    962966        cdef Py_ssize_t ii, jj, step
    963967           
    964968
    965         _sig_on
     969        _sig_on; _pari_catch()
    966970        if PyObject_TypeCheck(y, gen):
    967971            x = y
    968972        else:
     
    10751079        return gcmp_sage(left.g, (<gen>right).g)
    10761080
    10771081    def __copy__(gen self):
    1078         _sig_on
     1082        _sig_on; _pari_catch()
    10791083        return P.new_gen(gcopy(self.g))
    10801084
    10811085    ###########################################
     
    12521256        if typ(g) != t_VEC:
    12531257            raise TypeError, "gen must be of PARI type t_VEC"
    12541258
    1255         _sig_on
     1259        _sig_on; _pari_catch()
    12561260        L = glength(g)
    12571261        v = []
    12581262        for n from 0 <= n < L:
     
    13891393        Return Python float.
    13901394        """
    13911395        cdef double d
    1392         _sig_on
     1396        _sig_on; _pari_catch()
    13931397        d = gtodouble(self.g)
    13941398        _sig_off
    13951399        return d
     
    14181422            PariError: incorrect type (11)
    14191423        """
    14201424        cdef double re, im
    1421         _sig_on
     1425        _sig_on; _pari_catch()
    14221426        re = gtodouble(greal(self.g))
    14231427        im = gtodouble(gimag(self.g))
    14241428        _sig_off
     
    14771481            sage: n.isprime(2)
    14781482            False
    14791483        """
    1480         _sig_on       
     1484        _sig_on; _pari_catch()       
    14811485        t = bool(gisprime(self.g, flag) != stoi(0))
    14821486        _sig_off
    14831487        return t
     
    15201524            3
    15211525       
    15221526        """
    1523         _sig_on
     1527        _sig_on; _pari_catch()
    15241528        return P.new_gen(hclassno(n.g))
    15251529
    15261530    def ispseudoprime(gen self, flag=0):
     
    15571561            False
    15581562        """
    15591563        cdef long z
    1560         _sig_on
     1564        _sig_on; _pari_catch()
    15611565        z = ispseudoprime(self.g, flag)
    15621566        _sig_off
    15631567        return (z != 0)
     
    16071611        cdef GEN x
    16081612       
    16091613        if k is None:
    1610             _sig_on
     1614            _sig_on; _pari_catch()
    16111615            n = gisanypower(self.g, &x)
    16121616            if n == 0:
    16131617                _sig_off
     
    16171621        else:
    16181622            k = int(k)
    16191623            t0GEN(k)
    1620             _sig_on
     1624            _sig_on; _pari_catch()
    16211625            n = ispower(self.g, t0, &x)
    16221626            if n == 0:
    16231627                _sig_off
     
    16351639        respect to v (to main variable if v is omitted).
    16361640        """
    16371641        t0GEN(y)
    1638         _sig_on       
     1642        _sig_on; _pari_catch()       
    16391643        return P.new_gen(divrem(x.g, t0, P.get_var(var)))
    16401644
    16411645    def lex(gen x, y):
     
    16441648        if xy)
    16451649        """
    16461650        t0GEN(y)
    1647         _sig_on       
     1651        _sig_on; _pari_catch()       
    16481652        return lexcmp(x.g, t0)
    16491653
    16501654    def max(gen x, y):
     
    16521656        max(x,y): Return the maximum of x and y.
    16531657        """
    16541658        t0GEN(y)
    1655         _sig_on
     1659        _sig_on; _pari_catch()
    16561660        return P.new_gen(gmax(x.g, t0))
    16571661
    16581662    def min(gen x, y):
     
    16601664        min(x,y): Return the minimum of x and y.
    16611665        """
    16621666        t0GEN(y)
    1663         _sig_on
     1667        _sig_on; _pari_catch()
    16641668        return P.new_gen(gmin(x.g, t0))
    16651669
    16661670    def shift(gen x, long n):
    16671671        """
    16681672        shift(x,n): shift x left n bits if n=0, right -n bits if n0.
    16691673        """
    1670         _sig_on
     1674        _sig_on; _pari_catch()
    16711675        return P.new_gen(gshift(x.g, n))
    16721676
    16731677    def shiftmul(gen x, long n):
    16741678        """
    16751679        shiftmul(x,n): Return the product of x by `2^n`.
    16761680        """
    1677         _sig_on
     1681        _sig_on; _pari_catch()
    16781682        return P.new_gen(gmul2n(x.g, n))
    16791683
    16801684    def moebius(gen x):
    16811685        """
    16821686        moebius(x): Moebius function of x.
    16831687        """
    1684         _sig_on
     1688        _sig_on; _pari_catch()
    16851689        return P.new_gen(gmoebius(x.g))
    16861690
    16871691    def sign(gen x):
     
    16911695        """
    16921696        # Pari throws an error if you attempt to take the sign of
    16931697        # a complex number.
    1694         _sig_on
     1698        _sig_on; _pari_catch()
    16951699        return gsigne(x.g)
    16961700
    16971701    def vecmax(gen x):
     
    16991703        vecmax(x): Return the maximum of the elements of the vector/matrix
    17001704        x.
    17011705        """
    1702         _sig_on
     1706        _sig_on; _pari_catch()
    17031707        return P.new_gen(vecmax(x.g))
    17041708
    17051709       
     
    17081712        vecmin(x): Return the maximum of the elements of the vector/matrix
    17091713        x.
    17101714        """
    1711         _sig_on       
     1715        _sig_on; _pari_catch()       
    17121716        return P.new_gen(vecmin(x.g))
    17131717   
    17141718
     
    17641768            sage: pari('x + 3*x^3 + O(x^5)').Col()
    17651769            [1, 0, 3, 0]~
    17661770        """
    1767         _sig_on
     1771        _sig_on; _pari_catch()
    17681772        return P.new_gen(gtocol(x.g))
    17691773       
    17701774    def List(gen x):
     
    17841788            sage: w.type()
    17851789            't_LIST'
    17861790        """
    1787         _sig_on
     1791        _sig_on; _pari_catch()
    17881792        return P.new_gen(gtolist(x.g))
    17891793
    17901794    def Mat(gen x):
     
    18471851            sage: v.Mat()
    18481852            [1, 2; 3, 4]
    18491853        """
    1850         _sig_on
     1854        _sig_on; _pari_catch()
    18511855        return P.new_gen(gtomat(x.g))
    18521856   
    18531857    def Mod(gen x, y):
     
    19081912            't_POLMOD'
    19091913        """
    19101914        t0GEN(y)
    1911         _sig_on
     1915        _sig_on; _pari_catch()
    19121916        return P.new_gen(gmodulo(x.g,t0))
    19131917   
    19141918    def Pol(self, v=-1):
     
    19651969            sage: v.Pol()
    19661970            [1, 3]~*x + [2, 4]~
    19671971        """
    1968         _sig_on
     1972        _sig_on; _pari_catch()
    19691973        return P.new_gen(gtopoly(self.g, P.get_var(v)))
    19701974   
    19711975    def Polrev(self, v=-1):
     
    20112015            sage: v.Polrev()
    20122016            [2, 4]~*x + [1, 3]~
    20132017        """
    2014         _sig_on
     2018        _sig_on; _pari_catch()
    20152019        return P.new_gen(gtopolyrev(self.g, P.get_var(v)))
    20162020   
    20172021    def Qfb(gen a, b, c, D=0):
     
    20572061            Qfb(3, 7, 2, 0.E-19)
    20582062        """
    20592063        t0GEN(b); t1GEN(c); t2GEN(D)
    2060         _sig_on       
     2064        _sig_on; _pari_catch()       
    20612065        return P.new_gen(Qfb0(a.g, t0, t1, t2, prec))
    20622066       
    20632067   
     
    21122116            sage: pari(1).Ser()
    21132117            1 + O(x^16)
    21142118        """
    2115         _sig_on
     2119        _sig_on; _pari_catch()
    21162120        return P.new_gen(gtoser(x.g, P.get_var(v)))
    21172121       
    21182122   
     
    21492153            sage: pari('["bc","ab","bc"]').Set()
    21502154            ["\"ab\"", "\"bc\""]
    21512155        """
    2152         _sig_on           
     2156        _sig_on; _pari_catch()           
    21532157        return P.new_gen(gtoset(x.g))
    21542158
    21552159
     
    21862190            't_STR'
    21872191        """
    21882192        cdef char* c
    2189         _sig_on
     2193        _sig_on; _pari_catch()
    21902194        c = GENtostr(self.g)
    21912195        v = self.new_gen(strtoGENstr(c))
    21922196        free(c)
     
    22252229            sage: pari([83, 97, 103, 101]).Strchr()
    22262230            "Sage"
    22272231        """
    2228         _sig_on       
     2232        _sig_on; _pari_catch()       
    22292233        return P.new_gen(Strchr(x.g))
    22302234   
    22312235    def Strexpand(gen x):
     
    22392243        """
    22402244        if typ(x.g) != t_VEC:
    22412245            raise TypeError, "x must be of type t_VEC."
    2242         _sig_on
     2246        _sig_on; _pari_catch()
    22432247        return P.new_gen(Strexpand(x.g))
    22442248       
    22452249   
     
    22742278        """
    22752279        if typ(x.g) != t_VEC:
    22762280            x = P.vector(1, [x])
    2277         _sig_on           
     2281        _sig_on; _pari_catch()           
    22782282        return P.new_gen(Strtex(x.g))
    22792283       
    22802284    def printtex(gen x):
     
    23092313            sage: pari('ab').Vec()
    23102314            [1, 0]
    23112315        """
    2312         _sig_on       
     2316        _sig_on; _pari_catch()       
    23132317        return P.new_gen(gtovec(x.g))
    23142318
    23152319    def Vecrev(gen x):
     
    23562360        """
    23572361        cdef long lx, vx, i
    23582362        cdef GEN y
    2359         _sig_on
     2363        _sig_on; _pari_catch()
    23602364        if typ(x.g) == t_POL:
    23612365            lx = lg(x.g)
    23622366            y = cgetg(lx-1, t_VEC)
     
    24052409            sage: pari(1234).Vecsmall()
    24062410            Vecsmall([1234])
    24072411        """
    2408         _sig_on       
     2412        _sig_on; _pari_catch()       
    24092413        return P.new_gen(gtovecsmall(x.g))
    24102414   
    24112415    def binary(gen x):
     
    24452449        """
    24462450        if typ(x.g) != t_INT:
    24472451            raise TypeError, "x (=%s) must be of type t_INT, but is of type %s."%(x,x.type())
    2448         _sig_on
     2452        _sig_on; _pari_catch()
    24492453        return P.new_gen(binaire(x.g))
    24502454   
    24512455    def bitand(gen x, y):
     
    24852489            -1
    24862490        """
    24872491        t0GEN(y)
    2488         _sig_on
     2492        _sig_on; _pari_catch()
    24892493        return P.new_gen(gbitand(x.g, t0))
    24902494       
    24912495   
     
    25312535            sage: -570 % 2^10
    25322536            454
    25332537        """
    2534         _sig_on
     2538        _sig_on; _pari_catch()
    25352539        return P.new_gen(gbitneg(x.g,n))
    25362540   
    25372541   
     
    25652569            4
    25662570        """
    25672571        t0GEN(y)
    2568         _sig_on
     2572        _sig_on; _pari_catch()
    25692573        return P.new_gen(gbitnegimply(x.g, t0))
    25702574
    25712575   
     
    26002604            13
    26012605        """
    26022606        t0GEN(y)
    2603         _sig_on
     2607        _sig_on; _pari_catch()
    26042608        return P.new_gen(gbitor(x.g, t0))
    26052609
    26062610   
     
    26402644            sage: [pari(-3).bittest(n) for n in range(10)]
    26412645            [True, False, True, True, True, True, True, True, True, True]
    26422646        """
    2643         _sig_on
     2647        _sig_on; _pari_catch()
    26442648        b = bool(bittest(x.g, n))
    26452649        _sig_off
    26462650        return b
     
    26742678            6
    26752679        """
    26762680        t0GEN(y)
    2677         _sig_on
     2681        _sig_on; _pari_catch()
    26782682        return P.new_gen(gbitxor(x.g, t0))
    26792683
    26802684   
     
    27172721            sage: pari(x^2+5*x+2.5).ceil()
    27182722            x^2 + 5*x + 2.50000000000000
    27192723        """
    2720         _sig_on
     2724        _sig_on; _pari_catch()
    27212725        return P.new_gen(gceil(x.g))
    27222726   
    27232727    def centerlift(gen x, v=-1):
     
    27552759            sage: f.centerlift('y')
    27562760            Mod(x - y, x^2 + 1)
    27572761        """
    2758         _sig_on
     2762        _sig_on; _pari_catch()
    27592763        return P.new_gen(centerlift0(x.g, P.get_var(v)))
    27602764
    27612765   
     
    28022806            ...
    28032807            PariError:  (5)
    28042808        """
    2805         _sig_on
     2809        _sig_on; _pari_catch()
    28062810        return P.new_gen(compo(x.g, n))
    28072811   
    28082812    def conj(gen x):
     
    28342838            ...
    28352839            PariError: incorrect type (11)
    28362840        """
    2837         _sig_on
     2841        _sig_on; _pari_catch()
    28382842        return P.new_gen(gconj(x.g))
    28392843   
    28402844    def conjvec(gen x):
     
    28582862            sage: pari('Mod(x,x^3-3)').conjvec()
    28592863            [1.44224957030741, -0.721124785153704 + 1.24902476648341*I, -0.721124785153704 - 1.24902476648341*I]~
    28602864        """
    2861         _sig_on
     2865        _sig_on; _pari_catch()
    28622866        return P.new_gen(conjvec(x.g, prec))
    28632867   
    28642868    def denominator(gen x):
     
    28882892            sage: pari('[2/3, 5/8, 7/3, 1/5]').denominator()
    28892893            120
    28902894        """
    2891         _sig_on
     2895        _sig_on; _pari_catch()
    28922896        return P.new_gen(denom(x.g))
    28932897   
    28942898    def floor(gen x):
     
    29312935            ...
    29322936            PariError: incorrect type (11)
    29332937        """
    2934         _sig_on
     2938        _sig_on; _pari_catch()
    29352939        return P.new_gen(gfloor(x.g))
    29362940   
    29372941    def frac(gen x):
     
    29572961            ...
    29582962            PariError: incorrect type (11)
    29592963        """
    2960         _sig_on
     2964        _sig_on; _pari_catch()
    29612965        return P.new_gen(gfrac(x.g))
    29622966   
    29632967    def imag(gen x):
     
    29882992            sage: pari('[1,2,3] + [4*I,5,6]').imag()
    29892993            [4, 0, 0]
    29902994        """
    2991         _sig_on
     2995        _sig_on; _pari_catch()
    29922996        return P.new_gen(gimag(x.g))
    29932997   
    29942998    def length(self):
     
    30273031       
    30283032        ??? more examples
    30293033        """
    3030         _sig_on
     3034        _sig_on; _pari_catch()
    30313035        if v == -1:
    30323036            return P.new_gen(lift(x.g))
    30333037        return P.new_gen(lift0(x.g, P.get_var(v)))
     
    30433047            sage: pari(100).numbpart()
    30443048            190569292
    30453049        """
    3046         _sig_on
     3050        _sig_on; _pari_catch()
    30473051        return P.new_gen(numbpart(x.g))
    30483052   
    30493053    def numerator(gen x):
     
    30603064       
    30613065        EXAMPLES:
    30623066        """
    3063         _sig_on
     3067        _sig_on; _pari_catch()
    30643068        return P.new_gen(numer(x.g))
    30653069   
    30663070
     
    30853089       
    30863090        EXAMPLES:
    30873091        """
    3088         _sig_on       
     3092        _sig_on; _pari_catch()       
    30893093        return P.new_gen(numtoperm(n, k.g))
    30903094
    30913095   
     
    31333137        """
    31343138        if typ(x.g) != t_VEC:
    31353139            raise TypeError, "x (=%s) must be of type t_VEC, but is of type %s."%(x,x.type())
    3136         _sig_on
     3140        _sig_on; _pari_catch()
    31373141        return P.new_gen(permtonum(x.g))
    31383142   
    31393143    def precision(gen x, long n=-1):
     
    31553159        """
    31563160        if n <= -1:
    31573161            return precision(x.g)
    3158         _sig_on
     3162        _sig_on; _pari_catch()
    31593163        return P.new_gen(precision0(x.g, n))
    31603164   
    31613165    def random(gen N):
     
    31793183        """
    31803184        if typ(N.g) != t_INT:
    31813185            raise TypeError, "x (=%s) must be of type t_INT, but is of type %s."%(N,N.type())
    3182         _sig_on
     3186        _sig_on; _pari_catch()
    31833187        return P.new_gen(genrand(N.g))
    31843188   
    31853189    def real(gen x):
     
    31963200       
    31973201        EXAMPLES:
    31983202        """
    3199         _sig_on
     3203        _sig_on; _pari_catch()
    32003204        return P.new_gen(greal(x.g))
    32013205   
    32023206    def round(gen x, estimate=False):
     
    32493253        cdef int n
    32503254        cdef long e
    32513255        cdef gen y
    3252         _sig_on
     3256        _sig_on; _pari_catch()
    32533257        if not estimate:
    32543258            return P.new_gen(ground(x.g))
    32553259        y = P.new_gen(grndtoi(x.g, &e))
     
    32933297            sage: y.type()
    32943298            't_REAL'
    32953299        """
    3296         _sig_on
     3300        _sig_on; _pari_catch()
    32973301        return P.new_gen(simplify(x.g))
    32983302   
    32993303    def sizeword(gen x):
     
    34523456        """
    34533457        cdef long e
    34543458        cdef gen y
    3455         _sig_on
     3459        _sig_on; _pari_catch()
    34563460        if not estimate:
    34573461            return P.new_gen(gtrunc(x.g))
    34583462        y = P.new_gen(gcvtoi(x.g, &e))
     
    35293533            9223372036854775807   # 64-bit
    35303534        """
    35313535        t0GEN(p)
    3532         _sig_on
     3536        _sig_on; _pari_catch()
    35333537        v = ggval(x.g, t0)
    35343538        _sig_off
    35353539        return v
     
    35613565            sage: pari('y0+z0').variable()
    35623566            y0
    35633567        """
    3564         _sig_on
     3568        _sig_on; _pari_catch()
    35653569        return P.new_gen(gpolvar(x.g))
    35663570
    35673571
     
    35933597            sage: pari('x-1.2*x^2').abs()
    35943598            1.20000000000000*x^2 - x
    35953599        """
    3596         _sig_on
     3600        _sig_on; _pari_catch()
    35973601        # the prec parameter here has no effect
    35983602        return P.new_gen(gabs(x.g, prec))
    35993603   
     
    36203624            sage: pari(1.1+i).acos()
    36213625            0.849343054245252 - 1.09770986682533*I
    36223626        """
    3623         _sig_on
     3627        _sig_on; _pari_catch()
    36243628        return P.new_gen(gacos(x.g, pbw(precision)))
    36253629
    36263630    def acosh(gen x, precision=0):
     
    36453649            sage: pari(i).acosh()
    36463650            0.881373587019543 + 1.57079632679490*I
    36473651        """
    3648         _sig_on
     3652        _sig_on; _pari_catch()
    36493653        return P.new_gen(gach(x.g, pbw(precision)))
    36503654
    36513655    def agm(gen x, y, precision=0):
     
    36753679            -0.964731722290876 + 1.15700282952632*I
    36763680        """
    36773681        t0GEN(y)
    3678         _sig_on
     3682        _sig_on; _pari_catch()
    36793683        return P.new_gen(agm(x.g, t0, pbw(precision)))
    36803684
    36813685    def arg(gen x, precision=0):
     
    36933697            sage: pari(2+i).arg()               
    36943698            0.463647609000806
    36953699        """
    3696         _sig_on
     3700        _sig_on; _pari_catch()
    36973701        return P.new_gen(garg(x.g, pbw(precision)))
    36983702
    36993703    def asin(gen x, precision=0):
     
    37153719            sage: pari(2).asin()
    37163720            1.57079632679490 + 1.31695789692482*I
    37173721        """
    3718         _sig_on
     3722        _sig_on; _pari_catch()
    37193723        return P.new_gen(gasin(x.g, pbw(precision)))
    37203724
    37213725    def asinh(gen x, precision=0):
     
    37363740            sage: pari(2+i).asinh()
    37373741            1.52857091948100 + 0.427078586392476*I
    37383742        """
    3739         _sig_on
     3743        _sig_on; _pari_catch()
    37403744        return P.new_gen(gash(x.g, pbw(precision)))
    37413745
    37423746    def atan(gen x, precision=0):
     
    37573761            sage: pari(1.5+i).atan()
    37583762            1.10714871779409 + 0.255412811882995*I
    37593763        """
    3760         _sig_on
     3764        _sig_on; _pari_catch()
    37613765        return P.new_gen(gatan(x.g, pbw(precision)))
    37623766
    37633767    def atanh(gen x, precision=0):
     
    37793783            sage: pari(2).atanh()
    37803784            0.549306144334055 + 1.57079632679490*I
    37813785        """
    3782         _sig_on
     3786        _sig_on; _pari_catch()
    37833787        return P.new_gen(gath(x.g, pbw(precision)))
    37843788
    37853789    def bernfrac(gen x):
     
    37963800            sage: [pari(n).bernfrac() for n in range(10)]
    37973801            [1, -1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0]
    37983802        """
    3799         _sig_on
     3803        _sig_on; _pari_catch()
    38003804        return P.new_gen(bernfrac(x))
    38013805
    38023806    def bernreal(gen x):
     
    38103814            sage: pari(18).bernreal()
    38113815            54.9711779448622
    38123816        """
    3813         _sig_on
     3817        _sig_on; _pari_catch()
    38143818        # the argument prec has no effect
    38153819        return P.new_gen(bernreal(x, prec))
    38163820
     
    38323836            sage: [pari(2*n).bernfrac() for n in range(9)]
    38333837            [1, 1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6, -3617/510]
    38343838        """
    3835         _sig_on
     3839        _sig_on; _pari_catch()
    38363840        return P.new_gen(bernvec(x))
    38373841
    38383842    def besselh1(gen nu, x, precision=0):
     
    38523856            0.486091260585891 - 0.160400393484924*I
    38533857        """
    38543858        t0GEN(x)
    3855         _sig_on
     3859        _sig_on; _pari_catch()
    38563860        return P.new_gen(hbessel1(nu.g, t0, pbw(precision)))
    38573861
    38583862    def besselh2(gen nu, x, precision=0):
     
    38723876            0.486091260585891 + 0.160400393484924*I
    38733877        """
    38743878        t0GEN(x)
    3875         _sig_on
     3879        _sig_on; _pari_catch()
    38763880        return P.new_gen(hbessel2(nu.g, t0, pbw(precision)))
    38773881
    38783882    def besselj(gen nu, x, precision=0):
     
    38953899            0.486091260585891
    38963900        """
    38973901        t0GEN(x)
    3898         _sig_on
     3902        _sig_on; _pari_catch()
    38993903        return P.new_gen(jbessel(nu.g, t0, pbw(precision)))
    39003904
    39013905    def besseljh(gen nu, x, precision=0):
     
    39203924            0.412710032209716     # 64-bit
    39213925        """
    39223926        t0GEN(x)
    3923         _sig_on
     3927        _sig_on; _pari_catch()
    39243928        return P.new_gen(jbesselh(nu.g, t0, pbw(precision)))
    39253929
    39263930    def besseli(gen nu, x, precision=0):
     
    39463950            1.12539407613913 + 2.08313822670661*I
    39473951        """
    39483952        t0GEN(x)
    3949         _sig_on
     3953        _sig_on; _pari_catch()
    39503954        return P.new_gen(ibessel(nu.g, t0, pbw(precision)))
    39513955
    39523956    def besselk(gen nu, x, long flag=0, precision=0):
     
    39893993            3.74224603319728 E-132 + 2.49071062641525 E-134*I
    39903994        """
    39913995        t0GEN(x)
    3992         _sig_on
     3996        _sig_on; _pari_catch()
    39933997        return P.new_gen(kbessel(nu.g, t0, pbw(precision)))
    39943998
    39953999    def besseln(gen nu, x, precision=0):
     
    40104014            -0.280775566958244 - 0.486708533223726*I
    40114015        """
    40124016        t0GEN(x)
    4013         _sig_on
     4017        _sig_on; _pari_catch()
    40144018        return P.new_gen(nbessel(nu.g, t0, pbw(precision)))
    40154019
    40164020    def cos(gen x, precision=0):
     
    40324036            sage: pari('x+O(x^8)').cos()
    40334037            1 - 1/2*x^2 + 1/24*x^4 - 1/720*x^6 + 1/40320*x^8 + O(x^9)
    40344038        """
    4035         _sig_on
     4039        _sig_on; _pari_catch()
    40364040        return P.new_gen(gcos(x.g, pbw(precision)))
    40374041
    40384042    def cosh(gen x, precision=0):
     
    40544058            sage: pari('x+O(x^8)').cosh()
    40554059            1 + 1/2*x^2 + 1/24*x^4 + 1/720*x^6 + O(x^8)
    40564060        """
    4057         _sig_on
     4061        _sig_on; _pari_catch()
    40584062        return P.new_gen(gch(x.g, pbw(precision)))
    40594063
    40604064    def cotan(gen x, precision=0):
     
    40814085            sage: pari(x).cotan()         # random
    40824086            -8.17674825 E15
    40834087        """
    4084         _sig_on
     4088        _sig_on; _pari_catch()
    40854089        return P.new_gen(gcotan(x.g, pbw(precision)))
    40864090
    40874091    def dilog(gen x, precision=0):
     
    41034107            sage: pari(1+i).dilog()
    41044108            0.616850275068085 + 1.46036211675312*I
    41054109        """
    4106         _sig_on
     4110        _sig_on; _pari_catch()
    41074111        return P.new_gen(dilog(x.g, pbw(precision)))
    41084112
    41094113    def eint1(gen x, long n=0, precision=0):
     
    41304134       
    41314135        EXAMPLES:
    41324136        """
    4133         _sig_on
     4137        _sig_on; _pari_catch()
    41344138        if n <= 0:
    41354139            return P.new_gen(eint1(x.g, pbw(precision)))
    41364140        else:
     
    41564160            sage: pari(1).erfc()
    41574161            0.157299207050285
    41584162        """
    4159         _sig_on
     4163        _sig_on; _pari_catch()
    41604164        return P.new_gen(gerfc(x.g, pbw(precision)))
    41614165
    41624166    def eta(gen x, flag=0, precision=0):
     
    41844188            sage: pari(i).eta()
    41854189            0.998129069925959 + 0.E-21*I
    41864190        """
    4187         _sig_on
     4191        _sig_on; _pari_catch()
    41884192        if flag == 1:
    41894193            return P.new_gen(trueeta(x.g, pbw(precision)))
    41904194        return P.new_gen(eta(x.g, pbw(precision)))
     
    42074211            sage: pari('x+O(x^8)').exp()
    42084212            1 + x + 1/2*x^2 + 1/6*x^3 + 1/24*x^4 + 1/120*x^5 + 1/720*x^6 + 1/5040*x^7 + O(x^8)
    42094213        """
    4210         _sig_on       
     4214        _sig_on; _pari_catch()       
    42114215        return P.new_gen(gexp(self.g, pbw(precision)))
    42124216
    42134217    def gamma(gen s, precision=0):
     
    42364240            ...
    42374241            PariError:  (5)
    42384242        """
    4239         _sig_on
     4243        _sig_on; _pari_catch()
    42404244        return P.new_gen(ggamma(s.g, pbw(precision)))
    42414245       
    42424246    def gammah(gen s, precision=0):
     
    42584262            sage: pari(1+i).gammah()
    42594263            0.575315188063452 + 0.0882106775440939*I
    42604264        """
    4261         _sig_on
     4265        _sig_on; _pari_catch()
    42624266        return P.new_gen(ggamd(s.g, pbw(precision)))
    42634267
    42644268    def hyperu(gen a, b, x, precision=0):
     
    42784282        """
    42794283        t0GEN(b)
    42804284        t1GEN(x)
    4281         _sig_on
     4285        _sig_on; _pari_catch()
    42824286        return P.new_gen(hyperu(a.g, t0, t1, pbw(precision)))
    42834287
    42844288    def incgam(gen s, x, y=None, precision=0):
     
    42984302            -0.0458297859919946 + 0.0433696818726677*I
    42994303        """
    43004304        t0GEN(x)
    4301         _sig_on
     4305        _sig_on; _pari_catch()
    43024306        if y is None:
    43034307            return P.new_gen(incgam(s.g, t0, pbw(precision)))
    43044308        else:
     
    43284332            0.864664716763387
    43294333        """
    43304334        t0GEN(x)
    4331         _sig_on
     4335        _sig_on; _pari_catch()
    43324336        return P.new_gen(incgamc(s.g, t0, pbw(precision)))
    43334337   
    43344338    def log(gen x, precision=0):
     
    43714375            sage: pari(i).log()
    43724376            0.E-19 + 1.57079632679490*I
    43734377        """
    4374         _sig_on       
     4378        _sig_on; _pari_catch()       
    43754379        return P.new_gen(glog(x.g, pbw(precision)))
    43764380
    43774381    def lngamma(gen x, precision=0):
     
    44134417            sage: pari(100).log_gamma()
    44144418            359.134205369575
    44154419        """
    4416         _sig_on
     4420        _sig_on; _pari_catch()
    44174421        return P.new_gen(glngamma(x.g, pbw(precision)))
    44184422
    44194423    def polylog(gen x, long m, flag=0, precision=0):
     
    44414445            sage: pari(10).polylog(3,2)
    44424446            -0.400459056163451
    44434447        """
    4444         _sig_on
     4448        _sig_on; _pari_catch()
    44454449        return P.new_gen(polylog0(m, x.g, flag, pbw(precision)))
    44464450
    44474451    def psi(gen x, precision=0):
     
    44614465            sage: pari(1).psi()
    44624466            -0.577215664901533
    44634467        """
    4464         _sig_on
     4468        _sig_on; _pari_catch()
    44654469        return P.new_gen(gpsi(x.g, pbw(precision)))
    44664470
    44674471    def sin(gen x, precision=0):
     
    44814485            sage: pari(1+i).sin()
    44824486            1.29845758141598 + 0.634963914784736*I
    44834487        """
    4484         _sig_on
     4488        _sig_on; _pari_catch()
    44854489        return P.new_gen(gsin(x.g, pbw(precision)))
    44864490
    44874491    def sinh(gen x, precision=0):
     
    45014505            sage: pari(1+i).sinh()
    45024506            0.634963914784736 + 1.29845758141598*I
    45034507        """
    4504         _sig_on
     4508        _sig_on; _pari_catch()
    45054509        return P.new_gen(gsh(x.g, pbw(precision)))
    45064510
    45074511    def sqr(gen x):
     
    45274531            sage: x = pari("1+O(2^5)"); x*x
    45284532            1 + O(2^6)
    45294533        """
    4530         _sig_on
     4534        _sig_on; _pari_catch()
    45314535        return P.new_gen(gsqr(x.g))
    45324536   
    45334537
     
    45454549            sage: pari(2).sqrt()
    45464550            1.41421356237310
    45474551        """
    4548         _sig_on
     4552        _sig_on; _pari_catch()
    45494553        return P.new_gen(gsqrt(x.g, pbw(precision)))
    45504554
    45514555    def sqrtn(gen x, n, precision=0):
     
    46044608        # TODO: ???  lots of good examples in the PARI docs ???
    46054609        cdef GEN zetan
    46064610        t0GEN(n)
    4607         _sig_on
     4611        _sig_on; _pari_catch()
    46084612        ans = P.new_gen_noclear(gsqrtn(x.g, t0, &zetan, pbw(precision)))
    46094613        return ans, P.new_gen(zetan)
    46104614
     
    46254629            sage: pari(i).tan()
    46264630            0.E-19 + 0.761594155955765*I
    46274631        """
    4628         _sig_on
     4632        _sig_on; _pari_catch()
    46294633        return P.new_gen(gtan(x.g, pbw(precision)))
    46304634
    46314635    def tanh(gen x, precision=0):
     
    46504654            sage: result.imag()
    46514655            1.55740772465490
    46524656        """
    4653         _sig_on
     4657        _sig_on; _pari_catch()
    46544658        return P.new_gen(gth(x.g, pbw(precision)))
    46554659
    46564660    def teichmuller(gen x):
     
    46654669            sage: pari('2+O(7^5)').teichmuller()
    46664670            2 + 4*7 + 6*7^2 + 3*7^3 + O(7^5)
    46674671        """
    4668         _sig_on
     4672        _sig_on; _pari_catch()
    46694673        return P.new_gen(teich(x.g))
    46704674
    46714675    def theta(gen q, z, precision=0):
     
    46844688            1.63202590295260
    46854689        """
    46864690        t0GEN(z)
    4687         _sig_on
     4691        _sig_on; _pari_catch()
    46884692        return P.new_gen(theta(q.g, t0, pbw(precision)))
    46894693
    46904694    def thetanullk(gen q, long k, precision=0):
     
    47014705            sage: pari(0.5).thetanullk(1)
    47024706            0.548978532560341
    47034707        """
    4704         _sig_on
     4708        _sig_on; _pari_catch()
    47054709        return P.new_gen(thetanullk(q.g, k, pbw(precision)))
    47064710
    47074711    def weber(gen x, flag=0, precision=0):
     
    47324736            sage: pari(i).weber(2)
    47334737            1.09050773266526 + 0.E-19*I
    47344738        """
    4735         _sig_on
     4739        _sig_on; _pari_catch()
    47364740        return P.new_gen(weber0(x.g, flag, pbw(precision)))
    47374741
    47384742    def zeta(gen s, precision=0):
     
    47824786            sage: pari('1+5*7+2*7^2+O(7^3)').zeta()
    47834787            4*7^-2 + 5*7^-1 + O(7^0)
    47844788        """
    4785         _sig_on
     4789        _sig_on; _pari_catch()
    47864790        return P.new_gen(gzeta(s.g, pbw(precision)))
    47874791
    47884792    ###########################################
     
    47934797        cdef gen u, v, g
    47944798        cdef GEN U, V, G
    47954799        t0GEN(y)
    4796         _sig_on
     4800        _sig_on; _pari_catch()
    47974801        G = gbezout(x.g, t0, &U, &V)
    47984802        g = P.new_gen_noclear(G)
    47994803        u = P.new_gen_noclear(U)
     
    48214825            sage: pari('2+x+O(x^2)').binomial(3)
    48224826            1/3*x + O(x^2)
    48234827        """
    4824         _sig_on
     4828        _sig_on; _pari_catch()
    48254829        return P.new_gen(binomial(x.g, k))
    48264830
    48274831    def contfrac(gen x, b=0, long lmax=0):
     
    48334837        expansion.
    48344838        """
    48354839        t0GEN(b)
    4836         _sig_on
     4840        _sig_on; _pari_catch()
    48374841        return P.new_gen(contfrac0(x.g, t0, lmax))
    48384842
    48394843    def contfracpnqn(gen x, b=0, long lmax=0):
     
    48414845        contfracpnqn(x): [p_n,p_n-1; q_n,q_n-1] corresponding to the
    48424846        continued fraction x.
    48434847        """
    4844         _sig_on
     4848        _sig_on; _pari_catch()
    48454849        return P.new_gen(pnqn(x.g))
    48464850   
    48474851    def fibonacci(gen x):
     
    48554859            sage: [pari(n).fibonacci() for n in range(10)]
    48564860            [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    48574861        """
    4858         _sig_on
     4862        _sig_on; _pari_catch()
    48594863        return P.new_gen(fibo(long(x)))
    48604864
    48614865
     
    48674871        and y must be polynomials)
    48684872        """
    48694873        t0GEN(y)
    4870         _sig_on
     4874        _sig_on; _pari_catch()
    48714875        return P.new_gen(ggcd0(x.g, t0))
    48724876
    48734877    def issquare(gen x, find_root=False):
     
    48784882        """
    48794883        cdef GEN G, t
    48804884        cdef gen g
    4881         _sig_on
     4885        _sig_on; _pari_catch()
    48824886        if find_root:
    48834887            t = gissquareall(x.g, &G)
    48844888            v = bool(P.new_gen_noclear(t))
     
    49004904            sage: pari(20).issquarefree()
    49014905            False
    49024906        """
    4903         _sig_on
     4907        _sig_on; _pari_catch()
    49044908        t = bool(issquarefree(self.g))
    49054909        _sig_off
    49064910        return t
     
    49134917            30
    49144918        """
    49154919        t0GEN(y)
    4916         _sig_on
     4920        _sig_on; _pari_catch()
    49174921        return P.new_gen(glcm(x.g, t0))
    49184922
    49194923    def numdiv(gen n):
     
    49254929            sage: pari(10).numdiv()
    49264930            4
    49274931        """
    4928         _sig_on
     4932        _sig_on; _pari_catch()
    49294933        return P.new_gen(gnumbdiv(n.g))
    49304934
    49314935    def phi(gen n):
     
    49354939            sage: pari(10).phi()
    49364940            4
    49374941        """
    4938         _sig_on
     4942        _sig_on; _pari_catch()
    49394943        return P.new_gen(geulerphi(n.g))
    49404944
    49414945    def primepi(gen self):
     
    49604964            41581
    49614965        """
    49624966        global num_primes
    4963         _sig_on
     4967        _sig_on; _pari_catch()
    49644968        if self > num_primes:
    49654969            P.init_primes(self + 10)
    49664970        if signe(self.g) != 1:
     
    49764980            sage: pari(10).sumdiv()
    49774981            18
    49784982        """
    4979         _sig_on
     4983        _sig_on; _pari_catch()
    49804984        return P.new_gen(sumdiv(n.g))
    49814985
    49824986    def sumdivk(gen n, long k):
     
    49884992            sage: pari(10).sumdivk(2)
    49894993            130
    49904994        """
    4991         _sig_on
     4995        _sig_on; _pari_catch()
    49924996        return P.new_gen(sumdivk(n.g, k))
    49934997
    49944998    def xgcd(gen x, y):
     
    50765080            sage: pari([0,x,0,2*x,1]).ellinit(flag=1)
    50775081            [0, x, 0, 2*x, 1, 4*x, 4*x, 4, -4*x^2 + 4*x, 16*x^2 - 96*x, -64*x^3 + 576*x^2 - 864, 64*x^4 - 576*x^3 + 576*x^2 - 432, (256*x^6 - 4608*x^5 + 27648*x^4 - 55296*x^3)/(4*x^4 - 36*x^3 + 36*x^2 - 27)]
    50785082        """
    5079         _sig_on
     5083        _sig_on; _pari_catch()
    50805084        return P.new_gen(ellinit0(self.g, flag, pbw(precision)))
    50815085
    50825086    def ellglobalred(self):
     
    51115115            sage: e.ellglobalred()
    51125116            [17, [1, 0, 0, 0], 4]
    51135117        """
    5114         _sig_on       
     5118        _sig_on; _pari_catch()       
    51155119        return self.new_gen(ellglobalred(self.g))
    51165120
    51175121    def elladd(self, z0, z1):
     
    51475151            [-3/4, -15/8]
    51485152        """
    51495153        t0GEN(z0); t1GEN(z1)
    5150         _sig_on
     5154        _sig_on; _pari_catch()
    51515155        return self.new_gen(addell(self.g, t0, t1))
    51525156
    51535157    def ellak(self, n):
     
    51855189            0
    51865190        """
    51875191        t0GEN(n)
    5188         _sig_on
     5192        _sig_on; _pari_catch()
    51895193        return self.new_gen(akell(self.g, t0))
    51905194
    51915195
     
    52195223            sage: type(v[0])
    52205224            <type 'int'>
    52215225        """
    5222         _sig_on
     5226        _sig_on; _pari_catch()
    52235227        cdef GEN g
    52245228        if python_ints:
    52255229            g = anell(self.g, n)
     
    52685272            0
    52695273        """
    52705274        t0GEN(p)
    5271         _sig_on
     5275        _sig_on; _pari_catch()
    52725276        return self.new_gen(ellap(self.g, t0))
    52735277
    52745278
     
    53225326            <type 'int'>
    53235327        """
    53245328        # 1. make a table of primes up to n.
    5325         _sig_on
     5329        _sig_on; _pari_catch()
    53265330        if n < 2:
    53275331            return self.new_gen(zerovec(0))
    53285332        cdef GEN g
    53295333        pari.init_primes(n+1)
    53305334        t0GEN(n)
    5331         _sig_on
     5335        _sig_on; _pari_catch()
    53325336        g = primes(gtolong(primepi(t0)))
    53335337
    53345338        # 2. Replace each prime in the table by ellap of it.
     
    53665370            0.418188984498861
    53675371        """
    53685372        t0GEN(z0); t1GEN(z1)
    5369         _sig_on
     5373        _sig_on; _pari_catch()
    53705374        # the prec argument has no effect
    53715375        return self.new_gen(bilhell(self.g, t0, t1, prec))
    53725376
     
    53985402            [1, -1, 0, 4, 3]
    53995403        """
    54005404        t0GEN(ch)
    5401         _sig_on
     5405        _sig_on; _pari_catch()
    54025406        return self.new_gen(ellchangecurve(self.g, t0))
    54035407
    54045408    def elleta(self):
     
    54195423            sage: w1*eta2-w2*eta1 == pari(2*pi*I)
    54205424            True
    54215425        """
    5422         _sig_on
     5426        _sig_on; _pari_catch()
    54235427        # the prec argument has no effect
    54245428        return self.new_gen(elleta(self.g, prec))
    54255429
     
    54675471            0.476711659343740
    54685472        """
    54695473        t0GEN(a)
    5470         _sig_on
     5474        _sig_on; _pari_catch()
    54715475        return self.new_gen(ellheight0(self.g, t0, flag, pbw(precision)))
    54725476
    54735477    def ellheightmatrix(self, x):
     
    54955499            [0.476711659343740, 0.418188984498861; 0.418188984498861, 0.686667083305587]
    54965500        """
    54975501        t0GEN(x)
    5498         _sig_on
     5502        _sig_on; _pari_catch()
    54995503        # the argument prec has no effect
    55005504        return self.new_gen(mathell(self.g, t0, prec))
    55015505
     
    55225526            True
    55235527        """
    55245528        t0GEN(x)
    5525         _sig_on
     5529        _sig_on; _pari_catch()
    55265530        t = bool(oncurve(self.g, t0) == 1)
    55275531        _sig_off
    55285532        return t
     
    56795683            [2, -10, [1, 96, 1, 316], 4]
    56805684        """
    56815685        t0GEN(p)
    5682         _sig_on
     5686        _sig_on; _pari_catch()
    56835687        return self.new_gen(elllocalred(self.g, t0))
    56845688
    56855689    def elllseries(self, s, A=1):
     
    57215725            0.402838047956645
    57225726        """
    57235727        t0GEN(s); t1GEN(A)
    5724         _sig_on
     5728        _sig_on; _pari_catch()
    57255729        # the argument prec has no effect
    57265730        return self.new_gen(elllseries(self.g, t0, t1, prec))
    57275731
     
    57575761        cdef GEN x, y
    57585762        cdef gen model, change
    57595763        cdef pari_sp t
    5760         _sig_on
     5764        _sig_on; _pari_catch()
    57615765        x = ellminimalmodel(self.g, &y)
    57625766        change = self.new_gen_noclear(y)
    57635767        model = self.new_gen(x)
     
    57915795            0
    57925796        """
    57935797        t0GEN(x)
    5794         _sig_on
     5798        _sig_on; _pari_catch()
    57955799        return self.new_gen(orderell(self.g, t0))
    57965800   
    57975801    def ellordinate(self, x):
     
    58225826            [-2*z - 7*z^2 - 23*z^3 + O(z^4), -1 + 2*z + 7*z^2 + 23*z^3 + O(z^4)]
    58235827        """
    58245828        t0GEN(x)
    5825         _sig_on
     5829        _sig_on; _pari_catch()
    58265830        # the prec argument has no effect
    58275831        return self.new_gen(ellordinate(self.g, t0, prec))
    58285832
     
    58495853            0
    58505854        """
    58515855        t0GEN(P)
    5852         _sig_on
     5856        _sig_on; _pari_catch()
    58535857        return self.new_gen(zell(self.g, t0, pbw(precision)))
    58545858
    58555859    def ellpow(self, z, n):
     
    58835887            sage: e.ellpow([0,0], I+1) # optional
    58845888        """
    58855889        t0GEN(z); t1GEN(n)
    5886         _sig_on
     5890        _sig_on; _pari_catch()
    58875891        return self.new_gen(powell(self.g, t0, t1))
    58885892   
    58895893    def ellrootno(self, p=1):
     
    59185922            1
    59195923        """
    59205924        t0GEN(p)
    5921         _sig_on
     5925        _sig_on; _pari_catch()
    59225926        return ellrootno(self.g, t0)
    59235927
    59245928    def ellsigma(self, z, flag=0):
     
    59355939            1.43490215804166 + 1.80307856719256*I
    59365940        """
    59375941        t0GEN(z)
    5938         _sig_on
     5942        _sig_on; _pari_catch()
    59395943        # the prec argument has no effect
    59405944        return self.new_gen(ellsigma(self.g, t0, flag, prec))
    59415945
     
    59625966            [0, 0]
    59635967        """
    59645968        t0GEN(z0); t1GEN(z1)
    5965         _sig_on
     5969        _sig_on; _pari_catch()
    59665970        return self.new_gen(subell(self.g, t0, t1))
    59675971
    59685972    def elltaniyama(self):
    5969         _sig_on
     5973        _sig_on; _pari_catch()
    59705974        return self.new_gen(taniyama(self.g))
    59715975
    59725976    def elltors(self, flag=0):
     
    60116015            sage: e.elltors()
    60126016            [12, [6, 2], [[-2, 8], [3, -2]]]
    60136017        """
    6014         _sig_on
     6018        _sig_on; _pari_catch()
    60156019        return self.new_gen(elltors0(self.g, flag))
    60166020
    60176021    def ellzeta(self, z):
     
    60456049            -0.350122658523049 - 0.350122658523049*I
    60466050        """
    60476051        t0GEN(z)
    6048         _sig_on
     6052        _sig_on; _pari_catch()
    60496053        # the prec argument has no effect
    60506054        return self.new_gen(ellzeta(self.g, t0, prec))
    60516055
     
    60846088            dprec = prec_words_to_dec(z.precision())
    60856089        except AttributeError:
    60866090            dprec = prec
    6087         _sig_on
     6091        _sig_on; _pari_catch()
    60886092        # the prec argument has no effect
    60896093        return self.new_gen(pointell(self.g, t0, dprec))
    60906094
     
    61346138            dprec = prec_words_to_dec(self.precision())
    61356139        except AttributeError:
    61366140            dprec = prec
    6137         _sig_on
     6141        _sig_on; _pari_catch()
    61386142        return P.new_gen(jell(self.g, dprec))
    61396143
    61406144
     
    61626166           for smaller `c` (which is the default).
    61636167        """
    61646168        cdef long n
    6165         _sig_on
     6169        _sig_on; _pari_catch()
    61666170        n = bnfcertify(self.g)
    61676171        _sig_off
    61686172        return n
    61696173   
    61706174    def bnfinit(self, long flag=0, tech=None):
    61716175        if tech is None:
    6172             _sig_on
     6176            _sig_on; _pari_catch()
    61736177            return P.new_gen(bnfinit0(self.g, flag, <GEN>0, prec))
    61746178        else:
    61756179            t0GEN(tech)
    6176             _sig_on
     6180            _sig_on; _pari_catch()
    61776181            return P.new_gen(bnfinit0(self.g, flag, t0, prec))
    61786182
    61796183    def bnfisintnorm(self, x):
    61806184        t0GEN(x)
    6181         _sig_on
     6185        _sig_on; _pari_catch()
    61826186        return self.new_gen(bnfisintnorm(self.g, t0))
    61836187
    61846188    def bnfisprincipal(self, x, long flag=1):
    61856189        t0GEN(x)
    6186         _sig_on
     6190        _sig_on; _pari_catch()
    61876191        return self.new_gen(bnfisprincipal0(self.g, t0, flag))
    61886192
    61896193    def bnfnarrow(self):
    6190         _sig_on
     6194        _sig_on; _pari_catch()
    61916195        return self.new_gen(buchnarrow(self.g))
    61926196
    61936197    def bnfunit(self):
    6194         _sig_on
     6198        _sig_on; _pari_catch()
    61956199        return self.new_gen(bnf_get_fu(self.g))       
    61966200
    61976201    def bnfisunit(self, x):
    61986202        t0GEN(x)
    6199         _sig_on
     6203        _sig_on; _pari_catch()
    62006204        return self.new_gen(bnfisunit(self.g, t0))
    62016205
    62026206    def dirzetak(self, n):
    62036207        t0GEN(n)
    6204         _sig_on
     6208        _sig_on; _pari_catch()
    62056209        return self.new_gen(dirzetak(self.g, t0))
    62066210
    62076211    def galoisapply(self, aut, x):
    62086212        t0GEN(aut)
    62096213        t1GEN(x)
    6210         _sig_on
     6214        _sig_on; _pari_catch()
    62116215        return self.new_gen(galoisapply(self.g, t0, t1))
    62126216
    62136217    def galoisinit(self, den=None):
     
    62166220        for meaning of den
    62176221        """
    62186222        if den is None:
    6219             _sig_on
     6223            _sig_on; _pari_catch()
    62206224            return self.new_gen(galoisinit(self.g, NULL))
    62216225        else:
    62226226            t0GEN(den)
    6223             _sig_on
     6227            _sig_on; _pari_catch()
    62246228            return self.new_gen(galoisinit(self.g, t0))
    62256229
    62266230    def galoispermtopol(self, perm):
    62276231        t0GEN(perm)
    6228         _sig_on
     6232        _sig_on; _pari_catch()
    62296233        return self.new_gen(galoispermtopol(self.g, t0))
    62306234
    62316235    def galoisfixedfield(self, v, long flag, long y):
    62326236        t0GEN(v);
    6233         _sig_on
     6237        _sig_on; _pari_catch()
    62346238        return self.new_gen(galoisfixedfield(self.g, t0, flag, y))
    62356239
    62366240    def idealred(self, I, vdir=0):
    62376241        t0GEN(I); t1GEN(vdir)
    6238         _sig_on
     6242        _sig_on; _pari_catch()
    62396243        return self.new_gen(idealred0(self.g, t0, t1 if vdir else NULL))
    62406244
    62416245    def idealadd(self, x, y):
    62426246        t0GEN(x); t1GEN(y)
    6243         _sig_on
     6247        _sig_on; _pari_catch()
    62446248        return self.new_gen(idealadd(self.g, t0, t1))
    62456249
    62466250    def idealaddtoone(self, x, y):
    62476251        t0GEN(x); t1GEN(y)
    6248         _sig_on
     6252        _sig_on; _pari_catch()
    62496253        return self.new_gen(idealaddtoone0(self.g, t0, t1))
    62506254
    62516255    def idealappr(self, x, long flag=0):
    62526256        t0GEN(x)
    6253         _sig_on
     6257        _sig_on; _pari_catch()
    62546258        return self.new_gen(idealappr(self.g, t0))
    62556259
    62566260    def idealcoprime(self, x, y):
     
    62746278            [5/43, 9/43, -1/43]~
    62756279        """
    62766280        t0GEN(x); t1GEN(y)
    6277         _sig_on
     6281        _sig_on; _pari_catch()
    62786282        return self.new_gen(idealcoprime(self.g, t0, t1))
    62796283
    62806284    def idealdiv(self, x, y, long flag=0):
    62816285        t0GEN(x); t1GEN(y)
    6282         _sig_on
     6286        _sig_on; _pari_catch()
    62836287        return self.new_gen(idealdiv0(self.g, t0, t1, flag))
    62846288
    62856289    def idealfactor(self, x):
    62866290        t0GEN(x)
    6287         _sig_on
     6291        _sig_on; _pari_catch()
    62886292        return self.new_gen(idealfactor(self.g, t0))
    62896293
    62906294    def idealhnf(self, a, b=None):
    62916295        t0GEN(a)
    6292         _sig_on
     6296        _sig_on; _pari_catch()
    62936297        if b is None:
    62946298            return self.new_gen(idealhnf(self.g, t0))
    62956299        else:
     
    62986302
    62996303    def idealintersection(self, x, y):
    63006304        t0GEN(x); t1GEN(y)
    6301         _sig_on
     6305        _sig_on; _pari_catch()
    63026306        return self.new_gen(idealintersect(self.g, t0, t1))
    63036307
    63046308    def ideallog(self, x, bid):
     
    63306334            [25]~
    63316335        """
    63326336        t0GEN(x); t1GEN(bid)
    6333         _sig_on
     6337        _sig_on; _pari_catch()
    63346338        return self.new_gen(ideallog(self.g, t0, t1))
    63356339
    63366340    def idealmul(self, x, y, long flag=0):
    63376341        t0GEN(x); t1GEN(y)
    6338         _sig_on
     6342        _sig_on; _pari_catch()
    63396343        if flag == 0:
    63406344            return self.new_gen(idealmul(self.g, t0, t1))
    63416345        else:
     
    63436347
    63446348    def idealnorm(self, x):
    63456349        t0GEN(x)
    6346         _sig_on
     6350        _sig_on; _pari_catch()
    63476351        return self.new_gen(idealnorm(self.g, t0))
    63486352
    63496353    def idealstar(self, I, long flag=1):
     
    63836387            [[[43, 9, 5; 0, 1, 0; 0, 0, 1], [0]], [42, [42]], Mat([[43, [9, 1, 0]~, 1, 1, [-5, -9, 1]~], 1]), [[[[42], [[3, 0, 0]~], [[3, 0, 0]~], [Vecsmall([])], 1]], [[], [], []]], Mat(1)]
    63846388        """
    63856389        t0GEN(I)
    6386         _sig_on
     6390        _sig_on; _pari_catch()
    63876391        return self.new_gen(idealstar0(self.g, t0, flag))
    63886392
    63896393    def idealtwoelt(self, x, a=None):
    63906394        t0GEN(x)
    63916395        if a is None:
    6392             _sig_on
     6396            _sig_on; _pari_catch()
    63936397            return self.new_gen(idealtwoelt0(self.g, t0, NULL))
    63946398        else:
    63956399            t1GEN(a)
    6396             _sig_on
     6400            _sig_on; _pari_catch()
    63976401            return self.new_gen(idealtwoelt0(self.g, t0, t1))
    63986402
    63996403    def idealval(self, x, p):
    64006404        t0GEN(x); t1GEN(p)
    6401         _sig_on
     6405        _sig_on; _pari_catch()
    64026406        return idealval(self.g, t0, t1)
    64036407
    64046408    def elementval(self, x, p):
    64056409        t0GEN(x); t1GEN(p)
    6406         _sig_on
     6410        _sig_on; _pari_catch()
    64076411        return nfval(self.g, t0, t1)
    64086412
    64096413    def modreverse(self):
     
    64126416       
    64136417        EXAMPLES:
    64146418        """
    6415         _sig_on
     6419        _sig_on; _pari_catch()
    64166420        return self.new_gen(modreverse(self.g))
    64176421
    64186422    def nfbasis(self, long flag=0, p=0):
     
    64236427            g = _p.g
    64246428        else:
    64256429            g = <GEN>NULL
    6426         _sig_on
     6430        _sig_on; _pari_catch()
    64276431        return self.new_gen(nfbasis0(self.g, flag, g))
    64286432
    64296433    def nfbasis_d(self, long flag=0, p=0):
     
    64566460        else:
    64576461            g = <GEN>NULL
    64586462           
    6459         _sig_on
     6463        _sig_on; _pari_catch()
    64606464        nfb = self.new_gen(nfbasis(self.g, &t0, flag, g))
    64616465        d = self.new_gen(t0)
    64626466        return nfb, d
     
    64936497            g = _p.g
    64946498        else:
    64956499            g = <GEN>NULL
    6496         _sig_on
     6500        _sig_on; _pari_catch()
    64976501        return self.new_gen(nfdisc0(self.g, flag, g))
    64986502
    64996503    def nfeltreduce(self, x, I):
     
    65136517            True
    65146518        """
    65156519        t0GEN(x); t1GEN(I)
    6516         _sig_on
     6520        _sig_on; _pari_catch()
    65176521        return self.new_gen(nfreduce(self.g, t0, t1))
    65186522
    65196523    def nffactor(self, x):
    65206524        t0GEN(x)
    6521         _sig_on
     6525        _sig_on; _pari_catch()
    65226526        return self.new_gen(nffactor(self.g, t0))
    65236527
    65246528    def nfgenerator(self):
     
    65276531        return x.Mod(f)
    65286532
    65296533    def nfinit(self, long flag=0):
    6530         _sig_on
     6534        _sig_on; _pari_catch()
    65316535        return P.new_gen(nfinit0(self.g, flag, prec))
    65326536
    65336537    def nfisisom(self, gen other):
     
    65676571            sage: F._pari_().nfisisom(H._pari_())
    65686572            0
    65696573        """
    6570         _sig_on
     6574        _sig_on; _pari_catch()
    65716575        return P.new_gen(nfisisom(self.g, other.g))
    65726576
    65736577    def nfrootsof1(self):
     
    65836587            sage: nf.nfrootsof1()
    65846588            [4, -x]
    65856589        """
    6586         _sig_on
     6590        _sig_on; _pari_catch()
    65876591        return P.new_gen(rootsof1(self.g))
    65886592
    65896593    def nfsubfields(self, long d=0):
     
    66016605       
    66026606        -  ``d`` - C long integer
    66036607        """
    6604         _sig_on
     6608        _sig_on; _pari_catch()
    66056609        return self.new_gen(nfsubfields(self.g, d))
    66066610
    66076611    def rnfcharpoly(self, T, a, v='x'):
    66086612        t0GEN(T); t1GEN(a); t2GEN(v)
    6609         _sig_on
     6613        _sig_on; _pari_catch()
    66106614        return self.new_gen(rnfcharpoly(self.g, t0, t1, gvar(t2)))
    66116615
    66126616    def rnfdisc(self, x):
    66136617        t0GEN(x)
    6614         _sig_on
     6618        _sig_on; _pari_catch()
    66156619        return self.new_gen(rnfdiscf(self.g, t0))
    66166620
    66176621    def rnfeltabstorel(self, x):
    66186622        t0GEN(x)
    6619         _sig_on
     6623        _sig_on; _pari_catch()
    66206624        polymodmod = self.new_gen(rnfelementabstorel(self.g, t0))
    66216625        return polymodmod.centerlift().centerlift()
    66226626
    66236627    def rnfeltreltoabs(self, x):
    66246628        t0GEN(x)
    6625         _sig_on
     6629        _sig_on; _pari_catch()
    66266630        return self.new_gen(rnfelementreltoabs(self.g, t0))
    66276631
    66286632    def rnfequation(self, poly, long flag=0):
    66296633        t0GEN(poly)
    6630         _sig_on
     6634        _sig_on; _pari_catch()
    66316635        return self.new_gen(rnfequation0(self.g, t0, flag))
    66326636
    66336637    def rnfidealabstorel(self, x):
    66346638        t0GEN(x)
    6635         _sig_on
     6639        _sig_on; _pari_catch()
    66366640        return self.new_gen(rnfidealabstorel(self.g, t0))
    66376641
    66386642    def rnfidealdown(self, x):
     
    66576661            [2, 0; 0, 2]
    66586662        """
    66596663        t0GEN(x)
    6660         _sig_on
     6664        _sig_on; _pari_catch()
    66616665        return self.new_gen(rnfidealdown(self.g, t0))
    66626666
    66636667    def rnfidealhnf(self, x):
    66646668        t0GEN(x)
    6665         _sig_on
     6669        _sig_on; _pari_catch()
    66666670        return self.new_gen(rnfidealhermite(self.g, t0))
    66676671
    66686672    def rnfidealnormrel(self, x):
    66696673        t0GEN(x)
    6670         _sig_on
     6674        _sig_on; _pari_catch()
    66716675        return self.new_gen(rnfidealnormrel(self.g, t0))
    66726676
    66736677    def rnfidealreltoabs(self, x):
    66746678        t0GEN(x)
    6675         _sig_on
     6679        _sig_on; _pari_catch()
    66766680        return self.new_gen(rnfidealreltoabs(self.g, t0))
    66776681
    66786682    def rnfidealtwoelt(self, x):
    66796683        t0GEN(x)
    6680         _sig_on
     6684        _sig_on; _pari_catch()
    66816685        return self.new_gen(rnfidealtwoelement(self.g, t0))
    66826686
    66836687    def rnfinit(self, poly):
     
    66936697            sage: L = K.rnfinit(g)
    66946698        """
    66956699        t0GEN(poly)
    6696         _sig_on
     6700        _sig_on; _pari_catch()
    66976701        return P.new_gen(rnfinit(self.g, t0))
    66986702
    66996703    def rnfisfree(self, poly):
    67006704        t0GEN(poly)
    6701         _sig_on
     6705        _sig_on; _pari_catch()
    67026706        return rnfisfree(self.g, t0)
    67036707
    67046708
     
    67166720        return self.Vec().Polrev()
    67176721
    67186722    def deriv(self, v=-1):
    6719         _sig_on
     6723        _sig_on; _pari_catch()
    67206724        return self.new_gen(deriv(self.g, self.get_var(v)))
    67216725
    67226726    def eval(self, x):
    67236727        t0GEN(x)
    6724         _sig_on
     6728        _sig_on; _pari_catch()
    67256729        return self.new_gen(poleval(self.g, t0))
    67266730
    67276731    def __call__(self, x):
     
    67346738        (use round 4) or 1 (use Buchmann-Lenstra)
    67356739        """
    67366740        t0GEN(p)
    6737         _sig_on
     6741        _sig_on; _pari_catch()
    67386742        return self.new_gen(factorpadic0(self.g, t0, r, flag))
    67396743
    67406744    def factormod(self, p, long flag=0):
     
    67456749        irreducible factors are given.
    67466750        """
    67476751        t0GEN(p)
    6748         _sig_on
     6752        _sig_on; _pari_catch()
    67496753        return self.new_gen(factormod0(self.g, t0, flag))
    67506754
    67516755    def intformal(self, y=-1):
     
    67536757        x.intformal(y): formal integration of x with respect to the main
    67546758        variable of y, or to the main variable of x if y is omitted
    67556759        """
    6756         _sig_on
     6760        _sig_on; _pari_catch()
    67576761        return self.new_gen(integ(self.g, self.get_var(y)))
    67586762
    67596763    def padicappr(self, a):
     
    67626766        p
    67636767        """
    67646768        t0GEN(a)
    6765         _sig_on
     6769        _sig_on; _pari_catch()
    67666770        return self.new_gen(padicappr(self.g, t0))
    67676771
    67686772    def newtonpoly(self, p):
     
    67776781            [1, 1, -1/3, -1/3, -1/3, -1/3, -1/3, -1/3]
    67786782        """
    67796783        t0GEN(p)
    6780         _sig_on
     6784        _sig_on; _pari_catch()
    67816785        return self.new_gen(newtonpoly(self.g, t0))
    67826786
    67836787    def polcoeff(self, long n, var=-1):
     
    67966800            sage: f.polcoeff(1, "y")
    67976801            x
    67986802        """
    6799         _sig_on
     6803        _sig_on; _pari_catch()
    68006804        return self.new_gen(polcoeff0(self.g, n, self.get_var(var)))
    68016805
    68026806    def polcompositum(self, pol2, long flag=0):
    68036807        t0GEN(pol2)
    6804         _sig_on
     6808        _sig_on; _pari_catch()
    68056809        return self.new_gen(polcompositum0(self.g, t0, flag))
    68066810
    68076811    def poldegree(self, var=-1):
    68086812        """
    68096813        f.poldegree(var=x): Return the degree of this polynomial.
    68106814        """
    6811         _sig_on
     6815        _sig_on; _pari_catch()
    68126816        n = poldegree(self.g, self.get_var(var))
    68136817        _sig_off
    68146818        return n
     
    68176821        """
    68186822        f.poldist(var=x): Return the discriminant of this polynomial.
    68196823        """
    6820         _sig_on
     6824        _sig_on; _pari_catch()
    68216825        return self.new_gen(poldisc0(self.g, self.get_var(var)))
    68226826
    68236827    def poldiscreduced(self):
    6824         _sig_on
     6828        _sig_on; _pari_catch()
    68256829        return self.new_gen(reduceddiscsmith(self.g))
    68266830
    68276831    def polgalois(self):
    68286832        """
    68296833        f.polgalois(): Galois group of the polynomial f
    68306834        """
    6831         _sig_on
     6835        _sig_on; _pari_catch()
    68326836        return self.new_gen(polgalois(self.g, prec))
    68336837
    68346838    def nfgaloisconj(self, long flag=0, denom=None, long prec=0):
     
    68576861            t0GEN(denom)
    68586862        else:
    68596863            t0 = NULL
    6860         _sig_on
     6864        _sig_on; _pari_catch()
    68616865        return self.new_gen(galoisconj0(self.g, flag, t0, pbw(prec)))
    68626866
    68636867    def nfroots(self, poly):
     
    68796883            [Mod(-zz, zz^4 + 2), Mod(zz, zz^4 + 2)]
    68806884        """
    68816885        t0GEN(poly)
    6882         _sig_on
     6886        _sig_on; _pari_catch()
    68836887        return self.new_gen(nfroots(self.g, t0))
    68846888       
    68856889    def polhensellift(self, y, p, long e):
     
    68906894        """
    68916895        t0GEN(y)
    68926896        t1GEN(p)
    6893         _sig_on
     6897        _sig_on; _pari_catch()
    68946898        return self.new_gen(polhensellift(self.g, t0, t1, e))
    68956899
    68966900    def polisirreducible(self):
     
    68986902        f.polisirreducible(): Returns True if f is an irreducible
    68996903        non-constant polynomial, or False if f is reducible or constant.
    69006904        """
    6901         _sig_on
     6905        _sig_on; _pari_catch()
    69026906        return bool(self.new_gen(gisirreducible(self.g)))
    69036907       
    69046908       
     
    69096913        to the main variable of self if v is omitted, with respect to the
    69106914        variable v otherwise
    69116915        """
    6912         _sig_on
     6916        _sig_on; _pari_catch()
    69136917        return self.new_gen(pollead(self.g, self.get_var(v)))
    69146918
    69156919    def polrecip(self):
    6916         _sig_on
     6920        _sig_on; _pari_catch()
    69176921        return self.new_gen(polrecip(self.g))
    69186922   
    69196923    def polred(self, flag=0, fa=None):
    69206924        if fa is None:
    6921             _sig_on
     6925            _sig_on; _pari_catch()
    69226926            return self.new_gen(polred0(self.g, flag, NULL))
    69236927        else:
    69246928            t0GEN(fa)
    6925             _sig_on
     6929            _sig_on; _pari_catch()
    69266930            return self.new_gen(polred0(self.g, flag, t0))
    69276931
    69286932    def polredabs(self, flag=0):
    6929         _sig_on
     6933        _sig_on; _pari_catch()
    69306934        return self.new_gen(polredabs0(self.g, flag))
    69316935
    69326936    def polresultant(self, y, var=-1, flag=0):
    69336937        t0GEN(y)
    6934         _sig_on
     6938        _sig_on; _pari_catch()
    69356939        return self.new_gen(polresultant0(self.g, t0, self.get_var(var), flag))
    69366940
    69376941    def polroots(self, flag=0, precision=0):
     
    69406944        optional, and can be 0: default, uses Schonhage's method modified
    69416945        by Gourdon, or 1: uses a modified Newton method.
    69426946        """
    6943         _sig_on
     6947        _sig_on; _pari_catch()
    69446948        return self.new_gen(roots0(self.g, flag, pbw(precision)))
    69456949   
    69466950    def polrootsmod(self, p, flag=0):
    69476951        t0GEN(p)
    6948         _sig_on
     6952        _sig_on; _pari_catch()
    69496953        return self.new_gen(rootmod0(self.g, t0, flag))
    69506954
    69516955    def polrootspadic(self, p, r=20):
    69526956        t0GEN(p)
    6953         _sig_on
     6957        _sig_on; _pari_catch()
    69546958        return self.new_gen(rootpadic(self.g, t0, r))
    69556959
    69566960    def polrootspadicfast(self, p, r=20):
    69576961        t0GEN(p)
    6958         _sig_on
     6962        _sig_on; _pari_catch()
    69596963        return self.new_gen(rootpadicfast(self.g, t0, r))
    69606964
    69616965    def polsturm(self, a, b):
    69626966        t0GEN(a)
    69636967        t1GEN(b)
    6964         _sig_on
     6968        _sig_on; _pari_catch()
    69656969        n = sturmpart(self.g, t0, t1)
    69666970        _sig_off
    69676971        return n
    69686972
    69696973    def polsturm_full(self):
    6970         _sig_on
     6974        _sig_on; _pari_catch()
    69716975        n = sturmpart(self.g, NULL, NULL)
    69726976        _sig_off
    69736977        return n
    69746978
    69756979    def polsylvestermatrix(self, g):
    69766980        t0GEN(g)
    6977         _sig_on
     6981        _sig_on; _pari_catch()
    69786982        return self.new_gen(sylvestermatrix(self.g, t0))
    69796983
    69806984    def polsym(self, long n):
    6981         _sig_on
     6985        _sig_on; _pari_catch()
    69826986        return self.new_gen(polsym(self.g, n))
    69836987
    69846988    def serconvol(self, g):
    69856989        t0GEN(g)
    6986         _sig_on
     6990        _sig_on; _pari_catch()
    69876991        return self.new_gen(convol(self.g, t0))
    69886992
    69896993    def serlaplace(self):
    6990         _sig_on
     6994        _sig_on; _pari_catch()
    69916995        return self.new_gen(laplace(self.g))
    69926996
    69936997    def serreverse(self):
     
    70087012            sage: g.subst('x',f)
    70097013            x + O(x^4)
    70107014        """
    7011         _sig_on
     7015        _sig_on; _pari_catch()
    70127016        return self.new_gen(recip(self.g))
    70137017   
    70147018    def thueinit(self, flag=0):
    7015         _sig_on
     7019        _sig_on; _pari_catch()
    70167020        return self.new_gen(thueinit(self.g, flag, prec))
    70177021
    70187022
     
    70397043        """
    70407044        t0GEN(y)
    70417045        if z is None:
    7042             _sig_on
     7046            _sig_on; _pari_catch()
    70437047            return P.new_gen(shallowextract(self.g, t0))
    70447048        else:
    70457049            t1GEN(z)
    7046             _sig_on
     7050            _sig_on; _pari_catch()
    70477051            return P.new_gen(extract0(self.g, t0, t1))
    70487052
    70497053    def ncols(self):
     
    70567060            8
    70577061        """
    70587062        cdef long n
    7059         _sig_on
     7063        _sig_on; _pari_catch()
    70607064        n = glength(self.g)
    70617065        _sig_off
    70627066        return n
     
    70717075            19
    70727076        """
    70737077        cdef long n
    7074         _sig_on
     7078        _sig_on; _pari_catch()
    70757079        # if this matrix has no columns
    70767080        # then it has no rows.
    70777081        if self.ncols() == 0:
     
    70907094            sage: pari('[1,2,3; 4,5,6;  7,8,9]').mattranspose()
    70917095            [1, 4, 7; 2, 5, 8; 3, 6, 9]
    70927096        """
    7093         _sig_on       
     7097        _sig_on; _pari_catch()       
    70947098        return self.new_gen(gtrans(self.g)).Mat()
    70957099
    70967100    def matadjoint(self):
     
    71047108            sage: pari('[a,b,c; d,e,f; g,h,i]').matadjoint()
    71057109            [(i*e - h*f), (-i*b + h*c), (f*b - e*c); (-i*d + g*f), i*a - g*c, -f*a + d*c; (h*d - g*e), -h*a + g*b, e*a - d*b]
    71067110        """
    7107         _sig_on       
     7111        _sig_on; _pari_catch()       
    71087112        return self.new_gen(adj(self.g)).Mat()
    71097113
    71107114    def qflll(self, long flag=0):
     
    71197123        but x may have polynomial coefficients, 8: same as 0 but x may have
    71207124        polynomial coefficients.
    71217125        """
    7122         _sig_on
     7126        _sig_on; _pari_catch()
    71237127        return self.new_gen(qflll0(self.g,flag)).Mat()
    71247128             
    71257129    def qflllgram(self, long flag=0):
     
    71327136        8: lllgramgen, same as qflllgram when the coefficients are
    71337137        polynomials.
    71347138        """
    7135         _sig_on
     7139        _sig_on; _pari_catch()
    71367140        return self.new_gen(qflllgram0(self.g,flag)).Mat()
    71377141
    71387142    def lllgram(self):
     
    71537157        """
    71547158        t0GEN(B)
    71557159        t1GEN(max)
    7156         _sig_on
     7160        _sig_on; _pari_catch()
    71577161        return self.new_gen(qfminim0(self.g,t0,t1,flag,precdl))
    71587162
    71597163    def qfrep(self, B, long flag=0):
     
    71647168        return a t_VECSMALL instead of a t_VEC.
    71657169        """
    71667170        t0GEN(B)
    7167         _sig_on
     7171        _sig_on; _pari_catch()
    71687172        return self.new_gen(qfrep0(self.g,t0,flag))
    71697173
    71707174    def matsolve(self, B):
     
    71917195            [1/2; 1/2]
    71927196        """
    71937197        t0GEN(B)
    7194         _sig_on
     7198        _sig_on; _pari_catch()
    71957199        return self.new_gen(gauss(self.g,t0))
    71967200       
    71977201    def matker(self, long flag=0):
     
    72207224            sage: pari('[1,2,3;4,5,6;7,8,9]*Mod(1,2)').matker()
    72217225            [Mod(1, 2); Mod(0, 2); Mod(1, 2)]
    72227226        """
    7223         _sig_on       
     7227        _sig_on; _pari_catch()       
    72247228        return self.new_gen(matker0(self.g, flag))
    72257229
    72267230    def matkerint(self, long flag=0):
     
    72467250            sage: pari('[2,1;2,1]').matkerint(1)
    72477251            [1; -2]
    72487252        """
    7249         _sig_on
     7253        _sig_on; _pari_catch()
    72507254        return self.new_gen(matkerint0(self.g, flag))
    72517255
    72527256    def matdet(self, long flag=0):
     
    72687272            sage: pari('[1,2; 3,4]').matdet(1)
    72697273            -2
    72707274        """
    7271         _sig_on       
     7275        _sig_on; _pari_catch()       
    72727276        return self.new_gen(det0(self.g, flag))
    72737277
    72747278    def trace(self):
     
    72807284            sage: pari('[1,2; 3,4]').trace() 
    72817285            5
    72827286        """
    7283         _sig_on       
     7287        _sig_on; _pari_catch()       
    72847288        return self.new_gen(gtrace(self.g))
    72857289
    72867290    def mathnf(self, flag=0):
     
    73067310            sage: pari('[1,2,3; 4,5,6;  7,8,9]').mathnf()
    73077311            [6, 1; 3, 1; 0, 1]
    73087312        """
    7309         _sig_on
     7313        _sig_on; _pari_catch()
    73107314        return self.new_gen(mathnf0(self.g, flag))
    73117315 
    73127316    def mathnfmod(self, d):
     
    73407344            [1, 0, 0; 0, 2, 0; 0, 0, 6]
    73417345        """
    73427346        t0GEN(d)
    7343         _sig_on
     7347        _sig_on; _pari_catch()
    73447348        return self.new_gen(hnfmod(self.g, t0))
    73457349
    73467350    def mathnfmodid(self, d):
     
    73697373            [1, 0, 0; 0, 1, 0; 0, 0, 6]
    73707374        """
    73717375        t0GEN(d)
    7372         _sig_on
     7376        _sig_on; _pari_catch()
    73737377        return self.new_gen(hnfmodid(self.g, t0))
    73747378
    73757379    def matsnf(self, flag=0):
     
    73867390            sage: pari('[1,2,3; 4,5,6;  7,8,9]').matsnf()
    73877391            [0, 3, 1]
    73887392        """
    7389         _sig_on
     7393        _sig_on; _pari_catch()
    73907394        return self.new_gen(matsnf0(self.g, flag))
    73917395
    73927396    def matfrobenius(self, flag=0):
     
    74287432
    74297433        - Martin Albrect (2006-04-02)
    74307434        """
    7431         _sig_on
     7435        _sig_on; _pari_catch()
    74327436        return self.new_gen(matfrobenius(self.g, flag, 0))
    74337437
    74347438
     
    74807484        """
    74817485        cdef int r
    74827486        if limit == -1 and typ(self.g) == t_INT and proof:
    7483             _sig_on
     7487            _sig_on; _pari_catch()
    74847488            r = factorint_withproof_sage(&t0, self.g, ten_to_15)
    74857489            z = P.new_gen(t0)
    74867490            if not r:
    74877491                return z
    74887492            else:
    74897493                return _factor_int_when_pari_factor_failed(self, z)
    7490         _sig_on
     7494        _sig_on; _pari_catch()
    74917495        return P.new_gen(factor0(self.g, limit))
    74927496           
    74937497
     
    74987502    def hilbert(x, y, p):
    74997503        t0GEN(y)
    75007504        t1GEN(p)
    7501         _sig_on
     7505        _sig_on; _pari_catch()
    75027506        return hilbert0(x.g, t0, t1)
    75037507       
    75047508    def chinese(self, y):
    75057509        t0GEN(y)
    7506         _sig_on
     7510        _sig_on; _pari_catch()
    75077511        return P.new_gen(chinese(self.g, t0))
    75087512
    75097513    def order(self):
    7510         _sig_on       
     7514        _sig_on; _pari_catch()       
    75117515        return P.new_gen(order(self.g))
    75127516   
    75137517    def znprimroot(self):
     
    75377541            sage: pari(2*109^10).znprimroot()
    75387542            Mod(236736367459211723407, 473472734918423446802)
    75397543        """
    7540         _sig_on       
     7544        _sig_on; _pari_catch()       
    75417545        return P.new_gen(znprimroot0(self.g))
    75427546       
    75437547    def __abs__(self):
    75447548        return self.abs()
    75457549   
    75467550    def norm(gen self):
    7547         _sig_on       
     7551        _sig_on; _pari_catch()       
    75487552        return P.new_gen(gnorm(self.g))
    75497553   
    75507554    def nextprime(gen self, bint add_one=0):
     
    75597563            1267650600228229401496703205653
    75607564        """
    75617565        if add_one:
    7562             _sig_on       
     7566            _sig_on; _pari_catch()       
    75637567            return P.new_gen(gnextprime(gaddsg(1,self.g)))
    75647568        #NOTE: This is much faster than MAGMA's NextPrime with Proof := False.
    7565         _sig_on       
     7569        _sig_on; _pari_catch()       
    75667570        return P.new_gen(gnextprime(self.g))
    75677571
    75687572    def subst(self, var, y):
     
    75877591        cdef long n
    75887592        n = P.get_var(var)       
    75897593        t0GEN(y)
    7590         _sig_on       
     7594        _sig_on; _pari_catch()       
    75917595        return P.new_gen(gsubst(self.g, n, t0))
    75927596
    75937597    def substpol(self, y, z):
    75947598        t0GEN(y)
    75957599        t1GEN(z)
    7596         _sig_on
     7600        _sig_on; _pari_catch()
    75977601        return self.new_gen(gsubstpol(self.g, t0, t1))
    75987602
    75997603    def taylor(self, v=-1):
    7600         _sig_on
     7604        _sig_on; _pari_catch()
    76017605        return self.new_gen(tayl(self.g, self.get_var(v), precdl))
    76027606
    76037607    def thue(self, rhs, ne):
    76047608        t0GEN(rhs)
    76057609        t1GEN(ne)
    7606         _sig_on
     7610        _sig_on; _pari_catch()
    76077611        return self.new_gen(thue(self.g, t0, t1))
    76087612
    76097613    def charpoly(self, var=-1, flag=0):
     
    76137617        Lagrange interpolation) or 2 (use Hessenberg form), 0 being the
    76147618        default.
    76157619        """
    7616         _sig_on       
     7620        _sig_on; _pari_catch()       
    76177621        return P.new_gen(charpoly0(self.g, P.get_var(var), flag))
    76187622
    76197623
    76207624    def kronecker(gen self, y):
    76217625        t0GEN(y)
    7622         _sig_on       
     7626        _sig_on; _pari_catch()       
    76237627        return P.new_gen(gkronecker(self.g, t0))
    76247628
    76257629
     
    76897693        t0GEN(ya)
    76907694        t1GEN(x)
    76917695        cdef GEN dy, g
    7692         _sig_on
     7696        _sig_on; _pari_catch()
    76937697        g = polint(self.g, t0, t1, &dy)
    76947698        dif = self.new_gen_noclear(dy)
    76957699        return self.new_gen(g), dif
     
    77097713            sage: pari.set_real_precision(n)
    77107714            210
    77117715        """
    7712         _sig_on
     7716        _sig_on; _pari_catch()
    77137717        return self.new_gen(algdep(self.g, n))
    77147718
    77157719    def concat(self, y):
    77167720        t0GEN(y)
    7717         _sig_on
     7721        _sig_on; _pari_catch()
    77187722        return self.new_gen(concat(self.g, t0))
    77197723
    77207724    def lindep(self, flag=0):
    7721         _sig_on
     7725        _sig_on; _pari_catch()
    77227726        return self.new_gen(lindep0(self.g, flag))
    77237727
    77247728    def listinsert(self, obj, long n):
    77257729        t0GEN(obj)
    7726         _sig_on
     7730        _sig_on; _pari_catch()
    77277731        return self.new_gen(listinsert(self.g, t0, n))
    77287732
    77297733    def listput(self, obj, long n):
    77307734        t0GEN(obj)
    7731         _sig_on
     7735        _sig_on; _pari_catch()
    77327736        return self.new_gen(listput(self.g, t0, n))
    77337737
    77347738
     
    77717775            sage: om.elleisnum(100)
    77727776            2.15314248576078 E50
    77737777        """
    7774         _sig_on
     7778        _sig_on; _pari_catch()
    77757779        # the argument prec has no effect
    77767780        return self.new_gen(elleisnum(self.g, k, flag, prec))
    77777781
     
    78707874            n = 0
    78717875        if n%2 == 1:
    78727876            n = n + 1
    7873         _sig_on
     7877        _sig_on; _pari_catch()
    78747878        try:
    78757879            dprec = prec_words_to_dec(z.precision())
    78767880        except AttributeError:
     
    78997903            True
    79007904        """
    79017905        t0GEN(y)
    7902         _sig_on
     7906        _sig_on; _pari_catch()
    79037907        return self.new_gen(ellchangepoint(self.g, t0))
    79047908
    79057909    def debug(gen self, long depth = -1):
     
    79177921                real = gen_0
    79187922                imag = [&=0000000004c5ef90] REAL(lg=4):0400000000000004 (+,expo=0):6000000000000000 8000000000000000 0000000000000000
    79197923        """
    7920         _sig_on
     7924        _sig_on; _pari_catch()
    79217925        dbgGEN(self.g, depth)
    79227926        _sig_off
    79237927        return
     
    80198023        initial_top = top
    80208024        bot = 0
    80218025
    8022         _sig_on
     8026        _sig_on; _pari_catch()
    80238027        init_stack(size)
    80248028        _sig_off
    80258029
     
    80368040        defaultOut.puts = sage_puts
    80378041        defaultOut.flush = sage_flush
    80388042
     8043        # Initialize exception catching mechanism (see pari_err.pyx)
     8044        sage.libs.pari.pari_err.PariInstance_init_err()
     8045
    80398046        # Take control of SIGSEGV back from PARI.
    80408047        import signal
    80418048        signal.signal(signal.SIGSEGV, signal.SIG_DFL)
     
    81148121       
    81158122        s = str(x)
    81168123        cdef GEN g
    8117         _sig_on
     8124        _sig_on; _pari_catch()
    81188125        g = gp_read_str(s)
    81198126        _sig_off
    81208127        return g
     
    81378144       
    81388145        k = GP_DATA.fmt.sigd
    81398146        s = str(n)
    8140         _sig_on
     8147        _sig_on; _pari_catch()
    81418148        sd_realprecision(s, 2)
    81428149        _sig_off
    81438150        return int(k)  # Python int
     
    82088215        limbs = mpz_size(value)
    82098216
    82108217        if (limbs > 500):
    8211             _sig_on
     8218            _sig_on; _pari_catch()
    82128219        z = cgetg( limbs+2, t_INT )
    82138220        setlgefint( z, limbs+2 )
    82148221        setsigne( z, mpz_sgn(value) )
     
    82178224        return self.new_gen(z)
    82188225
    82198226    cdef GEN new_GEN_from_mpz_t(self, mpz_t value):
    8220         ## expects that you _sig_on before entry
     8227        ## expects that you _sig_on; _pari_catch() before entry
    82218228        cdef GEN z
    82228229        cdef long limbs = 0
    82238230
     
    82318238        return z
    82328239
    82338240    cdef gen new_gen_from_int(self, int value):
    8234         _sig_on
     8241        _sig_on; _pari_catch()
    82358242        return self.new_gen(stoi(value))
    82368243
    82378244    cdef gen new_gen_from_mpq_t(self, mpq_t value):
     
    82418248            2/3
    82428249        """
    82438250        cdef GEN z
    8244         _sig_on
     8251        _sig_on; _pari_catch()
    82458252        QQ_to_t_FRAC(&z, value)
    82468253        return self.new_gen(z)
    82478254
     
    82548261        cdef GEN z
    82558262        cdef int i
    82568263
    8257         _sig_on
     8264        _sig_on; _pari_catch()
    82588265        z = cgetg( length + 2, t_POL )
    82598266        setvarn(z, varnum)
    82608267        if length != 0:
     
    82708277    cdef gen new_gen_from_padic(self, long ordp, long relprec,
    82718278                                mpz_t prime, mpz_t p_pow, mpz_t unit):
    82728279        cdef GEN z
    8273         _sig_on
     8280        _sig_on; _pari_catch()
    82748281        z = cgetg( 5, t_PADIC )
    82758282        setprecp( z, relprec )
    82768283        setvalp( z, ordp )
     
    83148321        # of precision (that's the number of mantissa bits in an IEEE
    83158322        # double).
    83168323
    8317         _sig_on
     8324        _sig_on; _pari_catch()
    83188325        if x == 0:
    83198326            return self.new_gen(real_0_bit(-53))
    83208327        else:
     
    83338340        t0GEN(re)
    83348341        t1GEN(im)
    83358342        cdef GEN cp
    8336         _sig_on
     8343        _sig_on; _pari_catch()
    83378344        cp = cgetg(3, t_COMPLEX)
    83388345        __set_lvalue__(gel(cp, 1), t0)
    83398346        __set_lvalue__(gel(cp, 2), t1)
     
    84638470
    84648471        cdef GEN g
    84658472        t = str(s)
    8466         _sig_str('evaluating PARI string')
     8473        # _sig_str('evaluating PARI string')
    84678474        g = gp_read_str(t)
    84688475        return self.new_gen(g)
    84698476
     
    84998506            sage: matrix(ZZ,2,[1..6])._pari_()   # indirect doctest
    85008507            [1, 2, 3; 4, 5, 6]
    85018508        """
    8502         _sig_on
     8509        _sig_on; _pari_catch()
    85038510        cdef GEN g
    85048511        if permute_for_hnf:
    85058512            g = self.integer_matrix_permuted_for_hnf_GEN(B, nr, nc)
     
    85298536            sage: matrix(QQ,2,[1..6])._pari_()   # indirect doctest
    85308537            [1, 2, 3; 4, 5, 6]
    85318538        """
    8532         _sig_on
     8539        _sig_on; _pari_catch()
    85338540        cdef GEN g = self.rational_matrix_GEN(B, nr, nc)
    85348541        return self.new_gen(g)
    85358542
     
    86028609        cdef char* c
    86038610        cdef int n
    86048611        _sig_off
    8605         _sig_on
     8612        _sig_on; _pari_catch()
    86068613        c = GENtostr(g)
    86078614        _sig_off
    86088615        s = str(c)
     
    86838690            sage: pari('mysquare(12)')
    86848691            144
    86858692        """
    8686         _sig_on
     8693        _sig_on; _pari_catch()
    86878694        return self.new_gen(gp_read_file(filename))
    86888695
    86898696
     
    87408747        """
    87418748        if n >= 2:
    87428749            self.nth_prime(n)
    8743         _sig_on
     8750        _sig_on; _pari_catch()
    87448751        return self.new_gen(primes(n))
    87458752
    87468753    def primes_up_to_n(self, long n):
     
    87778784        if n <= 0:
    87788785            raise ValueError, "nth prime meaningless for non-positive n (=%s)"%n
    87798786        cdef GEN g
    8780         _sig_on
     8787        _sig_on; _pari_catch()
    87818788        g = prime(n)
    87828789        return self.new_gen(g)
    87838790
     
    88008807            sage: pari.euler(precision=100).python()
    88018808            0.577215664901532860606512090082...
    88028809        """
    8803         _sig_on
     8810        _sig_on; _pari_catch()
    88048811        return self.new_gen(mpeuler(pbw(precision)))
    88058812
    88068813    def pi(self, precision=0):
     
    88158822            sage: pari.pi(precision=100).python()
    88168823            3.1415926535897932384626433832...
    88178824        """
    8818         _sig_on
     8825        _sig_on; _pari_catch()
    88198826        return self.new_gen(mppi(pbw(precision)))
    88208827
    88218828    def pollegendre(self, long n, v=-1):
     
    88328839            sage: pari.pollegendre(0)
    88338840            1
    88348841        """
    8835         _sig_on
     8842        _sig_on; _pari_catch()
    88368843        return self.new_gen(pollegendre(n, self.get_var(v)))
    88378844
    88388845    def poltchebi(self, long n, v=-1):
     
    88498856            sage: pari.poltchebi(0)
    88508857            1
    88518858        """
    8852         _sig_on
     8859        _sig_on; _pari_catch()
    88538860        return self.new_gen(polchebyshev1(n, self.get_var(v)))
    88548861       
    88558862    def factorial(self, long n):
     
    88678874            sage: pari.factorial(25)
    88688875            15511210043330985984000000
    88698876        """
    8870         _sig_on
     8877        _sig_on; _pari_catch()
    88718878        return self.new_gen(mpfact(n))
    88728879
    88738880    def polcyclo(self, long n, v=-1):
     
    88848891            sage: pari.polcyclo(1)
    88858892            x - 1
    88868893        """
    8887         _sig_on
     8894        _sig_on; _pari_catch()
    88888895        return self.new_gen(polcyclo(n, self.get_var(v)))
    88898896
    88908897    def polsubcyclo(self, long n, long d, v=-1):
     
    89068913            []
    89078914        """
    89088915        cdef gen plist
    8909         _sig_on
     8916        _sig_on; _pari_catch()
    89108917        plist = self.new_gen(polsubcyclo(n, d, self.get_var(v)))
    89118918        if typ(plist.g) != t_VEC:
    89128919            return pari.vector(1, [plist])
     
    89158922        #return self.new_gen(polsubcyclo(n, d, self.get_var(v)))
    89168923
    89178924    def polzagier(self, long n, long m):
    8918         _sig_on
     8925        _sig_on; _pari_catch()
    89198926        return self.new_gen(polzag(n, m))
    89208927
    89218928#  In pari 2.4.3 listcreate is "redundant and obsolete"
     
    89298936#             sage: pari.listcreate()
    89308937#             List([])
    89318938#         """
    8932 #         _sig_on
     8939#         _sig_on; _pari_catch()
    89338940#         return self.new_gen(listcreate())
    89348941
    89358942    def setrand(self, seed):
     
    90029009
    90039010    cdef gen _empty_vector(self, long n):
    90049011        cdef gen v
    9005         _sig_on
     9012        _sig_on; _pari_catch()
    90069013        v = self.new_gen(zerovec(n))
    90079014        return v
    90089015
     
    90159022        cdef gen A
    90169023        cdef gen x
    90179024       
    9018         _sig_on
     9025        _sig_on; _pari_catch()
    90199026         # The gtomat is very important!!  Without sage/PARI will segfault.
    90209027         # I do not know why. -- William Stein
    90219028        A = self.new_gen(gtomat(zeromat(m,n)))
     
    91779184    y.init(h, address)
    91789185    return y
    91799186
    9180 cdef gen xxx_new_gen(GEN x):
    9181     cdef gen y
    9182     y = PY_NEW(gen)
    9183     y.init(x, 0)
    9184     _sig_off
    9185     return y
    9186 
    9187 def min(x,y):
    9188     """
    9189     min(x,y): Return the minimum of x and y.
    9190     """
    9191     if x <= y:
    9192         return x
    9193     return y
    9194 
    9195 def max(x,y):
    9196     """
    9197     max(x,y): Return the maximum of x and y.
    9198     """
    9199     if x >= y:
    9200         return x
    9201     return y
    9202 
    9203 cdef int _read_script(char* s) except -1:
    9204     _sig_on
    9205     gp_read_str(s)
    9206     _sig_off
    9207 
    9208     # We set top to avma, so the script's affects won't be undone
    9209     # when we call new_gen again.
    9210     global mytop, top, avma
    9211     mytop = avma
    9212     return 0
    9213 
    9214 
    9215 #######################
    9216 # Base gen class
    9217 #######################
    9218 
    9219 
    9220 cdef extern from "pari/pari.h":
    9221     char *errmessage[]
    9222     int user
    9223     int errpile
    9224     int noer
     9187# This is never used -- jdemeyer
     9188# cdef gen xxx_new_gen(GEN x):
     9189#     cdef gen y
     9190#     y = PY_NEW(gen)
     9191#     y.init(x, 0)
     9192#     _sig_off
     9193#     return y
     9194
     9195# This is never used -- jdemeyer
     9196# def min(x,y):
     9197#     """
     9198#     min(x,y): Return the minimum of x and y.
     9199#     """
     9200#     if x <= y:
     9201#         return x
     9202#     return y
     9203#
     9204# This is never used -- jdemeyer
     9205# def max(x,y):
     9206#     """
     9207#     max(x,y): Return the maximum of x and y.
     9208#     """
     9209#     if x >= y:
     9210#         return x
     9211#     return y
     9212
     9213# This is not needed anymore, since pari.read() was simplified (why was
     9214# it ever so complicated anyway?) -- jdemeyer
     9215# cdef int _read_script(char* s) except -1:
     9216#     _sig_on; _pari_catch()
     9217#     gp_read_str(s)
     9218#     _sig_off
     9219#
     9220#     # We set top to avma, so the script's affects won't be undone
     9221#     # when we call new_gen again.
     9222#     global mytop, top, avma
     9223#     mytop = avma
     9224#     return 0
     9225
     9226
     9227def vecsmall_to_intlist(gen v):
     9228    """
     9229    INPUT:
     9230   
     9231   
     9232    -  ``v`` - a gen of type Vecsmall
     9233   
     9234   
     9235    OUTPUT: a Python list of Python ints
     9236    """
     9237    if typ(v.g) != t_VECSMALL:
     9238        raise TypeError, "input v must be of type vecsmall (use v.Vecsmall())"
     9239    return [v.g[k+1] for k in range(glength(v.g))]
     9240
    92259241
    92269242cdef extern from "misc.h":
    92279243    int     factorint_withproof_sage(GEN* ans, GEN x, GEN cutoff)
    92289244    int     gcmp_sage(GEN x, GEN y)
    92299245
    9230 def __errmessage(d):
    9231     if d <= 0 or d > noer:
    9232         return "unknown"
    9233     return errmessage[d]
    9234 
    9235 # FIXME: we derive PariError from RuntimeError, for backward
    9236 # compatibility with code that catches the latter. Once this is
    9237 # in production, we should change the base class to StandardError.
    9238 from exceptions import RuntimeError
    9239 
    9240 # can we have "cdef class" ?
    9241 # because of the inheritance, need to somehow "import" the built-in
    9242 # exception class...
    9243 class PariError (RuntimeError):
    9244 
    9245     errmessage = staticmethod(__errmessage)
    9246 
    9247     def __repr__(self):
    9248         return "PariError(%d)"%self.args[0]
    9249 
    9250     def __str__(self):
    9251         return "%s (%d)"%(self.errmessage(self.args[0]),self.args[0])
    9252 
    9253 # We expose a trap function to C.
    9254 # If this function returns without raising an exception,
    9255 # the code is retried.
    9256 # This is a proof-of-concept example.
    9257 # THE TRY CODE IS NOT REENTRANT -- NO CALLS TO PARI FROM HERE !!!
    9258 #              - Gonzalo Tornario
    9259 
    9260 cdef void _pari_trap "_pari_trap" (long errno, long retries) except *:
    9261     """
    9262     TESTS::
    9263    
    9264     """
    9265     _sig_off
    9266     if retries > 100:
    9267         raise RuntimeError, "_pari_trap recursion too deep"
    9268     if errno == errpile:
    9269         P.allocatemem(silent=True)
    9270        
    9271         #raise RuntimeError, "The PARI stack overflowed.  It has automatically been doubled using pari.allocatemem().  Please retry your computation, possibly after you manually call pari.allocatemem() a few times."
    9272         #print "Stack overflow! (%d retries so far)"%retries
    9273         #print " enlarge the stack."
    9274        
    9275     elif errno == user:
    9276        
    9277         raise Exception, "PARI user exception"
    9278    
    9279     else:
    9280        
    9281         raise PariError, errno
    9282 
    9283 
    9284 
    9285 def vecsmall_to_intlist(gen v):
    9286     """
    9287     INPUT:
    9288    
    9289    
    9290     -  ``v`` - a gen of type Vecsmall
    9291    
    9292    
    9293     OUTPUT: a Python list of Python ints
    9294     """
    9295     if typ(v.g) != t_VECSMALL:
    9296         raise TypeError, "input v must be of type vecsmall (use v.Vecsmall())"
    9297     return [v.g[k+1] for k in range(glength(v.g))]
    9298 
    9299 
    93009246
    93019247cdef _factor_int_when_pari_factor_failed(x, failed_factorization):
    93029248    """
     
    93329278    return m
    93339279
    93349280
     9281
     9282
  • sage/libs/pari/misc.h

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/misc.h
    a b  
    77
    88#define set_gel(x, n, z)  gel(x,n)=z;
    99
    10 #define _pari_sig_on _sig_on; _pari_catch;
    11 #define _pari_sig_str(s) _sig_str(s); _pari_catch;
    12 #define _pari_sig_off _pari_endcatch; _sig_off;
    1310
    1411inline int strcmp_to_cmp(int f) {
    1512    if (f > 0) {
  • sage/libs/pari/pari_err.h

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/pari_err.h
    a b  
    11#include <pari/pari.h>
    22#include "interrupt.h"
    33
     4int _pari_catch();
    45
    5 // global catch variable !
    6 // this means that the code is not reentrant -- beware !
    7 // THAT MEANS NO CALLING TO PARI from inside the trap....
    8 // Should replace by a stack, that would work.
    9 static long __catcherr = 0;
    10 
    11 #define _pari_raise(errno) { \
    12         PyErr_SetObject(PyExc_PariError, PyInt_FromLong(errno)); \
    13     }
    14 
    15 #define _pari_endcatch { err_leave(__catcherr); }
    16 
    17 /* Careful with pari_retries !
    18  * It should not be in a register, we flag it as "volatile".
    19  */
    20 #define _pari_catch { \
    21         long pari_errno; \
    22         long volatile pari_retries = 0; \
    23         jmp_buf __env; \
    24         __catcherr = 0; \
    25         if ((pari_errno=setjmp(__env))) { \
    26             _pari_trap(pari_errno, pari_retries); \
    27             if(PyErr_Occurred()) { \
    28                 _pari_endcatch; \
    29                 return NULL; \
    30             } \
    31             pari_retries++; \
    32         } \
    33         __catcherr = err_catch(CATCH_ALL, &__env); \
    34     }
     6#define _pari_sig_on _sig_on; _pari_catch();
     7#define _pari_sig_str(s) _sig_str(s); _pari_catch();
     8#define _pari_sig_off _sig_off;
  • sage/libs/pari/pari_err.pxi

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/pari_err.pxi
    a b  
    1 # vim:ft=pyrex:
    2 
    31cdef extern from 'pari_err.h':
    4     int _pari_catch
    5     int _pari_endcatch
    6     int _sig_on "_pari_sig_on"
    7     int _sig_off "_pari_sig_off"
    8     void _sig_str "_pari_sig_str" (char *)
     2    int _sig_on
     3    int _sig_off
  • new file sage/libs/pari/pari_err.pyx

    diff -r 37fb7c004f83 -r f902c841cbfb sage/libs/pari/pari_err.pyx
    - +  
     1include 'decl.pxi'
     2include 'pari_err.pxi'
     3
     4import gen
     5
     6cdef extern from "pari_err.h":
     7    int _pari_sig_on, _pari_sig_off
     8
     9
     10def __errmessage(d):
     11    if d <= 0 or d > noer:
     12        return "unknown"
     13    return errmessage[d]
     14
     15# FIXME: we derive PariError from RuntimeError, for backward
     16# compatibility with code that catches the latter. Once this is
     17# in production, we should change the base class to StandardError.
     18from exceptions import RuntimeError
     19
     20# can we have "cdef class" ?
     21# because of the inheritance, need to somehow "import" the built-in
     22# exception class...
     23class PariError (RuntimeError):
     24
     25    errmessage = staticmethod(__errmessage)
     26
     27    def __repr__(self):
     28        return "PariError(%d)"%self.args[0]
     29
     30    def __str__(self):
     31        return "%s (%d)"%(self.errmessage(self.args[0]),self.args[0])
     32
     33# We expose a trap function to C.
     34# If this function returns without raising an exception,
     35# the code is retried.
     36# This is a proof-of-concept example.
     37# THE TRY CODE IS NOT REENTRANT -- NO CALLS TO PARI FROM HERE !!!
     38#              - Gonzalo Tornario
     39
     40cdef void _pari_trap (long errno, long retries) except *:
     41    """
     42    TESTS::
     43   
     44    """
     45    _sig_off
     46    if retries > 100:
     47        raise RuntimeError, "_pari_trap recursion too deep"
     48    if errno == errpile:
     49        gen.pari.allocatemem(silent=True)
     50       
     51        #raise RuntimeError, "The PARI stack overflowed.  It has automatically been doubled using pari.allocatemem().  Please retry your computation, possibly after you manually call pari.allocatemem() a few times."
     52        #print "Stack overflow! (%d retries so far)"%retries
     53        #print " enlarge the stack."
     54       
     55    elif errno == user:
     56       
     57        raise Exception, "PARI user exception"
     58   
     59    else:
     60       
     61        raise PariError, errno
     62
     63def PariInstance_init_err():
     64    global cb_pari_handle_exception
     65    cb_pari_handle_exception = handle_pari_exception
     66    return
     67
     68cdef int handle_pari_exception_cython "handle_pari_exception_cython"(long numerr) except 0:
     69    _sig_off
     70    raise PariError, numerr