Ticket #11868: trac_11868-t0GEN.patch

File trac_11868-t0GEN.patch, 71.2 KB (added by pbruin, 9 years ago)

eliminate global GEN variables

  • sage/libs/pari/gen.pxd

    # HG changeset patch
    # User Peter Bruin <P.Bruin@warwick.ac.uk>
    # Date 1385259470 0
    # Node ID 9a9096a3c9a32d1957a7c89ab04ebd8caba217c7
    # Parent  33a4ab61f20f40e2d3ba5f075ab97a4ac368b6b7
    Trac 11868: eliminate global GEN variables
    
    diff --git a/sage/libs/pari/gen.pxd b/sage/libs/pari/gen.pxd
    a b  
    1414    cdef gen pari(self, object x)
    1515    cdef GEN _deepcopy_to_python_heap(self, GEN x, pari_sp* address)
    1616    cdef long get_var(self, v)
    17     cdef GEN get_nf(self) except NULL
    1817
    1918cdef class PariInstance(sage.structure.parent_base.ParentWithBase):
    2019    cdef gen PARI_ZERO, PARI_ONE, PARI_TWO
    2120    cdef gen new_gen(self, GEN x)
    22     cdef object new_gen_to_string(self, GEN x)
    2321    cdef gen new_gen_noclear(self, GEN x)
    2422    cdef gen new_gen_from_mpz_t(self, mpz_t value)
    2523    cdef inline GEN _new_GEN_from_mpz_t(self, mpz_t value)
     
    2927    cdef gen new_t_POL_from_int_star(self, int *vals, int length, long varnum)
    3028    cdef gen new_gen_from_padic(self, long ordp, long relprec, mpz_t prime, mpz_t p_pow, mpz_t unit)
    3129    cdef void clear_stack(self)
    32     cdef void set_mytop_to_avma(self)
    3330    cdef gen double_to_gen_c(self, double)
    3431    cdef GEN double_to_GEN(self, double)
    3532    cdef GEN deepcopy_to_python_heap(self, GEN x, pari_sp* address)
    3633    cdef gen new_ref(self, GEN g, gen parent)
    3734    cdef gen _empty_vector(self, long n)
    3835    cdef long get_var(self, v)
    39     cdef GEN toGEN(self, x, int i) except NULL
     36    cdef GEN toGEN(self, x) except NULL
    4037    cdef GEN _new_GEN_from_mpz_t_matrix(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc)
    4138    cdef GEN _new_GEN_from_mpz_t_matrix_rotate90(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc)
    4239    cdef gen integer_matrix(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc, bint permute_for_hnf)
  • sage/libs/pari/gen.pyx

    diff --git a/sage/libs/pari/gen.pyx b/sage/libs/pari/gen.pyx
    a b  
    189189cdef extern from "mpz_pylong.h":
    190190    cdef int mpz_set_pylong(mpz_t dst, src) except -1
    191191
    192 # Make sure we don't use mpz_t_offset before initializing it by
    193 # putting in a value that's likely to provoke a segmentation fault,
    194 # rather than silently corrupting memory.
    195 cdef long mpz_t_offset = 1000000000
    196 
    197192# so Galois groups are represented in a sane way
    198193# See the polgalois section of the PARI users manual.
    199194new_galois_format = 1   
     
    376371# Also a copy of PARI accessible from external pure python code.
    377372pari = pari_instance
    378373
    379 # temp variables
    380 cdef GEN t0,t1,t2,t3,t4
    381 t0heap = [0]*5
    382 
    383 cdef t0GEN(x):
    384     global t0
    385     t0 = P.toGEN(x, 0)
    386    
    387 cdef t1GEN(x):
    388     global t1
    389     t1 = P.toGEN(x, 1)
    390    
    391 cdef t2GEN(x):
    392     global t2
    393     t2 = P.toGEN(x, 2)
    394    
    395 cdef t3GEN(x):
    396     global t3
    397     t3 = P.toGEN(x, 3)
    398    
    399 cdef t4GEN(x):
    400     global t4
    401     t4 = P.toGEN(x, 4)
    402 
    403374cdef object Integer
    404375
    405376cdef void late_import():
     
    411382    import sage.rings.integer
    412383    Integer = sage.rings.integer.Integer
    413384
    414     global mpz_t_offset
    415     mpz_t_offset = sage.rings.integer.mpz_t_offset_python
    416385
    417386cdef class gen(sage.structure.element.RingElement):
    418387    """
     
    442411            sage_free(<void*> self.b)
    443412
    444413    def __repr__(self):
    445         pari_catch_sig_on()
    446         return P.new_gen_to_string(self.g)
     414        cdef char *c
     415        cdef str s
     416        pari_catch_sig_on()
     417        c = GENtostr(self.g)
     418        s = str(c)
     419        pari_free(c)
     420        pari_catch_sig_off()
     421        return s
    447422
    448423    def __hash__(self):
    449424        """
     
    681656            return P.new_gen(gmod(selfgen.g, othergen.g))
    682657        return sage.structure.element.bin_op(self, other, operator.mod)
    683658
    684     def __pow__(self, n, m):
    685         t0GEN(self)
    686         t1GEN(n)
    687         pari_catch_sig_on()
    688         # Note: the prec parameter here has no effect when t0,t1 are
    689         # real; the precision of the result is the minimum of the
    690         # precisions of t0 and t1.  In any case the 3rd parameter to
    691         # gpow should be a word-precision, not a decimal precision.
    692         return P.new_gen(gpow(t0, t1, prec))
     659    def __pow__(gen self, n, m):
     660        pari_catch_sig_on()
     661        cdef GEN t0 = P.toGEN(n)
     662        return P.new_gen(gpow(self.g, t0, prec))
    693663
    694664    def __neg__(gen self):
    695665        pari_catch_sig_on()
     
    715685    # ACCESS
    716686    ###########################################
    717687    def getattr(self, attr):
    718         t0GEN(str(self) + '.' + str(attr))
    719         pari_catch_sig_on()
    720         return self.new_gen(t0)
     688        return P(str(self) + '.' + str(attr))
    721689
    722690    def mod(self):
    723691        """
     
    742710        # stored.
    743711        return self.new_gen(gel(self.g, 1))
    744712
    745     cdef GEN get_nf(self) except NULL:
     713    def get_nf(self):
    746714        """
    747715        Given a PARI object `self`, convert it to a proper PARI number
    748716        field (nf) structure.
     
    781749        cdef long nftyp
    782750        pari_catch_sig_on()
    783751        nf = get_nf(self.g, &nftyp)
    784         pari_catch_sig_off()
    785752        if not nf:
     753            pari_catch_sig_off()
    786754            raise TypeError("Not a PARI number field")
    787         return nf
     755        return P.new_gen(nf)
    788756
    789757    def nf_get_pol(self):
    790758        """
     
    815783            ...
    816784            TypeError: Not a PARI number field
    817785        """
    818         cdef GEN nf = self.get_nf()
    819         pari_catch_sig_on()
    820         return self.new_gen(nf_get_pol(nf))
     786        cdef gen nf = self.get_nf()
     787        pari_catch_sig_on()
     788        return P.new_gen(nf_get_pol(nf.g))
    821789
    822790    def nf_get_diff(self):
    823791        """
     
    834802            sage: pari(K).nf_get_diff()
    835803            [12, 0, 0, 0; 0, 12, 8, 0; 0, 0, 4, 0; 0, 0, 0, 4]
    836804        """
    837         cdef GEN nf = self.get_nf()
     805        cdef gen nf = self.get_nf()
    838806        pari_catch_sig_on()
    839807        # Very bad code, but there doesn't seem to be a better way
    840         return self.new_gen(gel(gel(nf, 5), 5))
     808        return P.new_gen(gel(gel(nf.g, 5), 5))
    841809
    842810    def nf_get_sign(self):
    843811        """
     
    863831        """
    864832        cdef long r1
    865833        cdef long r2
    866         cdef GEN nf = self.get_nf()
    867         nf_get_sign(nf, &r1, &r2)
     834        cdef gen nf = self.get_nf()
     835        nf_get_sign(nf.g, &r1, &r2)
    868836        return [r1, r2]
    869837
    870838    def nf_get_zk(self):
     
    883851            sage: pari(K).nf_get_zk()
    884852            [1, y, y^3 - 4*y, y^2 - 2]
    885853        """
    886         cdef GEN nf = self.get_nf()
    887         pari_catch_sig_on()
    888         return self.new_gen(nf_get_zk(nf))
     854        cdef gen nf = self.get_nf()
     855        pari_catch_sig_on()
     856        return P.new_gen(nf_get_zk(nf.g))
    889857
    890858    def bnf_get_no(self):
    891859        """
     
    16281596            sage: int(pari("Mod(2, 7)"))
    16291597            2
    16301598        """
     1599        late_import()
    16311600        return int(Integer(self))
    16321601
    16331602    def int_unsafe(gen self):
     
    18221791            sage: long(pari("Mod(2, 7)"))
    18231792            2L
    18241793        """
     1794        late_import()
    18251795        return long(Integer(self))
    18261796   
    18271797    def __float__(gen self):
     
    19131883            sage: a.gequal(c)
    19141884            False
    19151885        """
    1916         t0GEN(b)
    1917         pari_catch_sig_on()
     1886        pari_catch_sig_on()
     1887        cdef GEN t0 = P.toGEN(b)
    19181888        cdef int ret = gequal(a.g, t0)
    1919         pari_catch_sig_off()
     1889        P.clear_stack()
    19201890        return ret != 0
    19211891
    19221892    def gequal0(gen a):
     
    21342104        """
    21352105        cdef int n
    21362106        cdef GEN x
     2107        cdef GEN t0
    21372108       
    21382109        if k is None:
    21392110            pari_catch_sig_on()
    21402111            n = gisanypower(self.g, &x)
    21412112            if n == 0:
    2142                 pari_catch_sig_off()
     2113                P.clear_stack()
    21432114                return 1, self
    21442115            else:
    21452116                return n, P.new_gen(x)
    21462117        else:
    21472118            k = int(k)
    2148             t0GEN(k)
    21492119            pari_catch_sig_on()
     2120            t0 = P.toGEN(k)
    21502121            n = ispower(self.g, t0, &x)
    21512122            if n == 0:
    2152                 pari_catch_sig_off()
     2123                P.clear_stack()
    21532124                return False, None
    21542125            else:
    21552126                return k, P.new_gen(x)
     
    21632134        2-dimensional column vector the quotient and the remainder, with
    21642135        respect to v (to main variable if v is omitted).
    21652136        """
    2166         t0GEN(y)
    21672137        pari_catch_sig_on()       
     2138        cdef GEN t0 = P.toGEN(y)
    21682139        return P.new_gen(divrem(x.g, t0, P.get_var(var)))
    21692140
    21702141    def lex(gen x, y):
     
    21722143        lex(x,y): Compare x and y lexicographically (1 if xy, 0 if x==y, -1
    21732144        if xy)
    21742145        """
    2175         t0GEN(y)
    21762146        pari_catch_sig_on()       
     2147        cdef GEN t0 = P.toGEN(y)
    21772148        return lexcmp(x.g, t0)
    21782149
    21792150    def max(gen x, y):
    21802151        """
    21812152        max(x,y): Return the maximum of x and y.
    21822153        """
    2183         t0GEN(y)
    2184         pari_catch_sig_on()
     2154        pari_catch_sig_on()
     2155        cdef GEN t0 = P.toGEN(y)
    21852156        return P.new_gen(gmax(x.g, t0))
    21862157
    21872158    def min(gen x, y):
    21882159        """
    21892160        min(x,y): Return the minimum of x and y.
    21902161        """
    2191         t0GEN(y)
    2192         pari_catch_sig_on()
     2162        pari_catch_sig_on()
     2163        cdef GEN t0 = P.toGEN(y)
    21932164        return P.new_gen(gmin(x.g, t0))
    21942165
    21952166    def shift(gen x, long n):
     
    24862457            sage: a.type()
    24872458            't_POLMOD'
    24882459        """
    2489         t0GEN(y)
    2490         pari_catch_sig_on()
    2491         return P.new_gen(gmodulo(x.g,t0))
     2460        pari_catch_sig_on()
     2461        cdef GEN t0 = P.toGEN(y)
     2462        return P.new_gen(gmodulo(x.g, t0))
    24922463   
    24932464    def Pol(self, v=-1):
    24942465        """
     
    26342605            ...
    26352606            PariError: square discriminant in Qfb
    26362607        """
    2637         t0GEN(b); t1GEN(c); t2GEN(D)
    2638         pari_catch_sig_on()
     2608        pari_catch_sig_on()
     2609        cdef GEN t0 = P.toGEN(b)
     2610        cdef GEN t1 = P.toGEN(c)
     2611        cdef GEN t2 = P.toGEN(D)
    26392612        return P.new_gen(Qfb0(a.g, t0, t1, t2, prec))
    26402613       
    26412614   
     
    27682741        cdef char* c
    27692742        pari_catch_sig_on()
    27702743        c = GENtostr(self.g)
    2771         v = self.new_gen(strtoGENstr(c))
     2744        v = P.new_gen(strtoGENstr(c))
    27722745        pari_free(c)
    27732746        return v
    27742747
     
    30833056            sage: pari(-1).bitand(-1)
    30843057            -1
    30853058        """
    3086         t0GEN(y)
    3087         pari_catch_sig_on()
     3059        pari_catch_sig_on()
     3060        cdef GEN t0 = P.toGEN(y)
    30883061        return P.new_gen(gbitand(x.g, t0))
    30893062       
    30903063   
     
    31633136            sage: pari(8+4).bitnegimply(8)
    31643137            4
    31653138        """
    3166         t0GEN(y)
    3167         pari_catch_sig_on()
     3139        pari_catch_sig_on()
     3140        cdef GEN t0 = P.toGEN(y)
    31683141        return P.new_gen(gbitnegimply(x.g, t0))
    31693142
    31703143   
     
    31983171            sage: pari(13).bitor(1)
    31993172            13
    32003173        """
    3201         t0GEN(y)
    3202         pari_catch_sig_on()
     3174        pari_catch_sig_on()
     3175        cdef GEN t0 = P.toGEN(y)
    32033176        return P.new_gen(gbitor(x.g, t0))
    32043177
    32053178   
     
    32723245            sage: pari(6).bitxor(0)
    32733246            6
    32743247        """
    3275         t0GEN(y)
    3276         pari_catch_sig_on()
     3248        pari_catch_sig_on()
     3249        cdef GEN t0 = P.toGEN(y)
    32773250        return P.new_gen(gbitxor(x.g, t0))
    32783251
    32793252   
     
    41644137            2147483647            # 32-bit
    41654138            9223372036854775807   # 64-bit
    41664139        """
    4167         cdef long v
    4168         t0GEN(p)
    4169         pari_catch_sig_on()
     4140        pari_catch_sig_on()
     4141        cdef GEN t0 = P.toGEN(p)
    41704142        v = ggval(x.g, t0)
    4171         pari_catch_sig_off()
     4143        P.clear_stack()
    41724144        return v
    41734145   
    41744146    def _valp(gen x):
     
    43334305            sage: pari(1+i).agm(-3)
    43344306            -0.964731722290876 + 1.15700282952632*I
    43354307        """
    4336         t0GEN(y)
    4337         pari_catch_sig_on()
     4308        pari_catch_sig_on()
     4309        cdef GEN t0 = P.toGEN(y)
    43384310        return P.new_gen(agm(x.g, t0, pbw(precision)))
    43394311
    43404312    def arg(gen x, precision=0):
     
    45104482            sage: pari(2).besselh1(3)
    45114483            0.486091260585891 - 0.160400393484924*I
    45124484        """
    4513         t0GEN(x)
    4514         pari_catch_sig_on()
    4515         return P.new_gen(hbessel1(nu.g, t0, pbw(precision)))
     4485        pari_catch_sig_on()
     4486        cdef GEN t0 = P.toGEN(x)
     4487        return P.new_gen(hbessel1(nu.g, t0, prec_bits_to_words(precision)))
    45164488
    45174489    def besselh2(gen nu, x, precision=0):
    45184490        r"""
     
    45304502            sage: pari(2).besselh2(3)
    45314503            0.486091260585891 + 0.160400393484924*I
    45324504        """
    4533         t0GEN(x)
    4534         pari_catch_sig_on()
    4535         return P.new_gen(hbessel2(nu.g, t0, pbw(precision)))
     4505        pari_catch_sig_on()
     4506        cdef GEN t0 = P.toGEN(x)
     4507        return P.new_gen(hbessel2(nu.g, t0, prec_bits_to_words(precision)))
    45364508
    45374509    def besselj(gen nu, x, precision=0):
    45384510        r"""
     
    45534525            sage: pari(2).besselj(3)
    45544526            0.486091260585891
    45554527        """
    4556         t0GEN(x)
    4557         pari_catch_sig_on()
    4558         return P.new_gen(jbessel(nu.g, t0, pbw(precision)))
     4528        pari_catch_sig_on()
     4529        cdef GEN t0 = P.toGEN(x)
     4530        return P.new_gen(jbessel(nu.g, t0, prec_bits_to_words(precision)))
    45594531
    45604532    def besseljh(gen nu, x, precision=0):
    45614533        """
     
    45784550            0.4127100324          # 32-bit
    45794551            0.412710032209716     # 64-bit
    45804552        """
    4581         t0GEN(x)
    4582         pari_catch_sig_on()
    4583         return P.new_gen(jbesselh(nu.g, t0, pbw(precision)))
     4553        pari_catch_sig_on()
     4554        cdef GEN t0 = P.toGEN(x)
     4555        return P.new_gen(jbesselh(nu.g, t0, prec_bits_to_words(precision)))
    45844556
    45854557    def besseli(gen nu, x, precision=0):
    45864558        r"""
     
    46044576            sage: pari(2).besseli(3+i)
    46054577            1.12539407613913 + 2.08313822670661*I
    46064578        """
    4607         t0GEN(x)
    4608         pari_catch_sig_on()
    4609         return P.new_gen(ibessel(nu.g, t0, pbw(precision)))
     4579        pari_catch_sig_on()
     4580        cdef GEN t0 = P.toGEN(x)
     4581        return P.new_gen(ibessel(nu.g, t0, prec_bits_to_words(precision)))
    46104582
    46114583    def besselk(gen nu, x, long flag=0, precision=0):
    46124584        """
     
    46474619            sage: pari(2+i).besselk(300, flag=1)
    46484620            3.74224603319728 E-132 + 2.49071062641525 E-134*I
    46494621        """
    4650         t0GEN(x)
    4651         pari_catch_sig_on()
    4652         return P.new_gen(kbessel(nu.g, t0, pbw(precision)))
     4622        pari_catch_sig_on()
     4623        cdef GEN t0 = P.toGEN(x)
     4624        return P.new_gen(kbessel(nu.g, t0, prec_bits_to_words(precision)))
    46534625
    46544626    def besseln(gen nu, x, precision=0):
    46554627        """
     
    46684640            sage: pari(2+i).besseln(3)
    46694641            -0.280775566958244 - 0.486708533223726*I
    46704642        """
    4671         t0GEN(x)
    4672         pari_catch_sig_on()
    4673         return P.new_gen(nbessel(nu.g, t0, pbw(precision)))
     4643        pari_catch_sig_on()
     4644        cdef GEN t0 = P.toGEN(x)
     4645        return P.new_gen(nbessel(nu.g, t0, prec_bits_to_words(precision)))
    46744646
    46754647    def cos(gen x, precision=0):
    46764648        """
     
    49354907            sage: pari(1).hyperu(2,3)
    49364908            0.333333333333333
    49374909        """
    4938         t0GEN(b)
    4939         t1GEN(x)
    4940         pari_catch_sig_on()
    4941         return P.new_gen(hyperu(a.g, t0, t1, pbw(precision)))
     4910        pari_catch_sig_on()
     4911        cdef GEN t0 = P.toGEN(b)
     4912        cdef GEN t1 = P.toGEN(x)
     4913        return P.new_gen(hyperu(a.g, t0, t1, prec_bits_to_words(precision)))
    49424914
    49434915    def incgam(gen s, x, y=None, precision=0):
    49444916        r"""
     
    49564928            sage: pari(1+i).incgam(3-i)
    49574929            -0.0458297859919946 + 0.0433696818726677*I
    49584930        """
    4959         t0GEN(x)
    4960         pari_catch_sig_on()
     4931        pari_catch_sig_on()
     4932        cdef GEN t0 = P.toGEN(x)
     4933        cdef GEN t1
    49614934        if y is None:
    4962             return P.new_gen(incgam(s.g, t0, pbw(precision)))
     4935            return P.new_gen(incgam(s.g, t0, prec_bits_to_words(precision)))
    49634936        else:
    4964             t1GEN(y)
    4965             return P.new_gen(incgam0(s.g, t0, t1, pbw(precision)))
     4937            t1 = P.toGEN(y)
     4938            return P.new_gen(incgam0(s.g, t0, t1, prec_bits_to_words(precision)))
    49664939
    49674940    def incgamc(gen s, x, precision=0):
    49684941        r"""
     
    49864959            sage: pari(1).incgamc(2)
    49874960            0.864664716763387
    49884961        """
    4989         t0GEN(x)
    4990         pari_catch_sig_on()
    4991         return P.new_gen(incgamc(s.g, t0, pbw(precision)))
     4962        pari_catch_sig_on()
     4963        cdef GEN t0 = P.toGEN(x)
     4964        return P.new_gen(incgamc(s.g, t0, prec_bits_to_words(precision)))
    49924965   
    49934966    def log(gen x, precision=0):
    49944967        r"""
     
    52625235            2.00000000000000 + 9.21571846612679 E-19*I  # 64-bit
    52635236        """
    52645237        # TODO: ???  lots of good examples in the PARI docs ???
     5238        pari_catch_sig_on()
    52655239        cdef GEN zetan
    5266         t0GEN(n)
    5267         pari_catch_sig_on()
    5268         ans = P.new_gen_noclear(gsqrtn(x.g, t0, &zetan, pbw(precision)))
     5240        cdef GEN t0 = P.toGEN(n)
     5241        ans = P.new_gen_noclear(gsqrtn(x.g, t0, &zetan, prec_bits_to_words(precision)))
    52695242        return ans, P.new_gen(zetan)
    52705243
    52715244    def tan(gen x, precision=0):
     
    53435316            sage: pari(0.5).theta(2)
    53445317            1.63202590295260
    53455318        """
    5346         t0GEN(z)
    5347         pari_catch_sig_on()
    5348         return P.new_gen(theta(q.g, t0, pbw(precision)))
     5319        pari_catch_sig_on()
     5320        cdef GEN t0 = P.toGEN(z)
     5321        return P.new_gen(theta(q.g, t0, prec_bits_to_words(precision)))
    53495322
    53505323    def thetanullk(gen q, long k, precision=0):
    53515324        """
     
    54435416            4*7^-2 + 5*7^-1 + O(7^0)
    54445417        """
    54455418        pari_catch_sig_on()
    5446         return P.new_gen(gzeta(s.g, pbw(precision)))
     5419        return P.new_gen(gzeta(s.g, prec_bits_to_words(precision)))
    54475420
    54485421    ###########################################
    54495422    # 4: NUMBER THEORETICAL functions
    54505423    ###########################################
    54515424   
    54525425    def bezout(gen x, y):
     5426        pari_catch_sig_on()
    54535427        cdef gen u, v, g
    54545428        cdef GEN U, V, G
    5455         t0GEN(y)
    5456         pari_catch_sig_on()
     5429        cdef GEN t0 = P.toGEN(y)
    54575430        G = gbezout(x.g, t0, &U, &V)
    54585431        g = P.new_gen_noclear(G)
    54595432        u = P.new_gen_noclear(U)
     
    54925465        a bound for the number of terms in the continued fraction
    54935466        expansion.
    54945467        """
    5495         t0GEN(b)
    5496         pari_catch_sig_on()
     5468        pari_catch_sig_on()
     5469        cdef GEN t0 = P.toGEN(b)
    54975470        return P.new_gen(contfrac0(x.g, t0, lmax))
    54985471
    54995472    def contfracpnqn(gen x, b=0, long lmax=0):
     
    55785551        (x and y must be polynomials), 2 use the subresultant algorithm (x
    55795552        and y must be polynomials)
    55805553        """
    5581         t0GEN(y)
    5582         pari_catch_sig_on()
     5554        pari_catch_sig_on()
     5555        cdef GEN t0 = P.toGEN(y)
    55835556        return P.new_gen(ggcd0(x.g, t0))
    55845557
    55855558    def issquare(gen x, find_root=False):
     
    56245597            sage: pari(10).lcm(15)
    56255598            30
    56265599        """
    5627         t0GEN(y)
    5628         pari_catch_sig_on()
     5600        pari_catch_sig_on()
     5601        cdef GEN t0 = P.toGEN(y)
    56295602        return P.new_gen(glcm(x.g, t0))
    56305603
    56315604    def numdiv(gen n):
     
    58595832            sage: e.elladd([1,0], [-1,1])
    58605833            [-3/4, -15/8]
    58615834        """
    5862         t0GEN(z0); t1GEN(z1)
    5863         pari_catch_sig_on()
    5864         return self.new_gen(addell(self.g, t0, t1))
     5835        pari_catch_sig_on()
     5836        cdef GEN t0 = P.toGEN(z0)
     5837        cdef GEN t1 = P.toGEN(z1)
     5838        return P.new_gen(addell(self.g, t0, t1))
    58655839
    58665840    def ellak(self, n):
    58675841        r"""
     
    58975871            sage: e.ellak(0)
    58985872            0
    58995873        """
    5900         t0GEN(n)
    5901         pari_catch_sig_on()
    5902         return self.new_gen(akell(self.g, t0))
     5874        pari_catch_sig_on()
     5875        cdef GEN t0 = P.toGEN(n)
     5876        return P.new_gen(akell(self.g, t0))
    59035877
    59045878
    59055879    def ellan(self, long n, python_ints=False):
     
    59925966            sage: e.ellak(-1)
    59935967            0
    59945968        """
    5995         t0GEN(p)
    5996         pari_catch_sig_on()
    5997         return self.new_gen(ellap(self.g, t0))
     5969        pari_catch_sig_on()
     5970        cdef GEN t0 = P.toGEN(p)
     5971        return P.new_gen(ellap(self.g, t0))
    59985972
    59995973
    60005974    def ellaplist(self, long n, python_ints=False):
     
    60496023        # 1. make a table of primes up to n.
    60506024        pari_catch_sig_on()
    60516025        if n < 2:
    6052             return self.new_gen(zerovec(0))
     6026            return P.new_gen(zerovec(0))
    60536027        cdef GEN g
    6054         pari.init_primes(n+1)
    6055         t0GEN(n)
     6028        P.init_primes(n+1)
     6029        cdef GEN t0 = P.toGEN(n)
    60566030        g = primes(gtolong(primepi(t0)))
    60576031
    60586032        # 2. Replace each prime in the table by ellap of it.
     
    60896063            sage: e.ellbil([1, 0], [-1, 1])
    60906064            0.418188984498861
    60916065        """
    6092         t0GEN(z0); t1GEN(z1)
    6093         pari_catch_sig_on()
    6094         # the prec argument has no effect
    6095         return self.new_gen(bilhell(self.g, t0, t1, prec))
     6066        pari_catch_sig_on()
     6067        cdef GEN t0 = P.toGEN(z0)
     6068        cdef GEN t1 = P.toGEN(z1)
     6069        return P.new_gen(bilhell(self.g, t0, t1, prec))
    60966070
    60976071    def ellchangecurve(self, ch):
    60986072        """
     
    61216095            sage: f[:5]
    61226096            [1, -1, 0, 4, 3]
    61236097        """
    6124         t0GEN(ch)
    6125         pari_catch_sig_on()
    6126         return self.new_gen(ellchangecurve(self.g, t0))
     6098        pari_catch_sig_on()
     6099        cdef GEN t0 = P.toGEN(ch)
     6100        return P.new_gen(ellchangecurve(self.g, t0))
    61276101
    61286102    def elleta(self):
    61296103        """
     
    61906164            sage: e.ellheight([1,0], flag=1)
    61916165            0.476711659343740
    61926166        """
    6193         t0GEN(a)
    6194         pari_catch_sig_on()
    6195         return self.new_gen(ellheight0(self.g, t0, flag, pbw(precision)))
     6167        pari_catch_sig_on()
     6168        cdef GEN t0 = P.toGEN(a)
     6169        return P.new_gen(ellheight0(self.g, t0, flag, prec_bits_to_words(precision)))
    61966170
    61976171    def ellheightmatrix(self, x):
    61986172        """
     
    62186192            sage: e.ellheightmatrix([[1,0], [-1,1]])
    62196193            [0.476711659343740, 0.418188984498861; 0.418188984498861, 0.686667083305587]
    62206194        """
    6221         t0GEN(x)
    6222         pari_catch_sig_on()
    6223         # the argument prec has no effect
    6224         return self.new_gen(mathell(self.g, t0, prec))
     6195        pari_catch_sig_on()
     6196        cdef GEN t0 = P.toGEN(x)
     6197        return P.new_gen(mathell(self.g, t0, prec))
    62256198
    62266199    def ellisoncurve(self, x):
    62276200        """
     
    62456218            sage: e.ellisoncurve([0])
    62466219            True
    62476220        """
    6248         t0GEN(x)
    6249         pari_catch_sig_on()
     6221        pari_catch_sig_on()
     6222        cdef GEN t0 = P.toGEN(x)
    62506223        t = bool(oncurve(self.g, t0) == 1)
    6251         pari_catch_sig_off()
     6224        P.clear_stack()
    62526225        return t
    62536226
    62546227    def elllocalred(self, p):
     
    64026375            sage: e.elllocalred(3)
    64036376            [2, -10, [1, 96, 1, 316], 4]
    64046377        """
    6405         t0GEN(p)
    6406         pari_catch_sig_on()
    6407         return self.new_gen(elllocalred(self.g, t0))
     6378        pari_catch_sig_on()
     6379        cdef GEN t0 = P.toGEN(p)
     6380        return P.new_gen(elllocalred(self.g, t0))
    64086381
    64096382    def elllseries(self, s, A=1):
    64106383        """
     
    64446417            sage: e.elllseries(2.1, A=1.1)
    64456418            0.402838047956645
    64466419        """
    6447         t0GEN(s); t1GEN(A)
    6448         pari_catch_sig_on()
    6449         # the argument prec has no effect
    6450         return self.new_gen(elllseries(self.g, t0, t1, prec))
     6420        pari_catch_sig_on()
     6421        cdef GEN t0 = P.toGEN(s)
     6422        cdef GEN t1 = P.toGEN(A)
     6423        return P.new_gen(elllseries(self.g, t0, t1, prec))
    64516424
    64526425    def ellminimalmodel(self):
    64536426        """
     
    65146487            sage: e.ellorder([1,0])
    65156488            0
    65166489        """
    6517         t0GEN(x)
    6518         pari_catch_sig_on()
    6519         return self.new_gen(orderell(self.g, t0))
     6490        pari_catch_sig_on()
     6491        cdef GEN t0 = P.toGEN(x)
     6492        return P.new_gen(orderell(self.g, t0))
    65206493   
    65216494    def ellordinate(self, x):
    65226495        """
     
    65456518            sage: e.ellordinate('z+2*z^2+O(z^4)')
    65466519            [-2*z - 7*z^2 - 23*z^3 + O(z^4), -1 + 2*z + 7*z^2 + 23*z^3 + O(z^4)]
    65476520        """
    6548         t0GEN(x)
    6549         pari_catch_sig_on()
    6550         # the prec argument has no effect
    6551         return self.new_gen(ellordinate(self.g, t0, prec))
    6552 
    6553     def ellpointtoz(self, P, long precision=0):
    6554         """
    6555         e.ellpointtoz(P): return the complex number (in the fundamental
    6556         parallelogram) corresponding to the point P on the elliptic curve
     6521        pari_catch_sig_on()
     6522        cdef GEN t0 = P.toGEN(x)
     6523        return P.new_gen(ellordinate(self.g, t0, prec))
     6524
     6525    def ellpointtoz(self, pt, long precision=0):
     6526        """
     6527        e.ellpointtoz(pt): return the complex number (in the fundamental
     6528        parallelogram) corresponding to the point ``pt`` on the elliptic curve
    65576529        e, under the complex uniformization of e given by the Weierstrass
    65586530        p-function.
    65596531       
     
    65726544            sage: e.ellpointtoz([0])
    65736545            0
    65746546        """
    6575         t0GEN(P)
    6576         pari_catch_sig_on()
    6577         return self.new_gen(zell(self.g, t0, pbw(precision)))
     6547        pari_catch_sig_on()
     6548        cdef GEN t0 = P.toGEN(pt)
     6549        return P.new_gen(zell(self.g, t0, prec_bits_to_words(precision)))
    65786550
    65796551    def ellpow(self, z, n):
    65806552        """
     
    66346606            ....:     P0 = e.elladd(e.ellpow(P, cm_minpoly[0]), e.ellpow(P2, cm))
    66356607            ....:     assert(P0 == E(0))
    66366608        """
    6637         t0GEN(z); t1GEN(n)
    6638         pari_catch_sig_on()
    6639         return self.new_gen(powell(self.g, t0, t1))
     6609        pari_catch_sig_on()
     6610        cdef GEN t0 = P.toGEN(z)
     6611        cdef GEN t1 = P.toGEN(n)
     6612        return P.new_gen(powell(self.g, t0, t1))
    66406613   
    66416614    def ellrootno(self, p=1):
    66426615        """
     
    66696642            sage: e.ellrootno(1009)
    66706643            1
    66716644        """
    6672         cdef long rootno
    6673         t0GEN(p)
    6674         pari_catch_sig_on()
     6645        pari_catch_sig_on()
     6646        cdef GEN t0 = P.toGEN(p)
    66756647        rootno =  ellrootno(self.g, t0)
    6676         pari_catch_sig_off()
     6648        P.clear_stack()
    66776649        return rootno
    66786650
    66796651    def ellsigma(self, z, flag=0):
     
    66896661            sage: e.ellsigma(2+i)
    66906662            1.43490215804166 + 1.80307856719256*I
    66916663        """
    6692         t0GEN(z)
    6693         pari_catch_sig_on()
    6694         # the prec argument has no effect
    6695         return self.new_gen(ellsigma(self.g, t0, flag, prec))
     6664        pari_catch_sig_on()
     6665        cdef GEN t0 = P.toGEN(z)
     6666        return P.new_gen(ellsigma(self.g, t0, flag, prec))
    66966667
    66976668    def ellsub(self, z0, z1):
    66986669        """
     
    67166687            sage: e.ellsub([1,0], [-1,1])
    67176688            [0, 0]
    67186689        """
    6719         t0GEN(z0); t1GEN(z1)
    6720         pari_catch_sig_on()
    6721         return self.new_gen(subell(self.g, t0, t1))
     6690        pari_catch_sig_on()
     6691        cdef GEN t0 = P.toGEN(z0)
     6692        cdef GEN t1 = P.toGEN(z1)
     6693        return P.new_gen(subell(self.g, t0, t1))
    67226694
    67236695    def elltaniyama(self):
    67246696        pari_catch_sig_on()
    6725         return self.new_gen(taniyama(self.g))
     6697        return P.new_gen(taniyama(self.g))
    67266698
    67276699    def elltors(self, flag=0):
    67286700        """
     
    67996771            sage: e.ellzeta(i-1)
    68006772            -0.350122658523049 - 0.350122658523049*I
    68016773        """
    6802         t0GEN(z)
    6803         pari_catch_sig_on()
    6804         # the prec argument has no effect
    6805         return self.new_gen(ellzeta(self.g, t0, prec))
     6774        pari_catch_sig_on()
     6775        cdef GEN t0 = P.toGEN(z)
     6776        return P.new_gen(ellzeta(self.g, t0, prec))
    68066777
    68076778    def ellztopoint(self, z):
    68086779        """
     
    68346805            sage: e.ellztopoint(0)
    68356806            [0]
    68366807        """
    6837         t0GEN(z)
     6808        pari_catch_sig_on()
     6809        cdef GEN t0 = P.toGEN(z)
    68386810        try:
    68396811            dprec = prec_words_to_dec(z.precision())
    68406812        except AttributeError:
    68416813            dprec = prec
    6842         pari_catch_sig_on()
    6843         # the prec argument has no effect
    6844         return self.new_gen(pointell(self.g, t0, dprec))
     6814        return P.new_gen(pointell(self.g, t0, dprec))
    68456815
    68466816    def omega(self):
    68476817        """
     
    69126882        .. [PariUsers] User's Guide to PARI/GP,
    69136883           http://pari.math.u-bordeaux.fr/pub/pari/manuals/2.5.1/users.pdf
    69146884        """
    6915         cdef long n
    69166885        pari_catch_sig_on()
    69176886        n = bnfcertify(self.g)
    69186887        pari_catch_sig_off()
    69196888        return n
    69206889   
    69216890    def bnfinit(self, long flag=0, tech=None):
     6891        cdef GEN t0
     6892        pari_catch_sig_on()
    69226893        if tech is None:
    6923             pari_catch_sig_on()
    6924             return P.new_gen(bnfinit0(self.g, flag, <GEN>0, prec))
     6894            t0 = NULL
    69256895        else:
    6926             t0GEN(tech)
    6927             pari_catch_sig_on()
    6928             return P.new_gen(bnfinit0(self.g, flag, t0, prec))
     6896            t0 = P.toGEN(tech)
     6897        return P.new_gen(bnfinit0(self.g, flag, t0, prec))
    69296898   
    69306899    def bnfisintnorm(self, x):
    6931         t0GEN(x)
    6932         pari_catch_sig_on()
    6933         return self.new_gen(bnfisintnorm(self.g, t0))
     6900        pari_catch_sig_on()
     6901        cdef GEN t0 = P.toGEN(x)
     6902        return P.new_gen(bnfisintnorm(self.g, t0))
    69346903
    69356904    def bnfisnorm(self, x, long flag=0):
    6936         t0GEN(x)
    6937         pari_catch_sig_on()
    6938         return self.new_gen(bnfisnorm(self.g, t0, flag))
     6905        pari_catch_sig_on()
     6906        cdef GEN t0 = P.toGEN(x)
     6907        return P.new_gen(bnfisnorm(self.g, t0, flag))
    69396908
    69406909    def bnfisprincipal(self, x, long flag=1):
    6941         t0GEN(x)
    6942         pari_catch_sig_on()
    6943         return self.new_gen(bnfisprincipal0(self.g, t0, flag))
     6910        pari_catch_sig_on()
     6911        cdef GEN t0 = P.toGEN(x)
     6912        return P.new_gen(bnfisprincipal0(self.g, t0, flag))
    69446913
    69456914    def bnfnarrow(self):
    69466915        pari_catch_sig_on()
    6947         return self.new_gen(buchnarrow(self.g))
    6948 
    6949     def bnfsunit(bnf, S, long precision=0):
    6950         t0GEN(S)
    6951         pari_catch_sig_on()
    6952         return bnf.new_gen(bnfsunit(bnf.g, t0, pbw(precision)))
     6916        return P.new_gen(buchnarrow(self.g))
     6917
     6918    def bnfsunit(self, S, long precision=0):
     6919        pari_catch_sig_on()
     6920        cdef GEN t0 = P.toGEN(S)
     6921        return P.new_gen(bnfsunit(self.g, t0, prec_bits_to_words(precision)))
    69536922
    69546923    def bnfunit(self):
    69556924        pari_catch_sig_on()
    6956         return self.new_gen(bnf_get_fu(self.g))       
     6925        return P.new_gen(bnf_get_fu(self.g))
    69576926
    69586927    def bnfisunit(self, x):
    6959         t0GEN(x)
    6960         pari_catch_sig_on()
    6961         return self.new_gen(bnfisunit(self.g, t0))
     6928        pari_catch_sig_on()
     6929        cdef GEN t0 = P.toGEN(x)
     6930        return P.new_gen(bnfisunit(self.g, t0))
    69626931
    69636932    def bnrclassno(self, I):
    69646933        r"""
     
    69786947            sage: K.pari_bnf().bnrclassno(p._pari_bid_())
    69796948            3
    69806949        """
    6981         t0GEN(I)
    6982         pari_catch_sig_on()
    6983         return self.new_gen(bnrclassno(self.g, t0))
     6950        pari_catch_sig_on()
     6951        cdef GEN t0 = P.toGEN(I)
     6952        return P.new_gen(bnrclassno(self.g, t0))
    69846953
    69856954    def bnfissunit(self, sunit_data, x):
    6986         t0GEN(x)
    6987         t1GEN(sunit_data)
    6988         pari_catch_sig_on()
    6989         return self.new_gen(bnfissunit(self.g, t1, t0))
     6955        pari_catch_sig_on()
     6956        cdef GEN t0 = P.toGEN(x)
     6957        cdef GEN t1 = P.toGEN(sunit_data)
     6958        return P.new_gen(bnfissunit(self.g, t1, t0))
    69906959
    69916960    def dirzetak(self, n):
    6992         t0GEN(n)
    6993         pari_catch_sig_on()
    6994         return self.new_gen(dirzetak(self.g, t0))
     6961        pari_catch_sig_on()
     6962        cdef GEN t0 = P.toGEN(n)
     6963        return P.new_gen(dirzetak(self.g, t0))
    69956964
    69966965    def galoisapply(self, aut, x):
    6997         t0GEN(aut)
    6998         t1GEN(x)
    6999         pari_catch_sig_on()
    7000         return self.new_gen(galoisapply(self.g, t0, t1))
     6966        pari_catch_sig_on()
     6967        cdef GEN t0 = P.toGEN(aut)
     6968        cdef GEN t1 = P.toGEN(x)
     6969        return P.new_gen(galoisapply(self.g, t0, t1))
    70016970
    70026971    def galoisinit(self, den=None):
    70036972        """
    70046973        galoisinit(K{,den}): calculate Galois group of number field K; see PARI manual
    70056974        for meaning of den
    70066975        """
     6976        cdef GEN t0
     6977        pari_catch_sig_on()
    70076978        if den is None:
    7008             pari_catch_sig_on()
    7009             return self.new_gen(galoisinit(self.g, NULL))
     6979            t0 = NULL
    70106980        else:
    7011             t0GEN(den)
    7012             pari_catch_sig_on()
    7013             return self.new_gen(galoisinit(self.g, t0))
     6981            t0 = P.toGEN(den)
     6982        return P.new_gen(galoisinit(self.g, t0))
    70146983
    70156984    def galoispermtopol(self, perm):
    7016         t0GEN(perm)
    7017         pari_catch_sig_on()
    7018         return self.new_gen(galoispermtopol(self.g, t0))
     6985        pari_catch_sig_on()
     6986        cdef GEN t0 = P.toGEN(perm)
     6987        return P.new_gen(galoispermtopol(self.g, t0))
    70196988
    70206989    def galoisfixedfield(self, perm, long flag=0, v=-1):
    7021         t0GEN(perm);
    7022         pari_catch_sig_on()
    7023         return self.new_gen(galoisfixedfield(self.g, t0, flag, P.get_var(v)))
     6990        pari_catch_sig_on()
     6991        cdef GEN t0 = P.toGEN(perm)
     6992        return P.new_gen(galoisfixedfield(self.g, t0, flag, P.get_var(v)))
    70246993
    70256994    def idealred(self, I, vdir=0):
    7026         t0GEN(I); t1GEN(vdir)
    7027         pari_catch_sig_on()
    7028         return self.new_gen(idealred0(self.g, t0, t1 if vdir else NULL))
     6995        pari_catch_sig_on()
     6996        cdef GEN t0 = P.toGEN(I)
     6997        cdef GEN t1 = P.toGEN(vdir)
     6998        return P.new_gen(idealred0(self.g, t0, t1 if vdir else NULL))
    70296999
    70307000    def idealadd(self, x, y):
    7031         t0GEN(x); t1GEN(y)
    7032         pari_catch_sig_on()
    7033         return self.new_gen(idealadd(self.g, t0, t1))
     7001        pari_catch_sig_on()
     7002        cdef GEN t0 = P.toGEN(x)
     7003        cdef GEN t1 = P.toGEN(y)
     7004        return P.new_gen(idealadd(self.g, t0, t1))
    70347005
    70357006    def idealaddtoone(self, x, y):
    7036         t0GEN(x); t1GEN(y)
    7037         pari_catch_sig_on()
    7038         return self.new_gen(idealaddtoone0(self.g, t0, t1))
     7007        pari_catch_sig_on()
     7008        cdef GEN t0 = P.toGEN(x)
     7009        cdef GEN t1 = P.toGEN(y)
     7010        return P.new_gen(idealaddtoone0(self.g, t0, t1))
    70397011
    70407012    def idealappr(self, x, long flag=0):
    7041         t0GEN(x)
    7042         pari_catch_sig_on()
    7043         return self.new_gen(idealappr0(self.g, t0, flag))
     7013        pari_catch_sig_on()
     7014        cdef GEN t0 = P.toGEN(x)
     7015        return P.new_gen(idealappr0(self.g, t0, flag))
    70447016
    70457017    def idealcoprime(self, x, y):
    70467018        """
     
    70627034            sage: nf.idealcoprime(x, y)
    70637035            [5/43, 9/43, -1/43]~
    70647036        """
    7065         t0GEN(x); t1GEN(y)
    7066         pari_catch_sig_on()
    7067         return self.new_gen(idealcoprime(self.g, t0, t1))
     7037        pari_catch_sig_on()
     7038        cdef GEN t0 = P.toGEN(x)
     7039        cdef GEN t1 = P.toGEN(y)
     7040        return P.new_gen(idealcoprime(self.g, t0, t1))
    70687041
    70697042    def idealdiv(self, x, y, long flag=0):
    7070         t0GEN(x); t1GEN(y)
    7071         pari_catch_sig_on()
    7072         return self.new_gen(idealdiv0(self.g, t0, t1, flag))
     7043        pari_catch_sig_on()
     7044        cdef GEN t0 = P.toGEN(x)
     7045        cdef GEN t1 = P.toGEN(y)
     7046        return P.new_gen(idealdiv0(self.g, t0, t1, flag))
    70737047
    70747048    def idealfactor(self, x):
    7075         t0GEN(x)
    7076         pari_catch_sig_on()
    7077         return self.new_gen(idealfactor(self.g, t0))
     7049        pari_catch_sig_on()
     7050        cdef GEN t0 = P.toGEN(x)
     7051        return P.new_gen(idealfactor(self.g, t0))
    70787052
    70797053    def idealhnf(self, a, b=None):
    7080         t0GEN(a)
     7054        pari_catch_sig_on()
     7055        cdef GEN t0 = P.toGEN(a)
     7056        cdef GEN t1
    70817057        if b is None:
    7082             pari_catch_sig_on()
    7083             return self.new_gen(idealhnf(self.g, t0))
     7058            return P.new_gen(idealhnf(self.g, t0))
    70847059        else:
    7085             t1GEN(b)
    7086             pari_catch_sig_on()
    7087             return self.new_gen(idealhnf0(self.g, t0, t1))
     7060            t1 = P.toGEN(b)
     7061            return P.new_gen(idealhnf0(self.g, t0, t1))
    70887062
    70897063    def idealintersection(self, x, y):
    7090         t0GEN(x); t1GEN(y)
    7091         pari_catch_sig_on()
    7092         return self.new_gen(idealintersect(self.g, t0, t1))
     7064        pari_catch_sig_on()
     7065        cdef GEN t0 = P.toGEN(x)
     7066        cdef GEN t1 = P.toGEN(y)
     7067        return P.new_gen(idealintersect(self.g, t0, t1))
    70937068
    70947069    def ideallist(self, long bound, long flag = 4):
    70957070        """
     
    71467121            sage: nf.ideallog(x, bid)
    71477122            [25]~
    71487123        """
    7149         t0GEN(x); t1GEN(bid)
    7150         pari_catch_sig_on()
    7151         return self.new_gen(ideallog(self.g, t0, t1))
     7124        pari_catch_sig_on()
     7125        cdef GEN t0 = P.toGEN(x)
     7126        cdef GEN t1 = P.toGEN(bid)
     7127        return P.new_gen(ideallog(self.g, t0, t1))
    71527128
    71537129    def idealmul(self, x, y, long flag=0):
    7154         t0GEN(x); t1GEN(y)
    7155         pari_catch_sig_on()
     7130        pari_catch_sig_on()
     7131        cdef GEN t0 = P.toGEN(x)
     7132        cdef GEN t1 = P.toGEN(y)
    71567133        if flag == 0:
    7157             return self.new_gen(idealmul(self.g, t0, t1))
     7134            return P.new_gen(idealmul(self.g, t0, t1))
    71587135        else:
    7159             return self.new_gen(idealmulred(self.g, t0, t1))
     7136            return P.new_gen(idealmulred(self.g, t0, t1))
    71607137
    71617138    def idealnorm(self, x):
    7162         t0GEN(x)
    7163         pari_catch_sig_on()
    7164         return self.new_gen(idealnorm(self.g, t0))
     7139        pari_catch_sig_on()
     7140        cdef GEN t0 = P.toGEN(x)
     7141        return P.new_gen(idealnorm(self.g, t0))
    71657142
    71667143    def idealprimedec(nf, p):
    71677144        """
     
    71797156            sage: F[0].pr_get_p()
    71807157            5
    71817158        """
    7182         t0GEN(p)
    7183         pari_catch_sig_on()
    7184         return nf.new_gen(idealprimedec(nf.g, t0))
     7159        pari_catch_sig_on()
     7160        cdef GEN t0 = P.toGEN(p)
     7161        return P.new_gen(idealprimedec(nf.g, t0))
    71857162
    71867163    def idealstar(self, I, long flag=1):
    71877164        """
     
    72197196            sage: nf.idealstar(I)
    72207197            [[[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)]
    72217198        """
    7222         t0GEN(I)
    7223         pari_catch_sig_on()
    7224         return self.new_gen(idealstar0(self.g, t0, flag))
     7199        pari_catch_sig_on()
     7200        cdef GEN t0 = P.toGEN(I)
     7201        return P.new_gen(idealstar0(self.g, t0, flag))
    72257202
    72267203    def idealtwoelt(self, x, a=None):
    7227         t0GEN(x)
     7204        pari_catch_sig_on()
     7205        cdef GEN t0 = P.toGEN(x)
     7206        cdef GEN t1
    72287207        if a is None:
    7229             pari_catch_sig_on()
    7230             return self.new_gen(idealtwoelt0(self.g, t0, NULL))
     7208            return P.new_gen(idealtwoelt0(self.g, t0, NULL))
    72317209        else:
    7232             t1GEN(a)
    7233             pari_catch_sig_on()
    7234             return self.new_gen(idealtwoelt0(self.g, t0, t1))
     7210            t1 = P.toGEN(a)
     7211            return P.new_gen(idealtwoelt0(self.g, t0, t1))
    72357212
    72367213    def idealval(self, x, p):
    7237         cdef long v
    7238         t0GEN(x); t1GEN(p)
    7239         pari_catch_sig_on()
     7214        pari_catch_sig_on()
     7215        cdef GEN t0 = P.toGEN(x)
     7216        cdef GEN t1 = P.toGEN(p)
    72407217        v = idealval(self.g, t0, t1)
    7241         pari_catch_sig_off()
     7218        P.clear_stack()
    72427219        return v
    72437220
    72447221    def elementval(self, x, p):
    7245         cdef long v
    7246         t0GEN(x); t1GEN(p)
    7247         pari_catch_sig_on()
     7222        pari_catch_sig_on()
     7223        cdef GEN t0 = P.toGEN(x)
     7224        cdef GEN t1 = P.toGEN(p)
    72487225        v = nfval(self.g, t0, t1)
    7249         pari_catch_sig_off()
     7226        P.clear_stack()
    72507227        return v
    72517228
    72527229    def modreverse(self):
     
    72987275            sage: pari('x^3 - 17').nfbasis(flag = 2)
    72997276            [1, x, 1/3*x^2 - 1/3*x + 1/3]
    73007277        """
    7301         global t0
    7302         t0GEN(fa)
     7278        pari_catch_sig_on()
     7279        cdef GEN t0 = P.toGEN(fa)
    73037280        if typ(t0) != t_MAT:
    7304             t0 = <GEN>0
    7305         pari_catch_sig_on()
    7306         return self.new_gen(nfbasis0(self.g, flag, t0))
     7281            t0 = NULL
     7282        return P.new_gen(nfbasis0(self.g, flag, t0))
    73077283
    73087284    def nfbasis_d(self, long flag=0, fa=0):
    73097285        """
     
    73277303            sage: pari([-2,0,0,1]).Polrev().nfbasis_d()
    73287304            ([1, x, x^2], -108)
    73297305        """
    7330         global t0
     7306        pari_catch_sig_on()
    73317307        cdef GEN disc
    7332         t0GEN(fa)
     7308        cdef GEN t0 = P.toGEN(fa)
    73337309        if typ(t0) != t_MAT:
    7334             t0 = <GEN>0
    7335         pari_catch_sig_on()
    7336         B = self.new_gen_noclear(nfbasis(self.g, &disc, flag, t0))
    7337         D = self.new_gen(disc);
     7310            t0 = NULL
     7311        B = P.new_gen_noclear(nfbasis(self.g, &disc, flag, t0))
     7312        D = P.new_gen(disc);
    73387313        return B,D
    73397314
    73407315    def nfbasistoalg(nf, x):
     
    73677342            sage: Kpari.getattr('zk') * pari("[3/2, -5, 0]~")
    73687343            -5/3*y^2 + 5/3*y - 1/6
    73697344        """
    7370         t0GEN(x)
    7371         pari_catch_sig_on()
    7372         return nf.new_gen(basistoalg(nf.g, t0))
     7345        pari_catch_sig_on()
     7346        cdef GEN t0 = P.toGEN(x)
     7347        return P.new_gen(basistoalg(nf.g, t0))
    73737348
    73747349    def nfbasistoalg_lift(nf, x):
    73757350        r"""
     
    74007375            sage: Kpari.getattr('zk') * pari("[3/2, -5, 0]~")
    74017376            -5/3*y^2 + 5/3*y - 1/6
    74027377        """
    7403         t0GEN(x)
    7404         pari_catch_sig_on()
    7405         return nf.new_gen(gel(basistoalg(nf.g, t0), 2))
     7378        pari_catch_sig_on()
     7379        cdef GEN t0 = P.toGEN(x)
     7380        return P.new_gen(gel(basistoalg(nf.g, t0), 2))
    74067381
    74077382    def nfdisc(self, long flag=0, p=0):
    74087383        """
     
    74527427            sage: pari(k).nfeltdiveuc(pari(x), pari(y))
    74537428            [2, -2]~
    74547429        """
    7455         t0GEN(x); t1GEN(y)
    7456         pari_catch_sig_on()
    7457         return self.new_gen(nfdiveuc(self.g, t0, t1))
     7430        pari_catch_sig_on()
     7431        cdef GEN t0 = P.toGEN(x)
     7432        cdef GEN t1 = P.toGEN(y)
     7433        return P.new_gen(nfdiveuc(self.g, t0, t1))
    74587434
    74597435    def nfeltreduce(self, x, I):
    74607436        """
     
    74727448            sage: 12 - k(kp.nfeltreduce(12, I.pari_hnf())) in I
    74737449            True
    74747450        """
    7475         t0GEN(x); t1GEN(I)
    7476         pari_catch_sig_on()
    7477         return self.new_gen(nfreduce(self.g, t0, t1))
     7451        pari_catch_sig_on()
     7452        cdef GEN t0 = P.toGEN(x)
     7453        cdef GEN t1 = P.toGEN(I)
     7454        return P.new_gen(nfreduce(self.g, t0, t1))
    74787455
    74797456    def nffactor(self, x):
    7480         t0GEN(x)
    7481         pari_catch_sig_on()
    7482         return self.new_gen(nffactor(self.g, t0))
     7457        pari_catch_sig_on()
     7458        cdef GEN t0 = P.toGEN(x)
     7459        return P.new_gen(nffactor(self.g, t0))
    74837460
    74847461    def nfgenerator(self):
    74857462        f = self[0]
     
    75087485            sage: pari(K).nfhilbert(pari(t), pari(t+2), P.pari_prime())
    75097486            1
    75107487        """
    7511         cdef long r
    7512         t0GEN(a)
    7513         t1GEN(b)
     7488        pari_catch_sig_on()
     7489        cdef GEN t0 = P.toGEN(a)
     7490        cdef GEN t1 = P.toGEN(b)
     7491        cdef GEN t2
    75147492        if p:
    7515             t2GEN(p)
    7516             pari_catch_sig_on()
     7493            t2 = P.toGEN(p)
    75177494            r = nfhilbert0(self.g, t0, t1, t2)
    75187495        else:
    7519             pari_catch_sig_on()
    75207496            r = nfhilbert(self.g, t0, t1)
    75217497        P.clear_stack()
    75227498        return r
     
    75847560
    75857561        - Aly Deines (2012-09-19)   
    75867562        """
    7587         t0GEN(x)
    7588         pari_catch_sig_on()
    7589         return self.new_gen(nfhnf(self.g,t0))
    7590        
    7591    
     7563        pari_catch_sig_on()
     7564        cdef GEN t0 = P.toGEN(x)
     7565        return P.new_gen(nfhnf(self.g, t0))
    75927566
    75937567
    75947568    def nfinit(self, long flag=0, long precision=0):
     
    77157689        -  ``d`` - C long integer
    77167690        """
    77177691        pari_catch_sig_on()
    7718         return self.new_gen(nfsubfields(self.g, d))
     7692        return P.new_gen(nfsubfields(self.g, d))
    77197693
    77207694    def rnfcharpoly(self, T, a, v='x'):
    7721         t0GEN(T); t1GEN(a); t2GEN(v)
    7722         pari_catch_sig_on()
    7723         return self.new_gen(rnfcharpoly(self.g, t0, t1, gvar(t2)))
     7695        pari_catch_sig_on()
     7696        cdef GEN t0 = P.toGEN(T)
     7697        cdef GEN t1 = P.toGEN(a)
     7698        cdef GEN t2 = P.toGEN(v)
     7699        return P.new_gen(rnfcharpoly(self.g, t0, t1, gvar(t2)))
    77247700
    77257701    def rnfdisc(self, x):
    7726         t0GEN(x)
    7727         pari_catch_sig_on()
    7728         return self.new_gen(rnfdiscf(self.g, t0))
     7702        pari_catch_sig_on()
     7703        cdef GEN t0 = P.toGEN(x)
     7704        return P.new_gen(rnfdiscf(self.g, t0))
    77297705
    77307706    def rnfeltabstorel(self, x):
    7731         t0GEN(x)
    7732         pari_catch_sig_on()
    7733         return self.new_gen(rnfelementabstorel(self.g, t0))
     7707        pari_catch_sig_on()
     7708        cdef GEN t0 = P.toGEN(x)
     7709        return P.new_gen(rnfelementabstorel(self.g, t0))
    77347710
    77357711    def rnfeltreltoabs(self, x):
    7736         t0GEN(x)
    7737         pari_catch_sig_on()
    7738         return self.new_gen(rnfelementreltoabs(self.g, t0))
     7712        pari_catch_sig_on()
     7713        cdef GEN t0 = P.toGEN(x)
     7714        return P.new_gen(rnfelementreltoabs(self.g, t0))
    77397715
    77407716    def rnfequation(self, poly, long flag=0):
    7741         t0GEN(poly)
    7742         pari_catch_sig_on()
    7743         return self.new_gen(rnfequation0(self.g, t0, flag))
     7717        pari_catch_sig_on()
     7718        cdef GEN t0 = P.toGEN(poly)
     7719        return P.new_gen(rnfequation0(self.g, t0, flag))
    77447720
    77457721    def rnfidealabstorel(self, x):
    7746         t0GEN(x)
    7747         pari_catch_sig_on()
    7748         return self.new_gen(rnfidealabstorel(self.g, t0))
     7722        pari_catch_sig_on()
     7723        cdef GEN t0 = P.toGEN(x)
     7724        return P.new_gen(rnfidealabstorel(self.g, t0))
    77497725
    77507726    def rnfidealdown(self, x):
    77517727        r"""
     
    77687744            sage: rnf.rnfidealdown(P)
    77697745            [2, 0; 0, 2]
    77707746        """
    7771         t0GEN(x)
    7772         pari_catch_sig_on()
    7773         return self.new_gen(rnfidealdown(self.g, t0))
     7747        pari_catch_sig_on()
     7748        cdef GEN t0 = P.toGEN(x)
     7749        return P.new_gen(rnfidealdown(self.g, t0))
    77747750
    77757751    def rnfidealhnf(self, x):
    7776         t0GEN(x)
    7777         pari_catch_sig_on()
    7778         return self.new_gen(rnfidealhermite(self.g, t0))
     7752        pari_catch_sig_on()
     7753        cdef GEN t0 = P.toGEN(x)
     7754        return P.new_gen(rnfidealhermite(self.g, t0))
    77797755
    77807756    def rnfidealnormrel(self, x):
    7781         t0GEN(x)
    7782         pari_catch_sig_on()
    7783         return self.new_gen(rnfidealnormrel(self.g, t0))
     7757        pari_catch_sig_on()
     7758        cdef GEN t0 = P.toGEN(x)
     7759        return P.new_gen(rnfidealnormrel(self.g, t0))
    77847760
    77857761    def rnfidealreltoabs(self, x):
    7786         t0GEN(x)
    7787         pari_catch_sig_on()
    7788         return self.new_gen(rnfidealreltoabs(self.g, t0))
     7762        pari_catch_sig_on()
     7763        cdef GEN t0 = P.toGEN(x)
     7764        return P.new_gen(rnfidealreltoabs(self.g, t0))
    77897765
    77907766    def rnfidealtwoelt(self, x):
    7791         t0GEN(x)
    7792         pari_catch_sig_on()
    7793         return self.new_gen(rnfidealtwoelement(self.g, t0))
     7767        pari_catch_sig_on()
     7768        cdef GEN t0 = P.toGEN(x)
     7769        return P.new_gen(rnfidealtwoelement(self.g, t0))
    77947770
    77957771    def rnfinit(self, poly):
    77967772        """
     
    78047780            sage: g = x^5 - x^2 + y
    78057781            sage: L = K.rnfinit(g)
    78067782        """
    7807         t0GEN(poly)
    7808         pari_catch_sig_on()
     7783        pari_catch_sig_on()
     7784        cdef GEN t0 = P.toGEN(poly)
    78097785        return P.new_gen(rnfinit(self.g, t0))
    78107786
    78117787    def rnfisfree(self, poly):
    7812         t0GEN(poly)
    7813         pari_catch_sig_on()
     7788        pari_catch_sig_on()
     7789        cdef GEN t0 = P.toGEN(poly)
    78147790        r = rnfisfree(self.g, t0)
    7815         pari_catch_sig_off()
     7791        P.clear_stack()
    78167792        return r
    78177793
    78187794    def quadhilbert(self):
     
    78617837            2/15
    78627838        """
    78637839        pari_catch_sig_on()
    7864         return self.new_gen(content(self.g))
     7840        return P.new_gen(content(self.g))
    78657841
    78667842    def deriv(self, v=-1):
    78677843        pari_catch_sig_on()
    7868         return self.new_gen(deriv(self.g, self.get_var(v)))
     7844        return P.new_gen(deriv(self.g, P.get_var(v)))
    78697845
    78707846    def eval(self, x):
    7871         t0GEN(x)
    7872         pari_catch_sig_on()
    7873         return self.new_gen(poleval(self.g, t0))
     7847        pari_catch_sig_on()
     7848        cdef GEN t0 = P.toGEN(x)
     7849        return P.new_gen(poleval(self.g, t0))
    78747850
    78757851    def __call__(self, x):
    78767852        return self.eval(x)
     
    78897865            sage: pari(x^2 - 2).factornf(K.pari_polynomial("a"))
    78907866            [x + Mod(-4*a, 8*a^2 - 1), 1; x + Mod(4*a, 8*a^2 - 1), 1]
    78917867        """
    7892         t0GEN(t)
    7893         pari_catch_sig_on()
    7894         return self.new_gen(polfnf(self.g, t0))
     7868        pari_catch_sig_on()
     7869        cdef GEN t0 = P.toGEN(t)
     7870        return P.new_gen(polfnf(self.g, t0))
    78957871
    78967872    def factorpadic(self, p, long r=20, long flag=0):
    78977873        """
     
    78997875        polynomial x to precision r. flag is optional and may be set to 0
    79007876        (use round 4) or 1 (use Buchmann-Lenstra)
    79017877        """
    7902         t0GEN(p)
    7903         pari_catch_sig_on()
    7904         return self.new_gen(factorpadic0(self.g, t0, r, flag))
     7878        pari_catch_sig_on()
     7879        cdef GEN t0 = P.toGEN(p)
     7880        return P.new_gen(factorpadic0(self.g, t0, r, flag))
    79057881
    79067882    def factormod(self, p, long flag=0):
    79077883        """
     
    79107886        simple factormod, same except that only the degrees of the
    79117887        irreducible factors are given.
    79127888        """
    7913         t0GEN(p)
    7914         pari_catch_sig_on()
    7915         return self.new_gen(factormod0(self.g, t0, flag))
     7889        pari_catch_sig_on()
     7890        cdef GEN t0 = P.toGEN(p)
     7891        return P.new_gen(factormod0(self.g, t0, flag))
    79167892
    79177893    def intformal(self, y=-1):
    79187894        """
     
    79207896        variable of y, or to the main variable of x if y is omitted
    79217897        """
    79227898        pari_catch_sig_on()
    7923         return self.new_gen(integ(self.g, self.get_var(y)))
     7899        return P.new_gen(integ(self.g, P.get_var(y)))
    79247900
    79257901    def padicappr(self, a):
    79267902        """
    79277903        x.padicappr(a): p-adic roots of the polynomial x congruent to a mod
    79287904        p
    79297905        """
    7930         t0GEN(a)
    7931         pari_catch_sig_on()
    7932         return self.new_gen(padicappr(self.g, t0))
     7906        pari_catch_sig_on()
     7907        cdef GEN t0 = P.toGEN(a)
     7908        return P.new_gen(padicappr(self.g, t0))
    79337909
    79347910    def newtonpoly(self, p):
    79357911        """
     
    79427918            sage: x.newtonpoly(3)
    79437919            [1, 1, -1/3, -1/3, -1/3, -1/3, -1/3, -1/3]
    79447920        """
    7945         t0GEN(p)
    7946         pari_catch_sig_on()
    7947         return self.new_gen(newtonpoly(self.g, t0))
     7921        pari_catch_sig_on()
     7922        cdef GEN t0 = P.toGEN(p)
     7923        return P.new_gen(newtonpoly(self.g, t0))
    79487924
    79497925    def polcoeff(self, long n, var=-1):
    79507926        """
     
    79637939            x
    79647940        """
    79657941        pari_catch_sig_on()
    7966         return self.new_gen(polcoeff0(self.g, n, self.get_var(var)))
     7942        return P.new_gen(polcoeff0(self.g, n, P.get_var(var)))
    79677943
    79687944    def polcompositum(self, pol2, long flag=0):
    7969         t0GEN(pol2)
    7970         pari_catch_sig_on()
    7971         return self.new_gen(polcompositum0(self.g, t0, flag))
     7945        pari_catch_sig_on()
     7946        cdef GEN t0 = P.toGEN(pol2)
     7947        return P.new_gen(polcompositum0(self.g, t0, flag))
    79727948
    79737949    def poldegree(self, var=-1):
    79747950        """
    79757951        f.poldegree(var=x): Return the degree of this polynomial.
    79767952        """
    79777953        pari_catch_sig_on()
    7978         n = poldegree(self.g, self.get_var(var))
     7954        n = poldegree(self.g, P.get_var(var))
    79797955        pari_catch_sig_off()
    79807956        return n
    79817957
     
    80187994            sage: nf.nfgaloisconj()
    80197995            [-x, x]~
    80207996        """
    8021         global t0
     7997        pari_catch_sig_on()
     7998        cdef GEN t0
    80227999        if denom is not None:
    8023             t0GEN(denom)
     8000            t0 = P.toGEN(denom)
    80248001        else:
    80258002            t0 = NULL
    8026         pari_catch_sig_on()
    8027         return self.new_gen(galoisconj0(self.g, flag, t0, pbw(precision)))
     8003        return P.new_gen(galoisconj0(self.g, flag, t0, prec_bits_to_words(precision)))
    80288004
    80298005    def nfroots(self, poly):
    80308006        r"""
     
    80448020            sage: nf.nfroots(y^4 + 2)
    80458021            [Mod(-zz, zz^4 + 2), Mod(zz, zz^4 + 2)]
    80468022        """
    8047         t0GEN(poly)
    8048         pari_catch_sig_on()
    8049         return self.new_gen(nfroots(self.g, t0))
     8023        pari_catch_sig_on()
     8024        cdef GEN t0 = P.toGEN(poly)
     8025        return P.new_gen(nfroots(self.g, t0))
    80508026       
    80518027    def polhensellift(self, y, p, long e):
    80528028        """
     
    80548030        modulo p to a factorization modulo `p^e` using Hensel lift.
    80558031        The factors in y must be pairwise relatively prime modulo p.
    80568032        """
    8057         t0GEN(y)
    8058         t1GEN(p)
    8059         pari_catch_sig_on()
    8060         return self.new_gen(polhensellift(self.g, t0, t1, e))
     8033        pari_catch_sig_on()
     8034        cdef GEN t0 = P.toGEN(y)
     8035        cdef GEN t1 = P.toGEN(p)
     8036        return P.new_gen(polhensellift(self.g, t0, t1, e))
    80618037
    80628038    def polisirreducible(self):
    80638039        """
     
    80768052        variable v otherwise
    80778053        """
    80788054        pari_catch_sig_on()
    8079         return self.new_gen(pollead(self.g, self.get_var(v)))
     8055        return P.new_gen(pollead(self.g, P.get_var(v)))
    80808056
    80818057    def polrecip(self):
    80828058        pari_catch_sig_on()
    8083         return self.new_gen(polrecip(self.g))
     8059        return P.new_gen(polrecip(self.g))
    80848060   
    80858061    def polred(self, flag=0, fa=None):
     8062        pari_catch_sig_on()
     8063        cdef GEN t0
    80868064        if fa is None:
    8087             pari_catch_sig_on()
    8088             return self.new_gen(polred0(self.g, flag, NULL))
     8065            t0 = NULL
    80898066        else:
    8090             t0GEN(fa)
    8091             pari_catch_sig_on()
    8092             return self.new_gen(polred0(self.g, flag, t0))
     8067            t0 = P.toGEN(fa)
     8068        return P.new_gen(polred0(self.g, flag, t0))
    80938069
    80948070    def polredabs(self, flag=0):
    80958071        pari_catch_sig_on()
    8096         return self.new_gen(polredabs0(self.g, flag))
     8072        return P.new_gen(polredabs0(self.g, flag))
    80978073
    80988074    def polredbest(self, flag=0):
    80998075        pari_catch_sig_on()
    8100         return self.new_gen(polredbest(self.g, flag))
     8076        return P.new_gen(polredbest(self.g, flag))
    81018077
    81028078    def polresultant(self, y, var=-1, flag=0):
    8103         t0GEN(y)
    8104         pari_catch_sig_on()
    8105         return self.new_gen(polresultant0(self.g, t0, self.get_var(var), flag))
     8079        pari_catch_sig_on()
     8080        t0 = P.toGEN(y)
     8081        return P.new_gen(polresultant0(self.g, t0, P.get_var(var), flag))
    81068082
    81078083    def polroots(self, flag=0, precision=0):
    81088084        """
     
    81118087        by Gourdon, or 1: uses a modified Newton method.
    81128088        """
    81138089        pari_catch_sig_on()
    8114         return self.new_gen(roots0(self.g, flag, pbw(precision)))
     8090        return P.new_gen(roots0(self.g, flag, prec_bits_to_words(precision)))
    81158091   
    81168092    def polrootsmod(self, p, flag=0):
    8117         t0GEN(p)
    8118         pari_catch_sig_on()
    8119         return self.new_gen(rootmod0(self.g, t0, flag))
     8093        pari_catch_sig_on()
     8094        cdef GEN t0 = P.toGEN(p)
     8095        return P.new_gen(rootmod0(self.g, t0, flag))
    81208096
    81218097    def polrootspadic(self, p, r=20):
    8122         t0GEN(p)
    8123         pari_catch_sig_on()
    8124         return self.new_gen(rootpadic(self.g, t0, r))
     8098        pari_catch_sig_on()
     8099        cdef GEN t0 = P.toGEN(p)
     8100        return P.new_gen(rootpadic(self.g, t0, r))
    81258101
    81268102    def polrootspadicfast(self, p, r=20):
    8127         t0GEN(p)
    8128         pari_catch_sig_on()
    8129         return self.new_gen(rootpadicfast(self.g, t0, r))
     8103        pari_catch_sig_on()
     8104        cdef GEN t0 = P.toGEN(p)
     8105        return P.new_gen(rootpadicfast(self.g, t0, r))
    81308106
    81318107    def polsturm(self, a, b):
    8132         t0GEN(a)
    8133         t1GEN(b)
    8134         pari_catch_sig_on()
     8108        pari_catch_sig_on()
     8109        cdef GEN t0 = P.toGEN(a)
     8110        cdef GEN t1 = P.toGEN(b)
    81358111        n = sturmpart(self.g, t0, t1)
    8136         pari_catch_sig_off()
     8112        P.clear_stack()
    81378113        return n
    81388114
    81398115    def polsturm_full(self):
     
    81438119        return n
    81448120
    81458121    def polsylvestermatrix(self, g):
    8146         t0GEN(g)
    8147         pari_catch_sig_on()
    8148         return self.new_gen(sylvestermatrix(self.g, t0))
     8122        pari_catch_sig_on()
     8123        cdef GEN t0 = P.toGEN(g)
     8124        return P.new_gen(sylvestermatrix(self.g, t0))
    81498125
    81508126    def polsym(self, long n):
    81518127        pari_catch_sig_on()
    8152         return self.new_gen(polsym(self.g, n))
     8128        return P.new_gen(polsym(self.g, n))
    81538129
    81548130    def serconvol(self, g):
    8155         t0GEN(g)
    8156         pari_catch_sig_on()
    8157         return self.new_gen(convol(self.g, t0))
     8131        pari_catch_sig_on()
     8132        cdef GEN t0 = P.toGEN(g)
     8133        return P.new_gen(convol(self.g, t0))
    81588134
    81598135    def serlaplace(self):
    81608136        pari_catch_sig_on()
    8161         return self.new_gen(laplace(self.g))
     8137        return P.new_gen(laplace(self.g))
    81628138
    81638139    def serreverse(self):
    81648140        """
     
    81798155            x + O(x^4)
    81808156        """
    81818157        pari_catch_sig_on()
    8182         return self.new_gen(recip(self.g))
     8158        return P.new_gen(recip(self.g))
    81838159   
    81848160    def thueinit(self, flag=0):
    81858161        pari_catch_sig_on()
    8186         return self.new_gen(thueinit(self.g, flag, prec))
     8162        return P.new_gen(thueinit(self.g, flag, prec))
    81878163
    81888164
    81898165    def rnfisnorminit(self, polrel, long flag=2):
    8190         t0GEN(polrel)
    8191         pari_catch_sig_on()
    8192         return self.new_gen(rnfisnorminit(self.g, t0, flag))
     8166        pari_catch_sig_on()
     8167        cdef GEN t0 = P.toGEN(polrel)
     8168        return P.new_gen(rnfisnorminit(self.g, t0, flag))
    81938169
    81948170    def rnfisnorm(self, T, long flag=0):
    8195         t0GEN(T)
    8196         pari_catch_sig_on()
    8197         return self.new_gen(rnfisnorm(t0, self.g, flag))
     8171        pari_catch_sig_on()
     8172        cdef GEN t0 = P.toGEN(T)
     8173        return P.new_gen(rnfisnorm(t0, self.g, flag))
    81988174
    81998175    ###########################################
    82008176    # 8: Vectors, matrices, LINEAR ALGEBRA and sets
     
    82148190           This function uses the PARI row and column indexing, so the
    82158191           first row or column is indexed by 1 instead of 0.
    82168192        """
    8217         t0GEN(y)
     8193        pari_catch_sig_on()
     8194        cdef GEN t0 = P.toGEN(y)
     8195        cdef GEN t1
    82188196        if z is None:
    8219             pari_catch_sig_on()
    82208197            return P.new_gen(shallowextract(self.g, t0))
    82218198        else:
    8222             t1GEN(z)
    8223             pari_catch_sig_on()
     8199            t1 = P.toGEN(z)
    82248200            return P.new_gen(extract0(self.g, t0, t1))
    82258201
    82268202    def ncols(self):
     
    83288304        robust, slower implementation, valid for non integral quadratic
    83298305        forms.
    83308306        """
    8331         t0GEN(B)
    8332         t1GEN(max)
    8333         pari_catch_sig_on()
    8334         return self.new_gen(qfminim0(self.g,t0,t1,flag,precdl))
     8307        pari_catch_sig_on()
     8308        cdef GEN t0 = P.toGEN(B)
     8309        cdef GEN t1 = P.toGEN(max)
     8310        return P.new_gen(qfminim0(self.g, t0, t1, flag, precdl))
    83358311
    83368312    def qfrep(self, B, long flag=0):
    83378313        """
     
    83408316        digits of flag mean 1: count vectors of even norm from 1 to 2B, 2:
    83418317        return a t_VECSMALL instead of a t_VEC.
    83428318        """
    8343         t0GEN(B)
    8344         pari_catch_sig_on()
    8345         return self.new_gen(qfrep0(self.g,t0,flag))
     8319        pari_catch_sig_on()
     8320        cdef GEN t0 = P.toGEN(B)
     8321        return P.new_gen(qfrep0(self.g, t0, flag))
    83468322
    83478323    def matsolve(self, B):
    83488324        """
     
    83678343            sage: pari('[1,1;1,-1]').matsolve(pari('[1;0]'))
    83688344            [1/2; 1/2]
    83698345        """
    8370         t0GEN(B)
    8371         pari_catch_sig_on()
    8372         return self.new_gen(gauss(self.g,t0))
     8346        pari_catch_sig_on()
     8347        cdef GEN t0 = P.toGEN(B)
     8348        return P.new_gen(gauss(self.g, t0))
    83738349   
    83748350    def matsolvemod(self, D, B, long flag = 0):
    83758351        r"""
     
    84138389            sage: M2.matsolvemod(9, pari('[2,45]~'), 1)
    84148390            [[1, 1]~, [-1, -4; 1, -5]]
    84158391        """
    8416         t0GEN(D)
    8417         t1GEN(B)
    8418         pari_catch_sig_on()
    8419         return self.new_gen(matsolvemod0(self.g, t0, t1, flag))
     8392        pari_catch_sig_on()
     8393        cdef GEN t0 = P.toGEN(D)
     8394        cdef GEN t1 = P.toGEN(B)
     8395        return P.new_gen(matsolvemod0(self.g, t0, t1, flag))
    84208396   
    84218397    def matker(self, long flag=0):
    84228398        """
     
    85638539            sage: pari(M).mathnfmod(12)
    85648540            [1, 0, 0; 0, 2, 0; 0, 0, 6]
    85658541        """
    8566         t0GEN(d)
    8567         pari_catch_sig_on()
    8568         return self.new_gen(hnfmod(self.g, t0))
     8542        pari_catch_sig_on()
     8543        cdef GEN t0 = P.toGEN(d)
     8544        return P.new_gen(hnfmod(self.g, t0))
    85698545
    85708546    def mathnfmodid(self, d):
    85718547        """
     
    85928568            sage: pari(M).mathnfmod(6)
    85938569            [1, 0, 0; 0, 1, 0; 0, 0, 6]
    85948570        """
    8595         t0GEN(d)
    8596         pari_catch_sig_on()
    8597         return self.new_gen(hnfmodid(self.g, t0))
     8571        pari_catch_sig_on()
     8572        cdef GEN t0 = P.toGEN(d)
     8573        return P.new_gen(hnfmodid(self.g, t0))
    85988574
    85998575    def matsnf(self, flag=0):
    86008576        """
     
    87018677            PariError: sorry, factor for general polynomials is not yet implemented
    87028678        """
    87038679        cdef int r
     8680        cdef GEN t0
    87048681        cdef GEN cutoff
    87058682        if limit == -1 and typ(self.g) == t_INT and proof:
    87068683            pari_catch_sig_on()
     
    87228699    ###########################################
    87238700
    87248701    def hilbert(x, y, p):
    8725         cdef long ret
    8726         t0GEN(y)
    8727         t1GEN(p)
    8728         pari_catch_sig_on()
     8702        pari_catch_sig_on()
     8703        cdef GEN t0 = P.toGEN(y)
     8704        cdef GEN t1 = P.toGEN(p)
    87298705        ret = hilbert0(x.g, t0, t1)
    8730         pari_catch_sig_off()
     8706        P.clear_stack()
    87318707        return ret
    87328708       
    87338709    def chinese(self, y):
    8734         t0GEN(y)
    8735         pari_catch_sig_on()
     8710        pari_catch_sig_on()
     8711        cdef GEN t0 = P.toGEN(y)
    87368712        return P.new_gen(chinese(self.g, t0))
    87378713
    87388714    def order(self):
     
    88678843            sage: f.subst(x, "xyz")^2
    88688844            xyz^6 + 34*xyz^4 + 6*xyz^3 + 289*xyz^2 + 102*xyz + 9
    88698845        """
    8870         cdef long n
    8871         n = P.get_var(var)
    8872         t0GEN(z)
    8873         pari_catch_sig_on()
     8846        pari_catch_sig_on()
     8847        cdef long n = P.get_var(var)
     8848        cdef GEN t0 = P.toGEN(z)
    88748849        return P.new_gen(gsubst(self.g, n, t0))
    88758850
    88768851    def substpol(self, y, z):
    8877         t0GEN(y)
    8878         t1GEN(z)
    8879         pari_catch_sig_on()
    8880         return self.new_gen(gsubstpol(self.g, t0, t1))
     8852        pari_catch_sig_on()
     8853        cdef GEN t0 = P.toGEN(y)
     8854        cdef GEN t1 = P.toGEN(z)
     8855        return P.new_gen(gsubstpol(self.g, t0, t1))
    88818856
    88828857    def nf_subst(self, z):
    88838858        """
     
    89168891            sage: Lpari.bnf_get_cyc()  # We still have a bnf after substituting
    89178892            [2]
    89188893        """
    8919         cdef GEN nf = self.get_nf()
    8920         t0GEN(z)
    8921         pari_catch_sig_on()
    8922         return P.new_gen(gsubst(self.g, nf_get_varn(nf), t0))
     8894        pari_catch_sig_on()
     8895        cdef gen nf = self.get_nf()
     8896        cdef GEN t0 = P.toGEN(z)
     8897        return P.new_gen(gsubst(self.g, nf_get_varn(nf.g), t0))
    89238898
    89248899    def taylor(self, v=-1):
    89258900        pari_catch_sig_on()
    8926         return self.new_gen(tayl(self.g, self.get_var(v), precdl))
     8901        return P.new_gen(tayl(self.g, P.get_var(v), precdl))
    89278902
    89288903    def thue(self, rhs, ne):
    8929         t0GEN(rhs)
    8930         t1GEN(ne)
    8931         pari_catch_sig_on()
    8932         return self.new_gen(thue(self.g, t0, t1))
     8904        pari_catch_sig_on()
     8905        cdef GEN t0 = P.toGEN(rhs)
     8906        cdef GEN t1 = P.toGEN(ne)
     8907        return P.new_gen(thue(self.g, t0, t1))
    89338908
    89348909    def charpoly(self, var=-1, flag=0):
    89358910        """
     
    89438918
    89448919
    89458920    def kronecker(gen self, y):
    8946         t0GEN(y)
    89478921        pari_catch_sig_on()       
     8922        cdef GEN t0 = P.toGEN(y)
    89488923        return P.new_gen(gkronecker(self.g, t0))
    89498924
    89508925
     
    90138988        P(self[i]) = ya[i] for all i). Also return an error estimate on the
    90148989        returned value.
    90158990        """
    9016         t0GEN(ya)
    9017         t1GEN(x)
     8991        pari_catch_sig_on()
     8992        cdef GEN t0 = P.toGEN(ya)
     8993        cdef GEN t1 = P.toGEN(x)
    90188994        cdef GEN dy, g
    9019         pari_catch_sig_on()
    90208995        g = polint(self.g, t0, t1, &dy)
    9021         dif = self.new_gen_noclear(dy)
    9022         return self.new_gen(g), dif
     8996        dif = P.new_gen_noclear(dy)
     8997        return P.new_gen(g), dif
    90238998
    90248999    def algdep(self, long n):
    90259000        """
     
    90379012            210
    90389013        """
    90399014        pari_catch_sig_on()
    9040         return self.new_gen(algdep(self.g, n))
     9015        return P.new_gen(algdep(self.g, n))
    90419016
    90429017    def concat(self, y):
    9043         t0GEN(y)
    9044         pari_catch_sig_on()
    9045         return self.new_gen(concat(self.g, t0))
     9018        pari_catch_sig_on()
     9019        cdef GEN t0 = P.toGEN(y)
     9020        return P.new_gen(concat(self.g, t0))
    90469021
    90479022    def lindep(self, flag=0):
    90489023        pari_catch_sig_on()
    9049         return self.new_gen(lindep0(self.g, flag))
     9024        return P.new_gen(lindep0(self.g, flag))
    90509025
    90519026    def listinsert(self, obj, long n):
    9052         t0GEN(obj)
    9053         pari_catch_sig_on()
    9054         return self.new_gen(listinsert(self.g, t0, n))
     9027        pari_catch_sig_on()
     9028        cdef GEN t0 = P.toGEN(obj)
     9029        return P.new_gen(listinsert(self.g, t0, n))
    90559030
    90569031    def listput(self, obj, long n):
    9057         t0GEN(obj)
    9058         pari_catch_sig_on()
    9059         return self.new_gen(listput(self.g, t0, n))
     9032        pari_catch_sig_on()
     9033        cdef GEN t0 = P.toGEN(obj)
     9034        return P.new_gen(listput(self.g, t0, n))
    90609035
    90619036
    90629037
     
    91679142            sage: E.ellwp(1, flag=1)
    91689143            [13.9658695257485 + 0.E-18*I, 50.5619300880073 ... E-18*I]
    91699144        """
    9170         t0GEN(z)
    9171         pari_catch_sig_on()
     9145        pari_catch_sig_on()
     9146        cdef GEN t0 = P.toGEN(z)
    91729147        cdef long dprec
    91739148        dprec = gprecision(t0)
    91749149        if dprec:
    91759150            dprec = prec_words_to_dec(dprec)
    91769151        else:
    91779152            dprec = prec
    9178         return self.new_gen(ellwp0(self.g, t0, flag, n+2, dprec))
     9153        return P.new_gen(ellwp0(self.g, t0, flag, n+2, dprec))
    91799154
    91809155    def ellchangepoint(self, y):
    91819156        """
     
    91989173            sage: f.ellisoncurve([-1,4])
    91999174            True
    92009175        """
    9201         t0GEN(y)
    9202         pari_catch_sig_on()
    9203         return self.new_gen(ellchangepoint(self.g, t0))
     9176        pari_catch_sig_on()
     9177        cdef GEN t0 = P.toGEN(y)
     9178        return P.new_gen(ellchangepoint(self.g, t0))
    92049179
    92059180    def debug(gen self, long depth = -1):
    92069181        r"""
     
    94469421        """
    94479422        return int(self.default('debug'))
    94489423
    9449     cdef GEN toGEN(self, x, int i) except NULL:
    9450         cdef gen _x
    9451         if PY_TYPE_CHECK(x, gen):
    9452             _x = x
    9453             return _x.g
    9454 
    9455         t0heap[i] = self(x)
    9456         _x = t0heap[i]
    9457         return _x.g
    9458 
    94599424    def set_real_precision(self, long n):
    94609425        """
    94619426        Sets the PARI default real precision.
     
    94979462
    94989463    def get_series_precision(self):
    94999464        return precdl
    9500        
    9501 
    9502     ###########################################
    9503     # Create a gen from a GEN object.
    9504     # This *steals* a reference to the GEN, as it
    9505     # frees the memory the GEN occupied.
    9506     ###########################################
     9465
     9466    cdef void clear_stack(self):
     9467        """
     9468        Call ``pari_catch_sig_off()``, and clear the entire PARI stack
     9469        if we are leaving the outermost ``pari_catch_sig_on() ...
     9470        pari_catch_sig_off()`` block.
     9471
     9472        """
     9473        global mytop, avma
     9474        if _signals.sig_on_count <= 1:
     9475            avma = mytop
     9476        pari_catch_sig_off()
    95079477
    95089478    cdef gen new_gen(self, GEN x):
    95099479        """
    9510         Create a new gen, then free the \*entire\* stack and call
    9511         pari_catch_sig_off().
    9512         """
    9513         cdef gen g
    9514         g = _new_gen(x)
    9515         global mytop, avma
    9516         avma = mytop
    9517         pari_catch_sig_off()
     9480        Create a new gen wrapping `x`, then call ``clear_stack()``.
     9481        """
     9482        cdef gen g = _new_gen(x)
     9483        self.clear_stack()
    95189484        return g
    95199485
    9520     cdef object new_gen_to_string(self, GEN x):
    9521         """
    9522         Converts a gen to a Python string, free the \*entire\* stack and call
    9523         pari_catch_sig_off(). This is meant to be used in place of new_gen().
    9524         """
    9525         cdef char* c
    9526         cdef int n
    9527         c = GENtostr(x)
    9528         s = str(c)
    9529         pari_free(c)
    9530         global mytop, avma
    9531         avma = mytop
    9532         pari_catch_sig_off()
    9533         return s
    9534 
    9535     cdef void clear_stack(self):
    9536         """
    9537         Clear the entire PARI stack and call pari_catch_sig_off().
    9538         """
    9539         global mytop, avma
    9540         avma = mytop
    9541         pari_catch_sig_off()
    9542 
    9543     cdef void set_mytop_to_avma(self):
    9544         global mytop, avma
    9545         mytop = avma
    9546 
    95479486    cdef gen new_gen_noclear(self, GEN x):
    95489487        """
    95499488        Create a new gen, but don't free any memory on the stack and don't
     
    97249663        """
    97259664        Create a new complex number, initialized from re and im.
    97269665        """
    9727         t0GEN(re)
    9728         t1GEN(im)
    9729         cdef GEN cp
    9730         pari_catch_sig_on()
    9731         cp = cgetg(3, t_COMPLEX)
     9666        pari_catch_sig_on()
     9667        cdef GEN cp = cgetg(3, t_COMPLEX)
     9668        cdef GEN t0 = self.toGEN(re)
     9669        cdef GEN t1 = self.toGEN(im)
    97329670        set_gel(cp, 1, t0)
    97339671        set_gel(cp, 2, t1)
    97349672        return self.new_gen(cp)
     
    97939731
    97949732        See :func:`pari` for more examples.
    97959733        """
    9796         cdef int length, i
    9797         cdef gen v
    9798 
    9799         late_import()
    9800        
     9734        cdef GEN g
    98019735        if isinstance(s, gen):
    98029736            return s
    9803         elif isinstance(s, Integer):
    9804             return self.new_gen_from_mpz_t(<void *>s + mpz_t_offset)
    98059737        elif PyObject_HasAttrString(s, "_pari_"):
    98069738            return s._pari_()
     9739        else:
     9740            pari_catch_sig_on()
     9741            g = self.toGEN(s)
     9742            if g == gnil:
     9743                self.clear_stack()
     9744                return None
     9745            else:
     9746                return self.new_gen(g)
     9747
     9748    cdef GEN toGEN(self, s) except NULL:
     9749        """
     9750        Convert `s` to a GEN.
     9751
     9752        One should call ``pari_catch_sig_on()`` before and
     9753        ``pari_catch_sig_off()`` after.
     9754
     9755        """
     9756        cdef int length, i
     9757        cdef mpz_t mpz_int
     9758        cdef GEN g
     9759        cdef gen h
     9760
     9761        if isinstance(s, gen):
     9762            return (<gen>s).g
     9763        elif PyObject_HasAttrString(s, "_pari_"):
     9764            h = s._pari_()
     9765            return gcopy(h.g)
    98079766
    98089767        # Check basic Python types
    98099768        if PyInt_Check(s):
    9810             pari_catch_sig_on()
    9811             return self.new_gen(stoi(PyInt_AS_LONG(s)))
     9769            return stoi(PyInt_AS_LONG(s))
    98129770        if PyBool_Check(s):
    9813             return self.PARI_ONE if s else self.PARI_ZERO
    9814         cdef mpz_t mpz_int
    9815         cdef GEN g
     9771            return gen_1 if s else gen_0
    98169772        if PyLong_Check(s):
    9817             pari_catch_sig_on()
    98189773            mpz_init(mpz_int)
    98199774            mpz_set_pylong(mpz_int, s)
    98209775            g = self._new_GEN_from_mpz_t(mpz_int)
    98219776            mpz_clear(mpz_int)
    9822             return self.new_gen(g)
     9777            return g
    98239778        if PyFloat_Check(s):
    9824             pari_catch_sig_on()
    9825             return self.new_gen(dbltor(PyFloat_AS_DOUBLE(s)))
     9779            return dbltor(PyFloat_AS_DOUBLE(s))
    98269780        if PyComplex_Check(s):
    9827             pari_catch_sig_on()
    98289781            g = cgetg(3, t_COMPLEX)
    98299782            set_gel(g, 1, dbltor(PyComplex_RealAsDouble(s)))
    98309783            set_gel(g, 2, dbltor(PyComplex_ImagAsDouble(s)))
    9831             return self.new_gen(g)
     9784            return g
    98329785
    98339786        if isinstance(s, (types.ListType, types.XRangeType,
    98349787                            types.TupleType, types.GeneratorType)):
    98359788            length = len(s)
    9836             v = self._empty_vector(length)
     9789            g = cgetg(length + 1, t_VEC)
    98379790            for i from 0 <= i < length:
    9838                 v[i] = self(s[i])
    9839             return v
     9791                set_gel(g, i + 1, self.toGEN(s[i]))
     9792            return g
    98409793
    98419794        t = str(s)
    9842         pari_catch_sig_str('evaluating PARI string')
    9843         g = gp_read_str(t)
    9844         if g == gnil:
    9845             pari_catch_sig_off()
    9846             return None
    9847         return self.new_gen(g)
     9795        return gp_read_str(t)
    98489796
    98499797    cdef GEN _new_GEN_from_mpz_t_matrix(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc):
    98509798        r"""
     
    1038010328            sage: cyclotomic_polynomial(8)(2)
    1038110329            17
    1038210330        """
    10383         t0GEN(v)
    10384         pari_catch_sig_on()
     10331        pari_catch_sig_on()
     10332        cdef GEN t0 = self.toGEN(v)
    1038510333        return self.new_gen(polcyclo_eval(n, t0))
    1038610334
    1038710335    def polsubcyclo(self, long n, long d, v=-1):
     
    1045010398            ...
    1045110399            PariError: incorrect type in setrand
    1045210400        """
    10453         t0GEN(seed)
    10454         pari_catch_sig_on()
     10401        pari_catch_sig_on()
     10402        cdef GEN t0 = self.toGEN(seed)
    1045510403        setrand(t0)
    10456         pari_catch_sig_off()
     10404        self.clear_stack()
    1045710405
    1045810406    def getrand(self):
    1045910407        """
  • sage/rings/finite_rings/element_pari_ffelt.pyx

    diff --git a/sage/rings/finite_rings/element_pari_ffelt.pyx b/sage/rings/finite_rings/element_pari_ffelt.pyx
    a b  
    326326            c^4 + 2*c^3
    327327        """
    328328        pari_catch_sig_on()
    329         return pari.new_gen_to_string(self.val)
     329        return str(pari.new_gen(self.val))
    330330
    331331    def __hash__(FiniteFieldElement_pari_ffelt self):
    332332        """