U @f׊@sddlmZddlmZddlmZddlmZddlm Z ddl m Z m Z ddl mZddlmZdd lmZdd lmZmZdd lmZdd lmZmZmZdd lmZddlmZddl m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'ddl(m)Z)m*Z*m+Z+GdddeZ,Gddde,edZ-Gddde,Z.Gddde.Z/Gddde.Z0Gddde,Z1d)d!d"Z2Gd#d$d$e,Z3Gd%d&d&e3Z4Gd'd(d(e3Z5d S)*)Basic)cacheit)Tuple)call_highest_priority)global_parameters) AppliedUndefexpandMul)Integer)Eq)S Singleton)ordered)DummySymbolWildsympify)Matrix)lcmfactor)Interval Intersection)Idx)flatten is_sequenceiterablec@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 sequencesTcCs*z |j}Wntk r$tj}YnX|S)z[Return start (if possible) else S.Infinity. adapted from Set._infimum_key )startNotImplementedErrorr Infinity)exprr r$:/tmp/pip-unpacked-wheel-6uje5nh9/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,szSeqBase._intersect_intervalcCstd|dS)z&Returns the generator for the sequencez(%s).genNr!r*r$r$r%gen4sz SeqBase.gencCstd|dS)z-The interval on which the sequence is definedz (%s).intervalNr-r.r$r$r%r'9szSeqBase.intervalcCstd|dS):The starting point of the sequence. This point is includedz (%s).startNr-r.r$r$r%r >sz SeqBase.startcCstd|dS)z8The ending point of the sequence. This point is includedz (%s).stopNr-r.r$r$r%stopCsz SeqBase.stopcCstd|dS)zLength of the sequencez (%s).lengthNr-r.r$r$r%lengthHszSeqBase.lengthcCsdS)z-Returns a tuple of variables that are boundedr$r$r.r$r$r% variablesMszSeqBase.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]}|qqSr$) free_symbols differencer3).0ijr.r$r% `s z'SeqBase.free_symbols..argsr.r$r.r%r4RszSeqBase.free_symbolscCs0||jks||jkr&td||jf||S)z#Returns the coefficient at point ptzIndex %s out of bounds %s)r r1 IndexErrorr' _eval_coeffr*ptr$r$r%coeffcsz SeqBase.coeffcCstd|jdS)NzhThe _eval_coeff method should be added to%s to return coefficient so it is availablewhen coeff calls it.)r!funcr>r$r$r%r=jszSeqBase._eval_coeffcCs<|jtjkr|j}n|j}|jtjkr,d}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 r NegativeInfinityr1)r*r7initialstepr$r$r% _ith_pointps  zSeqBase._ith_pointcCsdS)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%_addsz SeqBase._addcCsdS)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$rHr$r$r%_mulsz 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 rHr$r$r% coeff_mulszSeqBase.coeff_mulcCs$t|tstdt|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 TypeErrortypeSeqAddrHr$r$r%__add__s zSeqBase.__add__rQcCs||SNr$rHr$r$r%__radd__szSeqBase.__radd__cCs&t|tstdt|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 %srLrHr$r$r%__sub__s zSeqBase.__sub__rTcCs | |SrRr$rHr$r$r%__rsub__szSeqBase.__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)) rB)rKr.r$r$r%__neg__s zSeqBase.__neg__cCs$t|tstdt|t||S)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)rMrrNrOSeqMulrHr$r$r%__mul__s zSeqBase.__mul__rXcCs||SrRr$rHr$r$r%__rmul__szSeqBase.__rmul__ccs*t|jD]}||}||Vq dSrR)ranger2rGr@)r*r7r?r$r$r%__iter__s zSeqBase.__iter__cstt|tr|}|St|trp|j|j}}|dkrBd}|dkrPj}fddt|||j phdDSdS)Nrcsg|]}|qSr$)r@rG)r6r7r.r$r% ,sz'SeqBase.__getitem__..rC) rMintrGr@slicer r1r2rZrF)r*indexr r1r$r.r% __getitem__"s     zSeqBase.__getitem__Ncs<ddlmfdd|d|D}t|}|dkr@|d}nt||d}g}td|dD]}d|} g} t|D]} | || | |qxt| } | dkr`| t||| } || krt | ddd}qJg} t|||D]} | || | |qt| } | | t|| dkr`t | ddd}qJq`|dkrX|St|}|dkrrgdfS||d||dd||d||}}t|dD]n}|||||7}t||dD]*}||||||||d8}q|||||d8}q|t |t |fSdS) 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)) rsimplifycsg|]}t|qSr$)r)r6trar$r%r\Rsz2SeqBase.find_linear_recurrence..NrCrB) Zsympy.simplifyrblenminrZappendrZdetZLUsolverr)r*ndZgfvarxZlxrZcoeffsll2Zmlistkmyr7r8r$rar%find_linear_recurrence/sJ"      2(zSeqBase.find_linear_recurrence)NN)#__name__ __module__ __qualname____doc__Zis_commutativeZ _op_priority staticmethodr&r,propertyr/r'r r1r2r3r4rr@r=rGrIrJrKrQrrSrTrUrVrXrYr[r`rqr$r$r$r%rsP         ,     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 cCstjSrR)r EmptySetr.r$r$r%r'szEmptySequence.intervalcCstjSrR)r ZZeror.r$r$r%r2szEmptySequence.lengthcCs|S)"See docstring of SeqBase.coeff_mulr$)r*r@r$r$r%rKszEmptySequence.coeff_mulcCstgSrR)iterr.r$r$r%r[szEmptySequence.__iter__N) rrrsrtrurwr'r2rKr[r$r$r$r%rxzs  rx) metaclassc@sXeZdZdZeddZeddZeddZedd 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 >>> from sympy import Tuple >>> s = SeqExpr(Tuple(1, 2, 3), Tuple(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 cCs |jdSNrr:r.r$r$r%r/sz SeqExpr.gencCst|jdd|jddS)NrCrd)rr;r.r$r$r%r'szSeqExpr.intervalcCs|jjSrRr'r(r.r$r$r%r sz SeqExpr.startcCs|jjSrRr'r)r.r$r$r%r1sz SeqExpr.stopcCs|j|jdSNrCr1r r.r$r$r%r2szSeqExpr.lengthcCs|jddfS)NrCrr:r.r$r$r%r3szSeqExpr.variablesN) rrrsrtrurwr/r'r r1r2r3r$r$r$r%r}s     r}c@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\}}}|dkr8||dtj}}}t|trvt|dkrZ|\}}}nt|dkrv||}|\}}t|ttfr|dks|dkrt dt ||tj kr|tjkrt dt|||f}t|trtt t |}n t d |t|d |dtjkrtjSt|||S) NcSs(|j}t|jdkr|StdSdS)NrCrn)r4repopr) periodicalfreer$r$r%_find_xszSeqPer.__new__.._find_xNNNrrdInvalid limits given: %sz/Both the start and end valuecannot be unboundedz6invalid period %s should be something like e.g (1, 2) rC)rr r"rrrerMrr ValueErrorstrrDtuplerrryrxr__new__)clsrlimitsrrjr r1r$r$r%rs0      zSeqPer.__new__cCs t|jSrR)rer/r.r$r$r%period+sz SeqPer.periodcCs|jSrRr/r.r$r$r%r/szSeqPer.periodicalcCsF|jtjkr|j||j}n||j|j}|j||jd|Sr~)r r rDr1rrsubsr3)r*r?idxr$r$r%r=3s zSeqPer._eval_coeffc Cst|tr|j|j}}|j|j}}t||}g}t|D]*}|||} |||} || | q<||\} } t||jd| | fSdSzSee docstring of SeqBase._addrN rMrrrrrZrgr,r3 r*r+Zper1Zlper1Zper2Zlper2Z per_lengthZnew_perrjZele1Zele2r r1r$r$r%rI:s     z SeqPer._addc Cst|tr|j|j}}|j|j}}t||}g}t|D]*}|||} |||} || | q<||\} } t||jd| | fSdSzSee docstring of SeqBase._mulrNrrr$r$r%rJKs     z SeqPer._mulcs,tfdd|jD}t||jdS)rzcsg|] }|qSr$r$r6rjr@r$r%r\_sz$SeqPer.coeff_mul..rC)rrrr;)r*r@Zperr$rr%rK\szSeqPer.coeff_mul)N) rrrsrtrurrwrrr=rIrJrKr$r$r$r%rs0 (  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\}}}|dkr8||dtj}}}t|trvt|dkrZ|\}}}nt|dkrv||}|\}}t|ttfr|dks|dkrt dt ||tj kr|tjkrt dt|||f}t |d |dtj krtjSt|||S) NcSs6|j}t|dkr|S|s&tdStd|dS)NrCrnz 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)))r4rerrr)formularr$r$r%rs z#SeqFormula.__new__.._find_xrrrrdrz0Both the start and end value cannot be unboundedrC)rr r"rrrerMrrrrrDrryrxrr)rrrrrjr r1r$r$r%rs&     zSeqFormula.__new__cCs|jSrRrr.r$r$r%rszSeqFormula.formulacCs|jd}|j||Sr~)r3rr)r*r?rir$r$r%r=s zSeqFormula._eval_coeffc Cs`t|tr\|j|jd}}|j|jd}}||||}||\}}t||||fSdSrrMrrr3rr, r*r+Zform1Zv1Zform2Zv2rr r1r$r$r%rIs  zSeqFormula._addc Cs`t|tr\|j|jd}}|j|jd}}||||}||\}}t||||fSdSrrrr$r$r%rJs  zSeqFormula._mulcCs"t|}|j|}t||jdS)rzrC)rrrr;)r*r@rr$r$r%rKs zSeqFormula.coeff_mulcOstt|jf|||jdSr)rrrr;)r*r;kwargsr$r$r%rszSeqFormula.expand)N) rrrsrtrurrwrr=rIrJrKrr$r$r$r%rcs( '   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|tstd|t|tr(|js6td||j|fkrJtd|jtd|fd}d}| }|D]f} t | jdkrtd| jd |||} | r| j r| dkstd | | |krp| }qp|sd 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 symbolrn)excluderrCz)Recurrence should be in a single variablezDRecurrence should have constant, negative, integer shifts (found {})cSsg|]}td|qS)zc_{})rformat)r6rnr$r$r%r\Gsz(RecursiveSeq.__new__..z)Number of initial terms must equal degreecss|]}t|VqdSrRrrr$r$r% Osz'RecursiveSeq.__new__..csi|]\}}||qSr$r$)r6rninitr rpr$r% Ss z(RecursiveSeq.__new__..)rMrrNrrZ is_symbolr;rArfindrematchZ is_constant is_integerrZrr rrr enumeratecachedegree) r recurrenceynrhrEr rnrZprev_ysZprev_yshiftseqr$rr%r#sF    zRecursiveSeq.__new__cCs |jdSzEquation defining recurrence.rr:r.r$r$r% _recurrenceXszRecursiveSeq._recurrencecCst|j|jdSr)r rr;r.r$r$r%r]szRecursiveSeq.recurrencecCs |jdS)z*Applied function representing the nth termrCr:r.r$r$r%rbszRecursiveSeq.yncCs|jjS)z3Undefined function for the nth term of the sequence)rrAr.r$r$r%rpgszRecursiveSeq.ycCs |jdS)zSequence index symbolrdr:r.r$r$r%rhlszRecursiveSeq.ncCs |jdS)z"The initial values of the sequencerr:r.r$r$r%rEqszRecursiveSeq.initialcCs |jdS)r0r:r.r$r$r%r vszRecursiveSeq.startcCstjS)z&The ending point of the sequence. (oo))r r"r.r$r$r%r1{szRecursiveSeq.stopcCs |jtjfS)z&Interval on which sequence is defined.)r r r"r.r$r$r%r'szRecursiveSeq.intervalcCs||jt|jkr$|j||Stt|j|dD]<}|j|}|j|j|i}||j}||j||<q8|j||j|Sr)r rerrprZrZxreplacerh)r*r_currentZ seq_indexZcurrent_recurrenceZnew_termr$r$r%r=s  zRecursiveSeq._eval_coeffccs |j}||V|d7}qdSr)r r=)r*r_r$r$r%r[s zRecursiveSeq.__iter__)Nr)rrrsrtrurrwrrrrprhrEr r1r'r=r[r$r$r$r%rs,L 5         rNcCs*t|}t|trt||St||SdS)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 N)rrrrr)rrr$r$r%sequences  rc@sXeZdZdZeddZeddZeddZedd Zed d Z ed d Z dS) 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. css|] }|jVqdSrRrr6ar$r$r%rsz SeqExprOp.gen..)rr;r.r$r$r%r/sz SeqExprOp.gencCstdd|jDS)zeSequence is defined on the intersection of all the intervals of respective sequences css|] }|jVqdSrRr'rr$r$r%rsz%SeqExprOp.interval..)rr;r.r$r$r%r'szSeqExprOp.intervalcCs|jjSrRrr.r$r$r%r szSeqExprOp.startcCs|jjSrRrr.r$r$r%r1szSeqExprOp.stopcCsttdd|jDS)z%Cumulative of all the bound variablescSsg|] }|jqSr$)r3rr$r$r%r\sz'SeqExprOp.variables..)rrr;r.r$r$r%r3szSeqExprOp.variablescCs|j|jdSrrr.r$r$r%r2szSeqExprOp.lengthN) rrrsrtrurwr/r'r r1r3r2r$r$r$r%rs     rc@s,eZdZdZddZeddZddZdS) rPaRepresents 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}|sBtjStdd|Dtjkr`tjS|rnt |Stt |t j }t j|f|S)NevaluatecsPt|tr,t|tr&tt|jgS|gSt|rDtt|gStddSNz2Input must be Sequences or iterables of Sequences)rMrrPsummapr;rrNarg_flattenr$r%r s  z SeqAdd.__new__.._flattencSsg|]}|tjk r|qSr$)r rxrr$r$r%r\,s z"SeqAdd.__new__..css|] }|jVqdSrRrrr$r$r%r2sz!SeqAdd.__new__..)getrrlistr rxrryrPreducerrr&rrrr;rrr$rr%rs  zSeqAdd.__new__csd}|r|t|D]h\}d}t|D]F\}||kr6q$}|dk r$fdd|D}||qlq$|r|}qqqt|dkr|St|ddSdS)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`` TFNcsg|]}|fkr|qSr$r$rsrcr$r%r\Us z!SeqAdd.reduce..rCr)rrIrgrerrPr;new_argsZid1Zid2Znew_seqr$rr%r=s$    z SeqAdd.reducecstfdd|jDS)z9adds up the coefficients of all the sequences at point ptc3s|]}|VqdSrRrrr?r$r%rcsz%SeqAdd._eval_coeff..)rr;r>r$rr%r=aszSeqAdd._eval_coeffNrrrsrtrurrvrr=r$r$r$r%rPs $ #rPc@s,eZdZdZddZeddZddZdS) rWa'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|}|s4tjStdd|DtjkrRtjS|r`t |Stt |t j }t j|f|S)NrcsRt|tr.t|tr&tt|jgS|gSnt|rFtt|gStddSr)rMrrWrrr;rrNrrr$r%rs  z SeqMul.__new__.._flattencss|] }|jVqdSrRrrr$r$r%rsz!SeqMul.__new__..)rrrrr rxrryrWrrrr&rrrr$rr%rs  zSeqMul.__new__csd}|r|t|D]h\}d}t|D]F\}||kr6q$}|dk r$fdd|D}||qlq$|r|}qqqt|dkr|St|ddSdS)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`` TFNcsg|]}|fkr|qSr$r$rrr$r%r\s z!SeqMul.reduce..rCr)rrJrgrerrWrr$rr%rs$   z SeqMul.reducecCs"d}|jD]}|||9}q |S)zs>            b%3sF ':j