Ticket #10061: 10061_fix_sig_on_sig_off.patch

File 10061_fix_sig_on_sig_off.patch, 45.7 KB (added by jdemeyer, 9 years ago)
  • sage/ext/gmp.pxi

    # HG changeset patch
    # User Jeroen Demeyer <jdemeyer@cage.ugent.be>
    # Date 1286661351 -7200
    # Node ID 37b3eef312daede262510475697cfbdb7ac33d52
    # Parent  9db1faa4044ea662dfbbb5632e15e61a0c3a3420
    #10061: Fix sig_on()/sig_off() bugs
    
    diff -r 9db1faa4044e -r 37b3eef312da sage/ext/gmp.pxi
    a b  
    99#
    1010# to include this in a file.
    1111
     12include '../ext/interrupt.pxi'
     13
    1214############ The following is the "one global set of vars"
    1315cdef extern from "gmp_globals.h":
    1416    cdef mpz_t u, v, q, u0, u1, u2, v0, v1, v2, t0, t1, t2, x, y, ssqr, m2
     
    100102##     t = str(s)
    101103##     print 'm = ', t
    102104##     #debug
     105    sig_on()
    103106    mpz_mod(a, a, m)     # a = a % m
    104107    if mpz_sgn(a) == 0 or mpz_sgn(m) == 0:    # a or m is zero
    105108        mpq_set_si(answer, 0, 1)              # return 0
     109        sig_off()
    106110        return 0
    107111    if mpz_sgn(m) < 0:  # m negative
    108112        mpz_neg(m, m)   # replace m by -m
     
    110114        mpz_sub(a, m, a)  # replace a by m - a
    111115    if mpz_cmp_si(a, 1) == 0:   # if a is 1
    112116        mpq_set_si(answer, 1, 1)
     117        sig_off()
    113118        return 0
    114119
    115120    mpz_set(u, m)       # u = m
     
    139144        mpq_set_z(answer, y)
    140145        mpq_set_z(tmp, x)
    141146        mpq_div(answer, answer, tmp)
     147        sig_off()
    142148        return 0
    143149
     150    sig_off()
    144151    raise ValueError, "Rational reconstruction of %s (mod %s) does not exist."%(mpz_to_str(a),mpz_to_str(m))
    145152
    146153
  • sage/graphs/generic_graph_pyx.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/graphs/generic_graph_pyx.pyx
    a b  
    728728
    729729                # We have found our copy !!!
    730730                if self.active == self.nh-1:
     731                    sig_off()
    731732                    return [self.g_vertices[self.stack[l]] for l in xrange(self.nh)]
    732733
    733734                # We are still missing several vertices ...
  • sage/libs/mpmath/ext_main.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/libs/mpmath/ext_main.pyx
    a b  
    673673        cdef mpc rc
    674674        cdef MPopts workopts
    675675        cdef int styp, ttyp
    676         MPF_init(&sre)
    677         MPF_init(&sim)
    678         MPF_init(&tre)
    679         MPF_init(&tim)
    680         MPF_init(&tmp)
    681676        workopts = global_opts
    682677        workopts.prec = workopts.prec * 2 + 50
    683678        workopts.rounding = ROUND_D
    684679        unknown = global_context.zero
    685         sig_on()
    686         styp = 1
    687         for term in terms:
    688             ttyp = MPF_set_any(&tre, &tim, term, workopts, 0)
    689             if ttyp == 0:
    690                 if absolute: term = ctx.absmax(term)
    691                 if squared: term = term**2
    692                 unknown += term
    693                 continue
    694             if absolute:
    695                 if squared:
     680        try:  # Way down, there is a ``finally`` with sig_off()
     681            sig_on()
     682            MPF_init(&sre)
     683            MPF_init(&sim)
     684            MPF_init(&tre)
     685            MPF_init(&tim)
     686            MPF_init(&tmp)
     687            styp = 1
     688            for term in terms:
     689                ttyp = MPF_set_any(&tre, &tim, term, workopts, 0)
     690                if ttyp == 0:
     691                    if absolute: term = ctx.absmax(term)
     692                    if squared: term = term**2
     693                    unknown += term
     694                    continue
     695                if absolute:
     696                    if squared:
     697                        if ttyp == 1:
     698                            MPF_mul(&tre, &tre, &tre, opts_exact)
     699                            MPF_add(&sre, &sre, &tre, workopts)
     700                        elif ttyp == 2:
     701                            # |(a+bi)^2| = a^2+b^2
     702                            MPF_mul(&tre, &tre, &tre, opts_exact)
     703                            MPF_add(&sre, &sre, &tre, workopts)
     704                            MPF_mul(&tim, &tim, &tim, opts_exact)
     705                            MPF_add(&sre, &sre, &tim, workopts)
     706                    else:
     707                        if ttyp == 1:
     708                            MPF_abs(&tre, &tre)
     709                            MPF_add(&sre, &sre, &tre, workopts)
     710                        elif ttyp == 2:
     711                            # |a+bi| = sqrt(a^2+b^2)
     712                            MPF_mul(&tre, &tre, &tre, opts_exact)
     713                            MPF_mul(&tim, &tim, &tim, opts_exact)
     714                            MPF_add(&tre, &tre, &tim, workopts)
     715                            MPF_sqrt(&tre, &tre, workopts)
     716                            MPF_add(&sre, &sre, &tre, workopts)
     717                elif squared:
    696718                    if ttyp == 1:
    697719                        MPF_mul(&tre, &tre, &tre, opts_exact)
    698720                        MPF_add(&sre, &sre, &tre, workopts)
    699721                    elif ttyp == 2:
    700                         # |(a+bi)^2| = a^2+b^2
     722                        # (a+bi)^2 = a^2-b^2 + 2i*ab
     723                        MPF_mul(&tmp, &tre, &tim, opts_exact)
     724                        MPF_mul(&tmp, &tmp, &MPF_C_2, opts_exact)
     725                        MPF_add(&sim, &sim, &tmp, workopts)
    701726                        MPF_mul(&tre, &tre, &tre, opts_exact)
    702727                        MPF_add(&sre, &sre, &tre, workopts)
    703728                        MPF_mul(&tim, &tim, &tim, opts_exact)
    704                         MPF_add(&sre, &sre, &tim, workopts)
     729                        MPF_sub(&sre, &sre, &tim, workopts)
     730                        styp = 2
    705731                else:
    706732                    if ttyp == 1:
    707                         MPF_abs(&tre, &tre)
    708733                        MPF_add(&sre, &sre, &tre, workopts)
    709734                    elif ttyp == 2:
    710                         # |a+bi| = sqrt(a^2+b^2)
    711                         MPF_mul(&tre, &tre, &tre, opts_exact)
    712                         MPF_mul(&tim, &tim, &tim, opts_exact)
    713                         MPF_add(&tre, &tre, &tim, workopts)
    714                         MPF_sqrt(&tre, &tre, workopts)
    715735                        MPF_add(&sre, &sre, &tre, workopts)
    716             elif squared:
    717                 if ttyp == 1:
    718                     MPF_mul(&tre, &tre, &tre, opts_exact)
    719                     MPF_add(&sre, &sre, &tre, workopts)
    720                 elif ttyp == 2:
    721                     # (a+bi)^2 = a^2-b^2 + 2i*ab
    722                     MPF_mul(&tmp, &tre, &tim, opts_exact)
    723                     MPF_mul(&tmp, &tmp, &MPF_C_2, opts_exact)
    724                     MPF_add(&sim, &sim, &tmp, workopts)
    725                     MPF_mul(&tre, &tre, &tre, opts_exact)
    726                     MPF_add(&sre, &sre, &tre, workopts)
    727                     MPF_mul(&tim, &tim, &tim, opts_exact)
    728                     MPF_sub(&sre, &sre, &tim, workopts)
    729                     styp = 2
     736                        MPF_add(&sim, &sim, &tim, workopts)
     737                        styp = 2
     738            MPF_clear(&tre)
     739            MPF_clear(&tim)
     740            if styp == 1:
     741                rr = PY_NEW(mpf)
     742                MPF_set(&rr.value, &sre)
     743                MPF_clear(&sre)
     744                MPF_clear(&sim)
     745                MPF_normalize(&rr.value, global_opts)
     746                if unknown is not global_context.zero:
     747                    return ctx._stupid_add(rr, unknown)
     748                return rr
     749            elif styp == 2:
     750                rc = PY_NEW(mpc)
     751                MPF_set(&rc.re, &sre)
     752                MPF_set(&rc.im, &sim)
     753                MPF_clear(&sre)
     754                MPF_clear(&sim)
     755                MPF_normalize(&rc.re, global_opts)
     756                MPF_normalize(&rc.im, global_opts)
     757                if unknown is not global_context.zero:
     758                    return ctx._stupid_add(rc, unknown)
     759                return rc
    730760            else:
    731                 if ttyp == 1:
    732                     MPF_add(&sre, &sre, &tre, workopts)
    733                 elif ttyp == 2:
    734                     MPF_add(&sre, &sre, &tre, workopts)
    735                     MPF_add(&sim, &sim, &tim, workopts)
    736                     styp = 2
    737         MPF_clear(&tre)
    738         MPF_clear(&tim)
    739         if styp == 1:
    740             rr = PY_NEW(mpf)
    741             MPF_set(&rr.value, &sre)
    742             MPF_clear(&sre)
    743             MPF_clear(&sim)
    744             MPF_normalize(&rr.value, global_opts)
    745             if unknown is not global_context.zero:
    746                 return ctx._stupid_add(rr, unknown)
    747             return rr
    748         elif styp == 2:
    749             rc = PY_NEW(mpc)
    750             MPF_set(&rc.re, &sre)
    751             MPF_set(&rc.im, &sim)
    752             MPF_clear(&sre)
    753             MPF_clear(&sim)
    754             MPF_normalize(&rc.re, global_opts)
    755             MPF_normalize(&rc.im, global_opts)
    756             if unknown is not global_context.zero:
    757                 return ctx._stupid_add(rc, unknown)
    758             return rc
    759         else:
    760             MPF_clear(&sre)
    761             MPF_clear(&sim)
    762             return +unknown
     761                MPF_clear(&sre)
     762                MPF_clear(&sim)
     763                return +unknown
     764        finally:
     765            sig_off()
    763766
    764767    def fdot(ctx, A, B=None, bint conjugate=False):
    765768        r"""
  • sage/libs/mwrank/mwrank.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/libs/mwrank/mwrank.pyx
    a b  
    507507        if verbose:
    508508            sys.stdout.flush()
    509509            sys.stderr.flush()
    510         sig_off()
    511510        from sage.misc.all import preparse
    512511        from sage.rings.all import Integer
    513512        return eval(s)
     
    783782        """
    784783        sig_on()
    785784        s = string_sigoff(mw_getbasis(self.x))
    786         sig_off()
    787785        return s
    788786
    789787    def regulator(self):
     
    816814        cdef float f
    817815        sig_on()
    818816        f = float(string_sigoff(mw_regulator(self.x)))
    819         sig_off()
    820817        return f
    821818
    822819    def rank(self):
     
    907904        sig_on()               
    908905        index = _bigint()
    909906        ok = mw_saturate(self.x, index.x, &s, sat_bd, odd_primes_only)
    910         unsat = string_sigoff(s)   # includes sig_off()
     907        unsat = string_sigoff(s)
    911908        return ok, index, unsat
    912909
    913910    def search(self, h_lim, int moduli_option=0, int verb=0):
  • sage/libs/ntl/ntl_ZZ.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/libs/ntl/ntl_ZZ.pyx
    a b  
    173173            self = ntl_ZZ(self)
    174174        if not PY_TYPE_CHECK(other, ntl_ZZ):
    175175            other = ntl_ZZ(other)
     176        sig_on()
    176177        ZZ_mul(r.x, (<ntl_ZZ>self).x, (<ntl_ZZ>other).x)
     178        sig_off()
    177179        return r
    178180
    179181    def __sub__(self, other):
     
    226228            122008981252869411022491112993141891091036959856659100591281395343249
    227229        """
    228230        cdef ntl_ZZ r = ntl_ZZ()
     231        sig_on()
    229232        ZZ_power(r.x, self.x, e)
     233        sig_off()
    230234        return r
    231235       
    232236    def __int__(self):
  • sage/libs/ntl/ntl_ZZX.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/libs/ntl/ntl_ZZX.pyx
    a b  
    2828
    2929ZZ = IntegerRing()
    3030
    31 cdef make_ZZ(ZZ_c* x):
     31cdef inline ntl_ZZ make_ZZ(ZZ_c* x):
    3232    """ These make_XXXX functions are deprecated and should be phased out."""
    3333    cdef ntl_ZZ y
    3434    y = ntl_ZZ()
    3535    y.x = x[0]
    3636    ZZ_delete(x)
     37    return y
     38
     39# You must do sig_on() before calling this function
     40cdef inline ntl_ZZ make_ZZ_sig_off(ZZ_c* x):
     41    cdef ntl_ZZ y = make_ZZ(x)
    3742    sig_off()
    3843    return y
    3944
    40 cdef make_ZZX(ZZX_c* x):
     45cdef inline ntl_ZZX make_ZZX(ZZX_c* x):
    4146    """ These make_XXXX functions are deprecated and should be phased out."""
    4247    cdef ntl_ZZX y
    43     sig_off()
    4448    y = ntl_ZZX()
    4549    y.x = x[0]
    4650    ZZX_delete(x)
    4751    return y
    4852
     53# You must do sig_on() before calling this function
     54cdef inline ntl_ZZX make_ZZX_sig_off(ZZX_c* x):
     55    cdef ntl_ZZX y = make_ZZX(x)
     56    sig_off()
     57    return y
     58
    4959from sage.structure.proof.proof import get_flag
    5060cdef proof_flag(t):
    5161    return get_flag(t, "polynomial")
     
    336346        q = ZZX_div(&self.x, &other.x, &divisible)
    337347        if not divisible:
    338348            ZZX_delete(q)
     349            sig_off()
    339350            raise ArithmeticError, "self (=%s) is not divisible by other (=%s)"%(self, other)
    340         result = make_ZZX(q)
     351        result = make_ZZX_sig_off(q)
    341352        return result
    342353
    343354    def __mod__(ntl_ZZX self, ntl_ZZX other):
     
    381392           True
    382393        """
    383394        cdef ZZX_c *r, *q
    384         sig_on()
    385         ZZX_quo_rem(&self.x, &other.x, &r, &q)
    386         return (make_ZZX(q), make_ZZX(r))
     395        try:
     396            sig_on()
     397            ZZX_quo_rem(&self.x, &other.x, &r, &q)
     398            return (make_ZZX(q), make_ZZX(r))
     399        finally:
     400            sig_off()
    387401
    388402    def square(self):
    389403        """
     
    395409            [1 0 -2 0 1]
    396410        """
    397411        sig_on()
    398         return make_ZZX(ZZX_square(&self.x))
     412        return make_ZZX_sig_off(ZZX_square(&self.x))
    399413
    400414    def __pow__(ntl_ZZX self, long n, ignored):
    401415        """
     
    592606            ([-1 3], [2])
    593607        """
    594608        cdef ZZX_c *r, *q
    595         sig_on()
    596         ZZX_pseudo_quo_rem(&self.x, &other.x, &r, &q)
    597         return (make_ZZX(q), make_ZZX(r))
     609        try:
     610            sig_on()
     611            ZZX_pseudo_quo_rem(&self.x, &other.x, &r, &q)
     612            return (make_ZZX(q), make_ZZX(r))
     613        finally:
     614            sig_off()
    598615
    599616    def gcd(self, ntl_ZZX other):
    600617        """
     
    610627            [1 2 3]
    611628        """
    612629        sig_on()
    613         return make_ZZX(ZZX_gcd(&self.x, &other.x))
     630        return make_ZZX_sig_off(ZZX_gcd(&self.x, &other.x))
    614631
    615632    def lcm(self, ntl_ZZX other):
    616633        """
     
    660677       
    661678        cdef ZZX_c *s, *t
    662679        cdef ZZ_c *r
    663         sig_on()
    664         ZZX_xgcd(&self.x, &other.x, &r, &s, &t, proof)
    665         return (make_ZZ(r), make_ZZX(s), make_ZZX(t))
     680        try:
     681            sig_on()
     682            ZZX_xgcd(&self.x, &other.x, &r, &s, &t, proof)
     683            return (make_ZZ(r), make_ZZX(s), make_ZZX(t))
     684        finally:
     685            sig_off()
    666686
    667687    def degree(self):
    668688        """
     
    811831            from copy import copy
    812832            return copy(zero_ZZX)
    813833        sig_on()
    814         return make_ZZX(ZZX_truncate(&self.x, m))
     834        return make_ZZX_sig_off(ZZX_truncate(&self.x, m))
    815835
    816836    def multiply_and_truncate(self, ntl_ZZX other, long m):
    817837        """
     
    866886            raise ArithmeticError, \
    867887                  "The constant term of self must be 1 or -1."
    868888        sig_on()       
    869         return make_ZZX(ZZX_invert_and_truncate(&self.x, m))
     889        return make_ZZX_sig_off(ZZX_invert_and_truncate(&self.x, m))
    870890       
    871891    def multiply_mod(self, ntl_ZZX other, ntl_ZZX modulus):
    872892        """
     
    881901            [-10 -34 -36]
    882902        """
    883903        sig_on()
    884         return make_ZZX(ZZX_multiply_mod(&self.x, &other.x, &modulus.x))
     904        return make_ZZX_sig_off(ZZX_multiply_mod(&self.x, &other.x, &modulus.x))
    885905
    886906    def trace_mod(self, ntl_ZZX modulus):
    887907        """
     
    896916            -37
    897917        """
    898918        sig_on()
    899         return make_ZZ(ZZX_trace_mod(&self.x, &modulus.x))
     919        return make_ZZ_sig_off(ZZX_trace_mod(&self.x, &modulus.x))
    900920
    901921    def trace_list(self):
    902922        """
     
    942962        proof = proof_flag(proof)
    943963        # NOTES: Within a factor of 2 in speed compared to MAGMA.
    944964        sig_on()
    945         return make_ZZ(ZZX_resultant(&self.x, &other.x, proof))
     965        return make_ZZ_sig_off(ZZX_resultant(&self.x, &other.x, proof))
    946966
    947967    def norm_mod(self, ntl_ZZX modulus, proof=None):
    948968        """
     
    965985        """
    966986        proof = proof_flag(proof)       
    967987        sig_on()
    968         return make_ZZ(ZZX_norm_mod(&self.x, &modulus.x, proof))
     988        return make_ZZ_sig_off(ZZX_norm_mod(&self.x, &modulus.x, proof))
    969989
    970990    def discriminant(self, proof=None):
    971991        r"""
     
    9891009        """
    9901010        proof = proof_flag(proof)
    9911011        sig_on()
    992         return make_ZZ(ZZX_discriminant(&self.x, proof))
     1012        return make_ZZ_sig_off(ZZX_discriminant(&self.x, proof))
    9931013
    9941014    #def __call__(self, ntl_ZZ a):
    9951015    #    sig_on()
    996     #    return make_ZZ(ZZX_polyeval(&self.x, a.x))
     1016    #    return make_ZZ_sig_off(ZZX_polyeval(&self.x, a.x))
    9971017
    9981018    def charpoly_mod(self, ntl_ZZX modulus, proof=None):
    9991019        """
     
    10141034        """
    10151035        proof = proof_flag(proof)
    10161036        sig_on()
    1017         return make_ZZX(ZZX_charpoly_mod(&self.x, &modulus.x, proof))
     1037        return make_ZZX_sig_off(ZZX_charpoly_mod(&self.x, &modulus.x, proof))
    10181038
    10191039    def minpoly_mod_noproof(self, ntl_ZZX modulus):
    10201040        """
     
    10351055            [0 0 1]
    10361056        """
    10371057        sig_on()
    1038         return make_ZZX(ZZX_minpoly_mod(&self.x, &modulus.x))
     1058        return make_ZZX_sig_off(ZZX_minpoly_mod(&self.x, &modulus.x))
    10391059
    10401060    def clear(self):
    10411061        """
  • sage/libs/ntl/ntl_mat_ZZ.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/libs/ntl/ntl_mat_ZZ.pyx
    a b  
    2424
    2525from ntl_ZZ import unpickle_class_args
    2626
    27 cdef make_ZZ(ZZ_c* x):
     27cdef inline ntl_ZZ make_ZZ(ZZ_c* x):
    2828    cdef ntl_ZZ y
    2929    y = ntl_ZZ()
    3030    y.x = x[0]
    3131    ZZ_delete(x)
     32    return y
     33
     34# You must do sig_on() before calling this function
     35cdef inline ntl_ZZ make_ZZ_sig_off(ZZ_c* x):
     36    cdef ntl_ZZ y = make_ZZ(x)
    3237    sig_off()
    3338    return y
    3439
    35 cdef make_mat_ZZ(mat_ZZ_c* x):
     40cdef inline ntl_mat_ZZ make_mat_ZZ(mat_ZZ_c* x):
    3641    cdef ntl_mat_ZZ y
    37     sig_off()
    3842    y = ntl_mat_ZZ(_INIT)
    3943    y.x = x[0]
    4044    mat_ZZ_delete(x)
     
    4246    y.__ncols = mat_ZZ_ncols(&y.x);
    4347    return y
    4448
     49# You must do sig_on() before calling this function
     50cdef inline ntl_mat_ZZ make_mat_ZZ_sig_off(mat_ZZ_c* x):
     51    cdef ntl_mat_ZZ y = make_mat_ZZ(x)
     52    sig_off()
     53    return y
     54
     55
    4556##############################################################################
    4657#
    4758# ntl_mat_ZZ: Matrices over the integers via NTL
     
    302313        i, j = ij
    303314        if i < 0 or i >= self.__nrows or j < 0 or j >= self.__ncols:
    304315            raise IndexError, "array index out of range"
    305         return make_ZZ(mat_ZZ_getitem(&self.x, i+1, j+1))
     316        sig_on()
     317        return make_ZZ_sig_off(mat_ZZ_getitem(&self.x, i+1, j+1))
    306318
    307319    def list(self):
    308320        """
     
    317329            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    318330        """
    319331        cdef int i, j
    320         return [make_ZZ(mat_ZZ_getitem(&self.x, i+1, j+1))
     332        sig_on()
     333        L = [make_ZZ(mat_ZZ_getitem(&self.x, i+1, j+1))
    321334                    for i from 0 <= i < self.__nrows
    322335                        for j from 0 <= j < self.__ncols]
     336        sig_off()
     337        return L
    323338
    324339    def determinant(self, deterministic=True):
    325340        """
     
    340355        if self.__nrows != self.__ncols:
    341356            raise TypeError, "cannot take determinant of non-square matrix."
    342357        sig_on()
    343         return make_ZZ(mat_ZZ_determinant(&self.x, deterministic))
     358        return make_ZZ_sig_off(mat_ZZ_determinant(&self.x, deterministic))
    344359
    345360    def HNF(self, D=None):
    346361        r"""
     
    400415        else:
    401416            _D = ntl_ZZ(D)
    402417        sig_on()
    403         return make_mat_ZZ(mat_ZZ_HNF(&self.x, &_D.x))
     418        return make_mat_ZZ_sig_off(mat_ZZ_HNF(&self.x, &_D.x))
    404419
    405420    def charpoly(self):
    406421        """
     
    12001215            U = PY_NEW(ntl_mat_ZZ)
    12011216            sig_on()
    12021217            rank = int(mat_ZZ_LLL_U(&det2, &self.x, &U.x, int(a), int(b), int(verbose)))
    1203             sig_off()
    1204             return rank, make_ZZ(det2), U
     1218            return rank, make_ZZ_sig_off(det2), U
    12051219        else:
    12061220            sig_on()
    12071221            rank = int(mat_ZZ_LLL(&det2,&self.x,int(a),int(b),int(verbose)))
    1208             sig_off()
    1209             return rank,make_ZZ(det2)
     1222            return rank, make_ZZ_sig_off(det2)
    12101223
    12111224    def LLL_FP(self, delta=0.75 , return_U=False, verbose=False):
    12121225        r"""
  • sage/matrix/matrix_integer_dense.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/matrix/matrix_integer_dense.pyx
    a b  
    48374837        cdef PariInstance P = sage.libs.pari.gen.pari
    48384838        sig_on()
    48394839        cdef GEN d = det0(pari_GEN(self), flag)
    4840         sig_off()
    48414840        # now convert d to a Sage integer e
    48424841        cdef Integer e = Integer()
    48434842        t_INT_to_ZZ(e.value, d)
     
    48584857        cdef PariInstance P = sage.libs.pari.gen.pari
    48594858        sig_on()
    48604859        cdef long r = rank(pari_GEN(self))
    4861         sig_off()
    48624860        P.clear_stack()
    48634861        return r
    48644862
     
    49144912        # Actually compute the HNF using PARI.
    49154913        sig_on()
    49164914        cdef GEN H = mathnf0(A, flag)
    4917         sig_off()
    4918 
    49194915        B = self.extract_hnf_from_pari_matrix(H, flag, include_zero_rows)
    49204916        P.clear_stack()
    49214917        return B
  • sage/matrix/matrix_modn_dense.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/matrix/matrix_modn_dense.pyx
    a b  
    796796            row_right = (<Matrix_modn_dense> right)._matrix[i]
    797797            for j from 0 <= j < self._ncols:
    798798                if row_self[j] < row_right[j]:
     799                    sig_off()
    799800                    return -1
    800801                elif row_self[j] > row_right[j]:
     802                    sig_off()
    801803                    return 1
    802804            #cmp = memcmp(row_self, row_right, sizeof(mod_int)*self._ncols)
    803805            #if cmp:
  • sage/matrix/matrix_rational_dense.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/matrix/matrix_rational_dense.pyx
    a b  
    144144
    145145        sig_on()
    146146        self._entries = <mpq_t *> sage_malloc(sizeof(mpq_t)*(self._nrows * self._ncols))
    147         sig_off()
    148147        if self._entries == NULL:
     148            sig_off()
    149149            raise MemoryError("out of memory allocating a matrix")
    150150
    151151        self._matrix =  <mpq_t **> sage_malloc(sizeof(mpq_t*) * self._nrows)
    152152        if self._matrix == NULL:
    153153            sage_free(self._entries)
    154154            self._entries = NULL
     155            sig_off()
    155156            raise MemoryError("out of memory allocating a matrix")
    156157
    157158        # store pointers to the starts of the rows
    158         sig_on()
    159159        k = 0
    160160        for i from 0 <= i < self._nrows:
    161161            self._matrix[i] = self._entries + k
     
    183183            if len(entries) != self._nrows * self._ncols:
    184184                raise TypeError("entries has the wrong length")
    185185
    186             sig_on()
    187186            if coerce:
    188187                for i from 0 <= i < self._nrows * self._ncols:
    189188                    # TODO: Should use an unsafe un-bounds-checked array access here.
     189                    sig_check()
    190190                    z = Rational(entries[i])
    191191                    mpq_set(self._entries[i], z.value)
    192192            else:
    193193                for i from 0 <= i < self._nrows * self._ncols:
    194194                    # TODO: Should use an unsafe un-bounds-checked array access here.
     195                    sig_check()
    195196                    mpq_set(self._entries[i], (<Rational> entries[i]).value)
    196             sig_off()
    197197                   
    198198        else:
    199199            # is it a scalar?
     
    10681068        cdef Integer D
    10691069        cdef mpz_t* AB_row,
    10701070        cdef mpq_t* res_row
     1071        sig_on()
    10711072        A, A_denom = self._clear_denom()
    10721073        B, B_denom = right._clear_denom()
    10731074        if algorithm == 'default':
     
    10751076        elif algorithm == 'multimodular':
    10761077            AB = A._multiply_multi_modular(B)
    10771078        else:
     1079            sig_off()
    10781080            raise ValueError("unknown algorithm '%s'"%algorithm)
    10791081        D = A_denom * B_denom
    10801082        if self._nrows == right._nrows:
     
    25122514        cdef PariInstance P = sage.libs.pari.gen.pari
    25132515        sig_on()
    25142516        cdef GEN d = det0(pari_GEN(self), flag)
    2515         sig_off()
    25162517        # now convert d to a Sage rational
    25172518        cdef Rational e = Rational()
    25182519        t_FRAC_to_QQ(e.value, d)
     
    25312532        cdef PariInstance P = sage.libs.pari.gen.pari
    25322533        sig_on()
    25332534        cdef long r = rank(pari_GEN(self))
    2534         sig_off()
    25352535        P.clear_stack()
    25362536        return r
    25372537
     
    25622562        cdef PariInstance P = sage.libs.pari.gen.pari
    25632563        sig_on()
    25642564        cdef GEN M = gmul(pari_GEN(self), pari_GEN(right))
    2565         sig_off()
    25662565        A = new_matrix_from_pari_GEN(self.matrix_space(self._nrows, right._ncols), M)
    25672566        P.clear_stack()
    25682567        return A
     
    25842583
    25852584        sig_on()
    25862585        M = pari_GEN(self)
    2587         sig_off()
    25882586
    25892587        # unfortunately I can't get signal handling to be good enough
    25902588        # to properly catch error (and clean up) when trying to
    25912589        # compute inverse, so we have to compute rank.  This does add
    25922590        # time... (!) :-(
     2591        #
     2592        # TODO: fix this in #10126 -- Jeroen Demeyer
    25932593        if rank(M) < self._nrows:
    25942594            P.clear_stack()
    25952595            raise ZeroDivisionError("input matrix must be nonsingular")
    2596         sig_on()
    25972596        d = ginv(M)
    2598         sig_off()
    25992597        # Convert matrix back to Sage.
    26002598        A = new_matrix_from_pari_GEN(self._parent, d)
    26012599        P.clear_stack()
  • sage/matrix/misc.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/matrix/misc.pyx
    a b  
    8787                                      A.parent().change_ring(QQ), 0,0,0)
    8888
    8989    cdef mpz_t a, bnd, other_bnd, one, denom
    90     mpz_init_set_si(denom, 1)
    91     mpz_init(a)
    92     mpz_init_set_si(one, 1)
    93     mpz_init(other_bnd)
    94 
    9590    cdef Integer _bnd
    96     import math
    97     _bnd = (N//2).isqrt()
    98     mpz_init_set(bnd, _bnd.value)
    99     mpz_sub(other_bnd, N.value, bnd)
    100 
    10191    cdef Py_ssize_t i, j
    10292    cdef int do_it
    103    
    104     for i from 0 <= i < A._nrows:
    105         for j from 0 <= j < A._ncols:
    106             mpz_set(a, A._matrix[i][j])
    107             if mpz_cmp(denom, one) != 0:
    108                 mpz_mul(a, a, denom)
    109             mpz_fdiv_r(a, a, N.value)
    110             do_it = 0
    111             if mpz_cmp(a, bnd) <= 0:
    112                 do_it = 1
    113             elif mpz_cmp(a, other_bnd) >= 0:
    114                 mpz_sub(a, a, N.value)
    115                 do_it = 1
    116             if do_it:
    117                 mpz_set(mpq_numref(R._matrix[i][j]), a)
     93    import math
     94
     95    try:
     96        sig_on()
     97        mpz_init_set_si(denom, 1)
     98        mpz_init(a)
     99        mpz_init_set_si(one, 1)
     100        mpz_init(other_bnd)
     101
     102        _bnd = (N//2).isqrt()
     103        mpz_init_set(bnd, _bnd.value)
     104        mpz_sub(other_bnd, N.value, bnd)
     105
     106        for i from 0 <= i < A._nrows:
     107            for j from 0 <= j < A._ncols:
     108                mpz_set(a, A._matrix[i][j])
    118109                if mpz_cmp(denom, one) != 0:
    119                     mpz_set(mpq_denref(R._matrix[i][j]), denom)
    120                     mpq_canonicalize(R._matrix[i][j])
     110                    mpz_mul(a, a, denom)
     111                mpz_fdiv_r(a, a, N.value)
     112                do_it = 0
     113                if mpz_cmp(a, bnd) <= 0:
     114                    do_it = 1
     115                elif mpz_cmp(a, other_bnd) >= 0:
     116                    mpz_sub(a, a, N.value)
     117                    do_it = 1
     118                if do_it:
     119                    mpz_set(mpq_numref(R._matrix[i][j]), a)
     120                    if mpz_cmp(denom, one) != 0:
     121                        mpz_set(mpq_denref(R._matrix[i][j]), denom)
     122                        mpq_canonicalize(R._matrix[i][j])
     123                    else:
     124                        mpz_set_si(mpq_denref(R._matrix[i][j]), 1)
    121125                else:
    122                     mpz_set_si(mpq_denref(R._matrix[i][j]), 1)
    123             else:
    124                 # Otherwise have to do it the hard way
    125                 mpq_rational_reconstruction(R._matrix[i][j], A._matrix[i][j], N.value)
    126                 mpz_lcm(denom, denom, mpq_denref(R._matrix[i][j]))
    127            
    128     mpz_clear(denom)
    129     mpz_clear(a)
    130     mpz_clear(one)
    131     mpz_clear(other_bnd)
    132     mpz_clear(bnd)
     126                    # Otherwise have to do it the hard way
     127                    mpq_rational_reconstruction(R._matrix[i][j], A._matrix[i][j], N.value)
     128                    mpz_lcm(denom, denom, mpq_denref(R._matrix[i][j]))
     129               
     130        mpz_clear(denom)
     131        mpz_clear(a)
     132        mpz_clear(one)
     133        mpz_clear(other_bnd)
     134        mpz_clear(bnd)
     135    finally:
     136        sig_off()
    133137    return R
    134138
    135139def matrix_integer_sparse_rational_reconstruction(Matrix_integer_sparse A, Integer N):
     
    162166                                      A.parent().change_ring(QQ), 0,0,0)
    163167   
    164168    cdef mpq_t t
    165     mpq_init(t)
    166 
    167169    cdef mpz_t a, bnd, other_bnd, one, denom
    168     mpz_init_set_si(denom, 1)
    169     mpz_init(a)
    170     mpz_init_set_si(one, 1)
    171     mpz_init(other_bnd)
    172 
    173170    cdef Integer _bnd
    174     import math
    175     _bnd = (N//2).isqrt()
    176     mpz_init_set(bnd, _bnd.value)
    177     mpz_sub(other_bnd, N.value, bnd)
    178 
    179171    cdef Py_ssize_t i, j
    180172    cdef int do_it
    181173    cdef mpz_vector* A_row
    182174    cdef mpq_vector* R_row
    183    
    184     for i from 0 <= i < A._nrows:
    185         A_row = &A._matrix[i]
    186         R_row = &R._matrix[i]
    187         reallocate_mpq_vector(R_row, A_row.num_nonzero)
    188         R_row.num_nonzero = A_row.num_nonzero
    189         R_row.degree = A_row.degree
    190         for j from 0 <= j < A_row.num_nonzero:
    191             mpz_set(a, A_row.entries[j])
    192             if mpz_cmp(denom, one) != 0:
    193                 mpz_mul(a, a, denom)
    194             mpz_fdiv_r(a, a, N.value)
    195             do_it = 0
    196             if mpz_cmp(a, bnd) <= 0:
    197                 do_it = 1
    198             elif mpz_cmp(a, other_bnd) >= 0:
    199                 mpz_sub(a, a, N.value)
    200                 do_it = 1
    201             if do_it:
    202                 mpz_set(mpq_numref(t), a)
     175    import math
     176
     177    try:
     178        sig_on()
     179        mpq_init(t)
     180        mpz_init_set_si(denom, 1)
     181        mpz_init(a)
     182        mpz_init_set_si(one, 1)
     183        mpz_init(other_bnd)
     184
     185        _bnd = (N//2).isqrt()
     186        mpz_init_set(bnd, _bnd.value)
     187        mpz_sub(other_bnd, N.value, bnd)
     188
     189        for i from 0 <= i < A._nrows:
     190            A_row = &A._matrix[i]
     191            R_row = &R._matrix[i]
     192            reallocate_mpq_vector(R_row, A_row.num_nonzero)
     193            R_row.num_nonzero = A_row.num_nonzero
     194            R_row.degree = A_row.degree
     195            for j from 0 <= j < A_row.num_nonzero:
     196                mpz_set(a, A_row.entries[j])
    203197                if mpz_cmp(denom, one) != 0:
    204                     mpz_set(mpq_denref(t), denom)
    205                     mpq_canonicalize(t)
     198                    mpz_mul(a, a, denom)
     199                mpz_fdiv_r(a, a, N.value)
     200                do_it = 0
     201                if mpz_cmp(a, bnd) <= 0:
     202                    do_it = 1
     203                elif mpz_cmp(a, other_bnd) >= 0:
     204                    mpz_sub(a, a, N.value)
     205                    do_it = 1
     206                if do_it:
     207                    mpz_set(mpq_numref(t), a)
     208                    if mpz_cmp(denom, one) != 0:
     209                        mpz_set(mpq_denref(t), denom)
     210                        mpq_canonicalize(t)
     211                    else:
     212                        mpz_set_si(mpq_denref(t), 1)
     213                    mpq_set(R_row.entries[j], t)
     214                    R_row.positions[j] = A_row.positions[j]
    206215                else:
    207                     mpz_set_si(mpq_denref(t), 1)
    208                 mpq_set(R_row.entries[j], t)
    209                 R_row.positions[j] = A_row.positions[j]
    210             else:
    211                 # Otherwise have to do it the hard way
    212                 mpq_rational_reconstruction(t, A_row.entries[j], N.value)
    213                 mpq_set(R_row.entries[j], t)
    214                 R_row.positions[j] = A_row.positions[j]
    215                 mpz_lcm(denom, denom, mpq_denref(t))
    216                
    217     mpq_clear(t)
     216                    # Otherwise have to do it the hard way
     217                    mpq_rational_reconstruction(t, A_row.entries[j], N.value)
     218                    mpq_set(R_row.entries[j], t)
     219                    R_row.positions[j] = A_row.positions[j]
     220                    mpz_lcm(denom, denom, mpq_denref(t))
     221                   
     222        mpq_clear(t)
    218223
    219     mpz_clear(denom)
    220     mpz_clear(a)
    221     mpz_clear(one)
    222     mpz_clear(other_bnd)
    223     mpz_clear(bnd)
     224        mpz_clear(denom)
     225        mpz_clear(a)
     226        mpz_clear(one)
     227        mpz_clear(other_bnd)
     228        mpz_clear(bnd)
     229    finally:
     230        sig_off()
    224231    return R
    225232
    226233
  • sage/rings/finite_rings/element_givaro.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/finite_rings/element_givaro.pyx
    a b  
    256256                cPoly.push_back(int( i % p ))
    257257            sig_on()
    258258            self.objectptr = gfq_factorypkp(p, k, cPoly)
    259             sig_off()
    260259        elif modulus == "random":
    261260            sig_on()
    262261            self.objectptr = gfq_factorypk(p,k)
    263             sig_off()
    264262        else:
    265263            raise ValueError, "Cannot understand modulus"
    266264
    267265        self._zero_element = make_FiniteField_givaroElement(self,self.objectptr.zero)
    268266        self._one_element = make_FiniteField_givaroElement(self,self.objectptr.one)
    269            
    270         self._zero_element = make_FiniteField_givaroElement(self,self.objectptr.zero)
    271         self._one_element = make_FiniteField_givaroElement(self,self.objectptr.one)
    272267        sig_off()
     268
    273269        parent._zero_element = self._zero_element
    274270        parent._one_element = self._one_element
    275271        if cache:
  • sage/rings/fraction_field_FpT.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/fraction_field_FpT.pyx
    a b  
    973973                if zmod_poly_degree(next._numer) > self.degree:
    974974                    zmod_poly_inc(next._denom, True)
    975975                    if zmod_poly_degree(next._denom) > self.degree:
     976                        sig_off()
    976977                        raise StopIteration
    977978                    zmod_poly_zero(next._numer)
    978979                    zmod_poly_set_coeff_ui(next._numer, 0, 1)
  • sage/rings/integer.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/integer.pyx
    a b  
    13301330        if mpz_sgn(self.value) < 0:
    13311331            self_abs = -self
    13321332
     1333        cdef bint do_sig_on
    13331334        if mpz_sgn(self.value) == 0:
    13341335            l = [the_integer_ring._zero_element if digits is None else digits[0]]*padto
    13351336        elif mpz_cmp_si(_base.value,2) == 0:
     
    13491350                    l[i] = o
    13501351        else:
    13511352            s = mpz_sizeinbase(self.value, 2)
    1352             if s > 256:
    1353                 sig_on()
     1353            do_sig_on = (s > 256)
     1354            if do_sig_on: sig_on()
    13541355
    13551356            #   We use a divide and conquer approach (suggested
    13561357            # by the prior author, malb?, of the digits method)
     
    14031404                # the case due to the optimization of skipping assigns assigning zero.
    14041405                _digits_internal(self.value,l,0,i-1,power_list,digits)
    14051406
    1406             if s > 256:
    1407                 sig_off()
     1407            if do_sig_on: sig_off()
    14081408
    14091409        # padding should be taken care of with-in the function
    14101410        # all we need to do is return
     
    20892089        if upper - lower == 2:
    20902090            # You could test it by checking rif_m**(lower+1), but I think that's a waste of time since it won't be conclusive
    20912091            # We must test with exact integer arithmetic which takes all the bits of self into account.
     2092            sig_off()
    20922093            if self >= m**(lower+1):
    20932094                return lower + 1
    20942095            else:
     
    21192120                    lower = middle
    21202121                    min_power = exp
    21212122                else:
     2123                    sig_off()
    21222124                    if m**middle <= self:
    21232125                        return middle
    21242126                    else:
     
    31123114                mpz_set_ui(x.value,5); return x
    31133115
    31143116            # x.value = floor(sqrt(self.value))
     3117            sig_on()
    31153118            mpz_abs(x.value, self.value)
    31163119            mpz_sqrt(x.value, x.value)
    31173120            if mpz_cmp_si(x.value, bound) < 0:
    31183121                limit = mpz_get_ui(x.value)
    31193122            else:
    31203123                limit = bound
    3121             sig_on()
    31223124            while m <= limit:
    31233125                if  mpz_divisible_ui_p(self.value, m):
    3124                     mpz_set_ui(x.value, m); return x
     3126                    mpz_set_ui(x.value, m)
     3127                    sig_off()
     3128                    return x
    31253129                m += dif[i%8]
    31263130                i += 1
     3131            mpz_abs(x.value, self.value)
    31273132            sig_off()
    3128             mpz_abs(x.value, self.value)
    31293133            return x
    31303134
    31313135    def _factor_trial_division(self, long limit=LONG_MAX):
  • sage/rings/padics/padic_ZZ_pX_FM_element.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/padics/padic_ZZ_pX_FM_element.pyx
    a b  
    739739                ZZ_pX_InvMod_newton_ram(ans.value, self.value, self.prime_pow.get_top_modulus()[0], self.prime_pow.get_top_context().x)
    740740            ZZ_negate(rZZ.x, rZZ.x)
    741741            ZZ_pX_PowerMod_pre(ans.value, ans.value, rZZ.x, self.prime_pow.get_top_modulus()[0])
     742            sig_off()
    742743        else:
    743744            sig_on()
    744745            ZZ_pX_PowerMod_pre(ans.value, self.value, rZZ.x, self.prime_pow.get_top_modulus()[0])
  • sage/rings/padics/pow_computer_ext.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/padics/pow_computer_ext.pyx
    a b  
    17601760        if n < 0:
    17611761            n = -n
    17621762        try:
    1763             sig_on()
    17641763            (<ntl_ZZ_pContext_class>self.c[n]).restore_c()
    1765             sig_off()
    17661764        except IndexError:
    1767             sig_on()
    17681765            (<ntl_ZZ_pContext_class>PowComputer_ZZ_pX.get_context(self, n)).restore_c()
    1769             sig_off()
    17701766
    17711767    cdef ntl_ZZ_pContext_class get_top_context(self):
    17721768        """
  • sage/rings/rational.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/rational.pyx
    a b  
    23192319            raise ZeroDivisionError, "Rational modulo by zero"
    23202320        n = self.numer() % other
    23212321        d = self.denom() % other
    2322         sig_on()
    23232322        d = d.inverse_mod(other)
    2324         sig_off()
    23252323        return (n*d)%other
    23262324
    23272325    def norm(self):
     
    32553253        raise ZeroDivisionError("The modulus cannot be zero")
    32563254    cdef Rational x
    32573255    x = <Rational> PY_NEW(Rational)
    3258     mpq_rational_reconstruction(x.value, a.get_value()[0], m.get_value()[0])
     3256    mpq_rational_reconstruction(x.value, a.value, m.value)
    32593257    return x
    32603258
    32613259def make_rational(s):
  • sage/rings/real_mpfr.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/rings/real_mpfr.pyx
    a b  
    25982598            sage: RealField(100)(0.0)._pari_().sizeword()
    25992599            2
    26002600        """
    2601         # This uses interfaces of MPFR and Pari which are documented
     2601        # This uses interfaces of MPFR and PARI which are documented
    26022602        # (and not marked subject-to-change).  It could be faster
    26032603        # by using internal interfaces of MPFR, which are documented
    26042604        # as subject-to-change.
    26052605
     2606        sig_on()
    26062607        if mpfr_nan_p(self.value) or mpfr_inf_p(self.value):
    26072608            raise ValueError, 'Cannot convert NaN or infinity to Pari float'
    26082609
  • sage/structure/coerce_actions.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/structure/coerce_actions.pyx
    a b  
    478478
    479479
    480480cdef inline fast_mul(a, n):
    481     sig_on()
     481    # We cannot use sig_on() here because this may call arbitrary Python
     482    # code raising exceptions. -- Jeroen Demeyer
    482483    if n < 0:
    483484        n = -n
    484485        a = -a
     
    493494        if n & 1:
    494495            sum += pow2a
    495496        n = n >> 1
    496     sig_off()
    497497    return sum
    498498
    499499cdef inline fast_mul_long(a, long n):
     500    # We cannot use sig_on() here because this may call arbitrary Python
     501    # code raising exceptions. -- Jeroen Demeyer
    500502    if n < 0:
    501503        n = -n
    502504        a = -a
     
    505507        elif n == 1: return a
    506508        elif n == 2: return a+a
    507509        elif n == 3: return a+a+a
    508     sig_on()
    509510    pow2a = a
    510511    while n & 1 == 0:
    511512        pow2a += pow2a
     
    517518        if n & 1:
    518519            sum += pow2a
    519520        n = n >> 1
    520     sig_off()
    521521    return sum
  • sage/symbolic/expression.pyx

    diff -r 9db1faa4044e -r 37b3eef312da sage/symbolic/expression.pyx
    a b  
    26172617        cdef Expression symbol = self.coerce_in(symb)
    26182618        if not is_a_symbol(symbol._gobj):
    26192619            raise TypeError, "argument symb must be a symbol"
    2620         sig_on()
    2621         cdef GEx x = self._gobj.diff(ex_to_symbol(symbol._gobj), deg)
    2622         sig_off()
     2620        cdef GEx x
     2621        try:
     2622            sig_on()
     2623            x = self._gobj.diff(ex_to_symbol(symbol._gobj), deg)
     2624        finally:
     2625            sig_off()
    26232626        return new_Expression_from_GEx(self._parent, x)
    26242627
    26252628    def gradient(self, variables=None):
     
    27362739            3.1415926824043994
    27372740        """
    27382741        cdef Expression symbol0 = self.coerce_in(symbol)
    2739         sig_on()
    2740         cdef GEx x = self._gobj.series(symbol0._gobj, order, 0)
    2741         sig_off()
     2742        cdef GEx x
     2743        try:
     2744            sig_on()
     2745            x = self._gobj.series(symbol0._gobj, order, 0)
     2746        finally:
     2747            sig_off()
    27422748        return new_Expression_from_GEx(self._parent, x)
    27432749
    27442750    def taylor(self, *args):
     
    29092915            else:
    29102916                raise ValueError, "side must be 'left', 'right', or None"
    29112917           
    2912         sig_on()
    2913         cdef GEx x = self._gobj.expand(0)
    2914         sig_off()
     2918        cdef GEx x
     2919        try:
     2920            sig_on()
     2921            x = self._gobj.expand(0)
     2922        finally:
     2923            sig_off()
    29152924        return new_Expression_from_GEx(self._parent, x)
    29162925
    29172926    expand_rational = rational_expand = expand
     
    45834592            1/7*x^5 - 17/7*y + 2/21
    45844593        """
    45854594        cdef Expression r = self.coerce_in(b)
    4586         sig_on()
    4587         cdef GEx x = g_gcd(self._gobj, r._gobj)
    4588         sig_off()
     4595        cdef GEx x
     4596        try:
     4597            sig_on()
     4598            x = g_gcd(self._gobj, r._gobj)
     4599        finally:
     4600            sig_off()
    45894601        return new_Expression_from_GEx(self._parent, x)
    45904602
    45914603    def collect(Expression self, s):
     
    46114623            (x^2*y^2 + 4)*z^2 + (x + 21*y)*z + 4*x*y + 20*y^2
    46124624        """
    46134625        cdef Expression s0 = self.coerce_in(s)
    4614         sig_on()
    4615         cdef GEx x = self._gobj.collect(s0._gobj, False)
    4616         sig_off()
     4626        cdef GEx x
     4627        try:
     4628            sig_on()
     4629            x = self._gobj.collect(s0._gobj, False)
     4630        finally:
     4631            sig_off()
    46174632        return new_Expression_from_GEx(self._parent, x)
    46184633
    46194634    def collect_common_factors(self):
     
    46254640            sage: (x/(x^2 + x)).collect_common_factors()
    46264641            1/(x + 1)
    46274642        """
    4628         sig_on()
    4629         cdef GEx x = g_collect_common_factors(self._gobj)
    4630         sig_off()
     4643        cdef GEx x
     4644        try:
     4645            sig_on()
     4646            x = g_collect_common_factors(self._gobj)
     4647        finally:
     4648            sig_off()
    46314649        return new_Expression_from_GEx(self._parent, x)
    46324650
    46334651    def __abs__(self):
     
    59315949            sage: t = SR(1).zeta(); t
    59325950            Infinity
    59335951        """
    5934         sig_on()
    5935         cdef GEx x = g_hold_wrapper(g_zeta, self._gobj, hold)
    5936         sig_off()
     5952        cdef GEx x
     5953        try:
     5954            sig_on()
     5955            x = g_hold_wrapper(g_zeta, self._gobj, hold)
     5956        finally:
     5957            sig_off()
    59375958        return new_Expression_from_GEx(self._parent, x)
    59385959   
    59395960    def factorial(self, hold=False):
     
    59725993            120
    59735994
    59745995        """
    5975         sig_on()
    5976         cdef GEx x = g_hold_wrapper(g_factorial, self._gobj, hold)
    5977         sig_off()
     5996        cdef GEx x
     5997        try:
     5998            sig_on()
     5999            x = g_hold_wrapper(g_factorial, self._gobj, hold)
     6000        finally:
     6001            sig_off()
    59786002        return new_Expression_from_GEx(self._parent, x)
    59796003
    59806004    def binomial(self, k, hold=False):
     
    60246048            1
    60256049        """
    60266050        cdef Expression nexp = self.coerce_in(k)
    6027         sig_on()
    6028         cdef GEx x = g_hold2_wrapper(g_binomial, self._gobj, nexp._gobj, hold)
    6029         sig_off()
     6051        cdef GEx x
     6052        try:
     6053            sig_on()
     6054            x = g_hold2_wrapper(g_binomial, self._gobj, nexp._gobj, hold)
     6055        finally:
     6056            sig_off()
    60306057        return new_Expression_from_GEx(self._parent, x)
    60316058
    60326059    def Order(self, hold=False):
     
    61036130            sage: a = SR(1/2).gamma(hold=True); a.simplify()
    61046131            sqrt(pi)
    61056132        """
    6106         sig_on()
    6107         cdef GEx x = g_hold_wrapper(g_tgamma, self._gobj, hold)
    6108         sig_off()
     6133        cdef GEx x
     6134        try:
     6135            sig_on()
     6136            x = g_hold_wrapper(g_tgamma, self._gobj, hold)
     6137        finally:
     6138            sig_off()
    61096139        return new_Expression_from_GEx(self._parent, x)
    61106140
    61116141    def lgamma(self, hold=False):
     
    61676197            TypeError: log_gamma() got an unexpected keyword argument 'hold'
    61686198
    61696199        """
    6170         sig_on()
    6171         cdef GEx x = g_hold_wrapper(g_lgamma, self._gobj, hold)
    6172         sig_off()
     6200        cdef GEx x
     6201        try:
     6202            sig_on()
     6203            x = g_hold_wrapper(g_lgamma, self._gobj, hold)
     6204        finally:
     6205            sig_off()
    61736206        return new_Expression_from_GEx(self._parent, x)
    61746207
    61756208    def default_variable(self):