o 8Va@sddlmZddlmZddlmZmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZmZdd lmZmZmZdd lmZddlm Z m!Z!ddl"m#Z#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,GdddeZ-Gddde-edZ.Gddde-Z/Gddde/Z0Gddde/Z1Gdd d e-Z2d*d"d#Z3Gd$d%d%e-Z4Gd&d'd'e4Z5Gd(d)d)e4Z6d!S)+)Basic)cacheit) is_sequenceiterableordered)Tuple)call_highest_priority)global_parameters) AppliedUndefMul)Integer)Eq)S Singleton)DummySymbolWildsympify)lcmfactor)Interval Intersection)simplify)Idx)flatten)expandc@seZdZdZdZdZeddZddZe dd Z e d d Z e d d Z e ddZ e ddZe ddZe ddZeddZddZddZddZddZd d!Zd"d#Zed$d%d&Zd'd(Zed)d*d+Zd,d-Zd.d/Zed0d1d2Zd3d4Z d5d6Z!d:d8d9Z"d7S);SeqBasezBase class for sequencesTc Cs.z|j}W|Stttfytj}Y|Sw)z[Return start (if possible) else S.Infinity. adapted from Set._infimum_key )startNotImplementedErrorAttributeError ValueErrorrInfinity)exprr r&8/usr/lib/python3/dist-packages/sympy/series/sequences.py _start_key!s zSeqBase._start_keycCst|j|j}|j|jfS)zTReturns start and stop. Takes intersection over the two intervals. )rintervalinfsup)selfotherr)r&r&r'_intersect_interval.s zSeqBase._intersect_intervalcC td|)z&Returns the generator for the sequencez(%s).genr!r,r&r&r'gen6 z SeqBase.gencCr/)z-The interval on which the sequence is definedz (%s).intervalr0r1r&r&r'r);r3zSeqBase.intervalcCr/):The starting point of the sequence. This point is includedz (%s).startr0r1r&r&r'r @r3z SeqBase.startcCr/)z8The ending point of the sequence. This point is includedz (%s).stopr0r1r&r&r'stopEr3z SeqBase.stopcCr/)zLength of the sequencez (%s).lengthr0r1r&r&r'lengthJr3zSeqBase.lengthcCdS)z-Returns a tuple of variables that are boundedr&r&r1r&r&r' variablesOszSeqBase.variablescsfddjDS)aG This method returns the symbols in the object, excluding those that take on a specific value (i.e. the dummy symbols). Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n, m >>> SeqFormula(m*n**2, (n, 0, 5)).free_symbols {m} cs$h|]}|jjD]}|q qSr&) free_symbols differencer8).0ijr1r&r' bs z'SeqBase.free_symbols..argsr1r&r1r'r9TszSeqBase.free_symbolscCs0||jks ||jkrtd||jf||S)z#Returns the coefficient at point ptzIndex %s out of bounds %s)r r5 IndexErrorr) _eval_coeffr,ptr&r&r'coeffes z SeqBase.coeffcCstd|j)NzhThe _eval_coeff method should be added to%s to return coefficient so it is availablewhen coeff calls it.)r!funcrCr&r&r'rBlszSeqBase._eval_coeffcCs<|jtjur |j}n|j}|jtjurd}nd}|||S)aReturns the i'th point of a sequence. Explanation =========== If start point is negative infinity, point is returned from the end. Assumes the first point to be indexed zero. Examples ========= >>> from sympy import oo >>> from sympy.series.sequences import SeqPer bounded >>> SeqPer((1, 2, 3), (-10, 10))._ith_point(0) -10 >>> SeqPer((1, 2, 3), (-10, 10))._ith_point(5) -5 End is at infinity >>> SeqPer((1, 2, 3), (0, oo))._ith_point(5) 5 Starts at negative infinity >>> SeqPer((1, 2, 3), (-oo, 0))._ith_point(5) -5 )r rNegativeInfinityr5)r,r<initialstepr&r&r' _ith_pointrs   zSeqBase._ith_pointcCr7)aI Should only be used internally. Explanation =========== self._add(other) returns a new, term-wise added sequence if self knows how to add with other, otherwise it returns ``None``. ``other`` should only be a sequence object. Used within :class:`SeqAdd` class. Nr&r,r-r&r&r'_addz SeqBase._addcCr7)aS Should only be used internally. Explanation =========== self._mul(other) returns a new, term-wise multiplied sequence if self knows how to multiply with other, otherwise it returns ``None``. ``other`` should only be a sequence object. Used within :class:`SeqMul` class. Nr&rMr&r&r'_mulrOz SeqBase._mulcCs t||S)a Should be used when ``other`` is not a sequence. Should be defined to define custom behaviour. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> SeqFormula(n**2).coeff_mul(2) SeqFormula(2*n**2, (n, 0, oo)) Notes ===== '*' defines multiplication of sequences with sequences only. r rMr&r&r' coeff_muls zSeqBase.coeff_mulcC$t|ts tdt|t||S)a4Returns the term-wise addition of 'self' and 'other'. ``other`` should be a sequence. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> SeqFormula(n**2) + SeqFormula(n**3) SeqFormula(n**3 + n**2, (n, 0, oo)) zcannot add sequence and %s isinstancer TypeErrortypeSeqAddrMr&r&r'__add__s  zSeqBase.__add__rXcCs||SNr&rMr&r&r'__radd__zSeqBase.__radd__cCs&t|ts tdt|t|| S)a7Returns the term-wise subtraction of ``self`` and ``other``. ``other`` should be a sequence. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> SeqFormula(n**2) - (SeqFormula(n)) SeqFormula(n**2 - n, (n, 0, oo)) zcannot subtract sequence and %srSrMr&r&r'__sub__s  zSeqBase.__sub__r\cCs | |SrYr&rMr&r&r'__rsub__ zSeqBase.__rsub__cCs |dS)zNegates the sequence. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> -SeqFormula(n**2) SeqFormula(-n**2, (n, 0, oo)) rG)rQr1r&r&r'__neg__s zSeqBase.__neg__cCrR)a{Returns the term-wise multiplication of 'self' and 'other'. ``other`` should be a sequence. For ``other`` not being a sequence see :func:`coeff_mul` method. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> SeqFormula(n**2) * (SeqFormula(n)) SeqFormula(n**3, (n, 0, oo)) zcannot multiply sequence and %s)rTrrUrVSeqMulrMr&r&r'__mul__ s  zSeqBase.__mul__racCs||SrYr&rMr&r&r'__rmul__r[zSeqBase.__rmul__ccs,t|jD] }||}||VqdSrY)ranger6rLrE)r,r<rDr&r&r'__iter__s  zSeqBase.__iter__cstt|tr|}|St|tr8|j|j}}|dur!d}|dur(j}fddt|||j p4dDSdS)Nrcsg|] }|qSr&)rErL)r;r<r1r&r' .z'SeqBase.__getitem__..rH) rTintrLrEslicer r5r6rcrK)r,indexr r5r&r1r' __getitem__$s     zSeqBase.__getitem__NcCs(ddlm}dd|d|D}t|}|dur|d}nt||d}g}td|dD]r} d| } g} t| D] } | || | | q:|| } | dkrt| ||| | }|| krnt |ddd}n3g} t| || D] } | || | | qw|| } | |||| dkrt |ddd}nq.|dur|St|} | dkrgdfS|| d|| dd|| d|| }}t| dD]5}|||||7}t| |dD]}||||||||d8}q|||||d8}q|tt |t |fS) a Finds the shortest linear recurrence that satisfies the first n terms of sequence of order `\leq` ``n/2`` if possible. If ``d`` is specified, find shortest linear recurrence of order `\leq` min(d, n/2) if possible. Returns list of coefficients ``[b(1), b(2), ...]`` corresponding to the recurrence relation ``x(n) = b(1)*x(n-1) + b(2)*x(n-2) + ...`` Returns ``[]`` if no recurrence is found. If gfvar is specified, also returns ordinary generating function as a function of gfvar. Examples ======== >>> from sympy import sequence, sqrt, oo, lucas >>> from sympy.abc import n, x, y >>> sequence(n**2).find_linear_recurrence(10, 2) [] >>> sequence(n**2).find_linear_recurrence(10) [3, -3, 1] >>> sequence(2**n).find_linear_recurrence(10) [2] >>> sequence(23*n**4+91*n**2).find_linear_recurrence(10) [5, -10, 10, -5, 1] >>> sequence(sqrt(5)*(((1 + sqrt(5))/2)**n - (-(1 + sqrt(5))/2)**(-n))/5).find_linear_recurrence(10) [1, 1] >>> sequence(x+y*(-2)**(-n), (n, 0, oo)).find_linear_recurrence(30) [1/2, 1/2] >>> sequence(3*5**n + 12).find_linear_recurrence(20,gfvar=x) ([6, -5], 3*(5 - 21*x)/((x - 1)*(5*x - 1))) >>> sequence(lucas(n)).find_linear_recurrence(15,gfvar=x) ([1, 1], (x - 2)/(x**2 + x - 1)) r)MatrixcSsg|]}tt|qSr&)rr)r;tr&r&r'reTsz2SeqBase.find_linear_recurrence..NrHrG) Zsympy.matricesrklenminrcappendZdetrZLUsolverr)r,ndZgfvarrkxZlxrZcoeffsll2Zmlistkmyr<r=r&r&r'find_linear_recurrence1sL "   2&zSeqBase.find_linear_recurrence)NN)#__name__ __module__ __qualname____doc__Zis_commutativeZ _op_priority staticmethodr(r.propertyr2r)r r5r6r8r9rrErBrLrNrPrQrXrrZr\r]r_rarbrdrjrzr&r&r&r'rsR          ,     rc@s8eZdZdZeddZeddZddZdd Zd S) EmptySequenceaRepresents an empty sequence. The empty sequence is also available as a singleton as ``S.EmptySequence``. Examples ======== >>> from sympy import EmptySequence, SeqPer >>> from sympy.abc import x >>> EmptySequence EmptySequence >>> SeqPer((1, 2), (x, 0, 10)) + EmptySequence SeqPer((1, 2), (x, 0, 10)) >>> SeqPer((1, 2)) * EmptySequence EmptySequence >>> EmptySequence.coeff_mul(-1) EmptySequence cCtjSrY)rEmptySetr1r&r&r'r)zEmptySequence.intervalcCrrY)rZZeror1r&r&r'r6rzEmptySequence.lengthcCs|S)"See docstring of SeqBase.coeff_mulr&)r,rEr&r&r'rQszEmptySequence.coeff_mulcCstgSrY)iterr1r&r&r'rdszEmptySequence.__iter__N) r{r|r}r~rr)r6rQrdr&r&r&r'r|s   r) metaclassc@XeZdZdZeddZeddZeddZedd Zed d Z ed d Z dS)SeqExpraSequence expression class. Various sequences should inherit from this class. Examples ======== >>> from sympy.series.sequences import SeqExpr >>> from sympy.abc import x >>> s = SeqExpr((1, 2, 3), (x, 0, 10)) >>> s.gen (1, 2, 3) >>> s.interval Interval(0, 10) >>> s.length 11 See Also ======== sympy.series.sequences.SeqPer sympy.series.sequences.SeqFormula cC |jdSNrr?r1r&r&r'r2r^z SeqExpr.gencCst|jdd|jddS)NrHrm)rr@r1r&r&r'r)szSeqExpr.intervalcC|jjSrYr)r*r1r&r&r'r r[z SeqExpr.startcCrrYr)r+r1r&r&r'r5r[z SeqExpr.stopcC|j|jdSNrHr5r r1r&r&r'r6zSeqExpr.lengthcCs|jddfS)NrHrr?r1r&r&r'r8rzSeqExpr.variablesN) r{r|r}r~rr2r)r r5r6r8r&r&r&r'rs     rc@sReZdZdZdddZeddZeddZd d Zd d Z d dZ ddZ dS)SeqPera Represents a periodic sequence. The elements are repeated after a given period. Examples ======== >>> from sympy import SeqPer, oo >>> from sympy.abc import k >>> s = SeqPer((1, 2, 3), (0, 5)) >>> s.periodical (1, 2, 3) >>> s.period 3 For value at a particular point >>> s.coeff(3) 1 supports slicing >>> s[:] [1, 2, 3, 1, 2, 3] iterable >>> list(s) [1, 2, 3, 1, 2, 3] sequence starts from negative infinity >>> SeqPer((1, 2, 3), (-oo, 0))[0:6] [1, 2, 3, 1, 2, 3] Periodic formulas >>> SeqPer((k, k**2, k**3), (k, 0, oo))[0:6] [0, 1, 8, 3, 16, 125] See Also ======== sympy.series.sequences.SeqFormula NcCs"t|}dd}d\}}}|dur||dtj}}}t|tr;t|dkr-|\}}}nt|dkr;||}|\}}t|ttfrJ|dusJ|durRt dt ||tj ur`|tjur`t dt|||f}t|trutt t |}nt d |t|d |dtjurtjSt|||S) NcSs$|j}t|jdkr|StdS)NrHrw)r9rnpopr) periodicalfreer&r&r'_find_xszSeqPer.__new__.._find_xNNNrrmInvalid limits given: %sz/Both the start and end valuecannot be unboundedz6invalid period %s should be something like e.g (1, 2) rH)rrr$rrrnrTrrr#strrItuplerrrrr__new__)clsrlimitsrrsr r5r&r&r'rs0      zSeqPer.__new__cCs t|jSrY)rnr2r1r&r&r'period,r^z SeqPer.periodcC|jSrYr2r1r&r&r'r0rzSeqPer.periodicalcCsF|jtjur|j||j}n||j|j}|j||jd|Sr)r rrIr5rrsubsr8)r,rDidxr&r&r'rB4s zSeqPer._eval_coeffc Cst|trF|j|j}}|j|j}}t||}g}t|D]}|||} |||} || | q||\} } t||jd| | fSdSzSee docstring of SeqBase._addrN rTrrrrrcrpr.r8 r,r-Zper1Zlper1Zper2Zlper2Z per_lengthZnew_perrsZele1Zele2r r5r&r&r'rN;     z SeqPer._addc Cst|trF|j|j}}|j|j}}t||}g}t|D]}|||} |||} || | q||\} } t||jd| | fSdSzSee docstring of SeqBase._mulrNrrr&r&r'rPLrz SeqPer._mulcs,tfdd|jD}t||jdS)rcsg|]}|qSr&r&r;rsrEr&r're`sz$SeqPer.coeff_mul..rH)rrrr@)r,rEZperr&rr'rQ]szSeqPer.coeff_mulrY) r{r|r}r~rrrrrBrNrPrQr&r&r&r'rs 0(   rc@sNeZdZdZdddZeddZddZd d Zd d Z d dZ ddZ dS) SeqFormulaaf Represents sequence based on a formula. Elements are generated using a formula. Examples ======== >>> from sympy import SeqFormula, oo, Symbol >>> n = Symbol('n') >>> s = SeqFormula(n**2, (n, 0, 5)) >>> s.formula n**2 For value at a particular point >>> s.coeff(3) 9 supports slicing >>> s[:] [0, 1, 4, 9, 16, 25] iterable >>> list(s) [0, 1, 4, 9, 16, 25] sequence starts from negative infinity >>> SeqFormula(n**2, (-oo, 0))[0:6] [0, 1, 4, 9, 16, 25] See Also ======== sympy.series.sequences.SeqPer NcCst|}dd}d\}}}|dur||dtj}}}t|tr;t|dkr-|\}}}nt|dkr;||}|\}}t|ttfrJ|dusJ|durRt dt ||tj ur`|tjur`t dt|||f}t |d |dtj urvtjSt|||S) NcSs2|j}t|dkr |S|stdStd|)NrHrwz specify dummy variables for %s. If the formula contains more than one free symbol, a dummy variable should be supplied explicitly e.g., SeqFormula(m*n**2, (n, 0, 5)))r9rnrrr#)formularr&r&r'rs z#SeqFormula.__new__.._find_xrrrrmrz0Both the start and end value cannot be unboundedrH)rrr$rrrnrTrrr#rrIrrrrr)rrrrrsr r5r&r&r'rs&     zSeqFormula.__new__cCrrYrr1r&r&r'rrzSeqFormula.formulacCs|jd}|j||Sr)r8rr)r,rDrrr&r&r'rBs zSeqFormula._eval_coeffc Cs`t|tr.|j|jd}}|j|jd}}||||}||\}}t||||fSdSrrTrrr8rr. r,r-Zform1Zv1Zform2Zv2rr r5r&r&r'rN zSeqFormula._addc Cs`t|tr.|j|jd}}|j|jd}}||||}||\}}t||||fSdSrrrr&r&r'rPrzSeqFormula._mulcCs"t|}|j|}t||jdS)rrH)rrrr@)r,rErr&r&r'rQs zSeqFormula.coeff_mulcOs$tt|jg|Ri||jdSr)rrrr@)r,r@kwargsr&r&r'rs$zSeqFormula.expandrY) r{r|r}r~rrrrBrNrPrQrr&r&r&r'rds ('   rc@seZdZdZdddZeddZedd Zed d Zed d Z eddZ eddZ eddZ eddZ eddZddZddZdS) RecursiveSeqa A finite degree recursive sequence. Explanation =========== That is, a sequence a(n) that depends on a fixed, finite number of its previous values. The general form is a(n) = f(a(n - 1), a(n - 2), ..., a(n - d)) for some fixed, positive integer d, where f is some function defined by a SymPy expression. Parameters ========== recurrence : SymPy expression defining recurrence This is *not* an equality, only the expression that the nth term is equal to. For example, if :code:`a(n) = f(a(n - 1), ..., a(n - d))`, then the expression should be :code:`f(a(n - 1), ..., a(n - d))`. yn : applied undefined function Represents the nth term of the sequence as e.g. :code:`y(n)` where :code:`y` is an undefined function and `n` is the sequence index. n : symbolic argument The name of the variable that the recurrence is in, e.g., :code:`n` if the recurrence function is :code:`y(n)`. initial : iterable with length equal to the degree of the recurrence The initial values of the recurrence. start : start value of sequence (inclusive) Examples ======== >>> from sympy import Function, symbols >>> from sympy.series.sequences import RecursiveSeq >>> y = Function("y") >>> n = symbols("n") >>> fib = RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, [0, 1]) >>> fib.coeff(3) # Value at a particular point 2 >>> fib[:6] # supports slicing [0, 1, 1, 2, 3, 5] >>> fib.recurrence # inspect recurrence Eq(y(n), y(n - 2) + y(n - 1)) >>> fib.degree # automatically determine degree 2 >>> for x in zip(range(10), fib): # supports iteration ... print(x) (0, 0) (1, 1) (2, 1) (3, 2) (4, 3) (5, 5) (6, 8) (7, 13) (8, 21) (9, 34) See Also ======== sympy.series.sequences.SeqFormula Nrc s\t|ts td|t|tr|jstd||j|fkr%td|jtd|fd}d}| }|D]3} t | jdkrEtd| jd |||} | r\| j r\| dksctd | | |krk| }q8|swd d t|D}t ||krtd t|}ttd d|D}t|||||} fddt|D| _|| _| S)NzErecurrence sequence must be an applied undefined function, found `{}`z0recurrence variable must be a symbol, found `{}`z)recurrence sequence does not match symbolrw)ZexcluderrHz)Recurrence should be in a single variablezDRecurrence should have constant, negative, integer shifts (found {})cSsg|] }td|qS)zc_{})rformat)r;rwr&r&r'reHz(RecursiveSeq.__new__..z)Number of initial terms must equal degreecss|]}t|VqdSrYrrr&r&r' Psz'RecursiveSeq.__new__..csi|] \}}||qSr&r&)r;rwZinitr ryr&r' Tsz(RecursiveSeq.__new__..)rTr rUrrZ is_symbolr@rFrfindrnmatchZ is_constant is_integerrcr#r rrr enumeratecachedegree) r recurrenceynrqrJr rwrZprev_ysZprev_yshiftseqr&rr'r$sH     zRecursiveSeq.__new__cCrzEquation defining recurrence.rr?r1r&r&r' _recurrenceY zRecursiveSeq._recurrencecCst|j|jdSr)rrr@r1r&r&r'r^szRecursiveSeq.recurrencecCr)z*Applied function representing the nth termrHr?r1r&r&r'rcrzRecursiveSeq.yncCr)z3Undefined function for the nth term of the sequence)rrFr1r&r&r'ryhszRecursiveSeq.ycCr)zSequence index symbolrmr?r1r&r&r'rqmrzRecursiveSeq.ncCr)z"The initial values of the sequencerr?r1r&r&r'rJrrzRecursiveSeq.initialcCr)r4r?r1r&r&r'r wrzRecursiveSeq.startcCr)z&The ending point of the sequence. (oo))rr$r1r&r&r'r5|szRecursiveSeq.stopcCs |jtjfS)z&Interval on which sequence is defined.)r rr$r1r&r&r'r)r3zRecursiveSeq.intervalcCs||jt|jkr|j||Stt|j|dD]}|j|}|j|j|i}||j}||j||<q|j||j|Sr)r rnrryrcrZxreplacerq)r,riZcurrentZ seq_indexZcurrent_recurrenceZnew_termr&r&r'rBs  zRecursiveSeq._eval_coeffccs |j} ||V|d7}q)NTrH)r rB)r,rir&r&r'rds  zRecursiveSeq.__iter__r)r{r|r}r~rrrrrryrqrJr r5r)rBrdr&r&r&r'rs. L5          rNcCs&t|}t|trt||St||S)a Returns appropriate sequence object. Explanation =========== If ``seq`` is a sympy sequence, returns :class:`SeqPer` object otherwise returns :class:`SeqFormula` object. Examples ======== >>> from sympy import sequence >>> from sympy.abc import n >>> sequence(n**2, (n, 0, 5)) SeqFormula(n**2, (n, 0, 5)) >>> sequence((1, 2, 3), (n, 0, 5)) SeqPer((1, 2, 3), (n, 0, 5)) See Also ======== sympy.series.sequences.SeqPer sympy.series.sequences.SeqFormula )rrrrr)rrr&r&r'sequences   rc@r) SeqExprOpa Base class for operations on sequences. Examples ======== >>> from sympy.series.sequences import SeqExprOp, sequence >>> from sympy.abc import n >>> s1 = sequence(n**2, (n, 0, 10)) >>> s2 = sequence((1, 2, 3), (n, 5, 10)) >>> s = SeqExprOp(s1, s2) >>> s.gen (n**2, (1, 2, 3)) >>> s.interval Interval(5, 10) >>> s.length 6 See Also ======== sympy.series.sequences.SeqAdd sympy.series.sequences.SeqMul cCstdd|jDS)zjGenerator for the sequence. returns a tuple of generators of all the argument sequences. cs|]}|jVqdSrYrr;ar&r&r'rz SeqExprOp.gen..)rr@r1r&r&r'r2sz SeqExprOp.gencCstdd|jDS)zeSequence is defined on the intersection of all the intervals of respective sequences csrrYr)rr&r&r'rrz%SeqExprOp.interval..)rr@r1r&r&r'r)szSeqExprOp.intervalcCrrYrr1r&r&r'r r[zSeqExprOp.startcCrrYrr1r&r&r'r5r[zSeqExprOp.stopcCsttdd|jDS)z%Cumulative of all the bound variablescSsg|]}|jqSr&)r8rr&r&r'resz'SeqExprOp.variables..)rrr@r1r&r&r'r8szSeqExprOp.variablescCrrrr1r&r&r'r6rzSeqExprOp.lengthN) r{r|r}r~rr2r)r r5r8r6r&r&r&r'rs     rc@,eZdZdZddZeddZddZdS) rWaRepresents term-wise addition of sequences. Rules: * The interval on which sequence is defined is the intersection of respective intervals of sequences. * Anything + :class:`EmptySequence` remains unchanged. * Other rules are defined in ``_add`` methods of sequence classes. Examples ======== >>> from sympy import EmptySequence, oo, SeqAdd, SeqPer, SeqFormula >>> from sympy.abc import n >>> SeqAdd(SeqPer((1, 2), (n, 0, oo)), EmptySequence) SeqPer((1, 2), (n, 0, oo)) >>> SeqAdd(SeqPer((1, 2), (n, 0, 5)), SeqPer((1, 2), (n, 6, 10))) EmptySequence >>> SeqAdd(SeqPer((1, 2), (n, 0, oo)), SeqFormula(n**2, (n, 0, oo))) SeqAdd(SeqFormula(n**2, (n, 0, oo)), SeqPer((1, 2), (n, 0, oo))) >>> SeqAdd(SeqFormula(n**3), SeqFormula(n**2)) SeqFormula(n**3 + n**2, (n, 0, oo)) See Also ======== sympy.series.sequences.SeqMul cs|dtj}t|}fdd|}dd|D}|s!tjStdd|Dtjur0tjS|r7t |Stt |t j }t j|g|RS)NevaluatecLt|trt|trtt|jgS|gSt|r"tt|gStdNz2Input must be Sequences or iterables of Sequences)rTrrWsummapr@rrUarg_flattenr&r'r!  z SeqAdd.__new__.._flattencSsg|] }|tjur|qSr&)rrrr&r&r're-rz"SeqAdd.__new__..csrrYrrr&r&r'r3rz!SeqAdd.__new__..)getr rlistrrrrrWreducerrr(rrrr@rrr&rr'rs   zSeqAdd.__new__cd}|r?t|D]4\}d}t|D]#\}||krq}|dur5fdd|D}||nq|r<|}nq|st|dkrI|St|ddS)aSimplify :class:`SeqAdd` using known rules. Iterates through all pairs and ask the constituent sequences if they can simplify themselves with any other constituent. Notes ===== adapted from ``Union.reduce`` TFNcg|] }|fvr|qSr&r&rsrlr&r'reVrfz!SeqAdd.reduce..rHr)rrNrprnrrWr@new_argsZid1Zid2Znew_seqr&rr'r>s*     z SeqAdd.reducecstfdd|jDS)z9adds up the coefficients of all the sequences at point ptc3s|]}|VqdSrYrrrDr&r'rdsz%SeqAdd._eval_coeff..)rr@rCr&rr'rBbszSeqAdd._eval_coeffNr{r|r}r~rrrrBr&r&r&r'rWs $  #rWc@r) r`a'Represents term-wise multiplication of sequences. Explanation =========== Handles multiplication of sequences only. For multiplication with other objects see :func:`SeqBase.coeff_mul`. Rules: * The interval on which sequence is defined is the intersection of respective intervals of sequences. * Anything \* :class:`EmptySequence` returns :class:`EmptySequence`. * Other rules are defined in ``_mul`` methods of sequence classes. Examples ======== >>> from sympy import EmptySequence, oo, SeqMul, SeqPer, SeqFormula >>> from sympy.abc import n >>> SeqMul(SeqPer((1, 2), (n, 0, oo)), EmptySequence) EmptySequence >>> SeqMul(SeqPer((1, 2), (n, 0, 5)), SeqPer((1, 2), (n, 6, 10))) EmptySequence >>> SeqMul(SeqPer((1, 2), (n, 0, oo)), SeqFormula(n**2)) SeqMul(SeqFormula(n**2, (n, 0, oo)), SeqPer((1, 2), (n, 0, oo))) >>> SeqMul(SeqFormula(n**3), SeqFormula(n**2)) SeqFormula(n**5, (n, 0, oo)) See Also ======== sympy.series.sequences.SeqAdd cs|dtj}t|}fdd|}|stjStdd|Dtjur)tjS|r0t |Stt |t j }t j|g|RS)Nrcrr)rTrr`rrr@rrUrrr&r'rrz SeqMul.__new__.._flattencsrrYrrr&r&r'rrz!SeqMul.__new__..)rr rrrrrrr`rrrr(rrrr&rr'rs   zSeqMul.__new__cr)a.Simplify a :class:`SeqMul` using known rules. Explanation =========== Iterates through all pairs and ask the constituent sequences if they can simplify themselves with any other constituent. Notes ===== adapted from ``Union.reduce`` TFNcrr&r&rrr&r'rerfz!SeqMul.reduce..rHr)rrPrprnrr`rr&rr'rs*    z SeqMul.reducecCs"d}|jD] }|||9}q|S)zsB             c%2s F':j