g׊ddlmZddlmZddlmZddlmZddlm 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+GddeZ,Gdde,eZ-Gdde,Z.Gdde.Z/Gdde.Z0Gdde,Z1d(d!Z2Gd"d#e,Z3Gd$d%e3Z4Gd&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_sequenceiterableceZdZdZdZdZedZdZe dZ e dZ e dZ e d Z e d Ze d Ze d Zed ZdZdZdZdZdZdZeddZdZeddZdZdZeddZdZ dZ!d!d Z"dS)"SeqBasezBase class for sequencesTcP |j}n#t$rtj}YnwxYw|S)z[Return start (if possible) else S.Infinity. adapted from Set._infimum_key )startNotImplementedErrorrInfinity)exprr#s R/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/series/sequences.py _start_keyzSeqBase._start_key s;  JEE"   JEEE  s  ##cRt|j|j}|j|jfS)zTReturns start and stop. Takes intersection over the two intervals. )rintervalinfsup)selfotherr*s r'_intersect_intervalzSeqBase._intersect_interval,s&   u~>>|X\))c&td|z)z&Returns the generator for the sequencez(%s).genr$r-s r'genz SeqBase.gen4s"*t"3444r0c&td|z)z-The interval on which the sequence is definedz (%s).intervalr2r3s r'r*zSeqBase.interval9s"/D"8999r0c&td|z):The starting point of the sequence. This point is includedz (%s).startr2r3s r'r#z SeqBase.start>s","5666r0c&td|z)z8The ending point of the sequence. This point is includedz (%s).stopr2r3s r'stopz SeqBase.stopCs"+"4555r0c&td|z)zLength of the sequencez (%s).lengthr2r3s r'lengthzSeqBase.lengthHs"-$"6777r0cdS)z-Returns a tuple of variables that are boundedr=r3s r' variableszSeqBase.variablesMs rr0c*fdjDS)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} cXh|]&}|jjD]}|'Sr=) free_symbols differencer>).0ijr-s r' z'SeqBase.free_symbols..`sI000qq~Jt~..00!0000r0argsr3s`r'rAzSeqBase.free_symbolsRs/0000DI000 1r0c||jks ||jkrtd|d|j||S)z#Returns the coefficient at point ptzIndex z out of bounds )r#r9 IndexErrorr* _eval_coeffr-pts r'coeffz SeqBase.coeffcsJ  ??b49nn*BBB NOO O###r0c0td|jz)NzhThe _eval_coeff method should be added to%s to return coefficient so it is availablewhen coeff calls it.)r$funcrLs r'rKzSeqBase._eval_coeffjs%!#9%)I#.// /r0c|jtjur|j}n|j}|jtjurd}nd}|||zzS)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#rNegativeInfinityr9)r-rDinitialsteps r' _ith_pointzSeqBase._ith_pointpsP@ :+ + +iGGjG :+ + +DDD4r0cdS)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.s r'_addz SeqBase._add tr0cdS)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=rYs r'_mulz SeqBase._mulr[r0c"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 rYs r' coeff_mulzSeqBase.coeff_muls$4r0ct|tstdt|zt ||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 TypeErrortypeSeqAddrYs r'__add__zSeqBase.__add__sA%)) H84;;FGG GdE"""r0rfc ||zSNr=rYs r'__radd__zSeqBase.__radd__ e|r0ct|tstdt|zt || 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 %srarYs r'__sub__zSeqBase.__sub__sC%)) M=U KLL LdUF###r0rlc| |zSrhr=rYs r'__rsub__zSeqBase.__rsub__sr0c,|dS)zNegates the sequence. Examples ======== >>> from sympy import SeqFormula >>> from sympy.abc import n >>> -SeqFormula(n**2) SeqFormula(-n**2, (n, 0, oo)) rR)r_r3s r'__neg__zSeqBase.__neg__s~~b!!!r0ct|tstdt|zt ||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)rbr rcrdSeqMulrYs r'__mul__zSeqBase.__mul__sA%)) M=U KLL LdE"""r0rsc ||zSrhr=rYs r'__rmul__zSeqBase.__rmul__rjr0c#Kt|jD].}||}||V/dSrh)ranger;rWrN)r-rDrMs r'__iter__zSeqBase.__iter__sSt{## ! !A##B**R..  ! !r0c.t|tr*|}|St|tr?|j|j}}|d}|j}fdt|||j pdDSdS)Nrc`g|]*}|+Sr=)rNrW)rCrDr-s r' z'SeqBase.__getitem__..,s=999qDJJtq1122999r0rS) rbintrWrNslicer#r9r;rwrV)r-indexr#r9s` r' __getitem__zSeqBase.__getitem__"s eS ! ! 9OOE**E::e$$ $ u % % 9+uz4E}|{9999%uzQ77999 9  9 9r0Nc ddlmfd|d|D}t|}||dz}nt||dz}g}t d|dzD]5}d|z} g} t |D]"} | || | |z#t | } | dkr| t ||| } || krt| ddd}ng} t |||z D]"} | || | |z#t | } | | zt || dkrt| ddd}n7||St|}|dkrgdfS||dz ||dz zzd||dz ||zzz }}t |dz D]_}|||||zzz }t ||z dz D]"}|||||z|||zdzzzz}#|||||dzzzz}`|t|t|z 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)simplifyc@g|]}t|Sr=)r )rCtrs r'r{z2SeqBase.find_linear_recurrence..Rs) 3 3 3QXXfQii 3 3 3r0NrSrR) sympy.simplifyrlenminrwappendrdetLUsolverr)r-ndgfvarxlxrcoeffsll2mlistkmyrDrErs @r'find_linear_recurrencezSeqBase.find_linear_recurrence/sD ,+++++ 3 3 3 3$rr( 3 3 3 VV 9AAAAb!e Aq!A#  A1BE1XX ' ' Qq1uX&&&&u Auuww!||HQYYva"g778888$QtttW--FEqA++ALL1QqS5****5MMQ3&233..(($QtttW--FE =MF AAvv4x1veacl*Aqs E1H0D,D1qs00A1eQh&A"1Q3q5\\;;VAYqt^EAaCEN::51Q3<//AAxxq &))(;<<<rArrNrKrWrZr]r_rfrrirlrnrprsrurxrrr=r0r'r r sY""NL  \ ***55X5::X:77X766X688X8X11X1  $$ W$ /// * * * X     (###"9%%&%$$$"9%%&% " " "###$9%%&%!!! 9 9 9I=I=I=I=I=I=r0r cJeZdZdZedZedZdZdZdS) 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 ctjSrh)rEmptySetr3s r'r*zEmptySequence.intervals zr0ctjSrh)rZeror3s r'r;zEmptySequence.lengths v r0c|S)"See docstring of SeqBase.coeff_mulr=)r-rNs r'r_zEmptySequence.coeff_muls r0c tgSrh)iterr3s r'rxzEmptySequence.__iter__s Bxxr0N) rrrrrr*r;r_rxr=r0r'rrzsr(XXr0r) metaclassceZdZdZedZedZedZedZedZ edZ 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 c|jdSNrrGr3s r'r4z SeqExpr.gensy|r0cft|jdd|jddS)NrSr)rrHr3s r'r*zSeqExpr.intervals& ! Q1a999r0c|jjSrhr*r+r3s r'r#z SeqExpr.start }  r0c|jjSrhr*r,r3s r'r9z SeqExpr.stoprr0c&|j|jz dzSNrSr9r#r3s r'r;zSeqExpr.lengthy4:%))r0c*|jddfS)NrSrrGr3s r'r>zSeqExpr.variabless ! Q!!r0N) rrrrrr4r*r#r9r;r>r=r0r'rrs2X::X:!!X!!!X!**X*""X"""r0rc^eZdZdZd dZedZedZdZdZ dZ d Z 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 Nc:t|}d}d\}}}|||dtj}}}t|tr=t |dkr|\}}}n#t |dkr||}|\}}t |ttfr||tdt|z|tj ur|tjurtdt|||f}t|tr*ttt|}ntd|zt|d |dtjur tjSt#j|||S) Nc|j}t|jdkr|StdS)NrSr)rArpopr) periodicalfrees r'_find_xzSeqPer.__new__.._find_xs:*D:*++q00xxzz!Szz!r0NNNrrInvalid limits given: %sz/Both the start and end valuecannot be unboundedz6invalid period %s should be something like e.g (1, 2) rS)rrr%rrrrbrr ValueErrorstrrTtuplerrrrr__new__)clsrlimitsrrr#r9s r'rzSeqPer.__new__sZ((  " " "*5$ >$WZ00!QZduA vu % % %6{{a!'5$$V!!GJ''$ t!fc]++ Gu} 7#f++EFF F A& & &41:+=+= "7888!UD)** z5 ) ) > wz':':!;!;<> > F1Ivay ) )QZ 7 7? "}S*f555r0c*t|jSrh)rr4r3s r'periodz SeqPer.period+s48}}r0c|jSrhr4r3s r'rzSeqPer.periodical/ xr0c|jtjur|j|z |jz}n||jz |jz}|j||jd|Sr)r#rrTr9rrsubsr>)r-rMidxs r'rKzSeqPer._eval_coeff3s\ :+ + +9r>T[0CC ?dk1Cs#(():B???r0cxt|tr|j|j}}|j|j}}t ||}g}t |D]0}|||z} |||z} || | z1||\} } t||jd| | fSdSzSee docstring of SeqBase._addrN rbrrrrrwrr/r> r-r.per1lper1per2lper2 per_lengthnew_perrele1ele2r#r9s r'rZz SeqPer._add: eV $ $ E/4;%D*EL%DUE**JG:&& , ,AIAItd{++++22599KE4'DN1$5ud#CDD D E Er0cxt|tr|j|j}}|j|j}}t ||}g}t |D]0}|||z} |||z} || | z1||\} } t||jd| | fSdSzSee docstring of SeqBase._mulrNrrs r'r]z SeqPer._mulKrr0c~tfd|jD}t||jdS)rcg|]}|zSr=r=)rCrrNs r'r{z$SeqPer.coeff_mul.._s222Qq5y222r0rS)rrrrH)r-rNpers ` r'r_zSeqPer.coeff_mul\s?2222$/222c49Q<(((r0rh) rrrrrrrrrKrZr]r_r=r0r'rrs..`&6&6&6&6PXX@@@EEE"EEE")))))r0rcNeZdZdZd dZedZdZdZdZ dZ d Z 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 Nct|}d}d\}}}|||dtj}}}t|tr=t |dkr|\}}}n#t |dkr||}|\}}t |ttfr||tdt|z|tj ur|tjurtdt|||f}t|d|dtj ur tjStj|||S) Nc|j}t|dkr|S|stdSt d|z)NrSrz 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)))rArrrr)formulars r'rz#SeqFormula.__new__.._find_xs]'D4yyA~~xxzz! Szz! Or0rrrrrz0Both the start and end value cannot be unboundedrS)rrr%rrrrbrrrrrTrrrrr)rrrrrr#r9s r'rzSeqFormula.__new__s['""   *5$ >$WW--q!*duA vu % % %6{{a!'5$$V!!GG$$$ t!fc]++ Gu} 7#f++EFF F A& & &41:+=+= "7888!UD)** F1Ivay ) )QZ 7 7? "}S'6222r0c|jSrhrr3s r'rzSeqFormula.formularr0cR|jd}|j||Sr)r>rr)r-rMrs r'rKzSeqFormula._eval_coeffs& N1 |  B'''r0ct|trl|j|jd}}|j|jd}}||||z}||\}}t||||fSdSrrbrrr>rr/ r-r.form1v1form2v2rr#r9s r'rZzSeqFormula._add eZ ( ( : dnQ&72E uq'92EejjR000G22599KE4gE4'899 9  : :r0ct|trl|j|jd}}|j|jd}}||||z}||\}}t||||fSdSrrrs r'r]zSeqFormula._mulrr0cjt|}|j|z}t||jdS)rrS)rrrrH)r-rNrs r'r_zSeqFormula.coeff_muls/,&'49Q<000r0c^tt|jg|Ri||jdSr)rr rrH)r-rHkwargss r'r zSeqFormula.expands2&??????1NNNr0rh) rrrrrrrrKrZr]r_r r=r0r'rrcs&&P%3%3%3%3NX(((::::::111 OOOOOr0rceZdZdZddZedZedZedZedZ ed Z ed Z ed Z ed Z ed ZdZdZdS) 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, t|ts"td|t|tr|js"td||j|fkrtd|j td|f}d}| }|D]} t| jdkrtd| jd ||z|} | r | j r| dks"td | | |kr| }|sd t|D}t||krtd t!|}t#t%d |D}t j|||||}  fd t)|D| _|| _| S)NzErecurrence sequence must be an applied undefined function, found `{}`z0recurrence variable must be a symbol, found `{}`z)recurrence sequence does not match symbolr)excluderrSz)Recurrence should be in a single variablezDRecurrence should have constant, negative, integer shifts (found {})cRg|]$}td|%S)zc_{})rformat)rCrs r'r{z(RecursiveSeq.__new__..Gs,FFF1uV]]1--..FFFr0z)Number of initial terms must equal degreec34K|]}t|VdSrhr)rCrs r' z'RecursiveSeq.__new__..Os(66'!**666666r0c4i|]\}}|z|Sr=r=)rCrinitr#rs r' z(RecursiveSeq.__new__..Ss+JJJGAtQQuqy\\4JJJr0)rbrrcrr is_symbolrHrPrfindrmatch is_constant is_integerrwrr rrr enumeratecachedegree) r recurrenceynrrUr#rr prev_ysprev_yshiftseqrs ` @r'rzRecursiveSeq.__new__#s6"l++ 7++16"::77 7!U## 61; 6++16!9966 6 7qd??GHH H G qd # # # //!$$ F6;1$$ KLLLKN((Q//2E%%'' >E,< >!..4fVnn>>>v GFFf FFFG w<<6 ! !HII I66g6667mCRGUCCJJJJJy7I7IJJJ   r0c|jdSzEquation defining recurrence.rrGr3s r' _recurrencezRecursiveSeq._recurrenceXy|r0cBt|j|jdSr)r r rHr3s r'r zRecursiveSeq.recurrence]s$'49Q<(((r0c|jdS)z*Applied function representing the nth termrSrGr3s r'r zRecursiveSeq.ynbrr0c|jjS)z3Undefined function for the nth term of the sequence)r rPr3s r'rzRecursiveSeq.ygsw|r0c|jdS)zSequence index symbolrrGr3s r'rzRecursiveSeq.nlrr0c|jdS)z"The initial values of the sequencerrGr3s r'rUzRecursiveSeq.initialqrr0c|jdS)r7rGr3s r'r#zRecursiveSeq.startvrr0ctjS)z&The ending point of the sequence. (oo))rr%r3s r'r9zRecursiveSeq.stop{s zr0c(|jtjfS)z&Interval on which sequence is defined.)r#rr%r3s r'r*zRecursiveSeq.intervals AJ''r0c||jz t|jkr |j||St t|j|dzD]d}|j|z}|j|j|i}||j}||j||<e|j||j|zSr)r#rr rrwrxreplacer)r-r~current seq_indexcurrent_recurrencenew_terms r'rKzRecursiveSeq._eval_coeffs 4: DJ / /:dffUmm, ,S__eai88 5 5G W,I!%!1!:!:DFI;N!O!O )224:>>H,4DJtvvi(( ) )z$&&g!56677r0c#PK|j} ||V|dz })NTrS)r#rK)r-r~s r'rxzRecursiveSeq.__iter__s:  ""5)) ) ) ) QJE r0r)rrrrrrrr r rrrUr#r9r*rKrxr=r0r'rrsGJJX3333jX))X)XXXXXX((X( 8 8 8r0rNct|}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)rrs r'sequencer'sA4 #,,C3'c6"""#v&&&r0ceZdZdZedZedZedZedZedZ edZ 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 c>td|jDS)zjGenerator for the sequence. returns a tuple of generators of all the argument sequences. c3$K|] }|jV dSrhrrCas r'rz SeqExprOp.gen..s$..qQU......r0)rrHr3s r'r4z SeqExprOp.gens# ..DI......r0c2td|jDS)zeSequence is defined on the intersection of all the intervals of respective sequences c3$K|] }|jV dSrhr*r,s r'rz%SeqExprOp.interval..s$<r,s r'r{z'SeqExprOp.variables..s===aak===r0)rrrHr3s r'r>zSeqExprOp.variabless+W==49===>>???r0c&|j|jz dzSrrr3s r'r;zSeqExprOp.lengthrr0N) rrrrrr4r*r#r9r>r;r=r0r'r)r)s0//X/>>X> !!X!!!X!@@X@**X***r0r)c4eZdZdZdZedZdZdS)reaRepresents 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|dtj}t|}fd|}d|D}|s tjSt d|Dtjur tjS|rt |Stt|tj }tj|g|RS)Nevaluatect|tr;t|tr#tt |jgS|gSt |rtt |gStdNz2Input must be Sequences or iterables of Sequences)rbr resummaprHrrcarg_flattens r'r?z SeqAdd.__new__.._flatten s#w'' !c6**!s8SX66;;;5L}} 33x--r222677 7r0c.g|]}|tju|Sr=)rrr,s r'r{z"SeqAdd.__new__..,s$<<.2$33!*333333r0)getrr8listrrrrrereducerr r(rrrrHrr8r?s @r'rzSeqAdd.__new__s::j*;*DEEDzz 7 7 7 7 7x~~<<4<<< #? " 33d333 4 B B? "  '==&& &GD'"45566}S(4((((r0cnd}|rxt|D]f\}d}t|D]I\}||kr }|&fd|D}||nJ|r|}ng|xt|dkr|St |dS)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`` TFNc g|] }|fv| Sr=r=rCr-srs r'r{z!SeqAdd.reduce..U"#G#G#G!qAAr0rSr8)r rZrrrrerHnew_argsid1id2new_seqrJrs @@r'rEz SeqAdd.reduce=s #D//  Q 'oo  FCczz ffQiiG*#G#G#G#G#Gt#G#G#G 000+#DE " t99>>88:: $/// /r0cDtfd|jDS)z9adds up the coefficients of all the sequences at point ptc3BK|]}|VdSrh)rN)rCr-rMs r'rz%SeqAdd._eval_coeff..cs-2211772;;222222r0)r;rHrLs `r'rKzSeqAdd._eval_coeffas(2222 222222r0NrrrrrrrErKr=r0r'reresY8")")")H!0!0\!0F33333r0rec4eZdZdZdZedZdZdS)rra'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 c|dtj}t|}fd|}|s tjSt d|Dtjur tjS|rt |Stt|tj }tj|g|RS)Nr8ct|tr;t|tr#tt |jgS|gSt |rtt |gStdr:)rbr rrr;r<rHrrcr=s r'r?z SeqMul.__new__.._flattens#w'' 3c6**!s8SX66;;;5L# 33x--r222677 7r0c3$K|] }|jV dSrhr0r,s r'rz!SeqMul.__new__..rBr0)rCrr8rDrrrrrrrErr r(rrrFs @r'rzSeqMul.__new__s::j*;*DEEDzz 7 7 7 7 7x~~ #? " 33d333 4 B B? "  '==&& &GD'"45566}S(4((((r0cnd}|rxt|D]f\}d}t|D]I\}||kr }|&fd|D}||nJ|r|}ng|xt|dkr|St |dS)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`` TFNc g|] }|fv| Sr=r=rIs r'r{z!SeqMul.reduce..rKr0rSrL)r r]rrrrrrMs @@r'rEz SeqMul.reduces  #D//  Q 'oo  FCczz ffQiiG*#G#G#G#G#Gt#G#G#G 000+#DE " t99>>88:: $/// /r0cNd}|jD]}|||z}|S)zros[""""""$$$$$$''''''77777733333344444444&&&&&&$$$$$$--------&&&&&&1111111111&&&&&&!!!!!!########22222222$$$$$$DDDDDDDDDD^=^=^=^=^=e^=^=^=@ """""Gy""""J0"0"0"0"0"g0"0"0"fN)N)N)N)N)WN)N)N)bqOqOqOqOqOqOqOqOfBBBBB7BBBJ''''N7*7*7*7*7*7*7*7*tg3g3g3g3g3Yg3g3g3TqqqqqYqqqqqr0