a RG5d@sJddlmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZddlmZdd lmZmZdd lmZdd lmZmZdd lmZddlmZddlmZddl m!Z!m"Z"m#Z#m$Z$ddl%m&Z&ddl'm(Z(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?m@Z@ddlAmBZBmCZCmDZDddlEmFZFddlGmHZHdd lImJZJdd!lKmLZLdd"lMmNZNmOZOdd#lPmQZQdd$lRZRGd%d&d&e eZSd'd(ZTd)d*ZUd+d,ZVd-d.ZWd/d0ZXd1d2ZYd3d4ZZd5d6Z[d7d8Z\d9d:Z]d;d<Z^d$S)=)Tuple) is_decreasing)AccumulationBounds)ExprWithIntLimits) AddWithLimits) gosper_sum)Expr)Add) Derivativeexpand)Mul)Float_illegal)Eq)S)ordered)DummyWildSymbolsymbols) factorial) bernoulliharmonic)explog) Piecewise)cotcsc)hyper)KroneckerDelta)zeta)Integral)And)apart)PolynomialErrorPolificationFailed)parallel_poly_from_exprPolyfactor)together) limit_seq)Oresidue) FiniteSetInterval)siftNc@seZdZUdZdZeeeeefed<ddZ ddZ dd Z d d Z d d Z ddZddZddZddZddZddZddZddZd'd d!Zd"d#Zd$d%Zd&S)(SumaN Represents unevaluated summation. Explanation =========== ``Sum`` represents a finite or infinite series, with the first argument being the general form of terms in the series, and the second argument being ``(dummy_variable, start, end)``, with ``dummy_variable`` taking all integer values from ``start`` through ``end``. In accordance with long-standing mathematical convention, the end term is included in the summation. Finite sums =========== For finite sums (and sums with symbolic limits assumed to be finite) we follow the summation convention described by Karr [1], especially definition 3 of section 1.4. The sum: .. math:: \sum_{m \leq i < n} f(i) has *the obvious meaning* for `m < n`, namely: .. math:: \sum_{m \leq i < n} f(i) = f(m) + f(m+1) + \ldots + f(n-2) + f(n-1) with the upper limit value `f(n)` excluded. The sum over an empty set is zero if and only if `m = n`: .. math:: \sum_{m \leq i < n} f(i) = 0 \quad \mathrm{for} \quad m = n Finally, for all other sums over empty sets we assume the following definition: .. math:: \sum_{m \leq i < n} f(i) = - \sum_{n \leq i < m} f(i) \quad \mathrm{for} \quad m > n It is important to note that Karr defines all sums with the upper limit being exclusive. This is in contrast to the usual mathematical notation, but does not affect the summation convention. Indeed we have: .. math:: \sum_{m \leq i < n} f(i) = \sum_{i = m}^{n - 1} f(i) where the difference in notation is intentional to emphasize the meaning, with limits typeset on the top being inclusive. Examples ======== >>> from sympy.abc import i, k, m, n, x >>> from sympy import Sum, factorial, oo, IndexedBase, Function >>> Sum(k, (k, 1, m)) Sum(k, (k, 1, m)) >>> Sum(k, (k, 1, m)).doit() m**2/2 + m/2 >>> Sum(k**2, (k, 1, m)) Sum(k**2, (k, 1, m)) >>> Sum(k**2, (k, 1, m)).doit() m**3/3 + m**2/2 + m/6 >>> Sum(x**k, (k, 0, oo)) Sum(x**k, (k, 0, oo)) >>> Sum(x**k, (k, 0, oo)).doit() Piecewise((1/(1 - x), Abs(x) < 1), (Sum(x**k, (k, 0, oo)), True)) >>> Sum(x**k/factorial(k), (k, 0, oo)).doit() exp(x) Here are examples to do summation with symbolic indices. You can use either Function of IndexedBase classes: >>> f = Function('f') >>> Sum(f(n), (n, 0, 3)).doit() f(0) + f(1) + f(2) + f(3) >>> Sum(f(n), (n, 0, oo)).doit() Sum(f(n), (n, 0, oo)) >>> f = IndexedBase('f') >>> Sum(f[n]**2, (n, 0, 3)).doit() f[0]**2 + f[1]**2 + f[2]**2 + f[3]**2 An example showing that the symbolic result of a summation is still valid for seemingly nonsensical values of the limits. Then the Karr convention allows us to give a perfectly valid interpretation to those sums by interchanging the limits according to the above rules: >>> S = Sum(i, (i, 1, n)).doit() >>> S n**2/2 + n/2 >>> S.subs(n, -4) 6 >>> Sum(i, (i, 1, -4)).doit() 6 >>> Sum(-i, (i, -3, 0)).doit() 6 An explicit example of the Karr summation convention: >>> S1 = Sum(i**2, (i, m, m+n-1)).doit() >>> S1 m**2*n + m*n**2 - m*n + n**3/3 - n**2/2 + n/6 >>> S2 = Sum(i**2, (i, m+n, m-1)).doit() >>> S2 -m**2*n - m*n**2 + m*n - n**3/3 + n**2/2 - n/6 >>> S1 + S2 0 >>> S3 = Sum(i, (i, m, m-1)).doit() >>> S3 0 See Also ======== summation Product, sympy.concrete.products.product References ========== .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM, Volume 28 Issue 2, April 1981, Pages 305-350 http://dl.acm.org/citation.cfm?doid=322248.322255 .. [2] https://en.wikipedia.org/wiki/Summation#Capital-sigma_notation .. [3] https://en.wikipedia.org/wiki/Empty_sum limitscOsHtj||g|Ri|}t|ds(|Stdd|jDrDtd|S)Nr4css"|]}t|dkpd|vVqdS)N)len).0lr3r3U/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/concrete/summations.py zSum.__new__..z/Sum requires values for lower and upper bounds.)r__new__hasattranyr4 ValueError)clsfunctionr assumptionsobjr3r3r9r<s  z Sum.__new__cCs|jjs|jrdSdSNT)rAis_zerohas_empty_sequenceselfr3r3r9 _eval_is_zeroszSum._eval_is_zerocCs|jr dS|jjSrD)rFrAis_extended_realrGr3r3r9_eval_is_extended_realszSum._eval_is_extended_realcCs|jr|jdur|jjSdSNF)has_finite_limitshas_reversed_limitsrA is_positiverGr3r3r9_eval_is_positiveszSum._eval_is_positivecCs|jr|jdur|jjSdSrL)rMrNrA is_negativerGr3r3r9_eval_is_negativeszSum._eval_is_negativecCs|jr|jjrdSdSrD)rMrA is_finiterGr3r3r9_eval_is_finiteszSum._eval_is_finitec s|ddr |jjfi|}n|j}i}|jD]}t|}|r0|||d<q0|rdd|D||jfi|}t|trtfdd|D}n|dur|}n|}|S|jj r| }||kr|St |St |jD]\}} | \} } } | | } | dkrt jS| jr@| jr@| d | d } } | }t|| | | f}|dur||jkr||| | | f}|dur|S|S|j|g|j|dRS|}q|ddrt|ts|jfi|S|S) NdeepTrcSsi|]\}}||qSr3r3)r7kvr3r3r9 r;zSum.doit..csg|]}|qSr3xreplacer7iundor3r9 r;zSum.doit..r)getrAdoitr4)_dummy_with_inherited_properties_concreteitemsrZ isinstancetuple is_Matrixr _eval_matrix_sum enumeraterZero is_integerrQeval_sumeval_zeta_functionfuncr)rHhintsfrepsxabddidexpandednlimitr\abdifnewfZ zeta_functionr3r]r9rbsV            zSum.doitc Cs|\}}}td|gdtd|gdtd|gd}}}||||| } | dur|tjurd| || |} | |} | || ||} t| t| | t| dk| dkf|dfSdS) z Check whether the function matches with the zeta function. If it matches, then return a `Piecewise` expression because zeta function does not converge unless `s > 1` and `q > 0` wexcludeyzNrrT)rmatchrInfinityrr!r#) rHrpr4r\rxryr|rrresultcoeffsqr3r3r9rms .zSum.eval_zeta_functionc Cst|tr||jvrtjS|jt|j}}|d}|rL|j |g|R}|\}}}||jvsj||jvrndSt ||dd}| ||} | S)a Differentiate wrt x as long as x is not in the free symbols of any of the upper or lower limits. Explanation =========== Sum(a*b*x, (x, 1, a)) can be differentiated wrt x or b but not `a` since the value of the sum is discontinuous in `a`. In a case involving a limit variable, the unevaluated derivative is returned. r`NT)evaluate) rer free_symbolsrrjrAlistr4poprnr ) rHxrpr4rw_rxrydfrvr3r3r9_eval_derivatives   zSum._eval_derivativecCsf|jd\}}}||||}t|jdkr:|jd}n|j|jdd}t|||d|fS)Nr`rr)argssubsr6rnr2rb)rHrvsteprVrupperZ new_upperrpr3r3r9_eval_difference_deltaBs  zSum._eval_difference_deltac Kstt|j}g}g}|D]h}|trztt|}g}|D](}t|tr^|| q@||q@|t|q||qddl m } m } t| |g|R} | | |j dS)Nr) factor_sum sum_combine)r4)r make_argsr rAhasr2r reappend_eval_simplifysympy.simplify.simplifyrrr4) rHkwargstermsZs_tZo_ttermZsubtermsZ out_termsZsubtermrrrr3r3r9rMs     zSum._eval_simplifyc)stdtd\}}}|jdd|jdd|jdd|j}t|jdkr\tdjrnjrnt j St j urڈt j urt |dt j fot |t j dfSddlm}|| i} t j tjddd }||i}|t|jr^|jD]B\}}|dks8|jt j urt |f} | Sqt j Sz,t|} | d ur| jd urt jWSWntyYn0z0tt|} | d ur| jd urt jWSWntyYn0t|t j f} | j|} | d ur8| |d kr$t j S| |d kr8t jS| jd|td|ttd |p| jd|td |ttd |}|d ur"||dks||dkr||dks||||krdkrnn||dkrt j St jSz6t|}|d urV|j rV|dkrVt jWSWntylYn0|di}dd l!m"}ddl#m$}||||}zLt|}|d ur|j rt|dkrt jWSt|dkrt j WSWnty d }Yn0|dkr||%dd}|&}zDt|} | d ur~| j r~| dkrlt j WS| dkr~t jWSWntyYn0zPtt|d}|d ur|j r|dkrt j WS|dkrt jWSWntyYn0|t j'||}||(s:t)||r:t j Sd }ddl*m+}||,}|sh}n$t-|t.r|jj rt|jj}|d urt)||st)| |rt/|f}z |0}|j rt |jWSWntyYn0| jj1r| jj}t2|}tdddfdd}fdd} t3dt|D]}!t45||!D]l}"|t2|"}#t6|"}$t6|#}%t)|$r||%}&|&d ur|&S| |$|%}'|'d urZ|'SqZqJ|jdd}(||(i}td|d S)ah Checks for the convergence of a Sum. Explanation =========== We divide the study of convergence of infinite sums and products in two parts. First Part: One part is the question whether all the terms are well defined, i.e., they are finite in a sum and also non-zero in a product. Zero is the analogy of (minus) infinity in products as :math:`e^{-\infty} = 0`. Second Part: The second part is the question of convergence after infinities, and zeros in products, have been omitted assuming that their number is finite. This means that we only consider the tail of the sum or product, starting from some point after which all terms are well defined. For example, in a sum of the form: .. math:: \sum_{1 \leq i < \infty} \frac{1}{n^2 + an + b} where a and b are numbers. The routine will return true, even if there are infinities in the term sequence (at most two). An analogous product would be: .. math:: \prod_{1 \leq i < \infty} e^{\frac{1}{n^2 + an + b}} This is how convergence is interpreted. It is concerned with what happens at the limit. Finding the bad terms is another independent matter. Note: It is responsibility of user to see that the sum or product is well defined. There are various tests employed to check the convergence like divergence test, root test, integral test, alternating series test, comparison tests, Dirichlet tests. It returns true if Sum is convergent and false if divergent and NotImplementedError if it cannot be checked. References ========== .. [1] https://en.wikipedia.org/wiki/Convergence_tests Examples ======== >>> from sympy import factorial, S, Sum, Symbol, oo >>> n = Symbol('n', integer=True) >>> Sum(n/(n - 1), (n, 4, 7)).is_convergent() True >>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent() False >>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent() False >>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent() True See Also ======== Sum.is_absolutely_convergent() sympy.concrete.products.Product.is_convergent() zp q r)r@rrrzNconvergence checking for more than one symbol containing series is not handledsimplifyTintegerpositiveNFr`combsimp)powsimp)solvesetm)rcsNz6tt|jf}|dur4|jr4tjWSWntyHYn0dSN)r+r2infrbrSrtrueNotImplementedError)Zg_nZing_val)intervalrsymr3r9_dirichlet_testks   z*Sum.is_convergent.._dirichlet_testcshzPt|}|durN|js2t|trN|j|jjrNt|frNtj WSWnt ybYn0dSr) r+rSrermaxminr2is_absolutely_convergentrrr)Zg1_nZg2_nlim_val) lower_limitr upper_limitr3r9_bounded_convergent_testts    z3Sum.is_convergent.._bounded_convergent_testzFThe algorithm to find the Sum convergence of %s is not yet implemented)7rrr4rArr6rrrSrrNegativeInfinityrr2 is_convergentrrZrnamer0 is_Piecewiseras_setsupr+rEfalseabsr,exprrr is_numbersympy.simplify.combsimprsympy.simplify.powsimprr gammasimp NegativeOnerrsympy.solvers.solvesetrdiffrer/r"rbis_Mulsetrange itertools combinationsr ))rHprr sequence_termrZsym_rncondrrZ lim_val_absorderZ p_series_testZ n_log_testZlim_compZnext_sequence_termrrratioZ lim_ratioZtest_valZ lim_evaluatedZdict_valZcheck_intervalrmaximaZ integral_valZintegral_val_evaluatedrargsetrrrvZa_tupleZb_seta_nb_nZdirichZbc_test_symr3)rrrrrr9ros6J          <:                                   zSum.is_convergentcCstt|j|jS)az Checks for the absolute convergence of an infinite series. Same as checking convergence of absolute value of sequence_term of an infinite series. References ========== .. [1] https://en.wikipedia.org/wiki/Absolute_convergence Examples ======== >>> from sympy import Sum, Symbol, oo >>> n = Symbol('n', integer=True) >>> Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent() False >>> Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent() True See Also ======== Sum.is_convergent() )r2rrAr4rrGr3r3r9rszSum.is_absolutely_convergentrTcst|}t|}|jt|jdkr,td|jd\kdkrxdkr`tjtjfSdd tj}|rjrjrt|d}|r rt fddt |D}n }|rt |d|k}|dkr |t |fS|dks|tjfS|}t d|D]L} |}t |d|krn|dkrn|t |fS||7}q,d|kr|tjfS|7td } t | | f} |r| } || 7}fd d } | \} } | | d }}t d|d D]}| |\}}td |td |||}||krTq|r|r|d}|tjurtjtjfSt ||krq||7}|jd dd }q||t |fS)a Return an Euler-Maclaurin approximation of self, where m is the number of leading terms to sum directly and n is the number of terms in the tail. With m = n = 0, this is simply the corresponding integral plus a first-order endpoint correction. Returns (s, e) where s is the Euler-Maclaurin approximation and e is the estimated error (taken to be the magnitude of the first omitted term in the tail): >>> from sympy.abc import k, a, b >>> from sympy import Sum >>> Sum(1/k, (k, 2, 5)).doit().evalf() 1.28333333333333 >>> s, e = Sum(1/k, (k, 2, 5)).euler_maclaurin() >>> s -log(2) + 7/20 + log(5) >>> from sympy import sstr >>> print(sstr((s.evalf(), e.evalf()), full_prec=True)) (1.26629073187415, 0.0175000000000000) The endpoints may be symbolic: >>> s, e = Sum(1/k, (k, a, b)).euler_maclaurin() >>> s -log(a) + log(b) + 1/(2*b) + 1/(2*a) >>> e Abs(1/(12*b**2) - 1/(12*a**2)) If the function is a polynomial of degree at most 2n+1, the Euler-Maclaurin formula becomes exact (and e = 0 is returned): >>> Sum(k, (k, 2, b)).euler_maclaurin() (b**2/2 + b/2 - 1, 0) >>> Sum(k, (k, 2, b)).doit() b**2/2 + b/2 - 1 With a nonzero eps specified, the summation is ended as soon as the remainder term is less than the epsilon. rzMore than 1 limitrTcsg|]}|qSr3r)r7rV)rxrpr\r3r9r_r;z'Sum.euler_maclaurin..r5Frcs2tjur|dfS||fS)Nr)rrr)r)rxryr\r3r9fpoints z#Sum.euler_maclaurin..fpointrr)intrAr6r4r?rrj is_Integerr is_polynomialr rrrevalfrr"rbrrrNaN)rHrrveps eval_integralrrtestrVrIrfafbZitermggagbZ term_evalfr3)rxryrpr\r9euler_maclaurinsp+                     zSum.euler_maclaurinc Gst|}t|D] \}}t|ts||||<qd}g}t|jD]B\}}|}||vr|| }|d|dd|ddf}||qDt||jg|RS)ab Reverse the order of a limit in a Sum. Explanation =========== ``reverse_order(self, *indices)`` reverses some limits in the expression ``self`` which can be either a ``Sum`` or a ``Product``. The selectors in the argument ``indices`` specify some indices whose limits get reversed. These selectors are either variable names or numerical indices counted starting from the inner-most limit tuple. Examples ======== >>> from sympy import Sum >>> from sympy.abc import x, y, a, b, c, d >>> Sum(x, (x, 0, 3)).reverse_order(x) Sum(-x, (x, 4, -1)) >>> Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(x, y) Sum(x*y, (x, 6, 0), (y, 7, -1)) >>> Sum(x, (x, a, b)).reverse_order(x) Sum(-x, (x, b + 1, a - 1)) >>> Sum(x, (x, a, b)).reverse_order(0) Sum(-x, (x, b + 1, a - 1)) While one should prefer variable names when specifying which limits to reverse, the index counting notation comes in handy in case there are several symbols with the same name. >>> S = Sum(x**2, (x, a, b), (x, c, d)) >>> S Sum(x**2, (x, a, b), (x, c, d)) >>> S0 = S.reverse_order(0) >>> S0 Sum(-x**2, (x, b + 1, a - 1), (x, c, d)) >>> S1 = S0.reverse_order(1) >>> S1 Sum(x**2, (x, b + 1, a - 1), (x, d + 1, c - 1)) Of course we can mix both notations: >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) Sum(x*y, (x, b + 1, a - 1), (y, 6, 1)) >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) Sum(x*y, (x, b + 1, a - 1), (y, 6, 1)) See Also ======== sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit, sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder References ========== .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM, Volume 28 Issue 2, April 1981, Pages 305-350 http://dl.acm.org/citation.cfm?doid=322248.322255 rrr) rrirerindexr4rr2rA) rHindices l_indicesr\indxer4rwr8r3r3r9 reverse_orders>  zSum.reverse_ordercOs4ddlm}|jjr0t|t|jg|jRSdS)Nr)Product)sympy.concrete.productsrrArJrrr4)rHrrrr3r3r9_eval_rewrite_as_Productjs zSum._eval_rewrite_as_ProductN)rrrT)__name__ __module__ __qualname____doc__ __slots__tTuplerr __annotations__r<rIrKrPrRrTrbrmrrrrrrrrr3r3r3r9r2(s,  =# "& kOr2cOst|g|Ri|jddS)a Compute the summation of f with respect to symbols. Explanation =========== The notation for symbols is similar to the notation used in Integral. summation(f, (i, a, b)) computes the sum of f with respect to i from a to b, i.e., :: b ____ \ ` summation(f, (i, a, b)) = ) f /___, i = a If it cannot compute the sum, it returns an unevaluated Sum object. Repeated sums can be computed by introducing additional symbols tuples:: Examples ======== >>> from sympy import summation, oo, symbols, log >>> i, n, m = symbols('i n m', integer=True) >>> summation(2*i - 1, (i, 1, n)) n**2 >>> summation(1/2**i, (i, 0, oo)) 2 >>> summation(1/log(n)**n, (n, 2, oo)) Sum(log(n)**(-n), (n, 2, oo)) >>> summation(i, (i, 0, n), (n, 0, m)) m**3/6 + m**2/2 + m/3 >>> from sympy.abc import x >>> from sympy import factorial >>> summation(x**n/factorial(n), (n, 0, oo)) exp(x) See Also ======== Sum Product, sympy.concrete.products.product F)rU)r2rb)rprrr3r3r9 summationps2rcs,|\tfddt|DS)a Returns the direct summation of the terms of a telescopic sum Explanation =========== L is the term with lower index R is the term with higher index n difference between the indexes of L and R Examples ======== >>> from sympy.concrete.summations import telescopic_direct >>> from sympy.abc import k, a, b >>> telescopic_direct(1/k, -1/(k+2), 2, (k, a, b)) -1/(b + 2) - 1/(b + 1) + 1/(a + 1) + 1/a cs,g|]$}||qSr3r)r7rLRrxryr\r3r9r_r;z%telescopic_direct..)r r)rrrvr4r3rr9telescopic_directs rc s:|\}}jsjrdStd} |}d}|rt||vrt||}|jrp|dkstd}|durtd}z.ddlm} | ||pg}WntyYdS0fdd|D}t |dkrdS|d}|dkrt t |||fS|dkr6t |||fSdS) zi Tries to perform the summation using the telescopic property. Return None if not possible. NrVrrsolvecs0g|](}|jr|jr|qSr3)rrr rE)r7sirrr\r3r9r_sztelescopic..r) is_Addrrrrrsympy.solvers.solversrrr6rr) rrr4rxryrVsolrrrr3rr9 telescopics2    "    rc sj|\}}|jrtjS|jvr0|||dS||krD||St|trtfdd|jDsg}|jD].}t |j |}|durdS| ||j fqp|j |S|trddlm}m}|dddd}|||dr|||S||} | j} | r| d krt|||fSt|tr.dSt|||f} | durP| S| rft|||fSdS) Nrc3s|]}|jdjvVqdS)rN)rr)r7argr\r3r9r:r;zeval_sum..)deltasummation_has_simple_deltacSs t|tSr)rer2rr3r3r9r;zeval_sum..cSs|Sr)r)r r3r3r9r r;rd)rErrjrrrerr>rrlrrrrnrr deltarr replacereval_sum_directeval_sum_symbolicr ) rpr4rxrynewargsrnewexprrr rzdefinitevaluer3rr9rlsF           rlcs|\}|}jr\}}|dkrZt||f}|r||}|tjur|SnX\}} |st| |f} | r|| S| st||f} | r| | SztWntyYn0j r~\}}|dkr,t||f}|r~||d|}|tjur~|SnR\}} t||f} t| |f} d| | fvr~| | }|tjur~|St fddt |dDS)z Evaluate expression directly, but perform some simple checks first to possibly result in a smaller expression and faster execution. rrNcsg|]}|qSr3r)r7jrxrr\r3r9r_Wr;z#eval_sum_direct..) ras_independentrrr as_two_termsrr$r%rr r)rr4ryrz without_iwith_irrrrsRsLlsumrsumr3rr9rsN          rc& Cs$|}|\}}}||s(|||dS|jr||\}}|dkrpt||||f}|r||} | tjur| SnX|\} } | |st| |||f} | r| | S| |st| |||f} | r| | Szt||}WntyYn0|j r|\} } t | | |||f}|r|S||\}}|dkrnt||||f}|r|||d|} | tjur| SnFt| |||f}t| |||f}d||fvr||} | tjur| St d}| ||}|dur||}|j r|dkrP|tjur|tjus|tjur$|tjur$tjSt|d|dt|d||dS|j r|dkr|dkrt|t|dSt|t|t|dt|S|tjtjs|tjtjst d|gd}t d|gd}t d|gd}t d }| ||}|dur|| |||}|dur|||||}|||}|||||dd|} |||d}t|t|tjf| d fSt||||f} t| ttfrdd lm }dd l!m"}| j#t$|ddj#}|t%| }||j#@} g}!t&| D]|}"zZ|||"}|r>t|"|dntj'}#|#d krn|!(t)|j|#j*|+|#fWqWnt,yYqYn0q|!(| d ft|!S| dtjfvr| St-||||f}$|$dur|$St.||||f} | dur| S|/}%|%|kr t|%|||fSdS)Nrrrvr`c1r}c2c3wexpT)denomrF)0rrrrrrrr$r%rrrrrrrrr rrrrupdaterrrOnerrer r sympy.simplify.radsimpr#rrrrr*rrrr2rrbreval_sum_hypereval_sum_residuer))&rpr4Zf_origr\rxryrrrrrrrrZlrsumrrrvrrr r!r"rZe_exprrr8r#rZ non_limitdenZden_symrrWrhfactoredr3r3r9rZs             ,                  rc Cs|dkr t|||||dS||ddkr|ddlm}|||tdddddkrdtjdfSt|||d|dSddlm}|||}|durdSt|t rdd lm }||}dd l m }dd l m}dd lm} | t|\} } | |\} } | |\}}| |g}| |g}ggg}td D]}||D]}d}|jrd|j}|j}|jsddSt||}|dkrdS|\}}||||9<||||g|7<q8q,|ddg}|d}|d|d}t|||}||}||d|||jfS)z) Returns (res, cond). Sums from a to oo. rrr\Trr) hypersimpN) nsimplifyr) hyperexpand)fractionr)_eval_sum_hyperrrrrrrjr,rerr-rrsympy.simplify.hyperexpandr.r&r/r) as_coeff_mulris_Powrbaserr(degree all_coeffsrconvergence_statement)rpr\rxrr,hsr-rr.r/numerr#topZtoplbotZbotlabfactorsparamsrVfacmulrrrvapbqrr*r3r3r9r0sV             " r0cCs4|\}}}||durdS||jr*dSt||||f}|tjkr|tjurt||| || }|dur~t||dfSndd}||}t|||} | dus|| |krdSt|||d} | dus|| |krdS| | \} } \} } t | | } | dkrdSt| | | f|dfS|tjurt||| |d} t||d} | dus^| durbdS| \} } | \} } t | | } | dks| tj krdSt| | | f|dfSt|||}|dur0|\}}|dkr"|j r||t dddd|}|js |jrtjS|jrtjSdSt||dfSdS) NFTcstfddtDS)Nc3s|]}|VqdSr)count)r7rr r3r9r:3r;z3eval_sum_hyper....)sumrr r3r r9r 3r;z eval_sum_hyper..rrr\r)is_hypergeometricrr2rrrr0rrr#rEmptySetrrrOrErQ)rpi_a_br\rxryZold_sumresZ n_illegalZhadres1res2Zcond1cond2rrcr3r3r9r'!s^             r'cs|\}}dd}dd}dd}fdd}td fd d }jtgrXd S|jsr|tjtjfvsrd S|js|tjtjfvsd S|tjkr|tjkrd S|} | rd } | \} } n*|tj} | rd} | \} } nd S| | dkrd S||ftjtjfkrv|| } | d ur4d S| \}}|rFd S|| | | fdd|D}tj t |S|j r|tjusd S|| | s4|| }|jsd S|dkrd S| |} | |} || | sd S| r tjtj|| | n| | t||||fS|| } | d urJd S| \}}|rdd|D}t|}t|}t|||dksd S|t|krd S|| | | fdd||D}tj t |}|sF|did}fddtt|dD}fddtdt|D}|t |t |}|S|d}fddtt|dt|D}|t |}|S)aCompute the infinite summation with residues Notes ===== If $f(n), g(n)$ are polynomials with $\deg(g(n)) - \deg(f(n)) \ge 2$, some infinite summations can be computed by the following residue evaluations. .. math:: \sum_{n=-\infty, g(n) \ne 0}^{\infty} \frac{f(n)}{g(n)} = -\pi \sum_{\alpha|g(\alpha)=0} \text{Res}(\cot(\pi x) \frac{f(x)}{g(x)}, \alpha) .. math:: \sum_{n=-\infty, g(n) \ne 0}^{\infty} (-1)^n \frac{f(n)}{g(n)} = -\pi \sum_{\alpha|g(\alpha)=0} \text{Res}(\csc(\pi x) \frac{f(x)}{g(x)}, \alpha) Examples ======== >>> from sympy import Sum, oo, Symbol >>> x = Symbol('x') Doubly infinite series of rational functions. >>> Sum(1 / (x**2 + 1), (x, -oo, oo)).doit() pi/tanh(pi) Doubly infinite alternating series of rational functions. >>> Sum((-1)**x / (x**2 + 1), (x, -oo, oo)).doit() pi/sinh(pi) Infinite series of even rational functions. >>> Sum(1 / (x**2 + 1), (x, 0, oo)).doit() 1/2 + pi/(2*tanh(pi)) Infinite series of alternating even rational functions. >>> Sum((-1)**x / (x**2 + 1), (x, 0, oo)).doit() pi/(2*sinh(pi)) + 1/2 This also have heuristics to transform arbitrarily shifted summand or arbitrarily shifted summation range to the canonical problem the formula can handle. >>> Sum(1 / (x**2 + 2*x + 2), (x, -1, oo)).doit() 1/2 + pi/(2*tanh(pi)) >>> Sum(1 / (x**2 + 4*x + 5), (x, -2, oo)).doit() 1/2 + pi/(2*tanh(pi)) >>> Sum(1 / (x**2 + 1), (x, 1, oo)).doit() -1/2 + pi/(2*tanh(pi)) >>> Sum(1 / (x**2 + 1), (x, 2, oo)).doit() -1 + pi/(2*tanh(pi)) References ========== .. [#] http://www.supermath.info/InfiniteSeriesandtheResidueTheorem.pdf .. [#] Asmar N.H., Grafakos L. (2018) Residue Theory. In: Complex Analysis with Applications. Undergraduate Texts in Mathematics. Springer, Cham. https://doi.org/10.1007/978-3-319-94063-2_5 cSshtdd|D}tdd|D}tdd|D}tdd|D}|r`|pf|of|S)z1Test if the rational function is an even functioncss|]\}|ddkVqdSrrNr3r[r3r3r9r:r;z=eval_sum_residue..is_even_function..css|]\}|ddkVqdSrMr3r[r3r3r9r:r;css|]\}|ddkVqdSrrNr3r[r3r3r9r:r;css|]\}|ddkVqdSrNr3r[r3r3r9r:r;)allmonoms)r9r#Z numer_evenZ denom_evenZ numer_oddZ denom_oddr3r3r9is_even_functions z*eval_sum_residue..is_even_functionc SsH|\}}zt||f|\\}}}Wnttfy>YdS0||fSr)as_numer_denomr'r&r%)rpr\r9r#optr3r3r9match_rationals  z(eval_sum_residue..match_rationalcSs@|}t|dd}d|vr&dS|d|d}}||fS)NcSs|jSr)rkr r3r3r9r r;z5eval_sum_residue..get_poles..TF)sqf_part all_rootsr1)r#roots int_roots nonint_rootsr3r3r9 get_poless  z#eval_sum_residue..get_polescs<|}||}||d}| ||}|S)Nr)r5coeff_monomial)r#rvrxryshiftrr3r9 get_shifts  z#eval_sum_residue..get_shiftrcsF||}|s0|ttj9}n|ttj9}|Sr)as_exprrrrPir)r9r# alternatingresidue_factor)r\rr3r9get_residue_factors z,eval_sum_residue..get_residue_factorNFTrcsg|]}t|qSr3r-r7rootrarr3r9r_r;z$eval_sum_residue..rcSsg|] }t|qSr3)rrcr3r3r9r_r;rcsg|]}t|qSr3r-rcrer3r9r_$r;csg|]}|iqSr3rYr7i0rpr\r3r9r_-r;csg|]}|iqSr3rYrfrhr3r9r_.r;csg|]}|iqSr3rYrfrhr3r9r_7r;)rrrrrrrrr5r_rDrSr\r^r(rrr6rZrr)rprGrxryrQrTrZr]rbrr`r9r#ZpolesrXrYresiduesr\Z int_roots_maxZ int_roots_minZfull_sumZhalf_sumZextraneous_negZextraneous_posrZ extraneousr3)rpr\rarr9r(]sE             &  & r(c Cs~|j}t|jD]h\}}|\}}}||}|jr|dkdkrT|d|d}}| }t||||f}|dur|SqdS)NrTr)rArir4rrrb) expressionrprvrwr\rxryrzr{r3r3r9rh=s  rhc s|\}}}||g}gd}i}i}|D]>|jd}|rFd|<q&tfdd|Dr&d|<q&|r||tdi|SdS)z Return a Dummy symbol that inherits as many assumptions as possible from the provided symbol and limits. If the symbol already has all True assumption shared by the limits then return None. )extended_nonnegative nonnegativeextended_nonpositive nonpositiveextended_positiverextended_negativenegativerrationalfinitezeroreal extended_realNTc3s|]}t|dVqdS)is_N)getattrr[Zassumr3r9r:dr;z<_dummy_with_inherited_properties_concrete..rs)rs) _assumptionsrarOr$r) r4rrxryr8Zassumptions_to_considerZassumptions_to_keepZassumptions_to_addZ assum_truer3ryr9rcLs    rc)_typingrrZsympy.calculus.singularitiesr!sympy.calculus.accumulationboundsrexpr_with_intlimitsrexpr_with_limitsrZgosperrsympy.core.exprr Zsympy.core.addr sympy.core.containerssympy.core.functionr r sympy.core.mulr sympy.core.numbersrrsympy.core.relationalrsympy.core.singletonrsympy.core.sortingrsympy.core.symbolrrrr(sympy.functions.combinatorial.factorialsr%sympy.functions.combinatorial.numbersrr&sympy.functions.elementary.exponentialrr$sympy.functions.elementary.piecewiser(sympy.functions.elementary.trigonometricrrsympy.functions.special.hyperr(sympy.functions.special.tensor_functionsr &sympy.functions.special.zeta_functionsr!sympy.integrals.integralsr"sympy.logic.boolalgr#sympy.polys.partfracr$sympy.polys.polyerrorsr%r&sympy.polys.polytoolsr'r(r)sympy.polys.rationaltoolsr*sympy.series.limitseqr+sympy.series.orderr,Zsympy.series.residuesr.sympy.sets.setsr/r0sympy.utilities.iterablesr1rr2rrrrlrrr0r'r(rhrcr3r3r3r9sn                          N5./@6<a