\h&SrSSKJr SSKJrJr SSKJrJrJ r J r SSK J r SSK Jr SSKJrJrJr SS KJr SS KJr SS KJr \ S 5r\ S 5r\ S5r\ S5r\ S5r\ S5r\ S5r\ SSj5r g)z This module implements sums and products containing the Kronecker Delta function. References ========== .. [1] https://mathworld.wolfram.com/KroneckerDelta.html )product)Sum summation)AddMulSDummy)cacheit)default_sort_key)KroneckerDelta Piecewisepiecewise_fold)factor)Interval)solvecpUR(dU$Sn[n[R/nURHlnUcRUR (aA[ XQ5(a1SnURnURVs/sH odSU-PM nnMXUVs/sHofU-PM nnMn U"U6$s snfs snf)z: Expand the first Add containing a simple KroneckerDelta. NTr)is_Mulrr Oneargsis_Add_has_simple_deltafunc)exprindexdeltartermshts L/var/www/auris/envauris/lib/python3.13/site-packages/sympy/concrete/delta.py _expand_deltar!s ;; E D UUGE YY =QXX*;A*E*EE66D)*0A1XaZE0E"'(%QqS%E(E  <1(s <B.B3cN[X5(dSU4$[U[5(aU[R4$UR (d [ S5eSn/nURH+nUc[XA5(aUnMURU5 M- X R"U64$)a8 Extract a simple KroneckerDelta from the expression. Explanation =========== Returns the tuple ``(delta, newexpr)`` where: - ``delta`` is a simple KroneckerDelta expression if one was found, or ``None`` if no simple KroneckerDelta expression was found. - ``newexpr`` is a Mul containing the remaining terms; ``expr`` is returned unchanged if no simple KroneckerDelta expression was found. Examples ======== >>> from sympy import KroneckerDelta >>> from sympy.concrete.delta import _extract_delta >>> from sympy.abc import x, y, i, j, k >>> _extract_delta(4*x*y*KroneckerDelta(i, j), i) (KroneckerDelta(i, j), 4*x*y) >>> _extract_delta(4*x*y*KroneckerDelta(i, j), k) (None, 4*x*y*KroneckerDelta(i, j)) See Also ======== sympy.functions.special.tensor_functions.KroneckerDelta deltaproduct deltasummation NzIncorrect expr) r isinstancer r rr ValueErrorr_is_simple_deltaappendr)rrrrargs r _extract_deltar()sD T ) )d|$''aee} ;;)** E Eyy =-c99E LL   99e$ %%c^UR[5(aS[UT5(agUR(dUR(a[ U4SjUR 55$g)z Returns True if ``expr`` is an expression that contains a KroneckerDelta that is simple in the index ``index``, meaning that this KroneckerDelta is nonzero for a single value of the index ``index``. Tc3<># UHn[UT5v M g7f)N)r).0r'rs r $_has_simple_delta..gsJ (e44 sF)hasr r%rranyr)rrs `r rr\sI xx D% ( ( ;;$++J JJ J r)c[U[5(a^URU5(aHURSURS- R U5nU(aUR 5S:H$g)zi Returns True if ``delta`` is a KroneckerDelta and is nonzero for a single value of the index ``index``. rrF)r#r r/ras_polydegree)rrps r r%r%ksZ %((UYYu-=-= ZZ]UZZ] * 3 3E : 88:? " r)c UR(a0UR"[[[UR 556$UR (dU$/n/nUR HYn[U[5(a0URUR SUR S- 5 MHURU5 M[ U(dU$[USS9n[U5S:Xa[R$[U5S:XaRX$SR5VVs/sHupV[XV5PM snn- nUR"U6nX:wa [ U5$U$s snnf)z( Evaluate products of KroneckerDelta's. rrTdict)rrlistmap_remove_multiple_deltarrr#r r&rlenr Zeroitems)reqsnewargsr'solnskvexpr2s r r:r:xs  {{yy$s#9499EFGG ;; CGyy c> * * JJsxx{SXXa[0 1 NN3    #D !E 5zQvv Uq1X^^5EF5ETQN1(5EFF 7# =)%0 0 K GsEc H[U[5(au[URSURS- SS9nU(aD[ U5S:Xa5[ USR 5VVs/sHup#[X#46PM snn6$U$U$s snnf![a U$f=f)z: Rewrite a KroneckerDelta's indices in its simplest form. rrTr6)r#r rrr;rr=NotImplementedError)rslnskeyvalues r _simplify_deltarIs $'' 1 ! 44@DD Q.21gmmo?.= ,c\:.=?@@ K4K ?"   K s$AB/B B B B! B!c ^^^ TSTS- S:S:Xa[R$UR[5(d [ UT5$UR (Ga`Sm/n[ UR[S9H/nTc[UTS5(aUmMURU5 M1 UR"U6m [SSS9n[TS[5(ab[TS[5(aJ[T T5[!UUU 4S j[#[TS5[TSS-5555-nOs[T T5[%[T TSTSUS- 45TR'TSU5-[T TSUS-TS45-UTSTS4[T TS5S 9-n[)U5$[+UTS5umnT(d6[-UTS5nX:wa[/[UT55$[ UT5$[)UR'TSTS5[TSTS5-5[R[3[TSTSS- 55--$![0a [UT5s$f=f) z Handle products containing a KroneckerDelta. See Also ======== deltasummation sympy.functions.special.tensor_functions.KroneckerDelta sympy.concrete.products.product rrTN)rGkprime)integerc 3># UHLn[TTSTSUS- 45TRTSU5-[TTSUS-TS45-v MN g7f)rrrKN) deltaproductsubs)r,ikrlimitnewexprs r r-deltaproduct..st8Nu9EWuUVxY^_`YacehiciNj8k 58R(9)WuQxaq&BC9DNusAA) no_piecewise)r rr/r rrsortedrr rr&rr r#intrOsumrangedeltasummationrPr:r(r!rAssertionErrorrI) frRrr'rAresult_grrSs ` @@r rOrOs qE!H !d*uu 55 q%  xxx!&&&67C}!23a!A!A S! 8 &&%. (D ) eAh $ $E!Hc)B)B!'51C8NSTWX]^_X`TacfglmngorsgsctNu85F "'51NWuQxq1q5&AB 58Q'(WuQxQa&ABCE!HeAh'.waA 5F&f--aq*HE1  !U1X & 6 .l1e455q%  !!&&q58"<^ERSHV[\]V^=_"_ ` onU1XuQx!|DEE FF " .#Au-- .s,I11J  J c USUS- S:S:Xa[R$UR[5(d [ X5$USn[ X5nUR (a=[UR"URVs/sHn[XQU5PM sn65$[XC5upgUb;URb.URupUSU- S:*S:XaUSU - S:S:XaSnU(d [ X5$[URSURS- U5n [U 5S:Xa[R$[U 5S:wa [X5$U Sn U(aUR!X;5$[#UR!X;5[%USS6R'U 54[RS45$s snf)a Handle summations containing a KroneckerDelta. Explanation =========== The idea for summation is the following: - If we are dealing with a KroneckerDelta expression, i.e. KroneckerDelta(g(x), j), we try to simplify it. If we could simplify it, then we sum the resulting expression. We already know we can sum a simplified expression, because only simple KroneckerDelta expressions are involved. If we could not simplify it, there are two cases: 1) The expression is a simple expression: we return the summation, taking care if we are dealing with a Derivative or with a proper KroneckerDelta. 2) The expression is not simple (i.e. KroneckerDelta(cos(x))): we can do nothing at all. - If the expr is a multiplication expr having a KroneckerDelta term: First we expand it. If the expansion did work, then we try to sum the expansion. If not, we try to extract a simple KroneckerDelta term, then we have two cases: 1) We have a simple KroneckerDelta term, so we return the summation. 2) We did not have a simple term, but we do have an expression with simplified KroneckerDelta terms, so we sum this expression. Examples ======== >>> from sympy import oo, symbols >>> from sympy.abc import k >>> i, j = symbols('i, j', integer=True, finite=True) >>> from sympy.concrete.delta import deltasummation >>> from sympy import KroneckerDelta >>> deltasummation(KroneckerDelta(i, k), (k, -oo, oo)) 1 >>> deltasummation(KroneckerDelta(i, k), (k, 0, oo)) Piecewise((1, i >= 0), (0, True)) >>> deltasummation(KroneckerDelta(i, k), (k, 1, 3)) Piecewise((1, (i >= 1) & (i <= 3)), (0, True)) >>> deltasummation(k*KroneckerDelta(i, j)*KroneckerDelta(j, k), (k, -oo, oo)) j*KroneckerDelta(i, j) >>> deltasummation(j*KroneckerDelta(i, j), (j, -oo, oo)) i >>> deltasummation(i*KroneckerDelta(i, j), (i, -oo, oo)) j See Also ======== deltaproduct sympy.functions.special.tensor_functions.KroneckerDelta sympy.concrete.sums.summation rKrrT)r r<r/r rr!rrrrrZr( delta_rangerr;rrPrr as_relational) r\rRrUxr_rrrdinfdsupr@rHs r rZrZsH qE!H !d*vv 55 "" aAaAxx FFQVVLV^Al;VL MO O!&KE  1 1 =&&  !HtOq T )uQx$!/C.LL "" %**Q-%**Q-/ 3E 5zQvv Uq1} !HEyy""  1 ha 3AA%HI  +MsG N)F)!__doc__productsr summationsrr sympy.corerrr r sympy.core.cacher sympy.core.sortingr sympy.functionsr rrsympy.polys.polytoolsrsympy.sets.setsrsympy.solvers.solversrr!r(rr%r:rIrOrZr)r rrs&))$/EE($'  & /& /&d          8     7F 7Ft f fr)