o 8VaK@s ddlmZddlmZddlmZddlmZddlm Z ddl m Z m Z ddl mZddlmZmZdd lmZdd lmZmZdd lmZdd lmZdd lmZddlmZddlm Z ddl!m"Z"ddl#m$Z$ddZ%ddZ&GdddeZ'Gddde'Z(dS))Add) is_sequenceTuple)Expr)Mul)Equality Relational)S)SymbolDummy)sympify)piecewise_fold Piecewise)BooleanFunction)Idx)Interval)Range)flatten)sift)SymPyDeprecationWarningcOst|}t|trAt|\}}|rtdd|Ds$tddddd|j}|j}t||g|Ri|||g|Ri|S|t j urIt j S|rut|\}}t |D]\}} t | dkrs| | d | d }t| d d ||<qUn|j} t | d krtd |dd| Dd }}|t|krt|j|}|j}|t|ksi} dd|D} |tD] } | j| st| | <q|| }t|}|dd| D}|||fS)zReturn either a special return value or the tuple, (function, limits, orientation). This code is common to both ExprWithLimits and AddWithLimits.css|] }t|dkVqdSNlen).0limitrA/usr/lib/python3/dist-packages/sympy/concrete/expr_with_limits.py sz_common_new..zIntegral(Eq(x, y))z"Eq(Integral(x, z), Integral(y, z))iFg?)ZfeatureZ useinsteadZissueZdeprecated_since_versionrNzspecify dummy variables for %scSsg|]}t|qSrr)rsrrr ;z_common_new..cSsh|]}|dqSrrrirrr Fr%z_common_new..cSsi|]\}}||qSrr)rkvrrr Osz_common_new..)r isinstancer_process_limitsallrwarnlhsrhsr ZNaN enumeratersubsr free_symbols ValueErrortypelistlimitsfunctionatomsrhasr Zxreplaceritems)clsr:symbols assumptionsr9 orientationr1r2r(ZlifreeZrepsZsymbols_of_integrationprrr _common_news\            rDc Gs.g}d}|D]}t|ttfr|t}||f}t|ts(t|ddrSt|trK|j dus7|j dur?| t |n| t ||j |j n| t |qt |t rt|dkrt|dtr|dj}|dj}t|dj}|dgd|||||d|g}tt|}t|dttfst|dddr|d}t|dkrt|dtr|dj|djg|dd<n$t|dkr|ddur|ddur|d9}|gd d |ddD}t|trt|dkrt|d kr| t |qt|dkr\t|trT|j |j }}z|dur)t|d|ks)td Wn ty4Ynwz|durHt|d|ksHtd Wn tySYnw| t |qt|dksqt|dkry|ddury| t |qt|dkr| t ||dqtdt|||fS)aProcess the list of symbols and convert them to canonical limits, storing them as Tuple(symbol, lower, upper). The orientation of the function is also returned when the upper limit is missing so (x, 1, None) becomes (x, None, 1) and the orientation is changed. r" _diff_wrtFNrrr!cSsg|]}|dur|qSNrr'rrrr$zz#_process_limits..r z%Summation will set Idx value too low.z&Summation will set Idx value too high.zInvalid limits given: %s)r-r rr;r popZas_setgetattrrlowerupperappendrrrrinfsupabsstepr rrstartendboolr6 TypeErrorstr) r?r9rAVvariablelohiZdxZ newsymbolrrrr.Tsv      ( $  *r.c@seZdZdZddZeddZeddZedd Zed d Z ed d Z eddZ eddZ ddZ ddZeddZeddZdS)ExprWithLimits)is_commutativec Ost||g|Ri|}t|tur|\}}}n|Stdd|Dr'tdtj|fi|}|g}||t||_|j |_ |S)Ncss$|] }t|dkp d|vVqdSrrrlrrrrs"z)ExprWithLimits.__new__..z:ExprWithLimits requires values for lower and upper bounds.) rDr7tupleanyr6r__new__extend_argsr\) r>r:r?r@prer9_objarglistrrrras    zExprWithLimits.__new__cCs |jdS)a%Return the function applied across limits. Examples ======== >>> from sympy import Integral >>> from sympy.abc import x >>> Integral(x**2, (x,)).function x**2 See Also ======== limits, variables, free_symbols rrcselfrrrr:s zExprWithLimits.functioncCs|jjSrG)r:kindrirrrrkszExprWithLimits.kindcCs|jddS)a+Return the limits of expression. Examples ======== >>> from sympy import Integral >>> from sympy.abc import x, i >>> Integral(x**i, (i, 1, 3)).limits ((i, 1, 3),) See Also ======== function, variables, free_symbols r"Nrhrirrrr9szExprWithLimits.limitscCdd|jDS)aReturn a list of the limit variables. >>> from sympy import Sum >>> from sympy.abc import x, i >>> Sum(x**i, (i, 1, 3)).variables [i] See Also ======== function, limits, free_symbols as_dummy : Rename dummy variables sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable cSsg|]}|dqSr&rr]rrrr$r%z,ExprWithLimits.variables..r9rirrr variablesszExprWithLimits.variablescCrl)aReturn only variables that are dummy variables. Examples ======== >>> from sympy import Integral >>> from sympy.abc import x, i, j, k >>> Integral(x**i, (i, 1, 3), (j, 2), k).bound_symbols [i, j] See Also ======== function, limits, free_symbols as_dummy : Rename dummy variables sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable cSs g|] }t|dkr|dqS)r"rrr]rrrr$ z0ExprWithLimits.bound_symbols..rmrirrr bound_symbolsszExprWithLimits.bound_symbolscCsv|j|j}}|j}|D],}t|dkr||dq |d|vr)||d|ddD]}||jq/q |S)a4 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 Sum >>> from sympy.abc import x, y >>> Sum(x, (x, y, 1)).free_symbols {y} r"rN)r:r9r5raddremoveupdate)rjr:r9Zisymsxabr(rrrr5 s  zExprWithLimits.free_symbolscCs|j S)z7Return True if the Sum has no free symbols, else False.)r5rirrr is_number(szExprWithLimits.is_numbercs0fdd|jD}|j}|j|g|RS)Ncs&g|]}|dkr |nfqSr&rr'abxrrr$.s&z1ExprWithLimits._eval_interval..)r9r:func)rjryrwrxr9Z integrandrrvr_eval_interval-szExprWithLimits._eval_intervalc sddlm}m}|jt|j}}|ttr!j |j rd}t |D]D\}} dt | krB| dkrBj r>f} nf} t| dgfdd| ddDR||<t | dj j dkrkd}nq't|svt|rt|j tt} t|j tj} | | std d}|r|}n/t |D]*\}} t | d krt| dgfd d| ddDR||<| dkrnqt |D]\}} t | d kr| d| djrt| d||<q||j|g|RS) a Perform substitutions over non-dummy variables of an expression with limits. Also, can be used to specify point-evaluation of an abstract antiderivative. Examples ======== >>> from sympy import Sum, oo >>> from sympy.abc import s, n >>> Sum(1/n**s, (n, 1, oo)).subs(s, 2) Sum(n**(-2), (n, 1, oo)) >>> from sympy import Integral >>> from sympy.abc import x, a >>> Integral(a*x**2, x).subs(x, 4) Integral(a*x**2, (x, 4)) See Also ======== variables : Lists the integration variables transform : Perform mapping on the dummy variable for integrals change_index : Perform mapping on the sum and product dummy variables r) AppliedUndefUndefinedFunctionTr"cg|]}|qSrZ_subsr]newoldrrr$drHz-ExprWithLimits._eval_subs..NFz.substitution can not create dummy dependenciesrcr~rrr]rrrr$urHrF)Zsympy.core.functionr|r}r:r8r9reverser-r r5 intersectionr3rrErsetrnr;argsissubsetr6r4Zis_zerorz) rjrrr|r}rzr9Z sub_into_funcr(rtZsy2Zsy1rrr _eval_subs2sP  0   0 zExprWithLimits._eval_subscCsd}|jD]8}t|dkr4tdd|ddDrdStdd|ddDr3|djdur3d }q|djdur=d }q|rBdSd S) a# Returns True if the limits are known to be finite, either by the explicit bounds, assumptions on the bounds, or assumptions on the variables. False if known to be infinite, based on the bounds. None if not enough information is available to determine. Examples ======== >>> from sympy import Sum, Integral, Product, oo, Symbol >>> x = Symbol('x') >>> Sum(x, (x, 1, 8)).has_finite_limits True >>> Integral(x, (x, 1, oo)).has_finite_limits False >>> M = Symbol('M') >>> Sum(x, (x, 1, M)).has_finite_limits >>> N = Symbol('N', integer=True) >>> Product(x, (x, 1, N)).has_finite_limits True See Also ======== has_reversed_limits Frcss|]}|jVqdSrG is_infiniter]rrrrsz3ExprWithLimits.has_finite_limits..r"Ncss|]}|jduVqdSrGrr]rrrrsrT)r9rr`r)rjret_Nonelimrrrhas_finite_limitss!  z ExprWithLimits.has_finite_limitscCsXd}|jD] }t|dkr#|\}}}||}|jrdS|jr qd}qdS|r*dSdS)a Returns True if the limits are known to be in reversed order, either by the explicit bounds, assumptions on the bounds, or assumptions on the variables. False if known to be in normal order, based on the bounds. None if not enough information is available to determine. Examples ======== >>> from sympy import Sum, Integral, Product, oo, Symbol >>> x = Symbol('x') >>> Sum(x, (x, 8, 1)).has_reversed_limits True >>> Sum(x, (x, 1, oo)).has_reversed_limits False >>> M = Symbol('M') >>> Integral(x, (x, 1, M)).has_reversed_limits >>> N = Symbol('N', integer=True, positive=True) >>> Sum(x, (x, 1, N)).has_reversed_limits False >>> Product(x, (x, 2, N)).has_reversed_limits >>> Product(x, (x, 2, N)).subs(N, N + 2).has_reversed_limits False See Also ======== sympy.concrete.expr_with_intlimits.ExprWithIntLimits.has_empty_sequence FrTN)r9rZis_extended_negativeZis_extended_nonnegative)rjrrvarrwrxZdifrrrhas_reversed_limitss%   z"ExprWithLimits.has_reversed_limitsN)__name__ __module__ __qualname__ __slots__rapropertyr:rkr9rnrpr5rur{rrrrrrrr[s.       P 2r[c@s@eZdZdZddZddZddZdd Zd d Zd d Z dS) AddWithLimitszZRepresents unevaluated oriented additions. Parent class for Integral and Sum. c Ospt||g|Ri|}t|tur|\}}}n|Stj|fi|}||g}||t||_|j|_|SrG)rDr7r_rrarbrcr\) r>r:r?r@rdr9rArfrgrrrras     zAddWithLimits.__new__cC6tddt|jDr|j|jg|jRSdS)NcSg|]}|jqSrZis_realrryrrrr$z/AddWithLimits._eval_adjoint..)r/rr9rzr:Zadjointrirrr _eval_adjointzAddWithLimits._eval_adjointcCr)NcSrrrrrrrr$rz1AddWithLimits._eval_conjugate..)r/rr9rzr: conjugaterirrr_eval_conjugaterzAddWithLimits._eval_conjugatecCr)NcSrrrrrrrr$ rz1AddWithLimits._eval_transpose..)r/rr9rzr:Z transposerirrr_eval_transpose rzAddWithLimits._eval_transposec sdtjkr3jjdi|}|jr1t|jfdd}t|djt|dgjRSSjjgjddR}| j dsZdjdg |St |trj|jdSS) Nr"cs|jo tj|j@ SrG)r\rrnr5)wrirrsz,AddWithLimits._eval_factor..TFrr!r) rr9r:ZfactorZis_Mulrrrrzr<rnZdoitr-)rjhintssummandoutrrir _eval_factors " zAddWithLimits._eval_factorc sddlm}jjdi|}|jr!|jr!tfdd|jDSt||r/| fddS|jkr>j |gj RSS)Nr) MatrixBasecs g|] }j|gjRqSrrzr9r'rirrr$$roz4AddWithLimits._eval_expand_basic..csj|gjRSrGr)ryrirrr&r%z2AddWithLimits._eval_expand_basic..r) Zsympy.matrices.matricesrr:expandZis_Addr\rrr-Z applyfuncrzr9)rjrrrrrir_eval_expand_basics    z AddWithLimits._eval_expand_basicN) rrr__doc__rarrrrrrrrrrs rN))Zsympy.core.addrZsympy.core.compatibilityrZsympy.core.containersrZsympy.core.exprrZsympy.core.mulrZsympy.core.relationalrr Zsympy.core.singletonr Zsympy.core.symbolr r Zsympy.core.sympifyr Z$sympy.functions.elementary.piecewiserrZsympy.logic.boolalgrZsympy.tensor.indexedrZsympy.sets.setsrZsympy.sets.fancysetsrZsympy.utilitiesrZsympy.utilities.iterablesrZsympy.utilities.exceptionsrrDr.r[rrrrrs.             ?MM