\h׊SSKJr SSKJr SSKJr SSKJr SSKJ r SSK J r J r SSK Jr SSKJr SS KJr SS KJrJr SS KJr SS KJrJrJr SS KJr SSKJr SSK J!r!J"r" SSK#J$r$J%r% SSK&J'r' SSK(J)r)J*r*J+r+ "SS\5r,"SS\,\S9r-"SS\,5r."SS\.5r/"SS\.5r0"SS\,5r1S(S!jr2"S"S#\,5r3"S$S%\35r4"S&S'\35r5g )))Basic)cacheit)Tuple)call_highest_priority)global_parameters) AppliedUndefexpandMul)Integer)Eq)S Singleton)ordered)DummySymbolWildsympify)Matrix)lcmfactor)Interval Intersection)Idx)flatten is_sequenceiterablecV\rSrSrSrSrSr\S5rSr \ S5r \ S5r \ S 5r \ S 5r\ S 5r\ S 5r\ S 5r\S5rSrSrSrSrSrSr\"S5S5rSr\"S5S5rSrSr\"S5S5r Sr!Sr"S#S!jr#S"r$g )$SeqBasezBase class for sequencesTcbURnU$![a [RnU$f=f)zKReturn start (if possible) else S.Infinity. adapted from Set._infimum_key )startNotImplementedErrorrInfinity)exprr$s N/var/www/auris/envauris/lib/python3.13/site-packages/sympy/series/sequences.py _start_keySeqBase._start_key s6  JJE # JJE  s ..cr[URUR5nURUR4$)zDReturns start and stop. Takes intersection over the two intervals. )rintervalinfsup)selfotherr,s r(_intersect_intervalSeqBase._intersect_interval,s+   u~~>||X\\))c[SU-5e)z&Returns the generator for the sequencez(%s).genr%r/s r(gen SeqBase.gen4s"*t"344r3c[SU-5e)z-The interval on which the sequence is definedz (%s).intervalr5r6s r(r,SeqBase.interval9s"/D"899r3c[SU-5e):The starting point of the sequence. This point is includedz (%s).startr5r6s r(r$ SeqBase.start>s","566r3c[SU-5e)z8The ending point of the sequence. This point is includedz (%s).stopr5r6s r(stop SeqBase.stopCs"+"455r3c[SU-5e)zLength of the sequencez (%s).lengthr5r6s r(lengthSeqBase.lengthHs"-$"677r3cg)z-Returns a tuple of variables that are boundedrEr6s r( variablesSeqBase.variablesMsr3cURVVs1sH0oRRUR5Ho"iM M2 snn$s snnf)z 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} )args free_symbols differencerF)r/ijs r(rJSeqBase.free_symbolsRsH!II0Iq~~Jt~~.0/!0/I0 10s7A cXR:dXR:a[SU<SUR<35eUR U5$)z#Returns the coefficient at point ptzIndex z out of bounds )r$r? IndexErrorr, _eval_coeffr/pts r(coeff SeqBase.coeffcs:  ?b99nB NO O##r3c2[SUR-5e)NzhThe _eval_coeff method should be added to%s to return coefficient so it is availablewhen coeff calls it.)r%funcrRs r(rQSeqBase._eval_coeffjs"!#9%)II#./ /r3cUR[RLa URnO URnUR[RLaSnOSnX!U--$)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$rNegativeInfinityr?)r/rLinitialsteps r( _ith_pointSeqBase._ith_pointpsR@ ::++ +iiGjjG ::++ +DD4r3cg)a  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. NrEr/r0s r(_add SeqBase._addr3cg)a 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. NrErbs r(_mul SeqBase._mulrer3c[X5$)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 rbs r( coeff_mulSeqBase.coeff_muls$4r3cp[U[5(d[S[U5-5e[ X5$)zReturns 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 TypeErrortypeSeqAddrbs r(__add__SeqBase.__add__s1%))84;FG Gd""r3rrc X-$NrErbs r(__radd__SeqBase.__radd__ |r3cr[U[5(d[S[U5-5e[ X*5$)zReturns 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 %srmrbs r(__sub__SeqBase.__sub__s3%))=U KL LdF##r3rzcU*U-$rurErbs r(__rsub__SeqBase.__rsub__sr3c$URS5$)zNegates the sequence. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> -SeqFormula(n**2) SeqFormula(-n**2, (n, 0, oo)) rZ)rjr6s r(__neg__SeqBase.__neg__s~~b!!r3cp[U[5(d[S[U5-5e[ X5$)a3Returns 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)rnr rorpSeqMulrbs r(__mul__SeqBase.__mul__s1%))=U KL Ld""r3rc X-$rurErbs r(__rmul__SeqBase.__rmul__rxr3c## [UR5H'nURU5nURU5v M) g7fru)rangerBr_rT)r/rLrSs r(__iter__SeqBase.__iter__s4t{{#A#B**R. $sAAc[U[5(a"URU5nURU5$[U[5(axUR UR p2UcSnUc URn[X#UR=(d S5Vs/sH"o@RURU55PM$ sn$gs snf)Nrr[) rnintr_rTslicer$r?rBrr^)r/indexr$r?rLs r( __getitem__SeqBase.__getitem__"s eS ! !OOE*E::e$ $ u % %++uzz4}|{{%uzzQ79789JJtq1279 9 & 9s)CNc SSKJn USUVs/sHoT"[U55PM nn[U5nUcUS-nO[ X'S-5n/n [ SUS-5Hn SU -n /n [ U 5Hn U R XmX-5 M [U 5nUR5S:wdMRU"UR[XjU 555nX{:Xa[USSS25n Oa/n [ XU - 5Hn U R XmX-5 M [U 5nX-[XkS5:XdM[USSS25n O UcU $[U 5n U S:Xa/S4$XjS- X:S- --SXS- X:--- p![ U S- 5HQnXUUU--- n[ U U- S- 5HnXUUU-UUU-S----nM X)UUUS----nMS X"[U5[U5- 54$s snf)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)simplifyNr[rZ) sympy.simplifyrr lenminrappendrdetLUsolverr)r/ndgfvarrtxlxrcoeffsll2mlistkmyrLrMs r(find_linear_recurrenceSeqBase.find_linear_recurrence/s(D ,*.r( 3(QXfQi ( 3 V 9AAA!e Aq!A#A1BE1X QX&u Auuw!|QYYva"g788$QttW-FqAALLQS*'5M3&3.($QttW-F#$ =MF AAv4x1vecl*As EH0D,D1qsA1eQh&A"1Q3q5\AYqt^EAaCEN::*51Q3<//A $ xq &)(;<<>> 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 c"[R$ru)rEmptySetr6s r(r,EmptySequence.intervals zzr3c"[R$ru)rZeror6s r(rBEmptySequence.lengths vv r3cU$)"See docstring of SeqBase.coeff_mulrE)r/rTs r(rjEmptySequence.coeff_muls r3c[/5$ru)iterr6s r(rEmptySequence.__iter__s Bxr3rEN) rrrrrrr,rBrjrrrEr3r(rrzs9(r3r) metaclasscx\rSrSrSr\S5r\S5r\S5r\S5r \S5r \S5r S r g ) SeqExpriaSequence 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 c URS$NrrIr6s r(r7 SeqExpr.gensyy|r3cZ[URSSURSS5$)Nr[r)rrIr6s r(r,SeqExpr.intervals' ! Q1a99r3c.URR$rur,r-r6s r(r$ SeqExpr.start}}   r3c.URR$rur,r.r6s r(r? SeqExpr.stoprr3c:URUR- S-$Nr[r?r$r6s r(rBSeqExpr.lengthyy4::%))r3c(URSS4$)Nr[rrr6s r(rFSeqExpr.variabless ! Q!!r3rEN) rrrrrrr7r,r$r?rBrFrrEr3r(rrs2::!!!!**""r3rcZ\rSrSrSrS Sjr\S5r\S5rSr Sr S r S r S r g) SeqPeriaj 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 Nc[U5nSnSupEnUcU"U5S[Rpen[U[5(a0[ U5S:XaUupEnO[ U5S:Xa U"U5nUupV[ U[[45(aUbUc[S[U5-5eU[RLaU[RLa [S5e[XEU45n[U[5(a[[[U555nO[SU-5e[US US5[RLa[R $["R$"XU5$) NcURn[UR5S:XaUR5$[S5$)Nr[r)rJrpopr) periodicalfrees r(_find_xSeqPer.__new__.._find_xs6**D:**+q0xxz!Sz!r3NNNrrInvalid limits given: %sz/Both the start and end valuecannot be unboundedz6invalid period %s should be something like e.g (1, 2) r[)rrr&rrrrnrr ValueErrorstrr\tuplerrrrr__new__)clsrlimitsrrr$r?s r(rSeqPer.__new__sQZ(  "*$ >$Z0!QZZdA vu % %6{a!'$V!J'$ !fc]++u} 7#f+EF F A&& &41::+= "788!D)* z5 ) ) wz':!; > F1Ivay )QZZ 7?? "}}Sf55r3c,[UR5$ru)rr7r6s r(period SeqPer.period+s488}r3cUR$rur7r6s r(rSeqPer.periodical/ xxr3cUR[RLaURU- UR-nOXR- UR-nUR UR URSU5$r)r$rr\r?rrsubsrF)r/rSidxs r(rQSeqPer._eval_coeff3sc ::++ +99r>T[[0C ?dkk1Cs#(():B??r3cd[U[5(aURURp2URURpT[ X55n/n[ U5H$nX(U-n XHU-n UR X-5 M& URU5up[XpRSX45$gzSee docstring of SeqBase._addrN rnrrrrrrr1rF r/r0per1lper1per2lper2 per_lengthnew_perrele1ele2r$r?s r(rc SeqPer._add: eV $ $//4;;%**ELL%U*JG:&IIt{+' 2259KE'NN1$5u#CD D %r3cd[U[5(aURURp2URURpT[ X55n/n[ U5H$nX(U-n XHU-n UR X-5 M& URU5up[XpRSX45$gzSee docstring of SeqBase._mulrNrrs r(rg SeqPer._mulKrr3c[U5nURVs/sHo"U-PM nn[X0RS5$s snfrr[)rrrrI)r/rTrpers r(rjSeqPer.coeff_mul\s="&//2/Q5y/2c99Q<((3sArEru)rrrrrrrrrrQrcrgrjrrEr3r(rrsM.`&6P@E"E")r3rcP\rSrSrSrS Sjr\S5rSrSr Sr S r S r S r g) SeqFormulaica 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 Ncj[U5nSnSupEnUcU"U5S[Rpen[U[5(a0[ U5S:XaUupEnO[ U5S:Xa U"U5nUupV[ U[[45(aUbUc[S[U5-5eU[RLaU[RLa [S5e[XEU45n[USUS5[RLa[R$[R "XU5$) NcURn[U5S:XaUR5$U(d [S5$[ SU-5e)Nr[rz 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)))rJrrrr)formulars r(r#SeqFormula.__new__.._find_xsN''D4yA~xxz!Sz! Or3rrrrrz0Both the start and end value cannot be unboundedr[)rrr&rrrrnrrrrr\rrrrr)rrrrrr$r?s r(rSeqFormula.__new__s'" *$ >$W-q!**dA vu % %6{a!'$V!G$$ !fc]++u} 7#f+EF F A&& &41::+= "788!D)* F1Ivay )QZZ 7?? "}}S622r3cUR$rurr6s r(rSeqFormula.formularr3cVURSnURRX!5$r)rFrr)r/rSrs r(rQSeqFormula._eval_coeffs% NN1 ||  ''r3c[U[5(agURURSp2URURSpTX$R XS5-nUR U5upx[XcXx45$grrnrrrFrr1 r/r0form1v1form2v2rr$r?s r(rcSeqFormula._addo eZ ( ( dnnQ&72 uq'92jj00G2259KEgE'89 9 )r3c[U[5(agURURSp2URURSpTX$R XS5-nUR U5upx[XcXx45$grrrs r(rgSeqFormula._mulr!r3cf[U5nURU-n[X RS5$r )rrrrI)r/rTrs r(rjSeqFormula.coeff_muls,,,&'99Q<00r3cb[[UR/UQ70UD6URS5$r)rr rrI)r/rIkwargss r(r SeqFormula.expands*&???1NNr3rEru)rrrrrrrrrQrcrgrjr rrEr3r(rrcs<&P%3N(::1 Or3rc\rSrSrSrSSjr\S5r\S5r\S5r \S5r \S 5r \S 5r \S 5r \S 5r\S 5rSrSrSrg) RecursiveSeqia 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 NcT[U[5(d[SRU55e[U[5(aUR (d[SRU55eUR U4:wa [S5eURn[SU4S9nSnURU5n U Hn [U R 5S:wa [S5eU R SRX7-5Un U R5(aU R(aU S:d[S RU 55eU *U:dMU *nM U(d3[U5Vs/sHn[S RU55PM nn[U5U:wa [!S 5e[#U5n[%U5n['S U56n[R("XX#XE5n [+U5VV s0sHup}U"XW-5U _M sn nU lXlU $s snfs sn nf) NzErecurrence sequence must be an applied undefined function, found `{}`z0recurrence variable must be a symbol, found `{}`z)recurrence sequence does not match symbolr)excluderr[z)Recurrence should be in a single variablezDRecurrence should have constant, negative, integer shifts (found {})zc_{}z)Number of initial terms must equal degreec38# UHn[U5v M g7frur).0rs r( 'RecursiveSeq.__new__..Os6g'!**g)rnrroformatr is_symbolrIrWrfindrmatch is_constant is_integerrrrr rrr enumeratecachedegree)r recurrenceynrr]r$rrr:prev_ysprev_yshiftseqinits r(rRecursiveSeq.__new__#s"l++++16":7 7!U##1;;++16!96 6 77qd?GH H GG qd # //!$F6;;1$ KLLKKN((/2E%%''E,<,<!..4fVn>>v8=f F 1uV]]1-. GF w<6 !HI I6g67mmCRGC7@7IJ7IGAQuy\4'7IJ   GKs ,$H7H$c URS$zEquation defining recurrence.rrr6s r( _recurrenceRecursiveSeq._recurrenceXyy|r3cH[URURS5$rD)r r<rIr6s r(r;RecursiveSeq.recurrence]s$''499Q<((r3c URS$)z*Applied function representing the nth termr[rr6s r(r<RecursiveSeq.ynbrGr3c.URR$)z3Undefined function for the nth term of the sequence)r<rWr6s r(rRecursiveSeq.ygsww||r3c URS$)zSequence index symbolrrr6s r(rRecursiveSeq.nlrGr3c URS$)z"The initial values of the sequencerrr6s r(r]RecursiveSeq.initialqrGr3c URS$)r<rr6s r(r$RecursiveSeq.startvrGr3c"[R$)z&The ending point of the sequence. (oo))rr&r6s r(r?RecursiveSeq.stop{szzr3c:UR[R4$)z&Interval on which sequence is defined.)r$rr&r6s r(r,RecursiveSeq.intervals AJJ''r3c XR- [UR5:aURURU5$[ [UR5US-5HqnURU-nUR R URU05nUR UR5nXPRURU5'Ms URURURW-5$r)r$rr9rrrExreplacer)r/rcurrent seq_indexcurrent_recurrencenew_terms r(rQRecursiveSeq._eval_coeffs :: DJJ /::dffUm, ,S_eai8G W,I!%!1!1!:!:DFFI;N!O )224::>H,4JJtvvi( )9zz$&&g!5677r3c#X# URnURU5v US- nM7fr)r$rQ)r/rs r(rRecursiveSeq.__iter__s0 ""5) ) QJEs(*rEr)rrrrrrrrEr;r<rrr]r$r?r,rQrrrEr3r(r*r*sJX3j))(( 8r3r*Ncn[U5n[U[5(a [X5$[ X5$)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)r@rs r(sequencercs04 #,C3c""#&&r3cx\rSrSrSr\S5r\S5r\S5r\S5r \S5r \S5r S r g ) SeqExprOpia 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 c:[SUR55$)zZGenerator for the sequence. returns a tuple of generators of all the argument sequences. c38# UHoRv M g7frurr.as r(r/ SeqExprOp.gen..s.IqUUIr1)rrIr6s r(r7 SeqExprOp.gens .DII...r3c4[SUR56$)zUSequence is defined on the intersection of all the intervals of respective sequences c38# UHoRv M g7frur,rhs r(r/%SeqExprOp.interval..s<)Qjj)r1)rrIr6s r(r,SeqExprOp.intervals <$))<==r3c.URR$rurr6s r(r$SeqExprOp.startrr3c.URR$rurr6s r(r?SeqExprOp.stoprr3c|[[URVs/sHoRPM sn55$s snf)z%Cumulative of all the bound variables)rrrIrF)r/ris r(rFSeqExprOp.variabless,W499=9akk9=>??=s9 c:URUR- S-$rrr6s r(rBSeqExprOp.lengthrr3rEN) rrrrrrr7r,r$r?rFrBrrEr3r(reres0//>> !!!!@@**r3rec4\rSrSrSrSr\S5rSrSr g)rqiaFRepresents 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 c^URS[R5n[U5nU4SjmT"U5nUVs/sHoD[R LdMUPM nnU(d[R $[ SU56[RLa[R $U(a[RU5$[[U[R55n[R"U/UQ76$s snf)Nevaluatec>[U[5(a8[U[5(a [[ TUR 5/5$U/$[ U5(a[[ TU5/5$[S5eNz2Input must be Sequences or iterables of Sequences)rnr rqsummaprIrroarg_flattens r(r SeqAdd.__new__.._flatten sk#w''c6**s8SXX6;;5L}}3x-r2267 7r3c38# UHoRv M g7frurnrhs r(r/!SeqAdd.__new__..23d**dr1)getrr{listrrrrrqreducerr r)rr)rrIr'r{rirs @r(rSeqAdd.__new__s::j*;*D*DEDz 7~<4aAOO#;4<?? " 3d3 4 B?? " ==& &GD'"4"456}}S(4((=s C>C>c|SnU(a[U5Hnup#Sn[U5HMupEX$:XaM URU5nUcM"UVs/sH owX54;dM UPM nnURU5 O U(dMlUn O U(aM[U5S:XaUR 5$[ USS9$s snf)zSimplify :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`` TFr[r{)r8rcrrrrqrInew_argsid1sid2rnew_seqris r(r SeqAdd.reduce=s#D/ 'oFCz ffQiG*/3#Gt!At#G 0.8#D*h" t9>88: $/ /$H B9B9cB^[U4SjUR55$)z9adds up the coefficients of all the sequences at point ptc3D># UHoRT5v M g7fru)rT)r.rirSs r(r/%SeqAdd._eval_coeff..cs2 1772;; s )r~rIrRs `r(rQSeqAdd._eval_coeffas2 222r3rEN rrrrrrrrrQrrEr3r(rqrqs'8")H!0!0F3r3rqc4\rSrSrSrSr\S5rSrSr g)rifaRepresents 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 c^URS[R5n[U5nU4SjmT"U5nU(d[R $[ SU56[RLa[R $U(a[RU5$[[U[R55n[R"U/UQ76$)Nr{c>[U[5(a8[U[5(a [[ TUR 5/5$U/$[ U5(a[[ TU5/5$[S5er})rnr rr~rrIrrors r(r SeqMul.__new__.._flattensk#w''c6**s8SXX6;;5L#3x-r2267 7r3c38# UHoRv M g7frurnrhs r(r/!SeqMul.__new__..rr1)rrr{rrrrrrrrr r)rr)rrIr'r{rs @r(rSeqMul.__new__s::j*;*D*DEDz 7~?? " 3d3 4 B?? " ==& &GD'"4"456}}S(4((r3c|SnU(a[U5Hnup#Sn[U5HMupEX$:XaM URU5nUcM"UVs/sH owX54;dM UPM nnURU5 O U(dMlUn O U(aM[U5S:XaUR 5$[ USS9$s snf)zSimplify 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`` TFr[r)r8rgrrrrrs r(r SeqMul.reduces #D/ 'oFCz ffQiG*/3#Gt!At#G 0.8#D*h" t9>88: $/ /$HrcVSnURHnX#RU5-nM U$)zrs"$'734&$-&11&!#2$DD^=e^=@ "Gy"J0"g0"fN)WN)bqOqOfB7BJ'N7*7*tg3Yg3TqYqr3