Ticket #13433: trac_13433-base_patch-darijs_mod.patch

File trac_13433-base_patch-darijs_mod.patch, 39.6 KB (added by darij, 7 years ago)

Alternative version of the BASE patch, which applies on my system. The review patch needs no changes, hence is not included.

  • sage/combinat/species/series.py

    # HG changeset patch
    # User Mike Hansen <mhansen@gmail.com>
    # Date 1374443204 -3600
    # Node ID fa658c53d32c07db906e12255cdae79949849b74
    # Parent  58c07f33b3989be386d38e7af538e72b4aacb46f
    Lazy power series: fix bad handling of base ring and categorification
    
    diff --git a/sage/combinat/species/series.py b/sage/combinat/species/series.py
    a b In particular, the relevant section for  
    1515http://www.risc.uni-linz.ac.at/people/hemmecke/AldorCombinat/combinatse9.html.
    1616"""
    1717#*****************************************************************************
    18 #       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>, 
     18#       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>,
    1919#
    2020#  Distributed under the terms of the GNU General Public License (GPL)
    2121#
    from sage.rings.all import Integer, prod 
    3434from functools import partial
    3535from sage.misc.misc import repr_lincomb, is_iterator
    3636
    37 from sage.algebras.algebra import Algebra
    38 from sage.algebras.algebra_element import AlgebraElement
    39 import sage.structure.parent_base
    40 from sage.categories.all import Rings
     37from sage.structure.unique_representation import UniqueRepresentation
     38from sage.structure.element import Element
     39from sage.structure.parent_base import ParentWithBase
     40from sage.categories.all import (Rings, CommutativeRings,
     41                                 Algebras, CommutativeAlgebras)
    4142
    42 class LazyPowerSeriesRing(Algebra):
     43class LazyPowerSeriesRing(UniqueRepresentation, ParentWithBase):
    4344    def __init__(self, R, element_class = None, names=None):
    4445        """
    4546        TESTS::
    46        
     47
    4748            sage: from sage.combinat.species.series import LazyPowerSeriesRing
    48             sage: L = LazyPowerSeriesRing(QQ)
    49             sage: loads(dumps(L))
     49            sage: L = LazyPowerSeriesRing(QQ); L
    5050            Lazy Power Series Ring over Rational Field
     51            sage: L.category()
     52            Category of commutative algebras over Rational Field
     53
     54        We try to check that LazyPowerSeries works in non commutative cases (:trac:`13433`)::
     55
     56            sage: G = SymmetricGroup(3)
     57            sage: R = G.algebra(QQ)
     58            sage: L = LazyPowerSeriesRing(R)
     59            sage: L.category()
     60            Category of algebras over Group algebra of Symmetric group of order 3! as a permutation group over Rational Field
     61            sage: s = sum(R(p)*L.gen()^p.length() for p in G); s
     62            Uninitialized lazy power series
     63            sage: s.coefficient(10)
     64            0
     65            sage: s
     66            B[()]*1 + (B[(2,3)]+B[(1,2)])*x + (B[(1,2,3)]+B[(1,3,2)])*x^2 + B[(1,3)]*x^3 + O(x^11)
     67            sage: s.aorder
     68            0
     69
     70            sage: p = R.monomial(G.an_element()); p
     71            B[(1,2,3)]
     72            sage: s1 = s*L(p); s1.coefficient(10); s1
     73            0
     74            B[(1,2,3)]*1 + (B[(1,2)]+B[(1,3)])*x + (B[()]+B[(1,3,2)])*x^2 + B[(2,3)]*x^3 + O(x^11)
     75
     76            sage: s2 = L(p)*s; s2.coefficient(10); s2
     77            0
     78            B[(1,2,3)]*1 + (B[(2,3)]+B[(1,3)])*x + (B[()]+B[(1,3,2)])*x^2 + B[(1,2)]*x^3 + O(x^11)
     79            sage: s.aorder
     80            0
     81
     82        Equality is not decidable, so most tests are skipped::
     83
     84            sage: TestSuite(L).run(
     85            ...       skip = ['_test_additive_associativity', '_test_associativity',
     86            ...               '_test_distributivity', '_test_elements', '_test_one',
     87            ...               '_test_prod', '_test_zero'])
    5188        """
    5289        #Make sure R is a ring with unit element
    5390        if not R in Rings():
    5491            raise TypeError, "Argument R must be a ring."
    55         try:
    56             z = R(Integer(1))
    57         except StandardError:
    58             raise ValueError, "R must have a unit element"
    5992
    6093        #Take care of the names
    6194        if names is None:
    6295            names = 'x'
    6396        else:
    6497            names = names[0]
    65  
    66         self._element_class = element_class if element_class is not None else LazyPowerSeries
     98
     99        self.Element = element_class if element_class is not None else LazyPowerSeries
    67100        self._order = None
    68101        self._name = names
    69         sage.structure.parent_base.ParentWithBase.__init__(self, R)
     102        if R in CommutativeRings():
     103            category = CommutativeAlgebras(R)
     104        else:
     105            category = Algebras(R)
     106        ParentWithBase.__init__(
     107            self, R, category = category)
    70108
    71109    def ngens(self):
    72110        """
    73111        EXAMPLES::
    74        
     112
    75113            sage: LazyPowerSeriesRing(QQ).ngens()
    76114            1
    77115        """
    78116        return 1
    79117
    80     def __repr__(self):
     118    def _repr_(self):
    81119        """
    82120        EXAMPLES::
    83        
     121
    84122            sage: LazyPowerSeriesRing(QQ)
    85123            Lazy Power Series Ring over Rational Field
    86124        """
    class LazyPowerSeriesRing(Algebra): 
    89127    def __cmp__(self, x):
    90128        """
    91129        EXAMPLES::
    92        
     130
    93131            sage: LQ = LazyPowerSeriesRing(QQ)
    94132            sage: LZ = LazyPowerSeriesRing(ZZ)
    95133            sage: LQ == LQ
    class LazyPowerSeriesRing(Algebra): 
    104142    def _coerce_impl(self, x):
    105143        """
    106144        EXAMPLES::
    107        
     145
    108146            sage: L1 = LazyPowerSeriesRing(QQ)
    109147            sage: L2 = LazyPowerSeriesRing(RR)
    110148            sage: L2.has_coerce_map_from(L1)
    111149            True
    112150            sage: L1.has_coerce_map_from(L2)
    113151            False
    114        
     152
    115153        ::
    116        
     154
    117155            sage: a = L1([1]) + L2([1])
    118156            sage: a.coefficients(3)
    119157            [2.00000000000000, 2.00000000000000, 2.00000000000000]
    120158        """
    121159        return self(x)
    122        
     160
    123161
    124162    def __call__(self, x=None, order=unk):
    125163        """
    126164        EXAMPLES::
    127        
     165
    128166            sage: from sage.combinat.species.stream import Stream
    129167            sage: L = LazyPowerSeriesRing(QQ)
    130168            sage: L()
    class LazyPowerSeriesRing(Algebra): 
    137175            [0, 1, -1, 2, -2, 3, -3, 4, -4, 5]
    138176            sage: L(Stream(ZZ)).coefficients(10)
    139177            [0, 1, -1, 2, -2, 3, -3, 4, -4, 5]
    140        
     178
    141179        ::
    142        
     180
    143181            sage: a = L([1,2,3])
    144182            sage: a.coefficients(3)
    145183            [1, 2, 3]
    class LazyPowerSeriesRing(Algebra): 
    153191            Traceback (most recent call last):
    154192            ...
    155193            TypeError: do not know how to coerce ... into self
    156        
     194
    157195        TESTS::
    158        
     196
    159197            sage: L(pi)
    160198            Traceback (most recent call last):
    161199            ...
    162200            TypeError: do not know how to coerce pi into self
    163201        """
    164         cls = self._element_class
     202        cls = self.element_class
    165203        BR = self.base_ring()
    166        
     204
    167205        if x is None:
    168206            res = cls(self, stream=None, order=unk, aorder=unk,
    169207                      aorder_changed=True, is_initialized=False)
    class LazyPowerSeriesRing(Algebra): 
    172210
    173211        if isinstance(x, LazyPowerSeries):
    174212            x_parent = x.parent()
    175             if x_parent.__class__ != self.__class__:
     213
     214            # Same kind (ordinary/exponential...) of power series ring.
     215            # __base__ removes _with_category
     216            if x_parent.__class__.__base__ != self.__class__.__base__:
    176217                raise ValueError
    177            
     218
    178219            if x_parent.base_ring() == self.base_ring():
    179220                return x
    180221            else:
    181222                if self.base_ring().has_coerce_map_from(x_parent.base_ring()):
    182223                    return x._new(partial(x._change_ring_gen, self.base_ring()), lambda ao: ao, x, parent=self)
    183        
     224
    184225
    185226        if hasattr(x, "parent") and BR.has_coerce_map_from(x.parent()):
    186227            x = BR(x)
    class LazyPowerSeriesRing(Algebra): 
    199240        elif not hasattr(x, "parent"):
    200241            x = BR(x)
    201242            return self.term(x, 0)
    202            
     243
    203244        raise TypeError, "do not know how to coerce %s into self"%x
    204    
     245
    205246    def zero_element(self):
    206247        """
    207248        Returns the zero power series.
    208        
     249
    209250        EXAMPLES::
    210        
     251
    211252            sage: L = LazyPowerSeriesRing(QQ)
    212253            sage: L.zero_element()
    213254            0
    214255        """
    215         return self(self.base_ring()(0))
     256        return self(self.base_ring().zero())
    216257
    217258    def identity_element(self):
    218259        """
    219260        Returns the one power series.
    220        
     261
    221262        EXAMPLES::
    222        
     263
    223264            sage: L = LazyPowerSeriesRing(QQ)
    224265            sage: L.identity_element()
    225266            1
    226267        """
    227         return self(self.base_ring()(1))
     268        return self(self.base_ring().one())
    228269
    229     def gen(self, i=0):
     270    def gen(self):
    230271        """
     272        Returns the generator for `self`
     273
    231274        EXAMPLES::
    232        
     275
    233276            sage: L = LazyPowerSeriesRing(QQ)
    234277            sage: L.gen().coefficients(5)
    235278            [0, 1, 0, 0, 0]
     279            sage: L.gen()[1].parent() is QQ
     280            True
    236281        """
    237         res = self._new_initial(1, Stream([0,1,0]))
     282        R0 = self.base_ring().zero()
     283        R1 = self.base_ring().one()
     284        res = self._new_initial(1, Stream([R0, R1, R0]))
    238285        res._name = self._name
    239286        return res
    240287
     288    def gens(self):
     289        r"""
     290        Returns the generators for `self`
     291
     292        EXAMPLES::
     293
     294            sage: L.<z> = LazyPowerSeriesRing(QQ)
     295            sage: z
     296            z
     297            sage: z.parent()
     298            Lazy Power Series Ring over Rational Field
     299
     300        TESTS::
     301
     302            sage: z.parent() is L
     303            True
     304        """
     305        return [self.gen()]
     306
    241307    def term(self, r, n):
    242308        """
    243309        EXAMPLES::
    244        
     310
    245311            sage: L = LazyPowerSeriesRing(QQ)
    246312            sage: L.term(0,0)
    247313            0
    class LazyPowerSeriesRing(Algebra): 
    255321            res = self._new_initial(inf, Stream([0]))
    256322            res._name = "0"
    257323        else:
    258             zero = BR(0)
     324            zero = BR.zero()
    259325            s = [zero]*n+[BR(r),zero]
    260326            res = self._new_initial(n, Stream(s))
    261327
    class LazyPowerSeriesRing(Algebra): 
    271337    def _new_initial(self, order, stream):
    272338        """
    273339        Returns a new power series with specified order.
    274        
     340
    275341        INPUT:
    276        
    277        
     342
     343
    278344        -  ``order`` - a non-negative integer
    279        
     345
    280346        -  ``stream`` - a Stream object
    281        
    282        
     347
     348
    283349        EXAMPLES::
    284        
     350
    285351            sage: from sage.combinat.species.stream import Stream
    286352            sage: L = LazyPowerSeriesRing(QQ)
    287353            sage: L._new_initial(0, Stream([1,2,3,0])).coefficients(5)
    288354            [1, 2, 3, 0, 0]
    289355        """
    290         return self._element_class(self, stream=stream, order=order, aorder=order,
     356        return self.element_class(self, stream=stream, order=order, aorder=order,
    291357                                   aorder_changed=False, is_initialized=True)
    292358
    293359
    class LazyPowerSeriesRing(Algebra): 
    295361        """
    296362        Returns a generator for the coefficients of the sum the the lazy
    297363        power series in series_list.
    298        
     364
    299365        INPUT:
    300        
    301        
     366
     367
    302368        -  ``series_list`` - a list of lazy power series
    303        
    304        
     369
     370
    305371        EXAMPLES::
    306        
     372
    307373            sage: L = LazyPowerSeriesRing(QQ)
    308374            sage: series_list = [ L([1]), L([0,1]), L([0,0,1]) ]
    309375            sage: g = L._sum_gen(series_list)
    class LazyPowerSeriesRing(Algebra): 
    321387    def sum(self, a):
    322388        """
    323389        EXAMPLES::
    324        
     390
    325391            sage: L = LazyPowerSeriesRing(QQ)
    326392            sage: l = [L(ZZ)]*3
    327393            sage: L.sum(l).coefficients(10)
    class LazyPowerSeriesRing(Algebra): 
    333399    def _sum_generator_gen(self, g):
    334400        """
    335401        EXAMPLES::
    336        
     402
    337403            sage: L = LazyPowerSeriesRing(QQ)
    338404            sage: s = L([1])
    339405            sage: def f():
    class LazyPowerSeriesRing(Algebra): 
    346412        s = Stream(g)
    347413        n = 0
    348414        while True:
    349             r = s[n].coefficient(n) 
     415            r = s[n].coefficient(n)
    350416            for i in range(len(s)-1):
    351417                r += s[i].coefficient(n)
    352418            yield r
    class LazyPowerSeriesRing(Algebra): 
    355421    def sum_generator(self, g):
    356422        """
    357423        EXAMPLES::
    358        
     424
    359425            sage: L = LazyPowerSeriesRing(QQ)
    360426            sage: g = [L([1])]*6 + [L(0)]
    361427            sage: t = L.sum_generator(g)
    362428            sage: t.coefficients(10)
    363429            [1, 2, 3, 4, 5, 6, 6, 6, 6, 6]
    364        
     430
    365431        ::
    366        
     432
    367433            sage: s = L([1])
    368434            sage: def g():
    369435            ...       while True:
    class LazyPowerSeriesRing(Algebra): 
    378444    def _product_generator_gen(self, g):
    379445        """
    380446        EXAMPLES::
    381        
     447
    382448            sage: from itertools import imap
    383449            sage: from sage.combinat.species.stream import _integers_from
    384450            sage: L = LazyPowerSeriesRing(QQ)
    class LazyPowerSeriesRing(Algebra): 
    405471    def product_generator(self, g):
    406472        """
    407473        EXAMPLES::
    408        
     474
    409475            sage: L = LazyPowerSeriesRing(QQ)
    410476            sage: s1 = L([1,1,0])
    411477            sage: s2 = L([1,0,1,0])
    class LazyPowerSeriesRing(Algebra): 
    420486            sage: p = L.product_generator(g())
    421487            sage: p.coefficients(26)
    422488            [1, 1, 1, 2, 2, 3, 4, 4, 4, 5, 5, 5, 5, 4, 4, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0, 0]
    423        
     489
    424490        ::
    425        
     491
    426492            sage: def m(n):
    427493            ...       yield 1
    428494            ...       while True:
    class LazyPowerSeriesRing(Algebra): 
    438504            ...               yield 0
    439505            ...           yield q
    440506            ...
    441        
     507
    442508        ::
    443        
     509
    444510            sage: def lhs_gen():
    445511            ...       n = 1
    446512            ...       while True:
    447513            ...           yield L(m(n))
    448514            ...           n += 1
    449515            ...
    450        
     516
    451517        ::
    452        
     518
    453519            sage: def rhs_gen():
    454520            ...       n = 1
    455521            ...       while True:
    class LazyPowerSeriesRing(Algebra): 
    465531        """
    466532        return self(self._product_generator_gen(g))
    467533
    468 
    469                    
    470 class LazyPowerSeries(AlgebraElement):
     534class LazyPowerSeries(Element):
    471535    def __init__(self, A, stream=None, order=None, aorder=None, aorder_changed=True, is_initialized=False, name=None):
    472536        """
    473537        EXAMPLES::
    474        
     538
    475539            sage: L = LazyPowerSeriesRing(QQ)
    476540            sage: f = L()
    477541            sage: loads(dumps(f))
    478542            Uninitialized lazy power series
    479543        """
    480         AlgebraElement.__init__(self, A)
     544        Element.__init__(self, A)
    481545        self._stream = stream
    482546        self.order = unk if order is None else order
    483547        self.aorder = unk if aorder is None else aorder
    class LazyPowerSeries(AlgebraElement): 
    491555    def compute_aorder(*args, **kwargs):
    492556        """
    493557        The default compute_aorder does nothing.
    494        
     558
    495559        EXAMPLES::
    496        
     560
    497561            sage: L = LazyPowerSeriesRing(QQ)
    498562            sage: a = L(1)
    499563            sage: a.compute_aorder() is None
    class LazyPowerSeries(AlgebraElement): 
    504568    def _get_repr_info(self, x):
    505569        """
    506570        EXAMPLES::
    507        
     571
    508572            sage: L = LazyPowerSeriesRing(QQ)
    509573            sage: a = L([1,2,3])
    510574            sage: a.compute_coefficients(5)
    class LazyPowerSeries(AlgebraElement): 
    517581        c = [ self._stream[i] for i in range(n) ]
    518582        return [ (m,c) for m,c in zip(m,c) if c != 0]
    519583
    520     def __repr__(self):
     584    def _repr_(self):
    521585        """
    522586        EXAMPLES::
    523        
     587
    524588            sage: L = LazyPowerSeriesRing(QQ)
    525589            sage: s = L(); s._name = 's'; s
    526590            s
    527        
     591
    528592        ::
    529        
     593
    530594            sage: L()
    531595            Uninitialized lazy power series
    532        
     596
    533597        ::
    534        
     598
    535599            sage: a = L([1,2,3])
    536600            sage: a
    537601            O(1)
    class LazyPowerSeries(AlgebraElement): 
    541605            sage: a.compute_coefficients(4)
    542606            sage: a
    543607            1 + 2*x + 3*x^2 + 3*x^3 + 3*x^4 + 3*x^5 + ...
    544        
     608
    545609        ::
    546        
     610
    547611            sage: a = L([1,2,3,0])
    548612            sage: a.compute_coefficients(5)
    549613            sage: a
    class LazyPowerSeries(AlgebraElement): 
    551615        """
    552616        if self._name is not None:
    553617            return self._name
    554        
     618
    555619        if self.is_initialized:
    556620            n = len(self._stream)
    557621            x = self.parent()._name
    class LazyPowerSeries(AlgebraElement): 
    572636        """
    573637        Refines the approximate order of self as much as possible without
    574638        computing any coefficients.
    575        
     639
    576640        EXAMPLES::
    577        
     641
    578642            sage: L = LazyPowerSeriesRing(QQ)
    579643            sage: a = L([0,0,0,0,1])
    580644            sage: a.aorder
    class LazyPowerSeries(AlgebraElement): 
    586650            sage: a.refine_aorder()
    587651            sage: a.aorder
    588652            3
    589        
     653
    590654        ::
    591        
     655
    592656            sage: a = L([0,0])
    593657            sage: a.aorder
    594658            0
    class LazyPowerSeries(AlgebraElement): 
    597661            sage: a.refine_aorder()
    598662            sage: a.aorder
    599663            Infinite series order
    600        
     664
    601665        ::
    602        
     666
    603667            sage: a = L([0,0,1,0,0,0])
    604668            sage: a[4]
    605669            0
    class LazyPowerSeries(AlgebraElement): 
    633697        #aorder can never be infinity since order would have to
    634698        #be infinity as well
    635699        assert self.aorder != inf
    636        
     700
    637701        if self.aorder == unk or not self.is_initialized:
    638702            self.compute_aorder()
    639703        else:
    class LazyPowerSeries(AlgebraElement): 
    663727               
    664728            if ao < n:
    665729                self.order = ao
    666            
    667    
     730
     731
    668732        if hasattr(self, '_reference') and self._reference is not None:
    669733            self._reference._copy(self)
    670734
    671735    def initialize_coefficient_stream(self, compute_coefficients):
    672736        """
    673737        Initializes the coefficient stream.
    674        
     738
    675739        INPUT: compute_coefficients
    676        
     740
    677741        TESTS::
    678        
     742
    679743            sage: from sage.combinat.species.series_order import inf, unk
    680744            sage: L = LazyPowerSeriesRing(QQ)
    681745            sage: f = L()
    class LazyPowerSeries(AlgebraElement): 
    685749            sage: f.initialize_coefficient_stream(compute_coefficients)
    686750            sage: f.coefficients(5)
    687751            [0, 0, 0, 0, 0]
    688        
     752
    689753        ::
    690        
     754
    691755            sage: f = L()
    692756            sage: compute_coefficients = lambda ao: iter(ZZ)
    693757            sage: f.order = 1
    694758            sage: f.aorder = 1
    695759            sage: f.initialize_coefficient_stream(compute_coefficients)
    696             sage: f.coefficients(5)           
     760            sage: f.coefficients(5)
    697761            [0, 1, -1, 2, -2]
    698762        """
    699763        ao = self.aorder
    class LazyPowerSeries(AlgebraElement): 
    710774    def compute_coefficients(self, i):
    711775        """
    712776        Computes all the coefficients of self up to i.
    713        
     777
    714778        EXAMPLES::
    715        
     779
    716780            sage: L = LazyPowerSeriesRing(QQ)
    717781            sage: a = L([1,2,3])
    718782            sage: a.compute_coefficients(5)
    class LazyPowerSeries(AlgebraElement): 
    724788    def coefficients(self, n):
    725789        """
    726790        Returns the first n coefficients of self.
    727        
     791
    728792        EXAMPLES::
    729        
     793
    730794            sage: L = LazyPowerSeriesRing(QQ)
    731795            sage: f = L([1,2,3,0])
    732796            sage: f.coefficients(5)
    class LazyPowerSeries(AlgebraElement): 
    737801    def is_zero(self):
    738802        """
    739803        Returns True if and only if self is zero.
    740        
     804
    741805        EXAMPLES::
    742        
     806
    743807            sage: L = LazyPowerSeriesRing(QQ)
    744808            sage: s = L([0,2,3,0])
    745809            sage: s.is_zero()
    746810            False
    747        
     811
    748812        ::
    749        
     813
    750814            sage: s = L(0)
    751815            sage: s.is_zero()
    752816            True
    753        
     817
    754818        ::
    755        
     819
    756820            sage: s = L([0])
    757821            sage: s.is_zero()
    758822            False
    class LazyPowerSeries(AlgebraElement): 
    770834        """
    771835        Sets the approximate order of self and returns True if the
    772836        approximate order has changed otherwise it will return False.
    773        
     837
    774838        EXAMPLES::
    775        
     839
    776840            sage: L = LazyPowerSeriesRing(QQ)
    777841            sage: f = L([0,0,0,3,2,1,0])
    778842            sage: f.get_aorder()
    class LazyPowerSeries(AlgebraElement): 
    789853    def _copy(self, x):
    790854        """
    791855        EXAMPLES::
    792        
     856
    793857            sage: L = LazyPowerSeriesRing(QQ)
    794858            sage: f = L.term(2, 2)
    795859            sage: g = L()
    class LazyPowerSeries(AlgebraElement): 
    809873        self.compute_aorder = x.compute_aorder
    810874        self.is_initialized = x.is_initialized
    811875        self._stream = x._stream
    812        
     876
    813877    def define(self, x):
    814878        """
    815879        EXAMPLES: Test Recursive 0
    816        
     880
    817881        ::
    818        
     882
    819883            sage: L = LazyPowerSeriesRing(QQ)
    820884            sage: one = L(1)
    821885            sage: monom = L.gen()
    class LazyPowerSeries(AlgebraElement): 
    828892            Unknown series order
    829893            sage: [s.coefficient(i) for i in range(6)]
    830894            [1, 1, 1, 1, 1, 1]
    831        
     895
    832896        Test Recursive 1
    833        
     897
    834898        ::
    835        
     899
    836900            sage: s = L()
    837901            sage: s._name = 's'
    838902            sage: s.define(one+monom*s*s)
    class LazyPowerSeries(AlgebraElement): 
    842906            Unknown series order
    843907            sage: [s.coefficient(i) for i in range(6)]
    844908            [1, 1, 2, 5, 14, 42]
    845        
     909
    846910        Test Recursive 1b
    847        
     911
    848912        ::
    849        
     913
    850914            sage: s = L()
    851915            sage: s._name = 's'
    852916            sage: s.define(monom + s*s)
    853917            sage: s.aorder
    854             1
     918            Unknown series order
    855919            sage: s.order
    856920            Unknown series order
    857921            sage: [s.coefficient(i) for i in range(7)]
    858922            [0, 1, 1, 2, 5, 14, 42]
    859        
     923            sage: s.aorder
     924            1
     925            sage: s.order
     926            1
     927
    860928        Test Recursive 2
    861        
     929
    862930        ::
    863        
     931
    864932            sage: s = L()
    865933            sage: s._name = 's'
    866934            sage: t = L()
    class LazyPowerSeries(AlgebraElement): 
    871939            [1, 1, 3, 9, 34, 132, 546, 2327, 10191]
    872940            sage: [t.coefficient(i) for i in range(9)]
    873941            [1, 1, 2, 7, 24, 95, 386, 1641, 7150]
    874        
     942
    875943        Test Recursive 2b
    876        
     944
    877945        ::
    878        
     946
    879947            sage: s = L()
    880948            sage: s._name = 's'
    881949            sage: t = L()
    class LazyPowerSeries(AlgebraElement): 
    886954            [0, 1, 0, 1, 3, 3, 7, 30, 63]
    887955            sage: [t.coefficient(i) for i in range(9)]
    888956            [0, 1, 1, 0, 2, 6, 7, 20, 75]
    889        
     957
    890958        Test Recursive 3
    891        
     959
    892960        ::
    893        
     961
    894962            sage: s = L()
    895963            sage: s._name = 's'
    896964            sage: s.define(one+monom*s*s*s)
    class LazyPowerSeries(AlgebraElement): 
    903971    def coefficient(self, n):
    904972        """
    905973        Returns the coefficient of xn in self.
    906        
     974
    907975        EXAMPLES::
    908        
     976
    909977            sage: L = LazyPowerSeriesRing(QQ)
    910978            sage: f = L(ZZ)
    911979            sage: [f.coefficient(i) for i in range(5)]
    912980            [0, 1, -1, 2, -2]
    913981        """
    914982        # The following line must not be written n < self.get_aorder()
    915         # because comparison of Integer and OnfinityOrder is not implemented. 
     983        # because comparison of Integer and OnfinityOrder is not implemented.
    916984        if self.get_aorder() > n:
    917985            return self._zero
    918986
    class LazyPowerSeries(AlgebraElement): 
    923991    def get_aorder(self):
    924992        """
    925993        Returns the approximate order of self.
    926        
     994
    927995        EXAMPLES::
    928        
     996
    929997            sage: L = LazyPowerSeriesRing(QQ)
    930998            sage: a = L.gen()
    931999            sage: a.get_aorder()
    class LazyPowerSeries(AlgebraElement): 
    9371005    def get_order(self):
    9381006        """
    9391007        Returns the order of self.
    940        
     1008
    9411009        EXAMPLES::
    942        
     1010
    9431011            sage: L = LazyPowerSeriesRing(QQ)
    9441012            sage: a = L.gen()
    9451013            sage: a.get_order()
    class LazyPowerSeries(AlgebraElement): 
    9511019    def get_stream(self):
    9521020        """
    9531021        Returns self's underlying Stream object.
    954        
     1022
    9551023        EXAMPLES::
    956        
     1024
    9571025            sage: L = LazyPowerSeriesRing(QQ)
    9581026            sage: a = L.gen()
    9591027            sage: s = a.get_stream()
    class LazyPowerSeries(AlgebraElement): 
    9981066        parent = kwds['parent'] if 'parent' in kwds else self.parent()
    9991067        new_fps = self.__class__(parent, stream=None, order=unk, aorder=self.aorder,
    10001068                                 aorder_changed=True, is_initialized=False)
    1001        
     1069
    10021070        new_fps.compute_aorder = lambda: new_fps._approximate_order(compute_coefficients, order_op, *series)
    10031071        return new_fps
    10041072
    10051073    def _add_(self, y):
    10061074        """
    10071075        EXAMPLES: Test Plus 1
    1008        
     1076
    10091077        ::
    1010        
     1078
    10111079            sage: from sage.combinat.species.series import *
    10121080            sage: from sage.combinat.species.stream import Stream
    10131081            sage: L = LazyPowerSeriesRing(QQ)
    class LazyPowerSeries(AlgebraElement): 
    10261094            [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
    10271095            sage: [sum3.coefficient(i) for i in range(11)]
    10281096            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
    1029        
     1097
    10301098        Test Plus 2
    1031        
     1099
    10321100        ::
    1033        
     1101
    10341102            sage: gs1 = L([1,2,4,8,0])
    10351103            sage: gs2 = L([-1, 0,-1,-9,22,0])
    10361104            sage: sum = gs1 + gs2
    class LazyPowerSeries(AlgebraElement): 
    10431111            [0,  2, 3, -1, 22]
    10441112            sage: [ sum2.coefficient(i) for i in range(5, 11) ]
    10451113            [0, 0, 0, 0, 0, 0]
     1114
     1115
     1116        TESTS:
     1117
     1118        Check that :trac:`13433` is fixed::
     1119
     1120            sage: from sage.combinat.species.series import LazyPowerSeriesRing
     1121            sage: L = LazyPowerSeriesRing(QQ)
     1122            sage: g = L.gen(); z = L.zero()
     1123            sage: s = z+g; s
     1124            Uninitialized lazy power series
     1125            sage: s.coefficients(10)
     1126            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
     1127            sage: s
     1128            x + O(x^10)
    10461129        """
     1130        # print self.aorder, y.aorder
     1131        if ( self.aorder != unk and
     1132            ( y.aorder == unk or self.aorder > y.aorder ) ):
     1133            y, self = self, y
    10471134        return self._new(partial(self._plus_gen, y), min, self, y)
    1048    
    10491135    add = _add_
    10501136
    10511137
    class LazyPowerSeries(AlgebraElement): 
    10531139    def _plus_gen(self, y, ao):
    10541140        """
    10551141        EXAMPLES::
    1056        
     1142
    10571143            sage: L = LazyPowerSeriesRing(QQ)
    10581144            sage: gs1 = L([1])
    10591145            sage: g = gs1._plus_gen(gs1, 0)
    10601146            sage: [g.next() for i in range(5)]
    10611147            [2, 2, 2, 2, 2]
    1062        
     1148
    10631149        ::
    1064        
     1150
    10651151            sage: g = gs1._plus_gen(gs1, 2)
    10661152            sage: [g.next() for i in range(5)]
    10671153            [0, 0, 2, 2, 2]
    class LazyPowerSeries(AlgebraElement): 
    10781164    def _mul_(self, y):
    10791165        """
    10801166        EXAMPLES::
    1081        
     1167
    10821168            sage: L = LazyPowerSeriesRing(QQ)
    10831169            sage: gs0 = L(0)
    10841170            sage: gs1 = L([1])
    1085        
     1171
    10861172        ::
    1087        
     1173
    10881174            sage: prod0 = gs0 * gs1
    10891175            sage: [prod0.coefficient(i) for i in range(11)]
    10901176            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    1091        
     1177
    10921178        ::
    1093        
     1179
    10941180            sage: prod1 = gs1 * gs0
    10951181            sage: [prod1.coefficient(i) for i in range(11)]
    10961182            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    1097        
     1183
    10981184        ::
    1099        
     1185
    11001186            sage: prod2 = gs1 * gs1
    11011187            sage: [prod2.coefficient(i) for i in range(11)]
    11021188            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    1103        
     1189
    11041190        ::
    1105        
     1191
    11061192            sage: gs1 = L([1,2,4,8,0])
    11071193            sage: gs2 = L([-1, 0,-1,-9,22,0])
    1108        
     1194
    11091195        ::
    1110        
     1196
    11111197            sage: prod1 = gs1 * gs2
    11121198            sage: [prod1.coefficient(i) for i in range(11)]
    11131199            [-1, -2, -5, -19, 0, 0, 16, 176, 0, 0, 0]
    1114        
     1200
    11151201        ::
    1116        
     1202
    11171203            sage: prod2 = gs2 * gs1
    11181204            sage: [prod2.coefficient(i) for i in range(11)]
    11191205            [-1, -2, -5, -19, 0, 0, 16, 176, 0, 0, 0]
    11201206        """
    11211207
    1122         return self._new(partial(self._times_gen, y), lambda a,b:a+b, self, y)                     
     1208        return self._new(partial(self._times_gen, y), lambda a,b:a+b, self, y)
    11231209
    11241210    times = _mul_
    1125        
     1211
    11261212    def _times_gen(self, y, ao):
    11271213        """
    11281214        Returns an iterator for the coefficients of self \* y.
    1129        
     1215
    11301216        EXAMPLES::
    1131        
     1217
    11321218            sage: L = LazyPowerSeriesRing(QQ)
    11331219            sage: f = L([1,1,0])
    11341220            sage: g = f._times_gen(f,0)
    class LazyPowerSeries(AlgebraElement): 
    11481234            nth_coefficient = zero
    11491235
    11501236            #Handle the zero series
    1151             if low == inf or high == inf:     
     1237            if low == inf or high == inf:
    11521238                yield zero
    1153                 n += 1                       
    1154                 continue                     
     1239                n += 1
     1240                continue
    11551241
    11561242            for k in range(low, high+1):
    11571243                cx = self._stream[k]
    class LazyPowerSeries(AlgebraElement): 
    11641250    def __pow__(self, n):
    11651251        """
    11661252        EXAMPLES::
    1167        
     1253
    11681254            sage: L = LazyPowerSeriesRing(QQ)
    11691255            sage: f = L([1,1,0])  # 1+x
    11701256            sage: g = f^3
    11711257            sage: g.coefficients(4)
    11721258            [1, 3, 3, 1]
    1173        
     1259
    11741260        ::
    1175        
     1261
    11761262            sage: f^0
    11771263            1
    11781264        """
    class LazyPowerSeries(AlgebraElement): 
    11841270        """
    11851271        Returns the composition of this power series and the power series
    11861272        y.
    1187        
     1273
    11881274        EXAMPLES::
    1189        
     1275
    11901276            sage: L = LazyPowerSeriesRing(QQ)
    11911277            sage: s = L([1])
    11921278            sage: t = L([0,0,1])
    11931279            sage: u = s(t)
    11941280            sage: u.coefficients(11)
    11951281            [1, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    1196        
     1282
    11971283        Test Compose 2
    1198        
     1284
    11991285        ::
    1200        
     1286
    12011287            sage: s = L([1])
    12021288            sage: t = L([0,0,1,0])
    12031289            sage: u = s(t)
    class LazyPowerSeries(AlgebraElement): 
    12111297            0
    12121298            sage: u.order
    12131299            0
    1214        
     1300
    12151301        Test Compose 3 s = 1/(1-x), t = x/(1-x) s(t) = (1-x)/(1-2x)
    1216        
     1302
    12171303        ::
    1218        
     1304
    12191305            sage: s = L([1])
    12201306            sage: t = L([0,1])
    12211307            sage: u = s(t)
    class LazyPowerSeries(AlgebraElement): 
    12301316        """
    12311317        Returns a iterator for the coefficients of the composition of this
    12321318        power series with the power series y.
    1233        
     1319
    12341320        EXAMPLES::
    1235        
     1321
    12361322            sage: L = LazyPowerSeriesRing(QQ)
    12371323            sage: s = L([1])
    12381324            sage: t = L([0,1])
    class LazyPowerSeries(AlgebraElement): 
    12551341        """
    12561342        Returns the power series whose coefficients obtained by subtracting
    12571343        the constant term from this series and then dividing by x.
    1258        
     1344
    12591345        EXAMPLES::
    1260        
     1346
    12611347            sage: from sage.combinat.species.stream import Stream
    12621348            sage: L = LazyPowerSeriesRing(QQ)
    12631349            sage: f = L(range(20))
    class LazyPowerSeries(AlgebraElement): 
    12701356    def iterator(self, n=0, initial=None):
    12711357        """
    12721358        Returns an iterator for the coefficients of self starting at n.
    1273        
     1359
    12741360        EXAMPLES::
    1275        
     1361
    12761362            sage: from sage.combinat.species.stream import Stream
    12771363            sage: L = LazyPowerSeriesRing(QQ)
    12781364            sage: f = L(range(10))
    class LazyPowerSeries(AlgebraElement): 
    12951381    def _power_gen(self):
    12961382        """
    12971383        Returns a generator for all the powers self^k starting with k = 1.
    1298        
     1384
    12991385        EXAMPLES::
    1300        
     1386
    13011387            sage: L = LazyPowerSeriesRing(QQ)
    13021388            sage: f = L([1,1,0])
    13031389            sage: g = f._power_gen()
    class LazyPowerSeries(AlgebraElement): 
    13161402    def derivative(self):
    13171403        """
    13181404        EXAMPLES::
    1319        
     1405
    13201406            sage: from sage.combinat.species.stream import Stream
    13211407            sage: L = LazyPowerSeriesRing(QQ)
    13221408            sage: one = L(1)
    class LazyPowerSeries(AlgebraElement): 
    13251411            sage: u = s.derivative()
    13261412            sage: u.coefficients(10)
    13271413            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    1328        
     1414
    13291415        ::
    1330        
     1416
    13311417            sage: s = L()
    13321418            sage: s._name = 's'
    13331419            sage: s.define(one+monom*s*s)
    13341420            sage: u = s.derivative()
    13351421            sage: u.coefficients(5) #[1*1, 2*2, 3*5, 4*14, 5*42]
    13361422            [1, 4, 15, 56, 210]
    1337        
     1423
    13381424        ::
    1339        
     1425
    13401426            sage: s = L([1])
    13411427            sage: t = L([0,1])
    13421428            sage: u = s(t).derivative()
    class LazyPowerSeries(AlgebraElement): 
    13451431            [1, 4, 12, 32, 80, 192, 448, 1024, 2304, 5120, 11264]
    13461432            sage: v.coefficients(11)
    13471433            [1, 4, 12, 32, 80, 192, 448, 1024, 2304, 5120, 11264]
    1348        
     1434
    13491435        ::
    1350        
     1436
    13511437            sage: s = L(); s._name='s'
    13521438            sage: t = L(); t._name='t'
    13531439            sage: s.define(monom+t*t*t)
    class LazyPowerSeries(AlgebraElement): 
    13601446            [0, 2, 3, 4, 30, 72, 133, 552, 1791, 4260]
    13611447            sage: u.coefficients(10) == v.coefficients(10)
    13621448            True
    1363        
     1449
    13641450        ::
    1365        
     1451
    13661452            sage: f = L._new_initial(2, Stream([0,0,4,5,6,0]))
    13671453            sage: d = f.derivative()
    13681454            sage: d.get_aorder()
    class LazyPowerSeries(AlgebraElement): 
    13761462        """
    13771463        Returns an iterator for the coefficients of the derivative of
    13781464        self.
    1379        
     1465
    13801466        EXAMPLES::
    1381        
     1467
    13821468            sage: L = LazyPowerSeriesRing(QQ)
    13831469            sage: f = L([1])
    13841470            sage: g = f._diff_gen(0)
    class LazyPowerSeries(AlgebraElement): 
    13891475        while True:
    13901476            yield n*self._stream[n]
    13911477            n += 1
    1392                
    1393     ########### 
     1478
     1479    ###########
    13941480    #Integrals#
    13951481    ###########
    13961482    def integral(self, integration_constant = 0):
    13971483        """
    13981484        EXAMPLES::
    1399        
     1485
    14001486            sage: L = LazyPowerSeriesRing(QQ)
    14011487            sage: zero = L(0)
    14021488            sage: s = zero
    14031489            sage: t = s.integral()
    14041490            sage: t.is_zero()
    14051491            True
    1406        
     1492
    14071493        ::
    1408        
     1494
    14091495            sage: s = zero
    14101496            sage: t = s.integral(1)
    14111497            sage: t.coefficients(6)
    14121498            [1, 0, 0, 0, 0, 0]
    14131499            sage: t._stream.is_constant()
    14141500            True
    1415        
     1501
    14161502        ::
    1417        
     1503
    14181504            sage: s = L.term(1, 0)
    14191505            sage: t = s.integral()
    14201506            sage: t.coefficients(6)
    14211507            [0, 1, 0, 0, 0, 0]
    14221508            sage: t._stream.is_constant()
    14231509            True
    1424        
     1510
    14251511        ::
    1426        
     1512
    14271513            sage: s = L.term(1,0)
    14281514            sage: t = s.integral(1)
    14291515            sage: t.coefficients(6)
    14301516            [1, 1, 0, 0, 0, 0]
    14311517            sage: t._stream.is_constant()
    14321518            True
    1433        
     1519
    14341520        ::
    1435        
     1521
    14361522            sage: s = L.term(1, 4)
    14371523            sage: t = s.integral()
    14381524            sage: t.coefficients(10)
    14391525            [0, 0, 0, 0, 0, 1/5, 0, 0, 0, 0]
    1440        
     1526
    14411527        ::
    1442        
     1528
    14431529            sage: s = L.term(1,4)
    14441530            sage: t = s.integral(1)
    14451531            sage: t.coefficients(10)
    14461532            [1, 0, 0, 0, 0, 1/5, 0, 0, 0, 0]
    1447        
     1533
    14481534        TESTS::
    1449        
     1535
    14501536            sage: from sage.combinat.species.stream import Stream
    14511537            sage: f = L._new_initial(2, Stream([0,0,4,5,6,0]))
    14521538            sage: i = f.derivative().integral()
    class LazyPowerSeries(AlgebraElement): 
    14691555    def _integral_zero_gen(self, ao):
    14701556        """
    14711557        EXAMPLES::
    1472        
     1558
    14731559            sage: L = LazyPowerSeriesRing(QQ)
    14741560            sage: s = L.gen()
    14751561            sage: g = s._integral_zero_gen(1)
    class LazyPowerSeries(AlgebraElement): 
    14921578    def _integral_nonzero_gen(self, integration_constant):
    14931579        """
    14941580        EXAMPLES::
    1495        
     1581
    14961582            sage: from sage.combinat.species.stream import Stream
    14971583            sage: L = LazyPowerSeriesRing(QQ)
    14981584            sage: f = L._new_initial(2, Stream([0,0,4,5,6,0])).derivative()
    class LazyPowerSeries(AlgebraElement): 
    15101596        else:
    15111597            for _ in range(ao-1):
    15121598                yield self._zero
    1513                
     1599
    15141600            n = max(1,ao)
    15151601            while True:
    15161602                c = self.coefficient(n-1)
    class LazyPowerSeries(AlgebraElement): 
    15261612    def is_finite(self, n=None):
    15271613        """
    15281614        EXAMPLES::
    1529        
     1615
    15301616            sage: L = LazyPowerSeriesRing(QQ)
    15311617            sage: a = L([0,0,1,0,0]); a
    15321618            O(1)
    class LazyPowerSeries(AlgebraElement): 
    15501636
    15511637        if n is None:
    15521638            n = len(s)
    1553            
     1639
    15541640        if s.is_constant() and all(s[i] == 0 for i in range(n-1, max(n,len(s)))):
    15551641            return True
    15561642
    class LazyPowerSeries(AlgebraElement): 
    15591645    def exponential(self):
    15601646        """
    15611647        TESTS::
    1562        
     1648
    15631649            sage: def inv_factorial():
    15641650            ...       q = 1
    15651651            ...       yield 0
    class LazyPowerSeries(AlgebraElement): 
    15891675    def __getitem__(self, i):
    15901676        """
    15911677        Returns the ith coefficient of self.
    1592        
     1678
    15931679        EXAMPLES::
    1594        
     1680
    15951681            sage: L = LazyPowerSeriesRing(QQ)
    15961682            sage: f = L([1,2,3,0])
    15971683            sage: [f[i] for i in range(5)]
    class LazyPowerSeries(AlgebraElement): 
    16091695        min and going up to, but not including max. If min is not
    16101696        specified, then it is assumed to be zero. If max is not specified,
    16111697        then it is assumed to be infinity.
    1612        
     1698
    16131699        EXAMPLES::
    1614        
     1700
    16151701            sage: L = LazyPowerSeriesRing(QQ)
    16161702            sage: a = L([1])
    16171703            sage: a.restricted().coefficients(10)
    class LazyPowerSeries(AlgebraElement): 
    16271713        if ((min is None and max is None) or
    16281714            (max is None and self.get_aorder() >= min)):
    16291715            return self
    1630        
     1716
    16311717        return self._new(partial(self._restricted_gen, min, max),
    16321718                         lambda ao: __builtin__.max(ao, min), self)
    16331719
    16341720    def _restricted_gen(self, mn, mx, ao):
    16351721        """
    16361722        EXAMPLES::
    1637        
     1723
    16381724            sage: L = LazyPowerSeriesRing(QQ)
    16391725            sage: a = L([1])
    16401726            sage: g = a._restricted_gen(None, None, 2)
    class LazyPowerSeries(AlgebraElement): 
    16461732            sage: g = a._restricted_gen(3, None, 2)
    16471733            sage: [g.next() for i in range(10)]
    16481734            [0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
    1649        
     1735
    16501736        ::
    1651        
     1737
    16521738            sage: g = a._restricted_gen(1, 5, 2)
    16531739            sage: [g.next() for i in range(6)]
    16541740            [0, 0, 1, 1, 1, 0]
    16551741        """
    16561742        BR = self.parent().base_ring()
    16571743        for n in range(max(mn,ao)):
    1658             yield BR(0)
     1744            yield BR.zero()
    16591745
    16601746        n = max(mn, ao)
    16611747        while True:
    16621748            if mx is not None and n >= mx:
    1663                 yield BR(0)
     1749                yield BR.zero()
    16641750                break
    16651751            else:
    16661752                yield self._stream[n]
    class LazyPowerSeries(AlgebraElement): 
    16731759    def _change_ring_gen(self, R, ao):
    16741760        """
    16751761        EXAMPLES::
    1676        
     1762
    16771763            sage: L = LazyPowerSeriesRing(QQ)
    16781764            sage: L2 = LazyPowerSeriesRing(RR)
    16791765            sage: a = L([1])
    class LazyPowerSeries(AlgebraElement): 
    16931779
    16941780#################################
    16951781
    1696 
    1697 
    16981782def uninitialized():
    16991783    """
    17001784    EXAMPLES::
    1701    
     1785
    17021786        sage: from sage.combinat.species.series import uninitialized
    17031787        sage: uninitialized()
    17041788        Traceback (most recent call last):