ó ¡¼™\c@ sfddlmZmZddlmZddlmZdefd„ƒYZdefd„ƒYZ dS( iÿÿÿÿ(tprint_functiontdivision(tExprWithLimits(tSt ReorderErrorcB seZdZd„ZRS(sC Exception raised when trying to reorder dependent limits. cC s$tt|ƒjd||fƒdS(Ns%s could not be reordered: %s.(tsuperRt__init__(tselftexprtmsg((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyR s(t__name__t __module__t__doc__R(((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyRstExprWithIntLimitscB s/eZdd„Zd„Zd„Zd„ZRS(c C s¥|dkr|}ng}xH|jD]=}|d|krU|j|ƒ}|jƒdkrktdƒ‚n|j|ƒ}|jtjƒ}|jr$|tjkrÕ|j |||d|||d|fƒqR|tj kr|j |||d|||d|fƒqRtdƒ‚qb|j |||d|||d|fƒq%|j |ƒq%W|j j ||||ƒ} | j ||ƒ} |j | |ŒS(s\ Change index of a Sum or Product. Perform a linear transformation `x \mapsto a x + b` on the index variable `x`. For `a` the only values allowed are `\pm 1`. A new variable to be used after the change of index can also be specified. Usage ===== ``change_index(expr, var, trafo, newvar=None)`` where ``var`` specifies the index variable `x` to transform. The transformation ``trafo`` must be linear and given in terms of ``var``. If the optional argument ``newvar`` is provided then ``var`` gets replaced by ``newvar`` in the final expression. Examples ======== >>> from sympy import Sum, Product, simplify >>> from sympy.abc import x, y, a, b, c, d, u, v, i, j, k, l >>> S = Sum(x, (x, a, b)) >>> S.doit() -a**2/2 + a/2 + b**2/2 + b/2 >>> Sn = S.change_index(x, x + 1, y) >>> Sn Sum(y - 1, (y, a + 1, b + 1)) >>> Sn.doit() -a**2/2 + a/2 + b**2/2 + b/2 >>> Sn = S.change_index(x, -x, y) >>> Sn Sum(-y, (y, -b, -a)) >>> Sn.doit() -a**2/2 + a/2 + b**2/2 + b/2 >>> Sn = S.change_index(x, x+u) >>> Sn Sum(-u + x, (x, a + u, b + u)) >>> Sn.doit() -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u >>> simplify(Sn.doit()) -a**2/2 + a/2 + b**2/2 + b/2 >>> Sn = S.change_index(x, -x - u, y) >>> Sn Sum(-u - y, (y, -b - u, -a - u)) >>> Sn.doit() -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u >>> simplify(Sn.doit()) -a**2/2 + a/2 + b**2/2 + b/2 >>> P = Product(i*j**2, (i, a, b), (j, c, d)) >>> P Product(i*j**2, (i, a, b), (j, c, d)) >>> P2 = P.change_index(i, i+3, k) >>> P2 Product(j**2*(k - 3), (k, a + 3, b + 3), (j, c, d)) >>> P3 = P2.change_index(j, -j, l) >>> P3 Product(l**2*(k - 3), (k, a + 3, b + 3), (l, -d, -c)) When dealing with symbols only, we can make a general linear transformation: >>> Sn = S.change_index(x, u*x+v, y) >>> Sn Sum((-v + y)/u, (y, b*u + v, a*u + v)) >>> Sn.doit() -v*(a*u - b*u + 1)/u + (a**2*u**2/2 + a*u*v + a*u/2 - b**2*u**2/2 - b*u*v + b*u/2 + v)/u >>> simplify(Sn.doit()) a**2*u/2 + a/2 - b**2*u/2 + b/2 However, the last result can be inconsistent with usual summation where the index increment is always 1. This is obvious as we get back the original value only for ``u`` equal +1 or -1. See Also ======== sympy.concrete.simplification.index, sympy.concrete.simplification.reorder_limit, sympy.concrete.simplification.reorder, sympy.concrete.simplification.reverse_order iis"Index transformation is not linearis>Linear transformation results in non-linear summation stepsizeN(tNonetlimitstas_polytdegreet ValueErrortcoeff_monomialRtOnet is_numbertappendt NegativeOnetfunctiontsubstfunc( RtvarttrafotnewvarRtlimittptalphatbetaR((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyt change_indexs*X   111cC sXg|jD]}|d^q }|j|ƒdkrGt|dƒ‚n |j|ƒSdS(s÷ Return the index of a dummy variable in the list of limits. Usage ===== ``index(expr, x)`` returns the index of the dummy variable ``x`` in the limits of ``expr``. Note that we start counting with 0 at the inner-most limits tuple. Examples ======== >>> from sympy.abc import x, y, a, b, c, d >>> from sympy import Sum, Product >>> Sum(x*y, (x, a, b), (y, c, d)).index(x) 0 >>> Sum(x*y, (x, a, b), (y, c, d)).index(y) 1 >>> Product(x*y, (x, a, b), (y, c, d)).index(x) 0 >>> Product(x*y, (x, a, b), (y, c, d)).index(y) 1 See Also ======== reorder_limit, reorder, reverse_order iis0Number of instances of variable not equal to oneN(RtcountRtindex(RtxRt variables((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyR$…s cG s·|}xª|D]¢}t|ƒdkr7t|dƒ‚n|d}|d}t|dtƒst|j|dƒ}nt|dtƒs|j|dƒ}n|j||ƒ}q W|S(s‰ Reorder limits in a expression containing a Sum or a Product. Usage ===== ``expr.reorder(*arg)`` reorders the limits in the expression ``expr`` according to the list of tuples given by ``arg``. These tuples can contain numerical indices or index variable names or involve both. Examples ======== >>> from sympy import Sum, Product >>> from sympy.abc import x, y, z, a, b, c, d, e, f >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((x, y)) Sum(x*y, (y, c, d), (x, a, b)) >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder((x, y), (x, z), (y, z)) Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b)) >>> P = Product(x*y*z, (x, a, b), (y, c, d), (z, e, f)) >>> P.reorder((x, y), (x, z), (y, z)) Product(x*y*z, (z, e, f), (y, c, d), (x, a, b)) We can also select the index variables by counting them, starting with the inner-most one: >>> Sum(x**2, (x, a, b), (x, c, d)).reorder((0, 1)) Sum(x**2, (x, c, d), (x, a, b)) And of course we can mix both schemes: >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x)) Sum(x*y, (y, c, d), (x, a, b)) >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, 0)) Sum(x*y, (y, c, d), (x, a, b)) See Also ======== reorder_limit, index, reverse_order isInvalid number of argumentsii(tlenRt isinstancetintR$t reorder_limit(Rtargtnew_exprtrtindex1tindex2((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pytreorderªs-   c C sad„|jDƒ}|j|}|j|}tt|djƒj|ƒƒdkrNtt|djƒj|ƒƒdkrNtt|djƒj|ƒƒdkrNtt|djƒj|ƒƒdkrNg}xbt|jƒD]Q\}}||kr |j|ƒqã||kr'|j|ƒqã|j|ƒqãWt|ƒ|j|ŒSt |dƒ‚dS(sÌ Interchange two limit tuples of a Sum or Product expression. Usage ===== ``expr.reorder_limit(x, y)`` interchanges two limit tuples. The arguments ``x`` and ``y`` are integers corresponding to the index variables of the two limits which are to be interchanged. The expression ``expr`` has to be either a Sum or a Product. Examples ======== >>> from sympy.abc import x, y, z, a, b, c, d, e, f >>> from sympy import Sum, Product >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2) Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b)) >>> Sum(x**2, (x, a, b), (x, c, d)).reorder_limit(1, 0) Sum(x**2, (x, c, d), (x, a, b)) >>> Product(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2) Product(x*y*z, (z, e, f), (y, c, d), (x, a, b)) See Also ======== index, reorder, reverse_order cS sh|]}|d’qS(i((t.0R((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pys s iiis.could not interchange the two limits specifiedN( RR'tsett free_symbolst intersectiont enumerateRttypeRR( RR%tyRtlimit_xtlimit_yRtiR((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyR*ês   ((((  N(R R RR"R$R0R*(((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyR s v % @N( t __future__RRtsympy.concrete.expr_with_limitsRtsympy.core.singletonRtNotImplementedErrorRR (((sAlib/python2.7/site-packages/sympy/concrete/expr_with_intlimits.pyts