\c@ sddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZddlmZddlm Z ddl!m"Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7Z7dee fdYZ8dZ9dZ:dZ;d Z<d!Z=d"Z>d#Z?d$Z@dS(%i(tprint_functiontdivision(t is_decreasing(tAccumulationBounds(t AddWithLimits(tExprWithIntLimits(t gosper_sum(tAdd(trange(t Derivative(tMul(tEq(tS(tDummytWildtSymbol(tzeta(t Piecewise(tAnd(taparttPolynomialErrorttogether(t limit_seq(tO(t FiniteSet(tdenom(tcombsimp(tpowsimp(tsolve(tsolvesetNtSumcB seZdZdgZdZdZdZdZdZdZ de e e d Z d Z d Zd Zd d d edZdZRS(sRepresents unevaluated summation. ``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, 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 tis_commutativecO sWtj||||}t|ds+|Std|jDrStdn|S(Ntlimitscs s-|]#}t|dkp$d|kVqdS(iN(tlentNone(t.0tl((s8lib/python2.7/site-packages/sympy/concrete/summations.pys ss/Sum requires values for lower and upper bounds.(Rt__new__thasattrtanyR t ValueError(tclstfunctiontsymbolst assumptionstobj((s8lib/python2.7/site-packages/sympy/concrete/summations.pyR%s cC s|jjrtSdS(N(R*tis_zerotTrue(tself((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt _eval_is_zeros c K sv|jdtr'|jj|}n |j}|jjrL|jjSxt|jD]\}}|\}}}||}|jr|dktkr|d|d}}| }nt ||||f} | dkr7||jkr|j ||||f} | dk r| S|S|j ||j|Sn| }q\W|jdtrrt |tsr|j|Sn|S(Ntdeepii(tgetR/R*tdoitt is_Matrixtexpandt enumerateR t is_integerteval_sumR"teval_zeta_functiontfunct isinstanceR( R0thintstftntlimittitatbtdiftnewft zeta_function((s8lib/python2.7/site-packages/sympy/concrete/summations.pyR4s0       c C s|\}}}tdd|gtdd|gtdd|g}}}|j|||| } | dk r|tjkrd| || |} | |} | || ||} t| t| | t| dk| dkf|tfSdS(s 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` twtexcludetytziiN( RtmatchR"R tInfinityRRRR/( R0R>R RARBRCRGRIRJtresulttcoefftstq((s8lib/python2.7/site-packages/sympy/concrete/summations.pyR:sA c C st|tr%||jkr%tjS|jt|j}}|jd}|rh|j ||}nt |dkr|\}}}||jks||jkrdSt ||dt }|j ||} | StdSdS(sX Differentiate wrt x as long as x is not in the free symbols of any of the upper or lower limits. 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. iitevaluatesLower and upper bound expected.N(R<Rt free_symbolsR tZeroR*tlistR tpopR;R!R"R R/tNotImplementedError( R0txR>R R@t_RBRCtdftrv((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt_eval_derivativescC s|jd\}}}|j|||}t|jdkrQ|jd}n|j|jd }t|||d|fjS(Niiii(targstsubsR!R;RR4(R0R?tsteptkRXtuppert new_upperR>((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt_eval_difference_deltas g333333?cC s#ddlm}m}ddlm}ddlm}tj||j } g} g} x| D]} | j t r|j|| } g}x@| D]8}t |t r|j |jq|j |qW| j ||qa| j | qaWt|| | }||d|jS(Ni(t factor_sumt sum_combine(R6(R R (tsympy.simplify.simplifyRcRdtsympy.core.functionR6tsympy.core.mulR Rt make_argsR*thasRR<tappendt_eval_simplifyR (R0tratiotmeasuretrationaltinverseRcRdR6R ttermsts_tto_tttermtsubtermst out_termstsubtermRM((s8lib/python2.7/site-packages/sympy/concrete/summations.pyRks$  cC sdS(N(R"(R0R>RW((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt_eval_summation6sc* sddlm}m}m}m}m}|ddt\}}}|jdd|jdd|jdd|j} t | j dkrt dnj rj rt jSt jkrJt jkrt| dt jfjot| t jdfjS|| ji 6}  t jntjd td t} | ji| 6} | || jrx]| jD]R\} } | tks| jjt jkrt| f} | jSqWt jSy5t| }|dk r4|jtkr4t jSWnt k rHnXy;tt | }|dk r|jtkrt jSWnt k rnXt!| t jf}|j"j#|}|dk r||dkrt jS||dkrt jSn|j"j#d|}|dk rZ||dkr@t jS||dkrZt jSn|j"j#d||||||}|dk r||dks||dkr||dks||||kodknr ||dkr t jSt jSy?t| }|dk rR|j$rR|dkrRt jSWnt k rfnX| jid6}t%t&|| }y]t|}|dk r|j$rt |dkrt jSt |dkrt jSnWnt k rnXy_tt | d}|dk rf|j$rf|dkrPt jS|dkrft jSnWnt k rznX| j#d||}||j' rt(||rt jSd}t)| j*}|s}n3t+|t,r'|jj$r'||jj}n|dk rt(| |sRt(| |r|| f}y&|j-}|j$rt |j SWqt k rqXn|j"j.r|j"j}t/|}td d tfd } fd }!xt0dt |D]}"xt1j2||"D]{}#|t/|#}$t3|#}%t3|$}&t(|%r| |&}'|'dk r|'Sn|!|%|&}(|(dk r6|(Sq6WqWn|jdd})| ji|)6} t d| dS(s Checks for the convergence of a Sum. 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 can not 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() Product.is_convergent() i(tIntervaltIntegraltlogR+tsimplifysp q rR)iiisNconvergence checking for more than one symbol containing series is not handledtintegertpositivetmc sbyJtt|jfj}|dk rI|jrItjSWntk r]nXdS(N( RRtinfR4R"t is_finiteR ttrueRV(tg_nting_val(tintervalR~tsym(s8lib/python2.7/site-packages/sympy/concrete/summations.pyt_dirichlet_test&s *  c syrt|}|dk rq|jsIt|trq|j|jjrqt|fjrqt j SnWnt k rnXdS(N( RR"RR<RtmaxtminRtis_absolutely_convergentR RRV(tg1_ntg2_ntlim_val(t lower_limitRt upper_limit(s8lib/python2.7/site-packages/sympy/concrete/summations.pyt_bounded_convergent_test/s sFThe algorithm to find the Sum convergence of %s is not yet implementedN(4tsympyRxRyRzR+R{RR R*R!RRRVRR RtNegativeInfinityRLRt is_convergenttxreplaceR tnameR/t is_PiecewiseR\tas_settsupRR"R.tFalsetfalsetabsRtexprRKt is_numberRRRiRRtdiffR<RR4tis_MultsetRt itertoolst combinationsR (*R0RxRyRzR+R{tpRPtrt sequence_termtsym_R;tcondRORt lim_val_abstordertp1_series_testtp2_series_testt n_log_testtlim_comptnext_sequence_termRlt lim_ratiot lim_evaluatedtdict_valtcheck_intervaltmaximat integral_valtintegral_val_evaluatedR\targsetRRR?ta_tupletb_setta_ntb_ntdirichtbc_testt_sym((RRR~RRs8lib/python2.7/site-packages/sympy/concrete/summations.pyR9sF( !  $        <  4!      '               cC stt|j|jjS(s 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, sin, 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() (RRR*R R(R0((s8lib/python2.7/site-packages/sympy/concrete/summations.pyRNsic sddlm}m}ddlm}t|}t|}|j}t|jdkrkt dn|jd\kt krdkrt j t j fSdd| }nt j } |rkj r j r t|d}n| s#|jrWxt|D] } | |j| 7} q0Wn|j} | rt| jd|k} | t kr| t| fS| tks| t j fSn| | 7} xntd|D]]} |j| } t| jd|kr/| dkr/| t| fS| | 7} qWd|kr^| t j fS|7ntd} ||j| | f}|r|j}n| |7} fd }||\}}||d }|j}xtd|d D]} ||\}}|d | |d | ||} |rw| rwt| jd|ks| |krPn| | 7} |jd d t}qW| |t| fS( s 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. i(t bernoullit factorial(RyisMore than 1 limitiiRWc sGtjkr%|jdfS|j|jfS(Ni(R RLR](R(RBRCRA(s8lib/python2.7/site-packages/sympy/concrete/summations.pytfpointsiR{(tsympy.functionsRRtsympy.integralsRytintR*R!R R(R/R RSt is_IntegerRt is_polynomialRR]RtevalfRR R4R(R0R~R?tepst eval_integralRRRyR>ROR_RsttestRWtIRtfatfbtitermtgtgatgb((RBRCRAs8lib/python2.7/site-packages/sympy/concrete/summations.pyteuler_maclaurinksj+     !   '   $ &3 c G st|}x?t|D]1\}}t|ts|j|||>> 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 ======== index, reorder_limit, 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 iii( RTR7R<RtindexR RjRR*( R0tindicest l_indicesRAtindxteR R@R$((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt reverse_orders=  &(t__name__t __module__t__doc__t __slots__R%R1R4R:R[RbR"RRkRwRRR/RR(((s8lib/python2.7/site-packages/sympy/concrete/summations.pyRs   $  # $   icO st|||jdtS(s Compute the summation of f with respect to symbols. 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:: >>> 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, product R2(RR4R(R>R+tkwargs((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt summation#s,c C s^|\}}}d}xBt|D]4}||j||||j|||7}q"W|S(sReturns the direct summation of the terms of a telescopic sum L is the term with lower index R is the term with higher index n difference between the indexes of L and R For example: >>> 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 i(RR]( tLtRR?R RARBRCROR~((s8lib/python2.7/site-packages/sympy/concrete/summations.pyttelescopic_directRs 2c C s|\}}}|js!|jr%dStd}| j|j|||}d}|r||kr||}|jo|j|||| ksd}qn|dkrgtd} y-t|j||| || pg}Wntk rdSXg|D]8} | jr|j||| |j j r| ^q}t |dkrZdS|d}n|dkrt ||t ||||fS|dkrt ||||||fSdS(sbTries to perform the summation using the telescopic property return None if not possible R_R~iiN(tis_AddR"RRKR]RR RRVR6R.R!RR( RRR RARBRCR_tsolROR~tsi((s8lib/python2.7/site-packages/sympy/concrete/summations.pyt telescopichs2   &   - /  " c  sddlm}m}ddlm}|\}}|tjkrKtjS|jkrj|||dS||kr|j|St |t rt fd|j Dsg}xI|j D]>}t |j|} | dkrdS|j| |jfqW|j|Sn|j|rE|||drE|||S||} | j} | r| dkrt|||fSt |t rdSt|j||f} | dk r| S| rt|||fSdS(Ni(tdeltasummationt_has_simple_delta(tKroneckerDeltaic3 s%|]}|jdjkVqdS(iN(R\RR(R#targ(RA(s8lib/python2.7/site-packages/sympy/concrete/summations.pys siid(tsympy.concrete.deltaRRRRR RSRRR]R<RR'R\R9RR"RjRR;RiRteval_sum_directteval_sum_symbolicR6( R>R RRRRBRCtnewargsRtnewexprRDtdefinitetvalue((RAs8lib/python2.7/site-packages/sympy/concrete/summations.pyR9s>  "    cC s`ddlm}|\}}}||}|gt|dD]}|j|||^q=S(Ni(Ri(t sympy.coreRRR](RR RRARBRCRDtj((s8lib/python2.7/site-packages/sympy/concrete/summations.pyRs c&C sddlm}m}|}|\}}}|j|sJ|||dS|jr|j\}} |j|st| |||f} | r|| Sn| j|st||||f} | r| | Snyt||}Wqtk rqXn|j r|j\}} t || |||f} | r?| St||||f} t| |||f}d| |fkr| |}|t j k r|Sqntd}|j||}|dk r||}|jr|dkre|t jkr |t jk s*|t jkr1|t jk r1t jS||d|d||d||djS|jr|dkr|dkr||||dS||t|||dt|Sqqn|jt jt jp|jt jt jstdd|g}tdd|g}td d|g}td }|jj||}|dk r|j|jj|||}|dk r|j|qn|dk rA||j|}||j|}|||||dd|}|||d}t|t|t jf|tfSt||||f}t|tt frdd l!m"}m#}|j$||dj$}t%t&|}||j$@}g} x||D]}!yst'||!}"|"rt|!|"dnt j(}#|#t)krG| j*t+|j|#j,|j-|#fnPWqt.k r_qqXqW| j*|tft| S|dt j fkr|Snt/||||f}$|$dk r|$S|j0}%|%|krt|%|||fSdS( Ni(tharmonicRiR?itc1RHtc2tc3twexp(torderedtTuple(1RRRRiRt as_two_termsRRRRRR"R tNaNRRKRRLRR6RRRUtupdateR]RR tOneR/RR<R RRRRRRRRRRRRjRR\R4RVteval_sum_hypertfactor(&R>R RRtf_origRARBRCRRtsRtsLtlrsumtlsumtrsumRR?RMRRRRRte_expRRPR$RRt non_limittdentden_symR\tvROR~thtfactored((s8lib/python2.7/site-packages/sympy/concrete/summations.pyRs            4 3  &  "% " 1      c C sddlm}ddlm}m}m}m}ddlm}m } ddl m } |dkrt |j ||||dS|j |ddkr||j |tddtd tdkrtdtfSt |j ||d |dS|||} | d krd St| | rIdd lm} | | } n|| | \} }| j|\}}|j|\}}||g}||g}ggg}xtd D]}x||D]}d }|jr|j}|j}|jsd Sn|||}|jd kr)d S|j\}}||c||9<||c||g|7RARBR R R RR{RRRthsRtnumerRttopttopltbottbotltabtfactorstparamsR_tfactmulRR~R?taptbqRWR ((s8lib/python2.7/site-packages/sympy/concrete/summations.pyR@sT"  0         #  cC sddlm}|\}}}||jr0dSt||||f}|tjkrD|tjkrt|j || || }|dk rAt ||t fSqDt|||}t|||d} |dks| dkrdS|| \}} \} } || | } | t kr$dSt || | f|t fSn|tjkr t|j || |d}t||d} |dks| dkrdS|\}} | \} } || | } | t ks| j tjkrdSt || | f|t fSt|||}|dk r|\} }|t kr| jr|j |tddt dt |}|js|jrtjS|jrtjSndSt ||t fSdS(Ni(RiiRAR|R}(tsympy.logic.boolalgRRR"RR RLRRR]RR/RRtEmptySetRR t is_positiveR.t is_negative(R>ti_a_bRRARBRCtold_sumtrestres1tres2tcond1tcond2RRtc((s8lib/python2.7/site-packages/sympy/concrete/summations.pyRvsT       !    (  (At __future__RRtsympy.calculus.singularitiesRtsympy.calculus.utilRtsympy.concrete.expr_with_limitsRt"sympy.concrete.expr_with_intlimitsRtsympy.concrete.gosperRtsympy.core.addRtsympy.core.compatibilityRRfR RgR tsympy.core.relationalR tsympy.core.singletonR tsympy.core.symbolR RRt&sympy.functions.special.zeta_functionsRt$sympy.functions.elementary.piecewiseRR*Rt sympy.polysRRRtsympy.series.limitseqRtsympy.series.orderRtsympy.sets.setsRRRtsympy.simplify.combsimpRtsympy.simplify.powsimpRt sympy.solversRtsympy.solvers.solvesetRRRRRRR9RRRR(((s8lib/python2.7/site-packages/sympy/concrete/summations.pytsJ  /  + -  x 6