Ticket #11868: trac_11868-t0GEN_new.patch

File trac_11868-t0GEN_new.patch, 73.4 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 1385402703 0
    # Node ID ac52ef68ec4472b529334cdd9c5211077db2f446
    # 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
    4036    cdef GEN _new_GEN_from_mpz_t_matrix(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc)
    4137    cdef GEN _new_GEN_from_mpz_t_matrix_rotate90(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc)
    4238    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        cdef gen t0 = P(n)
     661        pari_catch_sig_on()
     662        return P.new_gen(gpow(self.g, t0.g, 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:
    746         """
    747         Given a PARI object `self`, convert it to a proper PARI number
    748         field (nf) structure.
     713    def nf_get_pol(self):
     714        """
     715        Returns the defining polynomial of this number field.
    749716
    750717        INPUT:
    751718
    752719        - ``self`` -- A PARI number field being the output of ``nfinit()``,
    753720                      ``bnfinit()`` or ``bnrinit()``.
    754721
    755         TESTS:
    756 
    757         We test this indirectly through `nf_get_pol()`::
     722        EXAMPLES::
     723
     724            sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
     725            sage: pari(K).nf_get_pol()
     726            y^4 - 4*y^2 + 1
     727            sage: bnr = pari("K = bnfinit(x^4 - 4*x^2 + 1); bnrinit(K, 2*x)")
     728            sage: bnr.nf_get_pol()
     729            x^4 - 4*x^2 + 1
     730
     731        For relative extensions, this returns the absolute polynomial,
     732        not the relative one::
     733
     734            sage: L.<b> = K.extension(x^2 - 5)
     735            sage: pari(L).nf_get_pol()   # Absolute polynomial
     736            y^8 - 28*y^6 + 208*y^4 - 408*y^2 + 36
     737            sage: L.pari_rnf().nf_get_pol()
     738            x^8 - 28*x^6 + 208*x^4 - 408*x^2 + 36
     739
     740        TESTS::
    758741
    759742            sage: x = polygen(QQ)
    760743            sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
     
    762745            y^4 - 4*y^2 + 1
    763746            sage: K.pari_bnf().nf_get_pol()
    764747            y^4 - 4*y^2 + 1
    765             sage: bnr = pari("K = bnfinit(x^4 - 4*x^2 + 1); bnrinit(K, 2*x)")
    766             sage: bnr.nf_get_pol()
    767             x^4 - 4*x^2 + 1
    768 
    769         It does not work with ``rnfinit()`` or garbage input::
    770 
    771             sage: K.extension(x^2 - 5, 'b').pari_rnf().nf_get_pol()
    772             Traceback (most recent call last):
    773             ...
    774             TypeError: Not a PARI number field
     748
     749        An error is raised for invalid input::
     750
    775751            sage: pari("[0]").nf_get_pol()
    776752            Traceback (most recent call last):
    777753            ...
    778             TypeError: Not a PARI number field
    779         """
    780         cdef GEN nf
    781         cdef long nftyp
    782         pari_catch_sig_on()
    783         nf = get_nf(self.g, &nftyp)
    784         pari_catch_sig_off()
    785         if not nf:
    786             raise TypeError("Not a PARI number field")
    787         return nf
    788 
    789     def nf_get_pol(self):
    790         """
    791         Returns the defining polynomial of this number field.
    792 
    793         INPUT:
    794 
    795         - ``self`` -- A PARI number field being the output of ``nfinit()``,
    796                       ``bnfinit()`` or ``bnrinit()``.
    797 
    798         EXAMPLES::
    799            
    800             sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
    801             sage: pari(K).nf_get_pol()
    802             y^4 - 4*y^2 + 1
    803             sage: bnr = pari("K = bnfinit(x^4 - 4*x^2 + 1); bnrinit(K, 2*x)")
    804             sage: bnr.nf_get_pol()
    805             x^4 - 4*x^2 + 1
    806 
    807         For relative extensions, we can only get the absolute polynomial,
    808         not the relative one::
    809 
    810             sage: L.<b> = K.extension(x^2 - 5)
    811             sage: pari(L).nf_get_pol()   # Absolute polynomial
    812             y^8 - 28*y^6 + 208*y^4 - 408*y^2 + 36
    813             sage: L.pari_rnf().nf_get_pol()
    814             Traceback (most recent call last):
    815             ...
    816             TypeError: Not a PARI number field
    817         """
    818         cdef GEN nf = self.get_nf()
    819         pari_catch_sig_on()
    820         return self.new_gen(nf_get_pol(nf))
     754            PariError: incorrect type in pol
     755        """
     756        pari_catch_sig_on()
     757        return P.new_gen(member_pol(self.g))
    821758
    822759    def nf_get_diff(self):
    823760        """
     
    834771            sage: pari(K).nf_get_diff()
    835772            [12, 0, 0, 0; 0, 12, 8, 0; 0, 0, 4, 0; 0, 0, 0, 4]
    836773        """
    837         cdef GEN nf = self.get_nf()
    838         pari_catch_sig_on()
    839         # Very bad code, but there doesn't seem to be a better way
    840         return self.new_gen(gel(gel(nf, 5), 5))
     774        pari_catch_sig_on()
     775        return P.new_gen(member_diff(self.g))
    841776
    842777    def nf_get_sign(self):
    843778        """
     
    863798        """
    864799        cdef long r1
    865800        cdef long r2
    866         cdef GEN nf = self.get_nf()
    867         nf_get_sign(nf, &r1, &r2)
     801        cdef GEN sign
     802        pari_catch_sig_on()
     803        sign = member_sign(self.g)
     804        r1 = itos(gel(sign, 1))
     805        r2 = itos(gel(sign, 2))
     806        pari_catch_sig_off()
    868807        return [r1, r2]
    869808
    870809    def nf_get_zk(self):
     
    883822            sage: pari(K).nf_get_zk()
    884823            [1, y, y^3 - 4*y, y^2 - 2]
    885824        """
    886         cdef GEN nf = self.get_nf()
    887         pari_catch_sig_on()
    888         return self.new_gen(nf_get_zk(nf))
     825        pari_catch_sig_on()
     826        return P.new_gen(member_zk(self.g))
    889827
    890828    def bnf_get_no(self):
    891829        """
     
    16281566            sage: int(pari("Mod(2, 7)"))
    16291567            2
    16301568        """
     1569        late_import()
    16311570        return int(Integer(self))
    16321571
    16331572    def int_unsafe(gen self):
     
    18221761            sage: long(pari("Mod(2, 7)"))
    18231762            2L
    18241763        """
     1764        late_import()
    18251765        return long(Integer(self))
    18261766   
    18271767    def __float__(gen self):
     
    19131853            sage: a.gequal(c)
    19141854            False
    19151855        """
    1916         t0GEN(b)
    1917         pari_catch_sig_on()
    1918         cdef int ret = gequal(a.g, t0)
     1856        cdef gen t0 = P(b)
     1857        pari_catch_sig_on()
     1858        cdef int ret = gequal(a.g, t0.g)
    19191859        pari_catch_sig_off()
    19201860        return ret != 0
    19211861
     
    21342074        """
    21352075        cdef int n
    21362076        cdef GEN x
     2077        cdef gen t0
    21372078       
    21382079        if k is None:
    21392080            pari_catch_sig_on()
     
    21442085            else:
    21452086                return n, P.new_gen(x)
    21462087        else:
    2147             k = int(k)
    2148             t0GEN(k)
     2088            t0 = P(k)
    21492089            pari_catch_sig_on()
    2150             n = ispower(self.g, t0, &x)
     2090            n = ispower(self.g, t0.g, &x)
    21512091            if n == 0:
    21522092                pari_catch_sig_off()
    21532093                return False, None
     
    21632103        2-dimensional column vector the quotient and the remainder, with
    21642104        respect to v (to main variable if v is omitted).
    21652105        """
    2166         t0GEN(y)
     2106        cdef gen t0 = P(y)
    21672107        pari_catch_sig_on()       
    2168         return P.new_gen(divrem(x.g, t0, P.get_var(var)))
     2108        return P.new_gen(divrem(x.g, t0.g, P.get_var(var)))
    21692109
    21702110    def lex(gen x, y):
    21712111        """
    21722112        lex(x,y): Compare x and y lexicographically (1 if xy, 0 if x==y, -1
    21732113        if xy)
    21742114        """
    2175         t0GEN(y)
     2115        cdef gen t0 = P(y)
    21762116        pari_catch_sig_on()       
    2177         return lexcmp(x.g, t0)
     2117        r = lexcmp(x.g, t0.g)
     2118        pari_catch_sig_off()
     2119        return r
    21782120
    21792121    def max(gen x, y):
    21802122        """
    21812123        max(x,y): Return the maximum of x and y.
    21822124        """
    2183         t0GEN(y)
    2184         pari_catch_sig_on()
    2185         return P.new_gen(gmax(x.g, t0))
     2125        cdef gen t0 = P(y)
     2126        pari_catch_sig_on()
     2127        return P.new_gen(gmax(x.g, t0.g))
    21862128
    21872129    def min(gen x, y):
    21882130        """
    21892131        min(x,y): Return the minimum of x and y.
    21902132        """
    2191         t0GEN(y)
    2192         pari_catch_sig_on()
    2193         return P.new_gen(gmin(x.g, t0))
     2133        cdef gen t0 = P(y)
     2134        pari_catch_sig_on()
     2135        return P.new_gen(gmin(x.g, t0.g))
    21942136
    21952137    def shift(gen x, long n):
    21962138        """
     
    22212163        # Pari throws an error if you attempt to take the sign of
    22222164        # a complex number.
    22232165        pari_catch_sig_on()
    2224         return gsigne(x.g)
     2166        r = gsigne(x.g)
     2167        pari_catch_sig_off()
     2168        return r
    22252169
    22262170    def vecmax(gen x):
    22272171        """
     
    24862430            sage: a.type()
    24872431            't_POLMOD'
    24882432        """
    2489         t0GEN(y)
    2490         pari_catch_sig_on()
    2491         return P.new_gen(gmodulo(x.g,t0))
     2433        cdef gen t0 = P(y)
     2434        pari_catch_sig_on()
     2435        return P.new_gen(gmodulo(x.g, t0.g))
    24922436   
    24932437    def Pol(self, v=-1):
    24942438        """
     
    26342578            ...
    26352579            PariError: square discriminant in Qfb
    26362580        """
    2637         t0GEN(b); t1GEN(c); t2GEN(D)
    2638         pari_catch_sig_on()
    2639         return P.new_gen(Qfb0(a.g, t0, t1, t2, prec))
     2581        cdef gen t0 = P(b)
     2582        cdef gen t1 = P(c)
     2583        cdef gen t2 = P(D)
     2584        pari_catch_sig_on()
     2585        return P.new_gen(Qfb0(a.g, t0.g, t1.g, t2.g, prec))
    26402586       
    26412587   
    26422588    def Ser(gen x, v=-1, long seriesprecision = 16):
     
    27682714        cdef char* c
    27692715        pari_catch_sig_on()
    27702716        c = GENtostr(self.g)
    2771         v = self.new_gen(strtoGENstr(c))
     2717        v = P.new_gen(strtoGENstr(c))
    27722718        pari_free(c)
    27732719        return v
    27742720
     
    30833029            sage: pari(-1).bitand(-1)
    30843030            -1
    30853031        """
    3086         t0GEN(y)
    3087         pari_catch_sig_on()
    3088         return P.new_gen(gbitand(x.g, t0))
     3032        cdef gen t0 = P(y)
     3033        pari_catch_sig_on()
     3034        return P.new_gen(gbitand(x.g, t0.g))
    30893035       
    30903036   
    30913037    def bitneg(gen x, long n=-1):
     
    31633109            sage: pari(8+4).bitnegimply(8)
    31643110            4
    31653111        """
    3166         t0GEN(y)
    3167         pari_catch_sig_on()
    3168         return P.new_gen(gbitnegimply(x.g, t0))
     3112        cdef gen t0 = P(y)
     3113        pari_catch_sig_on()
     3114        return P.new_gen(gbitnegimply(x.g, t0.g))
    31693115
    31703116   
    31713117    def bitor(gen x, y):
     
    31983144            sage: pari(13).bitor(1)
    31993145            13
    32003146        """
    3201         t0GEN(y)
    3202         pari_catch_sig_on()
    3203         return P.new_gen(gbitor(x.g, t0))
     3147        cdef gen t0 = P(y)
     3148        pari_catch_sig_on()
     3149        return P.new_gen(gbitor(x.g, t0.g))
    32043150
    32053151   
    32063152    def bittest(gen x, long n):
     
    32723218            sage: pari(6).bitxor(0)
    32733219            6
    32743220        """
    3275         t0GEN(y)
    3276         pari_catch_sig_on()
    3277         return P.new_gen(gbitxor(x.g, t0))
     3221        cdef gen t0 = P(y)
     3222        pari_catch_sig_on()
     3223        return P.new_gen(gbitxor(x.g, t0.g))
    32783224
    32793225   
    32803226    def ceil(gen x):
     
    41644110            2147483647            # 32-bit
    41654111            9223372036854775807   # 64-bit
    41664112        """
    4167         cdef long v
    4168         t0GEN(p)
    4169         pari_catch_sig_on()
    4170         v = ggval(x.g, t0)
     4113        cdef gen t0 = P(p)
     4114        pari_catch_sig_on()
     4115        v = ggval(x.g, t0.g)
    41714116        pari_catch_sig_off()
    41724117        return v
    41734118   
     
    43334278            sage: pari(1+i).agm(-3)
    43344279            -0.964731722290876 + 1.15700282952632*I
    43354280        """
    4336         t0GEN(y)
    4337         pari_catch_sig_on()
    4338         return P.new_gen(agm(x.g, t0, pbw(precision)))
     4281        cdef gen t0 = P(y)
     4282        pari_catch_sig_on()
     4283        return P.new_gen(agm(x.g, t0.g, prec_bits_to_words(precision)))
    43394284
    43404285    def arg(gen x, precision=0):
    43414286        r"""
     
    45104455            sage: pari(2).besselh1(3)
    45114456            0.486091260585891 - 0.160400393484924*I
    45124457        """
    4513         t0GEN(x)
    4514         pari_catch_sig_on()
    4515         return P.new_gen(hbessel1(nu.g, t0, pbw(precision)))
     4458        cdef gen t0 = P(x)
     4459        pari_catch_sig_on()
     4460        return P.new_gen(hbessel1(nu.g, t0.g, prec_bits_to_words(precision)))
    45164461
    45174462    def besselh2(gen nu, x, precision=0):
    45184463        r"""
     
    45304475            sage: pari(2).besselh2(3)
    45314476            0.486091260585891 + 0.160400393484924*I
    45324477        """
    4533         t0GEN(x)
    4534         pari_catch_sig_on()
    4535         return P.new_gen(hbessel2(nu.g, t0, pbw(precision)))
     4478        cdef gen t0 = P(x)
     4479        pari_catch_sig_on()
     4480        return P.new_gen(hbessel2(nu.g, t0.g, prec_bits_to_words(precision)))
    45364481
    45374482    def besselj(gen nu, x, precision=0):
    45384483        r"""
     
    45534498            sage: pari(2).besselj(3)
    45544499            0.486091260585891
    45554500        """
    4556         t0GEN(x)
    4557         pari_catch_sig_on()
    4558         return P.new_gen(jbessel(nu.g, t0, pbw(precision)))
     4501        cdef gen t0 = P(x)
     4502        pari_catch_sig_on()
     4503        return P.new_gen(jbessel(nu.g, t0.g, prec_bits_to_words(precision)))
    45594504
    45604505    def besseljh(gen nu, x, precision=0):
    45614506        """
     
    45784523            0.4127100324          # 32-bit
    45794524            0.412710032209716     # 64-bit
    45804525        """
    4581         t0GEN(x)
    4582         pari_catch_sig_on()
    4583         return P.new_gen(jbesselh(nu.g, t0, pbw(precision)))
     4526        cdef gen t0 = P(x)
     4527        pari_catch_sig_on()
     4528        return P.new_gen(jbesselh(nu.g, t0.g, prec_bits_to_words(precision)))
    45844529
    45854530    def besseli(gen nu, x, precision=0):
    45864531        r"""
     
    46044549            sage: pari(2).besseli(3+i)
    46054550            1.12539407613913 + 2.08313822670661*I
    46064551        """
    4607         t0GEN(x)
    4608         pari_catch_sig_on()
    4609         return P.new_gen(ibessel(nu.g, t0, pbw(precision)))
     4552        cdef gen t0 = P(x)
     4553        pari_catch_sig_on()
     4554        return P.new_gen(ibessel(nu.g, t0.g, prec_bits_to_words(precision)))
    46104555
    46114556    def besselk(gen nu, x, long flag=0, precision=0):
    46124557        """
     
    46474592            sage: pari(2+i).besselk(300, flag=1)
    46484593            3.74224603319728 E-132 + 2.49071062641525 E-134*I
    46494594        """
    4650         t0GEN(x)
    4651         pari_catch_sig_on()
    4652         return P.new_gen(kbessel(nu.g, t0, pbw(precision)))
     4595        cdef gen t0 = P(x)
     4596        pari_catch_sig_on()
     4597        return P.new_gen(kbessel(nu.g, t0.g, prec_bits_to_words(precision)))
    46534598
    46544599    def besseln(gen nu, x, precision=0):
    46554600        """
     
    46684613            sage: pari(2+i).besseln(3)
    46694614            -0.280775566958244 - 0.486708533223726*I
    46704615        """
    4671         t0GEN(x)
    4672         pari_catch_sig_on()
    4673         return P.new_gen(nbessel(nu.g, t0, pbw(precision)))
     4616        cdef gen t0 = P(x)
     4617        pari_catch_sig_on()
     4618        return P.new_gen(nbessel(nu.g, t0.g, prec_bits_to_words(precision)))
    46744619
    46754620    def cos(gen x, precision=0):
    46764621        """
     
    49354880            sage: pari(1).hyperu(2,3)
    49364881            0.333333333333333
    49374882        """
    4938         t0GEN(b)
    4939         t1GEN(x)
    4940         pari_catch_sig_on()
    4941         return P.new_gen(hyperu(a.g, t0, t1, pbw(precision)))
     4883        cdef gen t0 = P(b)
     4884        cdef gen t1 = P(x)
     4885        pari_catch_sig_on()
     4886        return P.new_gen(hyperu(a.g, t0.g, t1.g, prec_bits_to_words(precision)))
    49424887
    49434888    def incgam(gen s, x, y=None, precision=0):
    49444889        r"""
     
    49564901            sage: pari(1+i).incgam(3-i)
    49574902            -0.0458297859919946 + 0.0433696818726677*I
    49584903        """
    4959         t0GEN(x)
    4960         pari_catch_sig_on()
     4904        cdef gen t0 = P(x)
     4905        cdef gen t1
    49614906        if y is None:
    4962             return P.new_gen(incgam(s.g, t0, pbw(precision)))
     4907            pari_catch_sig_on()
     4908            return P.new_gen(incgam(s.g, t0.g, prec_bits_to_words(precision)))
    49634909        else:
    4964             t1GEN(y)
    4965             return P.new_gen(incgam0(s.g, t0, t1, pbw(precision)))
     4910            t1 = P(y)
     4911            pari_catch_sig_on()
     4912            return P.new_gen(incgam0(s.g, t0.g, t1.g, prec_bits_to_words(precision)))
    49664913
    49674914    def incgamc(gen s, x, precision=0):
    49684915        r"""
     
    49864933            sage: pari(1).incgamc(2)
    49874934            0.864664716763387
    49884935        """
    4989         t0GEN(x)
    4990         pari_catch_sig_on()
    4991         return P.new_gen(incgamc(s.g, t0, pbw(precision)))
     4936        cdef gen t0 = P(x)
     4937        pari_catch_sig_on()
     4938        return P.new_gen(incgamc(s.g, t0.g, prec_bits_to_words(precision)))
    49924939   
    49934940    def log(gen x, precision=0):
    49944941        r"""
     
    52635210        """
    52645211        # TODO: ???  lots of good examples in the PARI docs ???
    52655212        cdef GEN zetan
    5266         t0GEN(n)
    5267         pari_catch_sig_on()
    5268         ans = P.new_gen_noclear(gsqrtn(x.g, t0, &zetan, pbw(precision)))
     5213        cdef gen t0 = P(n)
     5214        pari_catch_sig_on()
     5215        ans = P.new_gen_noclear(gsqrtn(x.g, t0.g, &zetan, prec_bits_to_words(precision)))
    52695216        return ans, P.new_gen(zetan)
    52705217
    52715218    def tan(gen x, precision=0):
     
    53435290            sage: pari(0.5).theta(2)
    53445291            1.63202590295260
    53455292        """
    5346         t0GEN(z)
    5347         pari_catch_sig_on()
    5348         return P.new_gen(theta(q.g, t0, pbw(precision)))
     5293        cdef gen t0 = P(z)
     5294        pari_catch_sig_on()
     5295        return P.new_gen(theta(q.g, t0.g, prec_bits_to_words(precision)))
    53495296
    53505297    def thetanullk(gen q, long k, precision=0):
    53515298        """
     
    54435390            4*7^-2 + 5*7^-1 + O(7^0)
    54445391        """
    54455392        pari_catch_sig_on()
    5446         return P.new_gen(gzeta(s.g, pbw(precision)))
     5393        return P.new_gen(gzeta(s.g, prec_bits_to_words(precision)))
    54475394
    54485395    ###########################################
    54495396    # 4: NUMBER THEORETICAL functions
     
    54525399    def bezout(gen x, y):
    54535400        cdef gen u, v, g
    54545401        cdef GEN U, V, G
    5455         t0GEN(y)
    5456         pari_catch_sig_on()
    5457         G = gbezout(x.g, t0, &U, &V)
     5402        cdef gen t0 = P(y)
     5403        pari_catch_sig_on()
     5404        G = gbezout(x.g, t0.g, &U, &V)
    54585405        g = P.new_gen_noclear(G)
    54595406        u = P.new_gen_noclear(U)
    54605407        v = P.new_gen(V)
     
    54925439        a bound for the number of terms in the continued fraction
    54935440        expansion.
    54945441        """
    5495         t0GEN(b)
    5496         pari_catch_sig_on()
    5497         return P.new_gen(contfrac0(x.g, t0, lmax))
     5442        cdef gen t0 = P(b)
     5443        pari_catch_sig_on()
     5444        return P.new_gen(contfrac0(x.g, t0.g, lmax))
    54985445
    54995446    def contfracpnqn(gen x, b=0, long lmax=0):
    55005447        """
     
    55785525        (x and y must be polynomials), 2 use the subresultant algorithm (x
    55795526        and y must be polynomials)
    55805527        """
    5581         t0GEN(y)
    5582         pari_catch_sig_on()
    5583         return P.new_gen(ggcd0(x.g, t0))
     5528        cdef gen t0 = P(y)
     5529        pari_catch_sig_on()
     5530        return P.new_gen(ggcd0(x.g, t0.g))
    55845531
    55855532    def issquare(gen x, find_root=False):
    55865533        """
     
    56245571            sage: pari(10).lcm(15)
    56255572            30
    56265573        """
    5627         t0GEN(y)
    5628         pari_catch_sig_on()
    5629         return P.new_gen(glcm(x.g, t0))
     5574        cdef gen t0 = P(y)
     5575        pari_catch_sig_on()
     5576        return P.new_gen(glcm(x.g, t0.g))
    56305577
    56315578    def numdiv(gen n):
    56325579        """
     
    58595806            sage: e.elladd([1,0], [-1,1])
    58605807            [-3/4, -15/8]
    58615808        """
    5862         t0GEN(z0); t1GEN(z1)
    5863         pari_catch_sig_on()
    5864         return self.new_gen(addell(self.g, t0, t1))
     5809        cdef gen t0 = P(z0)
     5810        cdef gen t1 = P(z1)
     5811        pari_catch_sig_on()
     5812        return P.new_gen(addell(self.g, t0.g, t1.g))
    58655813
    58665814    def ellak(self, n):
    58675815        r"""
     
    58975845            sage: e.ellak(0)
    58985846            0
    58995847        """
    5900         t0GEN(n)
    5901         pari_catch_sig_on()
    5902         return self.new_gen(akell(self.g, t0))
     5848        cdef gen t0 = P(n)
     5849        pari_catch_sig_on()
     5850        return P.new_gen(akell(self.g, t0.g))
    59035851
    59045852
    59055853    def ellan(self, long n, python_ints=False):
     
    59925940            sage: e.ellak(-1)
    59935941            0
    59945942        """
    5995         t0GEN(p)
    5996         pari_catch_sig_on()
    5997         return self.new_gen(ellap(self.g, t0))
     5943        cdef gen t0 = P(p)
     5944        pari_catch_sig_on()
     5945        return P.new_gen(ellap(self.g, t0.g))
    59985946
    59995947
    60005948    def ellaplist(self, long n, python_ints=False):
     
    60465994            sage: type(v[0])
    60475995            <type 'int'>
    60485996        """
    6049         # 1. make a table of primes up to n.
    6050         pari_catch_sig_on()
     5997        cdef gen t0
     5998        cdef GEN g
     5999        cdef long i
     6000
    60516001        if n < 2:
    6052             return self.new_gen(zerovec(0))
    6053         cdef GEN g
    6054         pari.init_primes(n+1)
    6055         t0GEN(n)
    6056         g = primes(gtolong(primepi(t0)))
     6002            pari_catch_sig_on()
     6003            return P.new_gen(zerovec(0))
     6004
     6005        # 1. Make a table of primes up to n.
     6006        P.init_primes(n+1)
     6007        t0 = P(n)
     6008        pari_catch_sig_on()
     6009        g = primes(gtolong(primepi(t0.g)))
    60576010
    60586011        # 2. Replace each prime in the table by ellap of it.
    6059         cdef long i
    6060 
    60616012        if python_ints:
    6062             v = [gtolong(ellap(self.g, <GEN> g[i+1])) \
     6013            v = [gtolong(ellap(self.g, gel(g, i + 1))) \
    60636014                        for i in range(glength(g))]
    6064             (<PariInstance>pari).clear_stack()
     6015            P.clear_stack()
    60656016            return v
    60666017        else:
    60676018            for i from 0 <= i < glength(g):
    6068                 g[i+1] = <long> ellap(self.g, <GEN> g[i+1])
     6019                set_gel(g, i + 1, ellap(self.g, gel(g, i + 1)))
    60696020            return self.new_gen(g)
    60706021
    60716022
     
    60896040            sage: e.ellbil([1, 0], [-1, 1])
    60906041            0.418188984498861
    60916042        """
    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))
     6043        cdef gen t0 = P(z0)
     6044        cdef gen t1 = P(z1)
     6045        pari_catch_sig_on()
     6046        return P.new_gen(bilhell(self.g, t0.g, t1.g, prec))
    60966047
    60976048    def ellchangecurve(self, ch):
    60986049        """
     
    61216072            sage: f[:5]
    61226073            [1, -1, 0, 4, 3]
    61236074        """
    6124         t0GEN(ch)
    6125         pari_catch_sig_on()
    6126         return self.new_gen(ellchangecurve(self.g, t0))
     6075        cdef gen t0 = P(ch)
     6076        pari_catch_sig_on()
     6077        return P.new_gen(ellchangecurve(self.g, t0.g))
    61276078
    61286079    def elleta(self):
    61296080        """
     
    61906141            sage: e.ellheight([1,0], flag=1)
    61916142            0.476711659343740
    61926143        """
    6193         t0GEN(a)
    6194         pari_catch_sig_on()
    6195         return self.new_gen(ellheight0(self.g, t0, flag, pbw(precision)))
     6144        cdef gen t0 = P(a)
     6145        pari_catch_sig_on()
     6146        return P.new_gen(ellheight0(self.g, t0.g, flag, prec_bits_to_words(precision)))
    61966147
    61976148    def ellheightmatrix(self, x):
    61986149        """
     
    62186169            sage: e.ellheightmatrix([[1,0], [-1,1]])
    62196170            [0.476711659343740, 0.418188984498861; 0.418188984498861, 0.686667083305587]
    62206171        """
    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))
     6172        cdef gen t0 = P(x)
     6173        pari_catch_sig_on()
     6174        return P.new_gen(mathell(self.g, t0.g, prec))
    62256175
    62266176    def ellisoncurve(self, x):
    62276177        """
     
    62456195            sage: e.ellisoncurve([0])
    62466196            True
    62476197        """
    6248         t0GEN(x)
    6249         pari_catch_sig_on()
    6250         t = bool(oncurve(self.g, t0) == 1)
     6198        cdef gen t0 = P(x)
     6199        pari_catch_sig_on()
     6200        t = bool(oncurve(self.g, t0.g) == 1)
    62516201        pari_catch_sig_off()
    62526202        return t
    62536203
     
    64026352            sage: e.elllocalred(3)
    64036353            [2, -10, [1, 96, 1, 316], 4]
    64046354        """
    6405         t0GEN(p)
    6406         pari_catch_sig_on()
    6407         return self.new_gen(elllocalred(self.g, t0))
     6355        cdef gen t0 = P(p)
     6356        pari_catch_sig_on()
     6357        return P.new_gen(elllocalred(self.g, t0.g))
    64086358
    64096359    def elllseries(self, s, A=1):
    64106360        """
     
    64446394            sage: e.elllseries(2.1, A=1.1)
    64456395            0.402838047956645
    64466396        """
    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))
     6397        cdef gen t0 = P(s)
     6398        cdef gen t1 = P(A)
     6399        pari_catch_sig_on()
     6400        return P.new_gen(elllseries(self.g, t0.g, t1.g, prec))
    64516401
    64526402    def ellminimalmodel(self):
    64536403        """
     
    65146464            sage: e.ellorder([1,0])
    65156465            0
    65166466        """
    6517         t0GEN(x)
    6518         pari_catch_sig_on()
    6519         return self.new_gen(orderell(self.g, t0))
     6467        cdef gen t0 = P(x)
     6468        pari_catch_sig_on()
     6469        return P.new_gen(orderell(self.g, t0.g))
    65206470   
    65216471    def ellordinate(self, x):
    65226472        """
     
    65456495            sage: e.ellordinate('z+2*z^2+O(z^4)')
    65466496            [-2*z - 7*z^2 - 23*z^3 + O(z^4), -1 + 2*z + 7*z^2 + 23*z^3 + O(z^4)]
    65476497        """
    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
     6498        cdef gen t0 = P(x)
     6499        pari_catch_sig_on()
     6500        return P.new_gen(ellordinate(self.g, t0.g, prec))
     6501
     6502    def ellpointtoz(self, pt, long precision=0):
     6503        """
     6504        e.ellpointtoz(pt): return the complex number (in the fundamental
     6505        parallelogram) corresponding to the point ``pt`` on the elliptic curve
    65576506        e, under the complex uniformization of e given by the Weierstrass
    65586507        p-function.
    65596508       
     
    65726521            sage: e.ellpointtoz([0])
    65736522            0
    65746523        """
    6575         t0GEN(P)
    6576         pari_catch_sig_on()
    6577         return self.new_gen(zell(self.g, t0, pbw(precision)))
     6524        cdef gen t0 = P(pt)
     6525        pari_catch_sig_on()
     6526        return P.new_gen(zell(self.g, t0.g, prec_bits_to_words(precision)))
    65786527
    65796528    def ellpow(self, z, n):
    65806529        """
     
    66346583            ....:     P0 = e.elladd(e.ellpow(P, cm_minpoly[0]), e.ellpow(P2, cm))
    66356584            ....:     assert(P0 == E(0))
    66366585        """
    6637         t0GEN(z); t1GEN(n)
    6638         pari_catch_sig_on()
    6639         return self.new_gen(powell(self.g, t0, t1))
     6586        cdef gen t0 = P(z)
     6587        cdef gen t1 = P(n)
     6588        pari_catch_sig_on()
     6589        return P.new_gen(powell(self.g, t0.g, t1.g))
    66406590   
    66416591    def ellrootno(self, p=1):
    66426592        """
     
    66696619            sage: e.ellrootno(1009)
    66706620            1
    66716621        """
    6672         cdef long rootno
    6673         t0GEN(p)
    6674         pari_catch_sig_on()
    6675         rootno =  ellrootno(self.g, t0)
     6622        cdef gen t0 = P(p)
     6623        pari_catch_sig_on()
     6624        rootno =  ellrootno(self.g, t0.g)
    66766625        pari_catch_sig_off()
    66776626        return rootno
    66786627
     
    66896638            sage: e.ellsigma(2+i)
    66906639            1.43490215804166 + 1.80307856719256*I
    66916640        """
    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))
     6641        cdef gen t0 = P(z)
     6642        pari_catch_sig_on()
     6643        return P.new_gen(ellsigma(self.g, t0.g, flag, prec))
    66966644
    66976645    def ellsub(self, z0, z1):
    66986646        """
     
    67166664            sage: e.ellsub([1,0], [-1,1])
    67176665            [0, 0]
    67186666        """
    6719         t0GEN(z0); t1GEN(z1)
    6720         pari_catch_sig_on()
    6721         return self.new_gen(subell(self.g, t0, t1))
     6667        cdef gen t0 = P(z0)
     6668        cdef gen t1 = P(z1)
     6669        pari_catch_sig_on()
     6670        return P.new_gen(subell(self.g, t0.g, t1.g))
    67226671
    67236672    def elltaniyama(self):
    67246673        pari_catch_sig_on()
    6725         return self.new_gen(taniyama(self.g))
     6674        return P.new_gen(taniyama(self.g))
    67266675
    67276676    def elltors(self, flag=0):
    67286677        """
     
    67996748            sage: e.ellzeta(i-1)
    68006749            -0.350122658523049 - 0.350122658523049*I
    68016750        """
    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))
     6751        cdef gen t0 = P(z)
     6752        pari_catch_sig_on()
     6753        return P.new_gen(ellzeta(self.g, t0.g, prec))
    68066754
    68076755    def ellztopoint(self, z):
    68086756        """
     
    68346782            sage: e.ellztopoint(0)
    68356783            [0]
    68366784        """
    6837         t0GEN(z)
     6785        cdef gen t0 = P(z)
    68386786        try:
    68396787            dprec = prec_words_to_dec(z.precision())
    68406788        except AttributeError:
    68416789            dprec = prec
    68426790        pari_catch_sig_on()
    6843         # the prec argument has no effect
    6844         return self.new_gen(pointell(self.g, t0, dprec))
     6791        return P.new_gen(pointell(self.g, t0.g, dprec))
    68456792
    68466793    def omega(self):
    68476794        """
     
    69126859        .. [PariUsers] User's Guide to PARI/GP,
    69136860           http://pari.math.u-bordeaux.fr/pub/pari/manuals/2.5.1/users.pdf
    69146861        """
    6915         cdef long n
    69166862        pari_catch_sig_on()
    69176863        n = bnfcertify(self.g)
    69186864        pari_catch_sig_off()
    69196865        return n
    69206866   
    69216867    def bnfinit(self, long flag=0, tech=None):
     6868        cdef gen t0
    69226869        if tech is None:
    69236870            pari_catch_sig_on()
    6924             return P.new_gen(bnfinit0(self.g, flag, <GEN>0, prec))
     6871            return P.new_gen(bnfinit0(self.g, flag, NULL, prec))
    69256872        else:
    6926             t0GEN(tech)
     6873            t0 = P(tech)
    69276874            pari_catch_sig_on()
    6928             return P.new_gen(bnfinit0(self.g, flag, t0, prec))
     6875            return P.new_gen(bnfinit0(self.g, flag, t0.g, prec))
    69296876   
    69306877    def bnfisintnorm(self, x):
    6931         t0GEN(x)
    6932         pari_catch_sig_on()
    6933         return self.new_gen(bnfisintnorm(self.g, t0))
     6878        cdef gen t0 = P(x)
     6879        pari_catch_sig_on()
     6880        return P.new_gen(bnfisintnorm(self.g, t0.g))
    69346881
    69356882    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))
     6883        cdef gen t0 = P(x)
     6884        pari_catch_sig_on()
     6885        return P.new_gen(bnfisnorm(self.g, t0.g, flag))
    69396886
    69406887    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))
     6888        cdef gen t0 = P(x)
     6889        pari_catch_sig_on()
     6890        return P.new_gen(bnfisprincipal0(self.g, t0.g, flag))
    69446891
    69456892    def bnfnarrow(self):
    69466893        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)))
     6894        return P.new_gen(buchnarrow(self.g))
     6895
     6896    def bnfsunit(self, S, long precision=0):
     6897        cdef gen t0 = P(S)
     6898        pari_catch_sig_on()
     6899        return P.new_gen(bnfsunit(self.g, t0.g, prec_bits_to_words(precision)))
    69536900
    69546901    def bnfunit(self):
    69556902        pari_catch_sig_on()
    6956         return self.new_gen(bnf_get_fu(self.g))       
     6903        return P.new_gen(bnf_get_fu(self.g))
    69576904
    69586905    def bnfisunit(self, x):
    6959         t0GEN(x)
    6960         pari_catch_sig_on()
    6961         return self.new_gen(bnfisunit(self.g, t0))
     6906        cdef gen t0 = P(x)
     6907        pari_catch_sig_on()
     6908        return P.new_gen(bnfisunit(self.g, t0.g))
    69626909
    69636910    def bnrclassno(self, I):
    69646911        r"""
     
    69786925            sage: K.pari_bnf().bnrclassno(p._pari_bid_())
    69796926            3
    69806927        """
    6981         t0GEN(I)
    6982         pari_catch_sig_on()
    6983         return self.new_gen(bnrclassno(self.g, t0))
     6928        cdef gen t0 = P(I)
     6929        pari_catch_sig_on()
     6930        return P.new_gen(bnrclassno(self.g, t0.g))
    69846931
    69856932    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))
     6933        cdef gen t0 = P(x)
     6934        cdef gen t1 = P(sunit_data)
     6935        pari_catch_sig_on()
     6936        return P.new_gen(bnfissunit(self.g, t1.g, t0.g))
    69906937
    69916938    def dirzetak(self, n):
    6992         t0GEN(n)
    6993         pari_catch_sig_on()
    6994         return self.new_gen(dirzetak(self.g, t0))
     6939        cdef gen t0 = P(n)
     6940        pari_catch_sig_on()
     6941        return P.new_gen(dirzetak(self.g, t0.g))
    69956942
    69966943    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))
     6944        cdef gen t0 = P(aut)
     6945        cdef gen t1 = P(x)
     6946        pari_catch_sig_on()
     6947        return P.new_gen(galoisapply(self.g, t0.g, t1.g))
    70016948
    70026949    def galoisinit(self, den=None):
    70036950        """
    70046951        galoisinit(K{,den}): calculate Galois group of number field K; see PARI manual
    70056952        for meaning of den
    70066953        """
     6954        cdef gen t0
    70076955        if den is None:
    70086956            pari_catch_sig_on()
    7009             return self.new_gen(galoisinit(self.g, NULL))
     6957            return P.new_gen(galoisinit(self.g, NULL))
    70106958        else:
    7011             t0GEN(den)
     6959            t0 = P(den)
    70126960            pari_catch_sig_on()
    7013             return self.new_gen(galoisinit(self.g, t0))
     6961            return P.new_gen(galoisinit(self.g, t0.g))
    70146962
    70156963    def galoispermtopol(self, perm):
    7016         t0GEN(perm)
    7017         pari_catch_sig_on()
    7018         return self.new_gen(galoispermtopol(self.g, t0))
     6964        cdef gen t0 = P(perm)
     6965        pari_catch_sig_on()
     6966        return P.new_gen(galoispermtopol(self.g, t0.g))
    70196967
    70206968    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)))
     6969        cdef gen t0 = P(perm)
     6970        pari_catch_sig_on()
     6971        return P.new_gen(galoisfixedfield(self.g, t0.g, flag, P.get_var(v)))
    70246972
    70256973    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))
     6974        cdef gen t0 = P(I)
     6975        cdef gen t1 = P(vdir)
     6976        pari_catch_sig_on()
     6977        return P.new_gen(idealred0(self.g, t0.g, t1.g if vdir else NULL))
    70296978
    70306979    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))
     6980        cdef gen t0 = P(x)
     6981        cdef gen t1 = P(y)
     6982        pari_catch_sig_on()
     6983        return P.new_gen(idealadd(self.g, t0.g, t1.g))
    70346984
    70356985    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))
     6986        cdef gen t0 = P(x)
     6987        cdef gen t1 = P(y)
     6988        pari_catch_sig_on()
     6989        return P.new_gen(idealaddtoone0(self.g, t0.g, t1.g))
    70396990
    70406991    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))
     6992        cdef gen t0 = P(x)
     6993        pari_catch_sig_on()
     6994        return P.new_gen(idealappr0(self.g, t0.g, flag))
    70446995
    70456996    def idealcoprime(self, x, y):
    70466997        """
     
    70627013            sage: nf.idealcoprime(x, y)
    70637014            [5/43, 9/43, -1/43]~
    70647015        """
    7065         t0GEN(x); t1GEN(y)
    7066         pari_catch_sig_on()
    7067         return self.new_gen(idealcoprime(self.g, t0, t1))
     7016        cdef gen t0 = P(x)
     7017        cdef gen t1 = P(y)
     7018        pari_catch_sig_on()
     7019        return P.new_gen(idealcoprime(self.g, t0.g, t1.g))
    70687020
    70697021    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))
     7022        cdef gen t0 = P(x)
     7023        cdef gen t1 = P(y)
     7024        pari_catch_sig_on()
     7025        return P.new_gen(idealdiv0(self.g, t0.g, t1.g, flag))
    70737026
    70747027    def idealfactor(self, x):
    7075         t0GEN(x)
    7076         pari_catch_sig_on()
    7077         return self.new_gen(idealfactor(self.g, t0))
     7028        cdef gen t0 = P(x)
     7029        pari_catch_sig_on()
     7030        return P.new_gen(idealfactor(self.g, t0.g))
    70787031
    70797032    def idealhnf(self, a, b=None):
    7080         t0GEN(a)
     7033        cdef gen t0 = P(a)
     7034        cdef gen t1
    70817035        if b is None:
    70827036            pari_catch_sig_on()
    7083             return self.new_gen(idealhnf(self.g, t0))
     7037            return P.new_gen(idealhnf(self.g, t0.g))
    70847038        else:
    7085             t1GEN(b)
     7039            t1 = P(b)
    70867040            pari_catch_sig_on()
    7087             return self.new_gen(idealhnf0(self.g, t0, t1))
     7041            return P.new_gen(idealhnf0(self.g, t0.g, t1.g))
    70887042
    70897043    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))
     7044        cdef gen t0 = P(x)
     7045        cdef gen t1 = P(y)
     7046        pari_catch_sig_on()
     7047        return P.new_gen(idealintersect(self.g, t0.g, t1.g))
    70937048
    70947049    def ideallist(self, long bound, long flag = 4):
    70957050        """
     
    71467101            sage: nf.ideallog(x, bid)
    71477102            [25]~
    71487103        """
    7149         t0GEN(x); t1GEN(bid)
    7150         pari_catch_sig_on()
    7151         return self.new_gen(ideallog(self.g, t0, t1))
     7104        cdef gen t0 = P(x)
     7105        cdef gen t1 = P(bid)
     7106        pari_catch_sig_on()
     7107        return P.new_gen(ideallog(self.g, t0.g, t1.g))
    71527108
    71537109    def idealmul(self, x, y, long flag=0):
    7154         t0GEN(x); t1GEN(y)
     7110        cdef gen t0 = P(x)
     7111        cdef gen t1 = P(y)
    71557112        pari_catch_sig_on()
    71567113        if flag == 0:
    7157             return self.new_gen(idealmul(self.g, t0, t1))
     7114            return P.new_gen(idealmul(self.g, t0.g, t1.g))
    71587115        else:
    7159             return self.new_gen(idealmulred(self.g, t0, t1))
     7116            return P.new_gen(idealmulred(self.g, t0.g, t1.g))
    71607117
    71617118    def idealnorm(self, x):
    7162         t0GEN(x)
    7163         pari_catch_sig_on()
    7164         return self.new_gen(idealnorm(self.g, t0))
     7119        cdef gen t0 = P(x)
     7120        pari_catch_sig_on()
     7121        return P.new_gen(idealnorm(self.g, t0.g))
    71657122
    71667123    def idealprimedec(nf, p):
    71677124        """
     
    71797136            sage: F[0].pr_get_p()
    71807137            5
    71817138        """
    7182         t0GEN(p)
    7183         pari_catch_sig_on()
    7184         return nf.new_gen(idealprimedec(nf.g, t0))
     7139        cdef gen t0 = P(p)
     7140        pari_catch_sig_on()
     7141        return P.new_gen(idealprimedec(nf.g, t0.g))
    71857142
    71867143    def idealstar(self, I, long flag=1):
    71877144        """
     
    72197176            sage: nf.idealstar(I)
    72207177            [[[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)]
    72217178        """
    7222         t0GEN(I)
    7223         pari_catch_sig_on()
    7224         return self.new_gen(idealstar0(self.g, t0, flag))
     7179        cdef gen t0 = P(I)
     7180        pari_catch_sig_on()
     7181        return P.new_gen(idealstar0(self.g, t0.g, flag))
    72257182
    72267183    def idealtwoelt(self, x, a=None):
    7227         t0GEN(x)
     7184        cdef gen t0 = P(x)
     7185        cdef gen t1
    72287186        if a is None:
    72297187            pari_catch_sig_on()
    7230             return self.new_gen(idealtwoelt0(self.g, t0, NULL))
     7188            return P.new_gen(idealtwoelt0(self.g, t0.g, NULL))
    72317189        else:
    7232             t1GEN(a)
     7190            t1 = P(a)
    72337191            pari_catch_sig_on()
    7234             return self.new_gen(idealtwoelt0(self.g, t0, t1))
     7192            return P.new_gen(idealtwoelt0(self.g, t0.g, t1.g))
    72357193
    72367194    def idealval(self, x, p):
    7237         cdef long v
    7238         t0GEN(x); t1GEN(p)
    7239         pari_catch_sig_on()
    7240         v = idealval(self.g, t0, t1)
     7195        cdef gen t0 = P(x)
     7196        cdef gen t1 = P(p)
     7197        pari_catch_sig_on()
     7198        v = idealval(self.g, t0.g, t1.g)
    72417199        pari_catch_sig_off()
    72427200        return v
    72437201
    72447202    def elementval(self, x, p):
    7245         cdef long v
    7246         t0GEN(x); t1GEN(p)
    7247         pari_catch_sig_on()
    7248         v = nfval(self.g, t0, t1)
     7203        cdef gen t0 = P(x)
     7204        cdef gen t1 = P(p)
     7205        pari_catch_sig_on()
     7206        v = nfval(self.g, t0.g, t1.g)
    72497207        pari_catch_sig_off()
    72507208        return v
    72517209
     
    72987256            sage: pari('x^3 - 17').nfbasis(flag = 2)
    72997257            [1, x, 1/3*x^2 - 1/3*x + 1/3]
    73007258        """
    7301         global t0
    7302         t0GEN(fa)
    7303         if typ(t0) != t_MAT:
    7304             t0 = <GEN>0
    7305         pari_catch_sig_on()
    7306         return self.new_gen(nfbasis0(self.g, flag, t0))
     7259        cdef gen t0 = P(fa)
     7260        pari_catch_sig_on()
     7261        return P.new_gen(nfbasis0(self.g, flag, t0.g if typ(t0.g) == t_MAT else NULL))
    73077262
    73087263    def nfbasis_d(self, long flag=0, fa=0):
    73097264        """
     
    73277282            sage: pari([-2,0,0,1]).Polrev().nfbasis_d()
    73287283            ([1, x, x^2], -108)
    73297284        """
    7330         global t0
    73317285        cdef GEN disc
    7332         t0GEN(fa)
    7333         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);
     7286        cdef gen t0 = P(fa)
     7287        pari_catch_sig_on()
     7288        B = P.new_gen_noclear(nfbasis(self.g, &disc, flag, t0.g if typ(t0.g) == t_MAT else NULL))
     7289        D = P.new_gen(disc);
    73387290        return B,D
    73397291
    73407292    def nfbasistoalg(nf, x):
     
    73677319            sage: Kpari.getattr('zk') * pari("[3/2, -5, 0]~")
    73687320            -5/3*y^2 + 5/3*y - 1/6
    73697321        """
    7370         t0GEN(x)
    7371         pari_catch_sig_on()
    7372         return nf.new_gen(basistoalg(nf.g, t0))
     7322        cdef gen t0 = P(x)
     7323        pari_catch_sig_on()
     7324        return P.new_gen(basistoalg(nf.g, t0.g))
    73737325
    73747326    def nfbasistoalg_lift(nf, x):
    73757327        r"""
     
    74007352            sage: Kpari.getattr('zk') * pari("[3/2, -5, 0]~")
    74017353            -5/3*y^2 + 5/3*y - 1/6
    74027354        """
    7403         t0GEN(x)
    7404         pari_catch_sig_on()
    7405         return nf.new_gen(gel(basistoalg(nf.g, t0), 2))
     7355        cdef gen t0 = P(x)
     7356        pari_catch_sig_on()
     7357        return P.new_gen(gel(basistoalg(nf.g, t0.g), 2))
    74067358
    74077359    def nfdisc(self, long flag=0, p=0):
    74087360        """
     
    74527404            sage: pari(k).nfeltdiveuc(pari(x), pari(y))
    74537405            [2, -2]~
    74547406        """
    7455         t0GEN(x); t1GEN(y)
    7456         pari_catch_sig_on()
    7457         return self.new_gen(nfdiveuc(self.g, t0, t1))
     7407        cdef gen t0 = P(x)
     7408        cdef gen t1 = P(y)
     7409        pari_catch_sig_on()
     7410        return P.new_gen(nfdiveuc(self.g, t0.g, t1.g))
    74587411
    74597412    def nfeltreduce(self, x, I):
    74607413        """
     
    74727425            sage: 12 - k(kp.nfeltreduce(12, I.pari_hnf())) in I
    74737426            True
    74747427        """
    7475         t0GEN(x); t1GEN(I)
    7476         pari_catch_sig_on()
    7477         return self.new_gen(nfreduce(self.g, t0, t1))
     7428        cdef gen t0 = P(x)
     7429        cdef gen t1 = P(I)
     7430        pari_catch_sig_on()
     7431        return P.new_gen(nfreduce(self.g, t0.g, t1.g))
    74787432
    74797433    def nffactor(self, x):
    7480         t0GEN(x)
    7481         pari_catch_sig_on()
    7482         return self.new_gen(nffactor(self.g, t0))
     7434        cdef gen t0 = P(x)
     7435        pari_catch_sig_on()
     7436        return P.new_gen(nffactor(self.g, t0.g))
    74837437
    74847438    def nfgenerator(self):
    74857439        f = self[0]
     
    75087462            sage: pari(K).nfhilbert(pari(t), pari(t+2), P.pari_prime())
    75097463            1
    75107464        """
    7511         cdef long r
    7512         t0GEN(a)
    7513         t1GEN(b)
     7465        cdef gen t0 = P(a)
     7466        cdef gen t1 = P(b)
     7467        cdef gen t2
    75147468        if p:
    7515             t2GEN(p)
     7469            t2 = P(p)
    75167470            pari_catch_sig_on()
    7517             r = nfhilbert0(self.g, t0, t1, t2)
     7471            r = nfhilbert0(self.g, t0.g, t1.g, t2.g)
    75187472        else:
    75197473            pari_catch_sig_on()
    7520             r = nfhilbert(self.g, t0, t1)
    7521         P.clear_stack()
     7474            r = nfhilbert(self.g, t0.g, t1.g)
     7475        pari_catch_sig_off()
    75227476        return r
    75237477
    75247478
     
    75847538
    75857539        - Aly Deines (2012-09-19)   
    75867540        """
    7587         t0GEN(x)
    7588         pari_catch_sig_on()
    7589         return self.new_gen(nfhnf(self.g,t0))
    7590        
    7591    
     7541        cdef gen t0 = P(x)
     7542        pari_catch_sig_on()
     7543        return P.new_gen(nfhnf(self.g, t0.g))
    75927544
    75937545
    75947546    def nfinit(self, long flag=0, long precision=0):
     
    77157667        -  ``d`` - C long integer
    77167668        """
    77177669        pari_catch_sig_on()
    7718         return self.new_gen(nfsubfields(self.g, d))
     7670        return P.new_gen(nfsubfields(self.g, d))
    77197671
    77207672    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)))
     7673        cdef gen t0 = P(T)
     7674        cdef gen t1 = P(a)
     7675        cdef gen t2 = P(v)
     7676        pari_catch_sig_on()
     7677        return P.new_gen(rnfcharpoly(self.g, t0.g, t1.g, gvar(t2.g)))
    77247678
    77257679    def rnfdisc(self, x):
    7726         t0GEN(x)
    7727         pari_catch_sig_on()
    7728         return self.new_gen(rnfdiscf(self.g, t0))
     7680        cdef gen t0 = P(x)
     7681        pari_catch_sig_on()
     7682        return P.new_gen(rnfdiscf(self.g, t0.g))
    77297683
    77307684    def rnfeltabstorel(self, x):
    7731         t0GEN(x)
    7732         pari_catch_sig_on()
    7733         return self.new_gen(rnfelementabstorel(self.g, t0))
     7685        cdef gen t0 = P(x)
     7686        pari_catch_sig_on()
     7687        return P.new_gen(rnfelementabstorel(self.g, t0.g))
    77347688
    77357689    def rnfeltreltoabs(self, x):
    7736         t0GEN(x)
    7737         pari_catch_sig_on()
    7738         return self.new_gen(rnfelementreltoabs(self.g, t0))
     7690        cdef gen t0 = P(x)
     7691        pari_catch_sig_on()
     7692        return P.new_gen(rnfelementreltoabs(self.g, t0.g))
    77397693
    77407694    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))
     7695        cdef gen t0 = P(poly)
     7696        pari_catch_sig_on()
     7697        return P.new_gen(rnfequation0(self.g, t0.g, flag))
    77447698
    77457699    def rnfidealabstorel(self, x):
    7746         t0GEN(x)
    7747         pari_catch_sig_on()
    7748         return self.new_gen(rnfidealabstorel(self.g, t0))
     7700        cdef gen t0 = P(x)
     7701        pari_catch_sig_on()
     7702        return P.new_gen(rnfidealabstorel(self.g, t0.g))
    77497703
    77507704    def rnfidealdown(self, x):
    77517705        r"""
     
    77687722            sage: rnf.rnfidealdown(P)
    77697723            [2, 0; 0, 2]
    77707724        """
    7771         t0GEN(x)
    7772         pari_catch_sig_on()
    7773         return self.new_gen(rnfidealdown(self.g, t0))
     7725        cdef gen t0 = P(x)
     7726        pari_catch_sig_on()
     7727        return P.new_gen(rnfidealdown(self.g, t0.g))
    77747728
    77757729    def rnfidealhnf(self, x):
    7776         t0GEN(x)
    7777         pari_catch_sig_on()
    7778         return self.new_gen(rnfidealhermite(self.g, t0))
     7730        cdef gen t0 = P(x)
     7731        pari_catch_sig_on()
     7732        return P.new_gen(rnfidealhermite(self.g, t0.g))
    77797733
    77807734    def rnfidealnormrel(self, x):
    7781         t0GEN(x)
    7782         pari_catch_sig_on()
    7783         return self.new_gen(rnfidealnormrel(self.g, t0))
     7735        cdef gen t0 = P(x)
     7736        pari_catch_sig_on()
     7737        return P.new_gen(rnfidealnormrel(self.g, t0.g))
    77847738
    77857739    def rnfidealreltoabs(self, x):
    7786         t0GEN(x)
    7787         pari_catch_sig_on()
    7788         return self.new_gen(rnfidealreltoabs(self.g, t0))
     7740        cdef gen t0 = P(x)
     7741        pari_catch_sig_on()
     7742        return P.new_gen(rnfidealreltoabs(self.g, t0.g))
    77897743
    77907744    def rnfidealtwoelt(self, x):
    7791         t0GEN(x)
    7792         pari_catch_sig_on()
    7793         return self.new_gen(rnfidealtwoelement(self.g, t0))
     7745        cdef gen t0 = P(x)
     7746        pari_catch_sig_on()
     7747        return P.new_gen(rnfidealtwoelement(self.g, t0.g))
    77947748
    77957749    def rnfinit(self, poly):
    77967750        """
     
    78047758            sage: g = x^5 - x^2 + y
    78057759            sage: L = K.rnfinit(g)
    78067760        """
    7807         t0GEN(poly)
    7808         pari_catch_sig_on()
    7809         return P.new_gen(rnfinit(self.g, t0))
     7761        cdef gen t0 = P(poly)
     7762        pari_catch_sig_on()
     7763        return P.new_gen(rnfinit(self.g, t0.g))
    78107764
    78117765    def rnfisfree(self, poly):
    7812         t0GEN(poly)
    7813         pari_catch_sig_on()
    7814         r = rnfisfree(self.g, t0)
     7766        cdef gen t0 = P(poly)
     7767        pari_catch_sig_on()
     7768        r = rnfisfree(self.g, t0.g)
    78157769        pari_catch_sig_off()
    78167770        return r
    78177771
     
    78617815            2/15
    78627816        """
    78637817        pari_catch_sig_on()
    7864         return self.new_gen(content(self.g))
     7818        return P.new_gen(content(self.g))
    78657819
    78667820    def deriv(self, v=-1):
    78677821        pari_catch_sig_on()
    7868         return self.new_gen(deriv(self.g, self.get_var(v)))
     7822        return P.new_gen(deriv(self.g, P.get_var(v)))
    78697823
    78707824    def eval(self, x):
    7871         t0GEN(x)
    7872         pari_catch_sig_on()
    7873         return self.new_gen(poleval(self.g, t0))
     7825        cdef gen t0 = P(x)
     7826        pari_catch_sig_on()
     7827        return P.new_gen(poleval(self.g, t0.g))
    78747828
    78757829    def __call__(self, x):
    78767830        return self.eval(x)
     
    78897843            sage: pari(x^2 - 2).factornf(K.pari_polynomial("a"))
    78907844            [x + Mod(-4*a, 8*a^2 - 1), 1; x + Mod(4*a, 8*a^2 - 1), 1]
    78917845        """
    7892         t0GEN(t)
    7893         pari_catch_sig_on()
    7894         return self.new_gen(polfnf(self.g, t0))
     7846        cdef gen t0 = P(t)
     7847        pari_catch_sig_on()
     7848        return P.new_gen(polfnf(self.g, t0.g))
    78957849
    78967850    def factorpadic(self, p, long r=20, long flag=0):
    78977851        """
     
    78997853        polynomial x to precision r. flag is optional and may be set to 0
    79007854        (use round 4) or 1 (use Buchmann-Lenstra)
    79017855        """
    7902         t0GEN(p)
    7903         pari_catch_sig_on()
    7904         return self.new_gen(factorpadic0(self.g, t0, r, flag))
     7856        cdef gen t0 = P(p)
     7857        pari_catch_sig_on()
     7858        return P.new_gen(factorpadic0(self.g, t0.g, r, flag))
    79057859
    79067860    def factormod(self, p, long flag=0):
    79077861        """
     
    79107864        simple factormod, same except that only the degrees of the
    79117865        irreducible factors are given.
    79127866        """
    7913         t0GEN(p)
    7914         pari_catch_sig_on()
    7915         return self.new_gen(factormod0(self.g, t0, flag))
     7867        cdef gen t0 = P(p)
     7868        pari_catch_sig_on()
     7869        return P.new_gen(factormod0(self.g, t0.g, flag))
    79167870
    79177871    def intformal(self, y=-1):
    79187872        """
     
    79207874        variable of y, or to the main variable of x if y is omitted
    79217875        """
    79227876        pari_catch_sig_on()
    7923         return self.new_gen(integ(self.g, self.get_var(y)))
     7877        return P.new_gen(integ(self.g, P.get_var(y)))
    79247878
    79257879    def padicappr(self, a):
    79267880        """
    79277881        x.padicappr(a): p-adic roots of the polynomial x congruent to a mod
    79287882        p
    79297883        """
    7930         t0GEN(a)
    7931         pari_catch_sig_on()
    7932         return self.new_gen(padicappr(self.g, t0))
     7884        cdef gen t0 = P(a)
     7885        pari_catch_sig_on()
     7886        return P.new_gen(padicappr(self.g, t0.g))
    79337887
    79347888    def newtonpoly(self, p):
    79357889        """
     
    79427896            sage: x.newtonpoly(3)
    79437897            [1, 1, -1/3, -1/3, -1/3, -1/3, -1/3, -1/3]
    79447898        """
    7945         t0GEN(p)
    7946         pari_catch_sig_on()
    7947         return self.new_gen(newtonpoly(self.g, t0))
     7899        cdef gen t0 = P(p)
     7900        pari_catch_sig_on()
     7901        return P.new_gen(newtonpoly(self.g, t0.g))
    79487902
    79497903    def polcoeff(self, long n, var=-1):
    79507904        """
     
    79637917            x
    79647918        """
    79657919        pari_catch_sig_on()
    7966         return self.new_gen(polcoeff0(self.g, n, self.get_var(var)))
     7920        return P.new_gen(polcoeff0(self.g, n, P.get_var(var)))
    79677921
    79687922    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))
     7923        cdef gen t0 = P(pol2)
     7924        pari_catch_sig_on()
     7925        return P.new_gen(polcompositum0(self.g, t0.g, flag))
    79727926
    79737927    def poldegree(self, var=-1):
    79747928        """
    79757929        f.poldegree(var=x): Return the degree of this polynomial.
    79767930        """
    79777931        pari_catch_sig_on()
    7978         n = poldegree(self.g, self.get_var(var))
     7932        n = poldegree(self.g, P.get_var(var))
    79797933        pari_catch_sig_off()
    79807934        return n
    79817935
     
    80187972            sage: nf.nfgaloisconj()
    80197973            [-x, x]~
    80207974        """
    8021         global t0
    8022         if denom is not None:
    8023             t0GEN(denom)
     7975        cdef gen t0
     7976        if denom is None:
     7977            pari_catch_sig_on()
     7978            return P.new_gen(galoisconj0(self.g, flag, NULL, prec_bits_to_words(precision)))
    80247979        else:
    8025             t0 = NULL
    8026         pari_catch_sig_on()
    8027         return self.new_gen(galoisconj0(self.g, flag, t0, pbw(precision)))
     7980            t0 = P(denom)
     7981            pari_catch_sig_on()
     7982            return P.new_gen(galoisconj0(self.g, flag, t0.g, prec_bits_to_words(precision)))
    80287983
    80297984    def nfroots(self, poly):
    80307985        r"""
     
    80447999            sage: nf.nfroots(y^4 + 2)
    80458000            [Mod(-zz, zz^4 + 2), Mod(zz, zz^4 + 2)]
    80468001        """
    8047         t0GEN(poly)
    8048         pari_catch_sig_on()
    8049         return self.new_gen(nfroots(self.g, t0))
     8002        cdef gen t0 = P(poly)
     8003        pari_catch_sig_on()
     8004        return P.new_gen(nfroots(self.g, t0.g))
    80508005       
    80518006    def polhensellift(self, y, p, long e):
    80528007        """
     
    80548009        modulo p to a factorization modulo `p^e` using Hensel lift.
    80558010        The factors in y must be pairwise relatively prime modulo p.
    80568011        """
    8057         t0GEN(y)
    8058         t1GEN(p)
    8059         pari_catch_sig_on()
    8060         return self.new_gen(polhensellift(self.g, t0, t1, e))
     8012        cdef gen t0 = P(y)
     8013        cdef gen t1 = P(p)
     8014        pari_catch_sig_on()
     8015        return P.new_gen(polhensellift(self.g, t0.g, t1.g, e))
    80618016
    80628017    def polisirreducible(self):
    80638018        """
     
    80768031        variable v otherwise
    80778032        """
    80788033        pari_catch_sig_on()
    8079         return self.new_gen(pollead(self.g, self.get_var(v)))
     8034        return P.new_gen(pollead(self.g, P.get_var(v)))
    80808035
    80818036    def polrecip(self):
    80828037        pari_catch_sig_on()
    8083         return self.new_gen(polrecip(self.g))
     8038        return P.new_gen(polrecip(self.g))
    80848039   
    80858040    def polred(self, flag=0, fa=None):
     8041        cdef gen t0
    80868042        if fa is None:
    80878043            pari_catch_sig_on()
    8088             return self.new_gen(polred0(self.g, flag, NULL))
     8044            return P.new_gen(polred0(self.g, flag, NULL))
    80898045        else:
    8090             t0GEN(fa)
     8046            t0 = P(fa)
    80918047            pari_catch_sig_on()
    8092             return self.new_gen(polred0(self.g, flag, t0))
     8048            return P.new_gen(polred0(self.g, flag, t0.g))
    80938049
    80948050    def polredabs(self, flag=0):
    80958051        pari_catch_sig_on()
    8096         return self.new_gen(polredabs0(self.g, flag))
     8052        return P.new_gen(polredabs0(self.g, flag))
    80978053
    80988054    def polredbest(self, flag=0):
    80998055        pari_catch_sig_on()
    8100         return self.new_gen(polredbest(self.g, flag))
     8056        return P.new_gen(polredbest(self.g, flag))
    81018057
    81028058    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))
     8059        cdef gen t0 = P(y)
     8060        pari_catch_sig_on()
     8061        return P.new_gen(polresultant0(self.g, t0.g, P.get_var(var), flag))
    81068062
    81078063    def polroots(self, flag=0, precision=0):
    81088064        """
     
    81118067        by Gourdon, or 1: uses a modified Newton method.
    81128068        """
    81138069        pari_catch_sig_on()
    8114         return self.new_gen(roots0(self.g, flag, pbw(precision)))
     8070        return P.new_gen(roots0(self.g, flag, prec_bits_to_words(precision)))
    81158071   
    81168072    def polrootsmod(self, p, flag=0):
    8117         t0GEN(p)
    8118         pari_catch_sig_on()
    8119         return self.new_gen(rootmod0(self.g, t0, flag))
     8073        cdef gen t0 = P(p)
     8074        pari_catch_sig_on()
     8075        return P.new_gen(rootmod0(self.g, t0.g, flag))
    81208076
    81218077    def polrootspadic(self, p, r=20):
    8122         t0GEN(p)
    8123         pari_catch_sig_on()
    8124         return self.new_gen(rootpadic(self.g, t0, r))
     8078        cdef gen t0 = P(p)
     8079        pari_catch_sig_on()
     8080        return P.new_gen(rootpadic(self.g, t0.g, r))
    81258081
    81268082    def polrootspadicfast(self, p, r=20):
    8127         t0GEN(p)
    8128         pari_catch_sig_on()
    8129         return self.new_gen(rootpadicfast(self.g, t0, r))
     8083        cdef gen t0 = P(p)
     8084        pari_catch_sig_on()
     8085        return P.new_gen(rootpadicfast(self.g, t0.g, r))
    81308086
    81318087    def polsturm(self, a, b):
    8132         t0GEN(a)
    8133         t1GEN(b)
    8134         pari_catch_sig_on()
    8135         n = sturmpart(self.g, t0, t1)
     8088        cdef gen t0 = P(a)
     8089        cdef gen t1 = P(b)
     8090        pari_catch_sig_on()
     8091        n = sturmpart(self.g, t0.g, t1.g)
    81368092        pari_catch_sig_off()
    81378093        return n
    81388094
     
    81438099        return n
    81448100
    81458101    def polsylvestermatrix(self, g):
    8146         t0GEN(g)
    8147         pari_catch_sig_on()
    8148         return self.new_gen(sylvestermatrix(self.g, t0))
     8102        cdef gen t0 = P(g)
     8103        pari_catch_sig_on()
     8104        return P.new_gen(sylvestermatrix(self.g, t0.g))
    81498105
    81508106    def polsym(self, long n):
    81518107        pari_catch_sig_on()
    8152         return self.new_gen(polsym(self.g, n))
     8108        return P.new_gen(polsym(self.g, n))
    81538109
    81548110    def serconvol(self, g):
    8155         t0GEN(g)
    8156         pari_catch_sig_on()
    8157         return self.new_gen(convol(self.g, t0))
     8111        cdef gen t0 = P(g)
     8112        pari_catch_sig_on()
     8113        return P.new_gen(convol(self.g, t0.g))
    81588114
    81598115    def serlaplace(self):
    81608116        pari_catch_sig_on()
    8161         return self.new_gen(laplace(self.g))
     8117        return P.new_gen(laplace(self.g))
    81628118
    81638119    def serreverse(self):
    81648120        """
     
    81798135            x + O(x^4)
    81808136        """
    81818137        pari_catch_sig_on()
    8182         return self.new_gen(recip(self.g))
     8138        return P.new_gen(recip(self.g))
    81838139   
    81848140    def thueinit(self, flag=0):
    81858141        pari_catch_sig_on()
    8186         return self.new_gen(thueinit(self.g, flag, prec))
     8142        return P.new_gen(thueinit(self.g, flag, prec))
    81878143
    81888144
    81898145    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))
     8146        cdef gen t0 = P(polrel)
     8147        pari_catch_sig_on()
     8148        return P.new_gen(rnfisnorminit(self.g, t0.g, flag))
    81938149
    81948150    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))
     8151        cdef gen t0 = P(T)
     8152        pari_catch_sig_on()
     8153        return P.new_gen(rnfisnorm(t0.g, self.g, flag))
    81988154
    81998155    ###########################################
    82008156    # 8: Vectors, matrices, LINEAR ALGEBRA and sets
     
    82148170           This function uses the PARI row and column indexing, so the
    82158171           first row or column is indexed by 1 instead of 0.
    82168172        """
    8217         t0GEN(y)
     8173        cdef gen t0 = P(y)
     8174        cdef gen t1
    82188175        if z is None:
    82198176            pari_catch_sig_on()
    8220             return P.new_gen(shallowextract(self.g, t0))
     8177            return P.new_gen(shallowextract(self.g, t0.g))
    82218178        else:
    8222             t1GEN(z)
     8179            t1 = P(z)
    82238180            pari_catch_sig_on()
    8224             return P.new_gen(extract0(self.g, t0, t1))
     8181            return P.new_gen(extract0(self.g, t0.g, t1.g))
    82258182
    82268183    def ncols(self):
    82278184        """
     
    83288285        robust, slower implementation, valid for non integral quadratic
    83298286        forms.
    83308287        """
    8331         t0GEN(B)
    8332         t1GEN(max)
    8333         pari_catch_sig_on()
    8334         return self.new_gen(qfminim0(self.g,t0,t1,flag,precdl))
     8288        cdef gen t0 = P(B)
     8289        cdef gen t1 = P(max)
     8290        pari_catch_sig_on()
     8291        return P.new_gen(qfminim0(self.g, t0.g, t1.g, flag, precdl))
    83358292
    83368293    def qfrep(self, B, long flag=0):
    83378294        """
     
    83408297        digits of flag mean 1: count vectors of even norm from 1 to 2B, 2:
    83418298        return a t_VECSMALL instead of a t_VEC.
    83428299        """
    8343         t0GEN(B)
    8344         pari_catch_sig_on()
    8345         return self.new_gen(qfrep0(self.g,t0,flag))
     8300        cdef gen t0 = P(B)
     8301        pari_catch_sig_on()
     8302        return P.new_gen(qfrep0(self.g, t0.g, flag))
    83468303
    83478304    def matsolve(self, B):
    83488305        """
     
    83678324            sage: pari('[1,1;1,-1]').matsolve(pari('[1;0]'))
    83688325            [1/2; 1/2]
    83698326        """
    8370         t0GEN(B)
    8371         pari_catch_sig_on()
    8372         return self.new_gen(gauss(self.g,t0))
     8327        cdef gen t0 = P(B)
     8328        pari_catch_sig_on()
     8329        return P.new_gen(gauss(self.g, t0.g))
    83738330   
    83748331    def matsolvemod(self, D, B, long flag = 0):
    83758332        r"""
     
    84138370            sage: M2.matsolvemod(9, pari('[2,45]~'), 1)
    84148371            [[1, 1]~, [-1, -4; 1, -5]]
    84158372        """
    8416         t0GEN(D)
    8417         t1GEN(B)
    8418         pari_catch_sig_on()
    8419         return self.new_gen(matsolvemod0(self.g, t0, t1, flag))
     8373        cdef gen t0 = P(D)
     8374        cdef gen t1 = P(B)
     8375        pari_catch_sig_on()
     8376        return P.new_gen(matsolvemod0(self.g, t0.g, t1.g, flag))
    84208377   
    84218378    def matker(self, long flag=0):
    84228379        """
     
    85638520            sage: pari(M).mathnfmod(12)
    85648521            [1, 0, 0; 0, 2, 0; 0, 0, 6]
    85658522        """
    8566         t0GEN(d)
    8567         pari_catch_sig_on()
    8568         return self.new_gen(hnfmod(self.g, t0))
     8523        cdef gen t0 = P(d)
     8524        pari_catch_sig_on()
     8525        return P.new_gen(hnfmod(self.g, t0.g))
    85698526
    85708527    def mathnfmodid(self, d):
    85718528        """
     
    85928549            sage: pari(M).mathnfmod(6)
    85938550            [1, 0, 0; 0, 1, 0; 0, 0, 6]
    85948551        """
    8595         t0GEN(d)
    8596         pari_catch_sig_on()
    8597         return self.new_gen(hnfmodid(self.g, t0))
     8552        cdef gen t0 = P(d)
     8553        pari_catch_sig_on()
     8554        return P.new_gen(hnfmodid(self.g, t0.g))
    85988555
    85998556    def matsnf(self, flag=0):
    86008557        """
     
    87018658            PariError: sorry, factor for general polynomials is not yet implemented
    87028659        """
    87038660        cdef int r
     8661        cdef GEN t0
    87048662        cdef GEN cutoff
    87058663        if limit == -1 and typ(self.g) == t_INT and proof:
    87068664            pari_catch_sig_on()
     
    87228680    ###########################################
    87238681
    87248682    def hilbert(x, y, p):
    8725         cdef long ret
    8726         t0GEN(y)
    8727         t1GEN(p)
    8728         pari_catch_sig_on()
    8729         ret = hilbert0(x.g, t0, t1)
     8683        cdef gen t0 = P(y)
     8684        cdef gen t1 = P(p)
     8685        pari_catch_sig_on()
     8686        ret = hilbert0(x.g, t0.g, t1.g)
    87308687        pari_catch_sig_off()
    87318688        return ret
    87328689       
    87338690    def chinese(self, y):
    8734         t0GEN(y)
    8735         pari_catch_sig_on()
    8736         return P.new_gen(chinese(self.g, t0))
     8691        cdef gen t0 = P(y)
     8692        pari_catch_sig_on()
     8693        return P.new_gen(chinese(self.g, t0.g))
    87378694
    87388695    def order(self):
    87398696        pari_catch_sig_on()       
     
    88678824            sage: f.subst(x, "xyz")^2
    88688825            xyz^6 + 34*xyz^4 + 6*xyz^3 + 289*xyz^2 + 102*xyz + 9
    88698826        """
    8870         cdef long n
    8871         n = P.get_var(var)
    8872         t0GEN(z)
    8873         pari_catch_sig_on()
    8874         return P.new_gen(gsubst(self.g, n, t0))
     8827        cdef gen t0 = P(z)
     8828        pari_catch_sig_on()
     8829        cdef long n = P.get_var(var)
     8830        return P.new_gen(gsubst(self.g, n, t0.g))
    88758831
    88768832    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))
     8833        cdef gen t0 = P(y)
     8834        cdef gen t1 = P(z)
     8835        pari_catch_sig_on()
     8836        return P.new_gen(gsubstpol(self.g, t0.g, t1.g))
    88818837
    88828838    def nf_subst(self, z):
    88838839        """
     
    89168872            sage: Lpari.bnf_get_cyc()  # We still have a bnf after substituting
    89178873            [2]
    89188874        """
    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))
     8875        cdef gen t0 = P(z)
     8876        pari_catch_sig_on()
     8877        return P.new_gen(gsubst(self.g, gvar(self.g), t0.g))
    89238878
    89248879    def taylor(self, v=-1):
    89258880        pari_catch_sig_on()
    8926         return self.new_gen(tayl(self.g, self.get_var(v), precdl))
     8881        return P.new_gen(tayl(self.g, P.get_var(v), precdl))
    89278882
    89288883    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))
     8884        cdef gen t0 = P(rhs)
     8885        cdef gen t1 = P(ne)
     8886        pari_catch_sig_on()
     8887        return P.new_gen(thue(self.g, t0.g, t1.g))
    89338888
    89348889    def charpoly(self, var=-1, flag=0):
    89358890        """
     
    89438898
    89448899
    89458900    def kronecker(gen self, y):
    8946         t0GEN(y)
     8901        cdef gen t0 = P(y)
    89478902        pari_catch_sig_on()       
    8948         return P.new_gen(gkronecker(self.g, t0))
     8903        return P.new_gen(gkronecker(self.g, t0.g))
    89498904
    89508905
    89518906    def type(gen self):
     
    90138968        P(self[i]) = ya[i] for all i). Also return an error estimate on the
    90148969        returned value.
    90158970        """
    9016         t0GEN(ya)
    9017         t1GEN(x)
     8971        cdef gen t0 = P(ya)
     8972        cdef gen t1 = P(x)
    90188973        cdef GEN dy, g
    90198974        pari_catch_sig_on()
    9020         g = polint(self.g, t0, t1, &dy)
    9021         dif = self.new_gen_noclear(dy)
    9022         return self.new_gen(g), dif
     8975        g = polint(self.g, t0.g, t1.g, &dy)
     8976        dif = P.new_gen_noclear(dy)
     8977        return P.new_gen(g), dif
    90238978
    90248979    def algdep(self, long n):
    90258980        """
     
    90378992            210
    90388993        """
    90398994        pari_catch_sig_on()
    9040         return self.new_gen(algdep(self.g, n))
     8995        return P.new_gen(algdep(self.g, n))
    90418996
    90428997    def concat(self, y):
    9043         t0GEN(y)
    9044         pari_catch_sig_on()
    9045         return self.new_gen(concat(self.g, t0))
     8998        cdef gen t0 = P(y)
     8999        pari_catch_sig_on()
     9000        return P.new_gen(concat(self.g, t0.g))
    90469001
    90479002    def lindep(self, flag=0):
    90489003        pari_catch_sig_on()
    9049         return self.new_gen(lindep0(self.g, flag))
     9004        return P.new_gen(lindep0(self.g, flag))
    90509005
    90519006    def listinsert(self, obj, long n):
    9052         t0GEN(obj)
    9053         pari_catch_sig_on()
    9054         return self.new_gen(listinsert(self.g, t0, n))
     9007        cdef gen t0 = P(obj)
     9008        pari_catch_sig_on()
     9009        return P.new_gen(listinsert(self.g, t0.g, n))
    90559010
    90569011    def listput(self, obj, long n):
    9057         t0GEN(obj)
    9058         pari_catch_sig_on()
    9059         return self.new_gen(listput(self.g, t0, n))
     9012        cdef gen t0 = P(obj)
     9013        pari_catch_sig_on()
     9014        return P.new_gen(listput(self.g, t0.g, n))
    90609015
    90619016
    90629017
     
    91679122            sage: E.ellwp(1, flag=1)
    91689123            [13.9658695257485 + 0.E-18*I, 50.5619300880073 ... E-18*I]
    91699124        """
    9170         t0GEN(z)
     9125        cdef gen t0 = P(z)
    91719126        pari_catch_sig_on()
    91729127        cdef long dprec
    9173         dprec = gprecision(t0)
     9128        dprec = gprecision(t0.g)
    91749129        if dprec:
    91759130            dprec = prec_words_to_dec(dprec)
    91769131        else:
    91779132            dprec = prec
    9178         return self.new_gen(ellwp0(self.g, t0, flag, n+2, dprec))
     9133        return P.new_gen(ellwp0(self.g, t0.g, flag, n+2, dprec))
    91799134
    91809135    def ellchangepoint(self, y):
    91819136        """
     
    91989153            sage: f.ellisoncurve([-1,4])
    91999154            True
    92009155        """
    9201         t0GEN(y)
    9202         pari_catch_sig_on()
    9203         return self.new_gen(ellchangepoint(self.g, t0))
     9156        cdef gen t0 = P(y)
     9157        pari_catch_sig_on()
     9158        return P.new_gen(ellchangepoint(self.g, t0.g))
    92049159
    92059160    def debug(gen self, long depth = -1):
    92069161        r"""
     
    94469401        """
    94479402        return int(self.default('debug'))
    94489403
    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 
    94599404    def set_real_precision(self, long n):
    94609405        """
    94619406        Sets the PARI default real precision.
     
    94979442
    94989443    def get_series_precision(self):
    94999444        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     ###########################################
     9445
     9446    cdef void clear_stack(self):
     9447        """
     9448        Call ``pari_catch_sig_off()``, and clear the entire PARI stack
     9449        if we are leaving the outermost ``pari_catch_sig_on() ...
     9450        pari_catch_sig_off()`` block.
     9451
     9452        """
     9453        global mytop, avma
     9454        if _signals.sig_on_count <= 1:
     9455            avma = mytop
     9456        pari_catch_sig_off()
    95079457
    95089458    cdef gen new_gen(self, GEN x):
    95099459        """
    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()
     9460        Create a new gen wrapping `x`, then call ``clear_stack()``.
     9461        """
     9462        cdef gen g = _new_gen(x)
     9463        self.clear_stack()
    95189464        return g
    95199465
    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 
    95479466    cdef gen new_gen_noclear(self, GEN x):
    95489467        """
    95499468        Create a new gen, but don't free any memory on the stack and don't
     
    97249643        """
    97259644        Create a new complex number, initialized from re and im.
    97269645        """
    9727         t0GEN(re)
    9728         t1GEN(im)
    9729         cdef GEN cp
    9730         pari_catch_sig_on()
    9731         cp = cgetg(3, t_COMPLEX)
    9732         set_gel(cp, 1, t0)
    9733         set_gel(cp, 2, t1)
     9646        cdef gen t0 = self(re)
     9647        cdef gen t1 = self(im)
     9648        pari_catch_sig_on()
     9649        cdef GEN cp = mkcomplex(t0.g, t1.g)
    97349650        return self.new_gen(cp)
    97359651
    97369652    cdef GEN deepcopy_to_python_heap(self, GEN x, pari_sp* address):
     
    97939709
    97949710        See :func:`pari` for more examples.
    97959711        """
     9712        cdef GEN g
    97969713        cdef int length, i
     9714        cdef mpz_t mpz_int
    97979715        cdef gen v
    97989716
    9799         late_import()
    9800        
    98019717        if isinstance(s, gen):
    98029718            return s
    9803         elif isinstance(s, Integer):
    9804             return self.new_gen_from_mpz_t(<void *>s + mpz_t_offset)
    98059719        elif PyObject_HasAttrString(s, "_pari_"):
    98069720            return s._pari_()
    98079721
     
    98119725            return self.new_gen(stoi(PyInt_AS_LONG(s)))
    98129726        if PyBool_Check(s):
    98139727            return self.PARI_ONE if s else self.PARI_ZERO
    9814         cdef mpz_t mpz_int
    9815         cdef GEN g
    98169728        if PyLong_Check(s):
    98179729            pari_catch_sig_on()
    98189730            mpz_init(mpz_int)
     
    98399751            return v
    98409752
    98419753        t = str(s)
    9842         pari_catch_sig_str('evaluating PARI string')
     9754        pari_catch_sig_on()
    98439755        g = gp_read_str(t)
    98449756        if g == gnil:
    98459757            pari_catch_sig_off()
     
    1038010292            sage: cyclotomic_polynomial(8)(2)
    1038110293            17
    1038210294        """
    10383         t0GEN(v)
    10384         pari_catch_sig_on()
    10385         return self.new_gen(polcyclo_eval(n, t0))
     10295        cdef gen t0 = self(v)
     10296        pari_catch_sig_on()
     10297        return self.new_gen(polcyclo_eval(n, t0.g))
    1038610298
    1038710299    def polsubcyclo(self, long n, long d, v=-1):
    1038810300        """
     
    1045010362            ...
    1045110363            PariError: incorrect type in setrand
    1045210364        """
    10453         t0GEN(seed)
    10454         pari_catch_sig_on()
    10455         setrand(t0)
     10365        cdef gen t0 = self(seed)
     10366        pari_catch_sig_on()
     10367        setrand(t0.g)
    1045610368        pari_catch_sig_off()
    1045710369
    1045810370    def getrand(self):
  • 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        """