Ticket #13433: trac_13433-lazy_power_serie_gen_fix-fh.patch

File trac_13433-lazy_power_serie_gen_fix-fh.patch, 36.8 KB (added by mhansen, 8 years ago)
  • sage/combinat/species/series.py

    # HG changeset patch
    # User Mike Hansen <mhansen@gmail.com>
    # Date 1374443204 -3600
    # Node ID e8d03c4cbd96b861553c41026cffc29d7bd1c55e
    # Parent  b279f242b360ddf3d356ed04571bcf8d91be4281
    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  
    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#
     
    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        """
     
    89127    def __cmp__(self, x):
    90128        """
    91129        EXAMPLES::
    92        
     130
    93131            sage: LQ = LazyPowerSeriesRing(QQ)
    94132            sage: LZ = LazyPowerSeriesRing(ZZ)
    95133            sage: LQ == LQ
     
    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()
     
    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]
     
    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)
     
    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)
     
    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
     
    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
     
    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
     
    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)
     
    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)
     
    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():
     
    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
     
    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:
     
    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)
     
    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])
     
    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:
     
    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:
     
    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
     
    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
     
    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)
     
    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)
     
    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
     
    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
     
    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
     
    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
     
    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
     
    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:
     
    659723                    self.aorder = inf
    660724                    self.order  = inf
    661725                    return
    662    
     726
    663727        if hasattr(self, '_reference') and self._reference is not None:
    664728            self._reference._copy(self)
    665729
    666730    def initialize_coefficient_stream(self, compute_coefficients):
    667731        """
    668732        Initializes the coefficient stream.
    669        
     733
    670734        INPUT: compute_coefficients
    671        
     735
    672736        TESTS::
    673        
     737
    674738            sage: from sage.combinat.species.series_order import inf, unk
    675739            sage: L = LazyPowerSeriesRing(QQ)
    676740            sage: f = L()
     
    680744            sage: f.initialize_coefficient_stream(compute_coefficients)
    681745            sage: f.coefficients(5)
    682746            [0, 0, 0, 0, 0]
    683        
     747
    684748        ::
    685        
     749
    686750            sage: f = L()
    687751            sage: compute_coefficients = lambda ao: iter(ZZ)
    688752            sage: f.order = 1
    689753            sage: f.aorder = 1
    690754            sage: f.initialize_coefficient_stream(compute_coefficients)
    691             sage: f.coefficients(5)           
     755            sage: f.coefficients(5)
    692756            [0, 1, -1, 2, -2]
    693757        """
    694758        ao = self.aorder
     
    705769    def compute_coefficients(self, i):
    706770        """
    707771        Computes all the coefficients of self up to i.
    708        
     772
    709773        EXAMPLES::
    710        
     774
    711775            sage: L = LazyPowerSeriesRing(QQ)
    712776            sage: a = L([1,2,3])
    713777            sage: a.compute_coefficients(5)
     
    719783    def coefficients(self, n):
    720784        """
    721785        Returns the first n coefficients of self.
    722        
     786
    723787        EXAMPLES::
    724        
     788
    725789            sage: L = LazyPowerSeriesRing(QQ)
    726790            sage: f = L([1,2,3,0])
    727791            sage: f.coefficients(5)
     
    732796    def is_zero(self):
    733797        """
    734798        Returns True if and only if self is zero.
    735        
     799
    736800        EXAMPLES::
    737        
     801
    738802            sage: L = LazyPowerSeriesRing(QQ)
    739803            sage: s = L([0,2,3,0])
    740804            sage: s.is_zero()
    741805            False
    742        
     806
    743807        ::
    744        
     808
    745809            sage: s = L(0)
    746810            sage: s.is_zero()
    747811            True
    748        
     812
    749813        ::
    750        
     814
    751815            sage: s = L([0])
    752816            sage: s.is_zero()
    753817            False
     
    765829        """
    766830        Sets the approximate order of self and returns True if the
    767831        approximate order has changed otherwise it will return False.
    768        
     832
    769833        EXAMPLES::
    770        
     834
    771835            sage: L = LazyPowerSeriesRing(QQ)
    772836            sage: f = L([0,0,0,3,2,1,0])
    773837            sage: f.get_aorder()
     
    784848    def _copy(self, x):
    785849        """
    786850        EXAMPLES::
    787        
     851
    788852            sage: L = LazyPowerSeriesRing(QQ)
    789853            sage: f = L.term(2, 2)
    790854            sage: g = L()
     
    804868        self.compute_aorder = x.compute_aorder
    805869        self.is_initialized = x.is_initialized
    806870        self._stream = x._stream
    807        
     871
    808872    def define(self, x):
    809873        """
    810874        EXAMPLES: Test Recursive 0
    811        
     875
    812876        ::
    813        
     877
    814878            sage: L = LazyPowerSeriesRing(QQ)
    815879            sage: one = L(1)
    816880            sage: monom = L.gen()
     
    823887            Unknown series order
    824888            sage: [s.coefficient(i) for i in range(6)]
    825889            [1, 1, 1, 1, 1, 1]
    826        
     890
    827891        Test Recursive 1
    828        
     892
    829893        ::
    830        
     894
    831895            sage: s = L()
    832896            sage: s._name = 's'
    833897            sage: s.define(one+monom*s*s)
     
    837901            Unknown series order
    838902            sage: [s.coefficient(i) for i in range(6)]
    839903            [1, 1, 2, 5, 14, 42]
    840        
     904
    841905        Test Recursive 1b
    842        
     906
    843907        ::
    844        
     908
    845909            sage: s = L()
    846910            sage: s._name = 's'
    847911            sage: s.define(monom + s*s)
    848912            sage: s.aorder
    849             1
     913            Unknown series order
    850914            sage: s.order
    851915            Unknown series order
    852916            sage: [s.coefficient(i) for i in range(7)]
    853917            [0, 1, 1, 2, 5, 14, 42]
    854        
     918            sage: s.aorder
     919            1
     920            sage: s.order
     921            1
     922
    855923        Test Recursive 2
    856        
     924
    857925        ::
    858        
     926
    859927            sage: s = L()
    860928            sage: s._name = 's'
    861929            sage: t = L()
     
    866934            [1, 1, 3, 9, 34, 132, 546, 2327, 10191]
    867935            sage: [t.coefficient(i) for i in range(9)]
    868936            [1, 1, 2, 7, 24, 95, 386, 1641, 7150]
    869        
     937
    870938        Test Recursive 2b
    871        
     939
    872940        ::
    873        
     941
    874942            sage: s = L()
    875943            sage: s._name = 's'
    876944            sage: t = L()
     
    881949            [0, 1, 0, 1, 3, 3, 7, 30, 63]
    882950            sage: [t.coefficient(i) for i in range(9)]
    883951            [0, 1, 1, 0, 2, 6, 7, 20, 75]
    884        
     952
    885953        Test Recursive 3
    886        
     954
    887955        ::
    888        
     956
    889957            sage: s = L()
    890958            sage: s._name = 's'
    891959            sage: s.define(one+monom*s*s*s)
     
    898966    def coefficient(self, n):
    899967        """
    900968        Returns the coefficient of xn in self.
    901        
     969
    902970        EXAMPLES::
    903        
     971
    904972            sage: L = LazyPowerSeriesRing(QQ)
    905973            sage: f = L(ZZ)
    906974            sage: [f.coefficient(i) for i in range(5)]
    907975            [0, 1, -1, 2, -2]
    908976        """
    909977        # The following line must not be written n < self.get_aorder()
    910         # because comparison of Integer and OnfinityOrder is not implemented. 
     978        # because comparison of Integer and OnfinityOrder is not implemented.
    911979        if self.get_aorder() > n:
    912980            return self._zero
    913981
     
    918986    def get_aorder(self):
    919987        """
    920988        Returns the approximate order of self.
    921        
     989
    922990        EXAMPLES::
    923        
     991
    924992            sage: L = LazyPowerSeriesRing(QQ)
    925993            sage: a = L.gen()
    926994            sage: a.get_aorder()
     
    9321000    def get_order(self):
    9331001        """
    9341002        Returns the order of self.
    935        
     1003
    9361004        EXAMPLES::
    937        
     1005
    9381006            sage: L = LazyPowerSeriesRing(QQ)
    9391007            sage: a = L.gen()
    9401008            sage: a.get_order()
     
    9461014    def get_stream(self):
    9471015        """
    9481016        Returns self's underlying Stream object.
    949        
     1017
    9501018        EXAMPLES::
    951        
     1019
    9521020            sage: L = LazyPowerSeriesRing(QQ)
    9531021            sage: a = L.gen()
    9541022            sage: s = a.get_stream()
     
    9931061        parent = kwds['parent'] if 'parent' in kwds else self.parent()
    9941062        new_fps = self.__class__(parent, stream=None, order=unk, aorder=self.aorder,
    9951063                                 aorder_changed=True, is_initialized=False)
    996        
     1064
    9971065        new_fps.compute_aorder = lambda: new_fps._approximate_order(compute_coefficients, order_op, *series)
    9981066        return new_fps
    9991067
    10001068    def _add_(self, y):
    10011069        """
    10021070        EXAMPLES: Test Plus 1
    1003        
     1071
    10041072        ::
    1005        
     1073
    10061074            sage: from sage.combinat.species.series import *
    10071075            sage: from sage.combinat.species.stream import Stream
    10081076            sage: L = LazyPowerSeriesRing(QQ)
     
    10211089            [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
    10221090            sage: [sum3.coefficient(i) for i in range(11)]
    10231091            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
    1024        
     1092
    10251093        Test Plus 2
    1026        
     1094
    10271095        ::
    1028        
     1096
    10291097            sage: gs1 = L([1,2,4,8,0])
    10301098            sage: gs2 = L([-1, 0,-1,-9,22,0])
    10311099            sage: sum = gs1 + gs2
     
    10381106            [0,  2, 3, -1, 22]
    10391107            sage: [ sum2.coefficient(i) for i in range(5, 11) ]
    10401108            [0, 0, 0, 0, 0, 0]
     1109
     1110
     1111        TESTS:
     1112
     1113        Check that :trac:`13433` is fixed::
     1114
     1115            sage: from sage.combinat.species.series import LazyPowerSeriesRing
     1116            sage: L = LazyPowerSeriesRing(QQ)
     1117            sage: g = L.gen(); z = L.zero()
     1118            sage: s = z+g; s
     1119            Uninitialized lazy power series
     1120            sage: s.coefficients(10)
     1121            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
     1122            sage: s
     1123            x + O(x^10)
    10411124        """
     1125        # print self.aorder, y.aorder
     1126        if ( self.aorder != unk and
     1127            ( y.aorder == unk or self.aorder > y.aorder ) ):
     1128            y, self = self, y
    10421129        return self._new(partial(self._plus_gen, y), min, self, y)
    1043    
    10441130    add = _add_
    10451131
    10461132
     
    10481134    def _plus_gen(self, y, ao):
    10491135        """
    10501136        EXAMPLES::
    1051        
     1137
    10521138            sage: L = LazyPowerSeriesRing(QQ)
    10531139            sage: gs1 = L([1])
    10541140            sage: g = gs1._plus_gen(gs1, 0)
    10551141            sage: [g.next() for i in range(5)]
    10561142            [2, 2, 2, 2, 2]
    1057        
     1143
    10581144        ::
    1059        
     1145
    10601146            sage: g = gs1._plus_gen(gs1, 2)
    10611147            sage: [g.next() for i in range(5)]
    10621148            [0, 0, 2, 2, 2]
     
    10731159    def _mul_(self, y):
    10741160        """
    10751161        EXAMPLES::
    1076        
     1162
    10771163            sage: L = LazyPowerSeriesRing(QQ)
    10781164            sage: gs0 = L(0)
    10791165            sage: gs1 = L([1])
    1080        
     1166
    10811167        ::
    1082        
     1168
    10831169            sage: prod0 = gs0 * gs1
    10841170            sage: [prod0.coefficient(i) for i in range(11)]
    10851171            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    1086        
     1172
    10871173        ::
    1088        
     1174
    10891175            sage: prod1 = gs1 * gs0
    10901176            sage: [prod1.coefficient(i) for i in range(11)]
    10911177            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    1092        
     1178
    10931179        ::
    1094        
     1180
    10951181            sage: prod2 = gs1 * gs1
    10961182            sage: [prod2.coefficient(i) for i in range(11)]
    10971183            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    1098        
     1184
    10991185        ::
    1100        
     1186
    11011187            sage: gs1 = L([1,2,4,8,0])
    11021188            sage: gs2 = L([-1, 0,-1,-9,22,0])
    1103        
     1189
    11041190        ::
    1105        
     1191
    11061192            sage: prod1 = gs1 * gs2
    11071193            sage: [prod1.coefficient(i) for i in range(11)]
    11081194            [-1, -2, -5, -19, 0, 0, 16, 176, 0, 0, 0]
    1109        
     1195
    11101196        ::
    1111        
     1197
    11121198            sage: prod2 = gs2 * gs1
    11131199            sage: [prod2.coefficient(i) for i in range(11)]
    11141200            [-1, -2, -5, -19, 0, 0, 16, 176, 0, 0, 0]
    11151201        """
    11161202
    1117         return self._new(partial(self._times_gen, y), lambda a,b:a+b, self, y)                     
     1203        return self._new(partial(self._times_gen, y), lambda a,b:a+b, self, y)
    11181204
    11191205    times = _mul_
    1120        
     1206
    11211207    def _times_gen(self, y, ao):
    11221208        """
    11231209        Returns an iterator for the coefficients of self \* y.
    1124        
     1210
    11251211        EXAMPLES::
    1126        
     1212
    11271213            sage: L = LazyPowerSeriesRing(QQ)
    11281214            sage: f = L([1,1,0])
    11291215            sage: g = f._times_gen(f,0)
     
    11431229            nth_coefficient = zero
    11441230
    11451231            #Handle the zero series
    1146             if low == inf or high == inf:     
     1232            if low == inf or high == inf:
    11471233                yield zero
    1148                 n += 1                       
    1149                 continue                     
     1234                n += 1
     1235                continue
    11501236
    11511237            for k in range(low, high+1):
    11521238                cx = self._stream[k]
     
    11591245    def __pow__(self, n):
    11601246        """
    11611247        EXAMPLES::
    1162        
     1248
    11631249            sage: L = LazyPowerSeriesRing(QQ)
    11641250            sage: f = L([1,1,0])  # 1+x
    11651251            sage: g = f^3
    11661252            sage: g.coefficients(4)
    11671253            [1, 3, 3, 1]
    1168        
     1254
    11691255        ::
    1170        
     1256
    11711257            sage: f^0
    11721258            1
    11731259        """
     
    11791265        """
    11801266        Returns the composition of this power series and the power series
    11811267        y.
    1182        
     1268
    11831269        EXAMPLES::
    1184        
     1270
    11851271            sage: L = LazyPowerSeriesRing(QQ)
    11861272            sage: s = L([1])
    11871273            sage: t = L([0,0,1])
    11881274            sage: u = s(t)
    11891275            sage: u.coefficients(11)
    11901276            [1, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    1191        
     1277
    11921278        Test Compose 2
    1193        
     1279
    11941280        ::
    1195        
     1281
    11961282            sage: s = L([1])
    11971283            sage: t = L([0,0,1,0])
    11981284            sage: u = s(t)
     
    12061292            0
    12071293            sage: u.order
    12081294            0
    1209        
     1295
    12101296        Test Compose 3 s = 1/(1-x), t = x/(1-x) s(t) = (1-x)/(1-2x)
    1211        
     1297
    12121298        ::
    1213        
     1299
    12141300            sage: s = L([1])
    12151301            sage: t = L([0,1])
    12161302            sage: u = s(t)
     
    12251311        """
    12261312        Returns a iterator for the coefficients of the composition of this
    12271313        power series with the power series y.
    1228        
     1314
    12291315        EXAMPLES::
    1230        
     1316
    12311317            sage: L = LazyPowerSeriesRing(QQ)
    12321318            sage: s = L([1])
    12331319            sage: t = L([0,1])
     
    12501336        """
    12511337        Returns the power series whose coefficients obtained by subtracting
    12521338        the constant term from this series and then dividing by x.
    1253        
     1339
    12541340        EXAMPLES::
    1255        
     1341
    12561342            sage: from sage.combinat.species.stream import Stream
    12571343            sage: L = LazyPowerSeriesRing(QQ)
    12581344            sage: f = L(range(20))
     
    12651351    def iterator(self, n=0, initial=None):
    12661352        """
    12671353        Returns an iterator for the coefficients of self starting at n.
    1268        
     1354
    12691355        EXAMPLES::
    1270        
     1356
    12711357            sage: from sage.combinat.species.stream import Stream
    12721358            sage: L = LazyPowerSeriesRing(QQ)
    12731359            sage: f = L(range(10))
     
    12901376    def _power_gen(self):
    12911377        """
    12921378        Returns a generator for all the powers self^k starting with k = 1.
    1293        
     1379
    12941380        EXAMPLES::
    1295        
     1381
    12961382            sage: L = LazyPowerSeriesRing(QQ)
    12971383            sage: f = L([1,1,0])
    12981384            sage: g = f._power_gen()
     
    13111397    def derivative(self):
    13121398        """
    13131399        EXAMPLES::
    1314        
     1400
    13151401            sage: from sage.combinat.species.stream import Stream
    13161402            sage: L = LazyPowerSeriesRing(QQ)
    13171403            sage: one = L(1)
     
    13201406            sage: u = s.derivative()
    13211407            sage: u.coefficients(10)
    13221408            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    1323        
     1409
    13241410        ::
    1325        
     1411
    13261412            sage: s = L()
    13271413            sage: s._name = 's'
    13281414            sage: s.define(one+monom*s*s)
    13291415            sage: u = s.derivative()
    13301416            sage: u.coefficients(5) #[1*1, 2*2, 3*5, 4*14, 5*42]
    13311417            [1, 4, 15, 56, 210]
    1332        
     1418
    13331419        ::
    1334        
     1420
    13351421            sage: s = L([1])
    13361422            sage: t = L([0,1])
    13371423            sage: u = s(t).derivative()
     
    13401426            [1, 4, 12, 32, 80, 192, 448, 1024, 2304, 5120, 11264]
    13411427            sage: v.coefficients(11)
    13421428            [1, 4, 12, 32, 80, 192, 448, 1024, 2304, 5120, 11264]
    1343        
     1429
    13441430        ::
    1345        
     1431
    13461432            sage: s = L(); s._name='s'
    13471433            sage: t = L(); t._name='t'
    13481434            sage: s.define(monom+t*t*t)
     
    13551441            [0, 2, 3, 4, 30, 72, 133, 552, 1791, 4260]
    13561442            sage: u.coefficients(10) == v.coefficients(10)
    13571443            True
    1358        
     1444
    13591445        ::
    1360        
     1446
    13611447            sage: f = L._new_initial(2, Stream([0,0,4,5,6,0]))
    13621448            sage: d = f.derivative()
    13631449            sage: d.get_aorder()
     
    13711457        """
    13721458        Returns an iterator for the coefficients of the derivative of
    13731459        self.
    1374        
     1460
    13751461        EXAMPLES::
    1376        
     1462
    13771463            sage: L = LazyPowerSeriesRing(QQ)
    13781464            sage: f = L([1])
    13791465            sage: g = f._diff_gen(0)
     
    13841470        while True:
    13851471            yield n*self._stream[n]
    13861472            n += 1
    1387                
    1388     ########### 
     1473
     1474    ###########
    13891475    #Integrals#
    13901476    ###########
    13911477    def integral(self, integration_constant = 0):
    13921478        """
    13931479        EXAMPLES::
    1394        
     1480
    13951481            sage: L = LazyPowerSeriesRing(QQ)
    13961482            sage: zero = L(0)
    13971483            sage: s = zero
    13981484            sage: t = s.integral()
    13991485            sage: t.is_zero()
    14001486            True
    1401        
     1487
    14021488        ::
    1403        
     1489
    14041490            sage: s = zero
    14051491            sage: t = s.integral(1)
    14061492            sage: t.coefficients(6)
    14071493            [1, 0, 0, 0, 0, 0]
    14081494            sage: t._stream.is_constant()
    14091495            True
    1410        
     1496
    14111497        ::
    1412        
     1498
    14131499            sage: s = L.term(1, 0)
    14141500            sage: t = s.integral()
    14151501            sage: t.coefficients(6)
    14161502            [0, 1, 0, 0, 0, 0]
    14171503            sage: t._stream.is_constant()
    14181504            True
    1419        
     1505
    14201506        ::
    1421        
     1507
    14221508            sage: s = L.term(1,0)
    14231509            sage: t = s.integral(1)
    14241510            sage: t.coefficients(6)
    14251511            [1, 1, 0, 0, 0, 0]
    14261512            sage: t._stream.is_constant()
    14271513            True
    1428        
     1514
    14291515        ::
    1430        
     1516
    14311517            sage: s = L.term(1, 4)
    14321518            sage: t = s.integral()
    14331519            sage: t.coefficients(10)
    14341520            [0, 0, 0, 0, 0, 1/5, 0, 0, 0, 0]
    1435        
     1521
    14361522        ::
    1437        
     1523
    14381524            sage: s = L.term(1,4)
    14391525            sage: t = s.integral(1)
    14401526            sage: t.coefficients(10)
    14411527            [1, 0, 0, 0, 0, 1/5, 0, 0, 0, 0]
    1442        
     1528
    14431529        TESTS::
    1444        
     1530
    14451531            sage: from sage.combinat.species.stream import Stream
    14461532            sage: f = L._new_initial(2, Stream([0,0,4,5,6,0]))
    14471533            sage: i = f.derivative().integral()
     
    14641550    def _integral_zero_gen(self, ao):
    14651551        """
    14661552        EXAMPLES::
    1467        
     1553
    14681554            sage: L = LazyPowerSeriesRing(QQ)
    14691555            sage: s = L.gen()
    14701556            sage: g = s._integral_zero_gen(1)
     
    14871573    def _integral_nonzero_gen(self, integration_constant):
    14881574        """
    14891575        EXAMPLES::
    1490        
     1576
    14911577            sage: from sage.combinat.species.stream import Stream
    14921578            sage: L = LazyPowerSeriesRing(QQ)
    14931579            sage: f = L._new_initial(2, Stream([0,0,4,5,6,0])).derivative()
     
    15051591        else:
    15061592            for _ in range(ao-1):
    15071593                yield self._zero
    1508                
     1594
    15091595            n = max(1,ao)
    15101596            while True:
    15111597                c = self.coefficient(n-1)
     
    15211607    def is_finite(self, n=None):
    15221608        """
    15231609        EXAMPLES::
    1524        
     1610
    15251611            sage: L = LazyPowerSeriesRing(QQ)
    15261612            sage: a = L([0,0,1,0,0]); a
    15271613            O(1)
     
    15451631
    15461632        if n is None:
    15471633            n = len(s)
    1548            
     1634
    15491635        if s.is_constant() and all(s[i] == 0 for i in range(n-1, max(n,len(s)))):
    15501636            return True
    15511637
     
    15541640    def exponential(self):
    15551641        """
    15561642        TESTS::
    1557        
     1643
    15581644            sage: def inv_factorial():
    15591645            ...       q = 1
    15601646            ...       yield 0
     
    15841670    def __getitem__(self, i):
    15851671        """
    15861672        Returns the ith coefficient of self.
    1587        
     1673
    15881674        EXAMPLES::
    1589        
     1675
    15901676            sage: L = LazyPowerSeriesRing(QQ)
    15911677            sage: f = L([1,2,3,0])
    15921678            sage: [f[i] for i in range(5)]
     
    16041690        min and going up to, but not including max. If min is not
    16051691        specified, then it is assumed to be zero. If max is not specified,
    16061692        then it is assumed to be infinity.
    1607        
     1693
    16081694        EXAMPLES::
    1609        
     1695
    16101696            sage: L = LazyPowerSeriesRing(QQ)
    16111697            sage: a = L([1])
    16121698            sage: a.restricted().coefficients(10)
     
    16221708        if ((min is None and max is None) or
    16231709            (max is None and self.get_aorder() >= min)):
    16241710            return self
    1625        
     1711
    16261712        return self._new(partial(self._restricted_gen, min, max),
    16271713                         lambda ao: __builtin__.max(ao, min), self)
    16281714
    16291715    def _restricted_gen(self, mn, mx, ao):
    16301716        """
    16311717        EXAMPLES::
    1632        
     1718
    16331719            sage: L = LazyPowerSeriesRing(QQ)
    16341720            sage: a = L([1])
    16351721            sage: g = a._restricted_gen(None, None, 2)
     
    16411727            sage: g = a._restricted_gen(3, None, 2)
    16421728            sage: [g.next() for i in range(10)]
    16431729            [0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
    1644        
     1730
    16451731        ::
    1646        
     1732
    16471733            sage: g = a._restricted_gen(1, 5, 2)
    16481734            sage: [g.next() for i in range(6)]
    16491735            [0, 0, 1, 1, 1, 0]
    16501736        """
    16511737        BR = self.parent().base_ring()
    16521738        for n in range(max(mn,ao)):
    1653             yield BR(0)
     1739            yield BR.zero()
    16541740
    16551741        n = max(mn, ao)
    16561742        while True:
    16571743            if mx is not None and n >= mx:
    1658                 yield BR(0)
     1744                yield BR.zero()
    16591745                break
    16601746            else:
    16611747                yield self._stream[n]
     
    16681754    def _change_ring_gen(self, R, ao):
    16691755        """
    16701756        EXAMPLES::
    1671        
     1757
    16721758            sage: L = LazyPowerSeriesRing(QQ)
    16731759            sage: L2 = LazyPowerSeriesRing(RR)
    16741760            sage: a = L([1])
     
    16881774
    16891775#################################
    16901776
    1691 
    1692 
    16931777def uninitialized():
    16941778    """
    16951779    EXAMPLES::
    1696    
     1780
    16971781        sage: from sage.combinat.species.series import uninitialized
    16981782        sage: uninitialized()
    16991783        Traceback (most recent call last):