Ticket #12119: trac_12119.patch

File trac_12119.patch, 18.9 KB (added by aapitzsch, 3 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):