Ticket #12119: trac_12119.patch

File trac_12119.patch, 18.9 KB (added by aapitzsch, 5 years ago)
  • sage/databases/stein_watkins.py

    # HG changeset patch
    # User André Apitzsch <andre.apitzsch@st.ovgu.de>
    # Date 1323037826 -3600
    # Node ID 3de287228365089e414592000d6561efe48b6590
    # Parent  ab81fd06a0d8022ca316f851c4cb283820337552
    trac 12119: replace deprecated getslice (part 3)
    
    diff --git a/sage/databases/stein_watkins.py b/sage/databases/stein_watkins.py
    a b  
    220220    def __getitem__(self, N):
    221221        """
    222222        Return the curves of conductor N in this table. (Very slow!)
     223        Return all data about curves between the given levels in this
     224        database file.
    223225        """
    224226        X = []
    225         for C in self:
    226             M = C.conductor
    227             if M == N:
    228                 X.append(C)
    229             elif M > N:
    230                 return X
    231         return X
     227        if isinstance(N, slice):
     228            min_level, max_level, step = N.indices(len(list(self)))
     229            for C in self:
     230                M = C.conductor
     231                if M >= min_level and M <= max_level:
     232                    X.append(C)
     233                elif M > max_level:
     234                    return X
     235        else:
     236            for C in self:
     237                M = C.conductor
     238                if M == N:
     239                    X.append(C)
     240                elif M > N:
     241                    return X
     242            return X
    232243
    233244    def iter_levels(self):
    234245        """
     
    254265                C.append(E)
    255266        yield C
    256267
    257     def __getslice__(self, min_level, max_level):
    258         """
    259         Return all data about curves between the given levels in this
    260         database file.
    261         """
    262         X = []
    263         for C in self:
    264             M = C.conductor
    265             if M >= min_level and M <= max_level:
    266                 X.append(C)
    267             elif M > max_level:
    268                 return X
    269            
    270268
    271269class SteinWatkinsPrimeData(SteinWatkinsAllData):
    272270    def __init__(self, num):
  • sage/media/wav.py

    diff --git a/sage/media/wav.py b/sage/media/wav.py
    a b  
    312312
    313313        return list_plot(points, plotjoined=plotjoined, **kwds)
    314314
    315     # returns the ith frame of data in the wave, in the form of a string
    316315    def __getitem__(self, i):
    317         n = i*self._width
    318         return self._bytes[n:n+self._width]
     316        """
     317        Returns the `i`-th frame of data in the wave, in the form of a string,
     318        if `i` is an integer.
     319        Returns a slice of self if `i` is a slice.
     320        """
     321        if isinstance(i, slice):
     322            start, stop, step = i.indices(self._nframes)
     323            return self._copy(start, stop)
     324        else:
     325            n = i*self._width
     326            return self._bytes[n:n+self._width]
    319327
    320328    def slice_seconds(self, start, stop):
    321329        """
     
    332340        start = int(start*self.getframerate())
    333341        stop = int(stop*self.getframerate())
    334342        return self[start:stop]
    335    
    336     def __getslice__(self, start, stop):
    337         return self._copy(start, stop)
    338    
     343
    339344    # start and stop are frame numbers
    340345    def _copy(self, start, stop):
    341346        start = start * self._width
  • sage/modular/abvar/abvar.py

    diff --git a/sage/modular/abvar/abvar.py b/sage/modular/abvar/abvar.py
    a b  
    34713471
    34723472    def __getitem__(self, i):
    34733473        """
    3474         Return the `i^{th}` decomposition factor of self.
    3475        
     3474        Returns the `i^{th}` decomposition factor of self
     3475        or returns the slice `i` of decompositions of self.
     3476
    34763477        EXAMPLES::
    3477        
     3478
    34783479            sage: J = J0(389)
    34793480            sage: J.decomposition()
    34803481            [
     
    34883489            Simple abelian subvariety 389c(1,389) of dimension 3 of J0(389)
    34893490            sage: J[-1]
    34903491            Simple abelian subvariety 389e(1,389) of dimension 20 of J0(389)
    3491         """
    3492         return self.decomposition()[i]
    3493 
    3494     def __getslice__(self, i, j):
    3495         """
    3496         The slice i:j of decompositions of self.
    3497        
    3498         EXAMPLES::
    3499        
    35003492            sage: J = J0(125); J.decomposition()
    35013493            [
    35023494            Simple abelian subvariety 125a(1,125) of dimension 2 of J0(125),
     
    35093501            Simple abelian subvariety 125b(1,125) of dimension 2 of J0(125)
    35103502            ]
    35113503        """
    3512         return self.decomposition()[i:j]
    3513 
     3504        return self.decomposition()[i]
    35143505
    35153506
    35163507class ModularAbelianVariety(ModularAbelianVariety_abstract):
  • sage/modular/modform/element.py

    diff --git a/sage/modular/modform/element.py b/sage/modular/modform/element.py
    a b  
    323323
    324324    def __getitem__(self, n):
    325325        """
    326         Return the `q^n` coefficient of the `q`-expansion of self.
     326        Returns the `q^n` coefficient of the `q`-expansion of self or
     327        returns a list containing the `q^i` coefficients of self
     328        where `i` is in slice `n`.
    327329
    328330        EXAMPLES::
    329        
     331
    330332            sage: f = ModularForms(DirichletGroup(17).0^2,2).2
    331333            sage: f.__getitem__(10)
    332334            zeta8^3 - 5*zeta8^2 - 2*zeta8 + 10
    333335            sage: f[30]
    334336            -2*zeta8^3 - 17*zeta8^2 + 4*zeta8 + 29
    335         """
    336         return self.q_expansion(n+1)[int(n)]
    337    
    338     def __getslice__(self, i, j):
    339         """
    340         Return a list containing the `q^i` through `q^j` coefficients of self.
    341 
    342         EXAMPLES::
    343        
    344             sage: f = ModularForms(DirichletGroup(17).0^2,2).2
    345337            sage: f[10:15]
    346338            [zeta8^3 - 5*zeta8^2 - 2*zeta8 + 10,
    347339            -zeta8^3 + 11,
    348340            -2*zeta8^3 - 6*zeta8^2 + 3*zeta8 + 9,
    349341            12,
    350342            2*zeta8^3 - 7*zeta8^2 + zeta8 + 14]
    351 
    352             sage: f.__getslice__(10,15)
    353             [zeta8^3 - 5*zeta8^2 - 2*zeta8 + 10,
    354             -zeta8^3 + 11,
    355             -2*zeta8^3 - 6*zeta8^2 + 3*zeta8 + 9,
    356             12,
    357             2*zeta8^3 - 7*zeta8^2 + zeta8 + 14]
    358343        """
    359         return self.q_expansion(j+1).list()[int(i):int(j)]
     344        if isinstance(n, slice):
     345            if n.stop is None:
     346                return self.q_expansion().list()[n]
     347            else:
     348                return self.q_expansion(n.stop+1).list()[n]
     349        else:
     350            return self.q_expansion(n+1)[int(n)]
    360351
    361352    def padded_list(self, n):
    362353        """
  • sage/plot/animate.py

    diff --git a/sage/plot/animate.py b/sage/plot/animate.py
    a b  
    138138
    139139    def __getitem__(self, i):
    140140        """
    141         Get a frame from an animation.
    142        
     141        Get a frame from an animation or
     142        slice this animation returning a subanimation.
     143
    143144        EXAMPLES::
    144        
     145
    145146            sage: a = animate([x, x^2, x^3, x^4])
    146147            sage: a[2].show()       # optional -- ImageMagick
    147         """
    148         return self.__frames[i]
    149 
    150     def __getslice__(self, *args):
    151         """
    152         Slice this animation returning a subanimation.
    153        
    154         EXAMPLES::
    155        
    156148            sage: a = animate([circle((i,-i), 1-1/(i+1), hue=i/10) for i in srange(0,2,0.2)],
    157149            ...               xmin=0,ymin=-2,xmax=2,ymax=0,figsize=[2,2])
    158150            sage: a
     
    162154            Animation with 4 frames
    163155            sage: a[3:7].show() # optional -- ImageMagick
    164156        """
    165         return Animation(self.__frames.__getslice__(*args), **self.__kwds)
     157        if isinstance(i, slice):
     158            return Animation(self.__frames[i], **self.__kwds)
     159        else:
     160            return self.__frames[i]
    166161
    167162    def _repr_(self):
    168163        """
  • sage/rings/polynomial/padics/polynomial_padic_capped_relative_dense.py

    diff --git a/sage/rings/polynomial/padics/polynomial_padic_capped_relative_dense.py b/sage/rings/polynomial/padics/polynomial_padic_capped_relative_dense.py
    a b  
    396396
    397397    def __getitem__(self, n):
    398398        """
    399         Returns the coefficient of x^n
     399        Returns the coefficient of x^n if `n` is an integer,
     400        returns the monomials of self of degree in slice `n` if `n` is a slice.
    400401
    401         EXAMPLES:
     402        EXAMPLES::
     403
    402404        sage: K = Qp(13,7)
    403         sage: R.<t> = K[]       
     405        sage: R.<t> = K[]
    404406        sage: a = 13^7*t^3 + K(169,4)*t - 13^4
    405407        sage: a[1]
    406408        13^2 + O(13^4)
    407         """
    408         if n >= len(self._relprecs):
    409             return self.base_ring()(0)
    410         if not self._list is None:
    411             return self._list[n]
    412         return self.base_ring()(self.base_ring().prime_pow(self._valbase) * self._poly[n], absprec = self._valbase + self._relprecs[n])
    413 
    414     def __getslice__(self, i, j):
    415         """
    416         EXAMPLES:
    417         sage: K = Qp(13,7)
    418         sage: R.<t> = K[]       
    419         sage: a = 13^7*t^3 + K(169,4)*t - 13^4
    420409        sage: a[1:2]
    421410        (13^2 + O(13^4))*t
    422411        """
    423         if i < 0:
    424             i = len(self._relprecs) + i
    425             if i < 0:
    426                 raise IndexError, "list index out of range"
    427         if j > len(self._relprecs):
    428             j = len(self._relprecs)
    429         elif j < 0:
    430             j = len(self._relprecs) + j
    431             if j < 0:
    432                 raise IndexError, "list index out of range"
    433         if i >= j:
    434             return Polynomial_padic_capped_relative_dense(self.parent(), [])
     412        if isinstance(n, slice):
     413            start, stop = n.start, n.stop
     414            if start is None:
     415                start = 0
     416            elif start < 0:
     417                start = len(self._relprecs) + start
     418                if start < 0:
     419                    raise IndexError("list index out of range")
     420            if stop > len(self._relprecs) or stop is None:
     421                stop = len(self._relprecs)
     422            elif stop < 0:
     423                stop = len(self._relprecs) + stop
     424                if stop < 0:
     425                    raise IndexError("list index out of range")
     426            if start >= stop:
     427                return Polynomial_padic_capped_relative_dense(self.parent(), [])
     428            else:
     429                return Polynomial_padic_capped_relative_dense(self.parent(),
     430                    (self._poly[start:stop], self._valbase,
     431                    [infinity]*start + self._relprecs[start:stop], False,
     432                    None if self._valaddeds is None else [infinity]*start
     433                    + self._valaddeds[start:stop],
     434                    None if self._list is None else [self.base_ring()(0)]
     435                    * start + self._list[start:stop]), construct = True)
    435436        else:
    436             return Polynomial_padic_capped_relative_dense(self.parent(), (self._poly[i:j], self._valbase, [infinity]*i + self._relprecs[i:j], False, None if self._valaddeds is None else [infinity]*i + self._valaddeds[i:j], None if self._list is None else [self.base_ring()(0)] * i + self._list[i:j]), construct = True)
     437            if n >= len(self._relprecs):
     438                return self.base_ring()(0)
     439            if not self._list is None:
     440                return self._list[n]
     441            return self.base_ring()(self.base_ring().prime_pow(self._valbase)
     442                * self._poly[n], absprec = self._valbase + self._relprecs[n])
    437443
    438444    def _add_(self, right):
    439445        """
  • sage/rings/polynomial/polynomial_element_generic.py

    diff --git a/sage/rings/polynomial/polynomial_element_generic.py b/sage/rings/polynomial/polynomial_element_generic.py
    a b  
    291291       
    292292    def __getitem__(self,n):
    293293        """
    294         Return the n-th coefficient of this polynomial.
     294        Return the `n`-th coefficient of this polynomial if `n` is an integer,
     295        returns the monomials of self of degree in slice `n` if `n` is a slice.
    295296
    296297        Negative indexes are allowed and always return 0 (so you can
    297298        view the polynomial as embedding Laurent series).
     
    307308            sage: f[5]
    308309            0.0
    309310            sage: f[-1]
    310             0.0           
    311         """
    312         if not self.__coeffs.has_key(n):
    313             return self.base_ring()(0)
    314         return self.__coeffs[n]
    315 
    316     def __getslice__(self, i, j):
    317         """
    318         EXAMPLES::
    319 
     311            0.0
    320312            sage: R.<x> = PolynomialRing(RealField(19), sparse=True)
    321313            sage: f = (2-3.5*x)^3; f
    322314            -42.875*x^3 + 73.500*x^2 - 42.000*x + 8.0000
     
    325317            sage: f[:2]
    326318            -42.000*x + 8.0000
    327319            sage: f[2:]
    328             -42.875*x^3 + 73.500*x^2       
     320            -42.875*x^3 + 73.500*x^2
    329321        """
    330         if i < 0:
    331             i = 0
    332         v = {}
    333         x = self.__coeffs
    334         for k in x.keys():
    335             if i <= k and k < j:
    336                 v[k] = x[k]
    337         P = self.parent()
    338         return P(v)
     322        if isinstance(n, slice):
     323            start, stop = n.start, n.stop
     324            if start < 0:
     325                start = 0
     326            if stop is None:
     327                stop = len(self.__coeffs) + 1
     328            v = {}
     329            x = self.__coeffs
     330            for k in x.keys():
     331                if start <= k and k < stop:
     332                    v[k] = x[k]
     333            P = self.parent()
     334            return P(v)
     335        else:
     336            if not self.__coeffs.has_key(n):
     337                return self.base_ring()(0)
     338            return self.__coeffs[n]
    339339
    340340    def _unsafe_mutate(self, n, value):
    341341        r"""
  • sage/rings/polynomial/polynomial_integer_dense_ntl.pyx

    diff --git a/sage/rings/polynomial/polynomial_integer_dense_ntl.pyx b/sage/rings/polynomial/polynomial_integer_dense_ntl.pyx
    a b  
    281281        return Polynomial_integer_dense_ntl, \
    282282               (self.parent(), self.list(), False, self.is_gen())
    283283
    284     def __getitem__(self, long n):
     284    def __getitem__(self, n):
    285285        r"""
    286         Returns coefficient of `x^n`, or zero if n is negative.
     286        Returns coefficient of the monomial of degree `n` if `n` is an integer,
     287        returns the monomials of self of degree in slice `n` if `n` is a slice.
    287288
    288289        EXAMPLES::
    289290
     
    299300            0
    300301            sage: f[-1]
    301302            0
    302         """
    303         cdef Integer z = PY_NEW(Integer)
    304         if n < 0 or n > ZZX_deg(self.__poly):
    305             return z
    306         else:
    307             # Note that the NTL documentation blesses this direct access of the "rep" member in ZZX.txt.
    308             #  Check the "Miscellany" section.
    309             ZZ_to_mpz(&z.value, &self.__poly.rep.elts()[n])
    310             return z
    311 
    312     def __getslice__(self, long i, long j):
    313         r"""
    314         EXAMPLES::
    315 
    316             sage: R.<x> = PolynomialRing(ZZ, implementation='NTL')
    317303            sage: f = 1 + x + 2*x^2 + 3*x^3 + 4*x^4 + 5*x^5
    318304            sage: f[2:4]
    319305            3*x^3 + 2*x^2
     
    322308            sage: f[4:100]
    323309            5*x^5 + 4*x^4
    324310        """
     311        cdef Integer z = PY_NEW(Integer)
    325312        cdef long k
    326         i = max(0, i)
    327         j = min(j, self.degree()+1)
    328         v = [self[k] for k from i <= k < j]
    329         P = self.parent()
    330         return P([0] * int(i) + v)
     313        if isinstance(n, slice):
     314            start, stop = n.start, n.stop
     315            if stop > self.degree() + 1 or stop is None:
     316                stop = self.degree() + 1
     317            start = max(0, start)
     318            v = [self[k] for k from start <= k < stop]
     319            P = self.parent()
     320            return P([0] * int(start) + v)
     321        else:
     322            if n < 0 or n > ZZX_deg(self.__poly):
     323                return z
     324            else:
     325                # Note that the NTL documentation blesses this direct access of the "rep" member in ZZX.txt.
     326                #  Check the "Miscellany" section.
     327                ZZ_to_mpz(&z.value, &self.__poly.rep.elts()[n])
     328            return z
    331329
    332330    def _repr(self, name=None, bint latex=False):
    333331        """
  • sage/rings/polynomial/polynomial_rational_flint.pyx

    diff --git a/sage/rings/polynomial/polynomial_rational_flint.pyx b/sage/rings/polynomial/polynomial_rational_flint.pyx
    a b  
    358358        mpz_set_si(deg.value, fmpq_poly_degree(self.__poly))
    359359        return deg
    360360
    361     def __getitem__(self, long n):
     361    def __getitem__(self, n):
    362362        """
    363         Returns the `n`th coefficient of self.
    364        
     363        Returns coefficient of the monomial of degree `n` if `n` is an integer,
     364        returns the monomials of self of degree in slice `n` if `n` is a slice.
     365
    365366        INPUT:
    366        
     367
    367368        - ``n`` - Degree of the monomial whose coefficient is to be returned
    368        
     369                  or a slice.
     370
    369371        EXAMPLES::
    370            
     372
    371373            sage: R.<t> = QQ[]
    372374            sage: f = 1 + t + t^2/2 + t^3/3 + t^4/4
    373375            sage: f[-1], f[0], f[3], f[5]            # indirect doctest
    374376            (0, 1, 1/3, 0)
    375         """
    376         cdef Rational z = PY_NEW(Rational)
    377         if 0 <= n and n < fmpq_poly_length(self.__poly):
    378             fmpq_poly_get_coeff_mpq(z.value, self.__poly, n)
    379         return z
    380 
    381     def __getslice__(self, long i, long j):
    382         """
    383         Returns the subpolynomial of self from the `i`th to the `j`th
    384         coefficient, where the lower bound is inclusive and the upper bound
    385         is exclusive.
    386        
    387         INPUT:
    388        
    389         - ``i`` - Lower index for the slice
    390         - ``j`` - Upper index for the slice
    391        
    392         EXAMPLES::
    393        
    394             sage: R.<t> = QQ[]
    395             sage: f = 1 + t + t^2/2 + t^3/3 + t^4/4
    396377            sage: f[1:3]                             # indirect doctest
    397378            1/2*t^2 + t
    398379        """
     380        cdef Rational z = PY_NEW(Rational)
    399381        cdef Polynomial_rational_flint res = self._new()
    400382        cdef bint do_sig = _do_sig(self.__poly)
    401        
    402         if do_sig: sig_on()
    403         fmpq_poly_getslice(res.__poly, self.__poly, i, j)
    404         if do_sig: sig_off()
    405         return res
     383        if isinstance(n, slice):
     384            start, stop, step = n.indices(len(list(self)))
     385            if do_sig: sig_on()
     386            fmpq_poly_getslice(res.__poly, self.__poly, start, stop)
     387            if do_sig: sig_off()
     388            return res
     389        else:
     390            if 0 <= n and n < fmpq_poly_length(self.__poly):
     391                fmpq_poly_get_coeff_mpq(z.value, self.__poly, n)
     392            return z
    406393
    407394    cpdef _unsafe_mutate(self, unsigned long n, value):
    408395        """
  • sage/rings/power_series_poly.pyx

    diff --git a/sage/rings/power_series_poly.pyx b/sage/rings/power_series_poly.pyx
    a b  
    328328        elif n > self.__f.degree():
    329329            if self._prec > n:
    330330                return self.base_ring()(0)
    331             #elif isinstance(n, slice):
    332                 # It makes no sense that this is needed and that
    333                 # __getslice__ isn't just called by default...
    334             #    return self.__getslice__(slice[0],slice[1])
    335331            else:
    336                 raise IndexError, "coefficient not known"
     332                raise IndexError("coefficient not known")
    337333        return self.__f[n]
    338334
    339335    def __iter__(self):