\hX,TSSKJr SSKJr SSKJr "SS\5r"SS\5rg) )ExprWithLimits)S)Eqc,^\rSrSrSrU4SjrSrU=r$) ReorderErrorz; Exception raised when trying to reorder dependent limits. c4>[TU]U<SU<S35 g)Nz could not be reordered: .)super__init__)selfexprmsg __class__s Z/var/www/auris/envauris/lib/python3.13/site-packages/sympy/concrete/expr_with_intlimits.pyr ReorderError.__init__ s 04c : <)__name__ __module__ __qualname____firstlineno____doc__r __static_attributes__ __classcell__)rs@rrrs<>> 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.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit, sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order rz"Index transformation is not linearz>Linear transformation results in non-linear summation stepsize) limitsas_polydegree ValueErrorcoeff_monomialrOne is_numberappend NegativeOnefunctionsubsfunc) r vartrafonewvarr"limitpalphabetar+s r change_indexExprWithIntLimits.change_indexsqr >F[[EQx3MM#&88:?$%IJJ((-''.??~ vU1X~/DeRSHnW[F[&\]!--/ vU1X~/DeRSHnW[F[&\]()ijjMM6q>D+@%a.SWBW"XY e$%!(==%%c$J+=>==-yy+F++rcURVs/sHo"SPM nnURU5S:wa [US5eURU5$s snf)a Return the index of a dummy variable in the list of limits. Explanation =========== ``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, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order rr z0Number of instances of variable not equal to one)r"countr%index)rxr1 variabless rr9ExprWithIntLimits.indexsQ>,0;;7;%1X; 7 ??1  "T#UV V??1% % 8sAc8UnUHn[U5S:wa [US5eUSnUSn[US[5(dUR US5n[US[5(dUR US5nUR XE5nM U$)a Reorder limits in a expression containing a Sum or a Product. Explanation =========== ``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, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order r!zInvalid number of argumentsrr )lenr% isinstanceintr9 reorder_limit)rargnew_exprrindex1index2s rreorderExprWithIntLimits.reorders\A1v{ $ABBqTFqTFadC((AaD)adC((AaD)--f=Hrc8URVs1sHo3SiM nnURUnURUn[[USR5R U55S:XGa[[USR5R U55S:Xa[[USR5R U55S:Xa[[USR5R U55S:Xa}/n[ UR5HFupX:XaUR U5 MX:XaUR U5 M5UR U5 MH [U5"UR/UQ76$[US5es snf)a} Interchange two limit tuples of a Sum or Product expression. Explanation =========== ``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, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order rr r!z.could not interchange the two limits specified) r"r>set free_symbols intersection enumerater)typer+r) rr:yr1r.limit_xlimit_yr"is rrAExprWithIntLimits.reorder_limitsJ@&*[[1[EQx[1++a.++a. GAJ++,99#> ?1 D GAJ++,99#> ?1 D GAJ++,99#> ?1 D GAJ++,99#> ?1 DF%dkk26MM'*VMM'*MM%( 3:dmm5f5 5t%UV V)2sFcSnURH,nUSUS- n[US5nUS:Xa gUS:XaM*SnM. U(agg)a Returns True if the Sum or Product is computed for an empty sequence. Examples ======== >>> from sympy import Sum, Product, Symbol >>> m = Symbol('m') >>> Sum(m, (m, 1, 0)).has_empty_sequence True >>> Sum(m, (m, 1, 1)).has_empty_sequence False >>> M = Symbol('M', integer=True, positive=True) >>> Product(m, (m, 1, M)).has_empty_sequence False >>> Product(m, (m, 2, M)).has_empty_sequence >>> Product(m, (m, M + 1, M)).has_empty_sequence True >>> N = Symbol('N', integer=True, positive=True) >>> Sum(m, (m, N, M)).has_empty_sequence >>> N = Symbol('N', integer=True, negative=True) >>> Sum(m, (m, N, M)).has_empty_sequence False See Also ======== has_reversed_limits has_finite_limits Fr r!TN)r"r)r ret_Nonelimdifeqs rhas_empty_sequence$ExprWithIntLimits.has_empty_sequence.sXN;;Ca&3q6/CCBTzu r)N) rrrrr __slots__r5r9rGrApropertyrYrrrrrr s< It,n$&L>B4Wl33rrN) sympy.concrete.expr_with_limitsrsympy.core.singletonrsympy.core.relationalrNotImplementedErrorrrrrrras):"$<&<UUr