\hdPSSKJr SSKJrJr SSKJr SSKJr SSK J r SSK J r J r SSKJr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJrJrJrJr \(aSSKJ r SSK!J"r" SSK#J$r$ SSK%J&r&J'r'J(r( "SS\5r)"SS\*5r+"SS\)5r,"SS5r-g)) annotations)overload TYPE_CHECKING) attrgetter) defaultdict)sympy_deprecation_warning)_sympifysympify)Basic)cacheit)ordered) fuzzy_and)global_parameters)sift) Dispatcher#ambiguity_register_error_ignore_dup str_signatureRaiseNotImplementedErrorExprAddMul)BooleanAndOrc8^\rSrSr%SrSrS\S'SrS\S'\SS S .S j5r \ SU4S jj5r S S .Sjr \ S5r SSjrSrSr\\ SSj55r\\ SSj55r\\ SSj55r\\ SSj55r\ S Sj5rSrSrU=r$)!AssocOpaAssociative operations, can separate noncommutative and commutative parts. (a op b) op c == a op (b op c) == a op b op c. Base class for Add and Mul. This is an abstract base class, concrete derived classes must define the attribute `identity`. .. deprecated:: 1.7 Using arguments that aren't subclasses of :class:`~.Expr` in core operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is deprecated. See :ref:`non-expr-args-deprecated` for details. Parameters ========== *args : Arguments which are operated evaluate : bool, optional Evaluate the operation. If not passed, refer to ``global_parameters.evaluate``. is_commutativeztuple[str, ...] __slots__Nztype[Basic] | None _args_typeT)evaluater c :^ U(a[[[U55nURnUbSSKJm [ U 4SjU55(a[SUR-5eUHFn[XT5(aM[SURS[U5R<S3SS S S 9 MH Uc[RnU(d$URU5nURU5nU$UVs/sHowUR LdMUPM nn[#U5S :Xa UR $[#U5S:XaUS $UR%U5upn U (+n URX-U 5nURU5nU bS S KJn U "U/U Q76$U$s snf)Nr ) Relationalc3<># UHn[UT5v M g7fN) isinstance).0argr(s M/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/operations.py "AssocOp.__new__..Is?$3:c:..$szRelational cannot be used in %sz Using non-Expr arguments in z< is deprecated (in this case, one of the arguments has type z). If you really did intend to use a multiplication or addition operation with this object, use the * or + operator instead. z1.7znon-expr-args-deprecated)deprecated_since_versionactive_deprecations_target stacklevelr)Order)listmap _sympify_r% relationalr(any TypeError__name__r+rtyperr& _from_args _exec_constructor_postprocessorsidentitylenflattensympy.series.orderr5)clsr&r argstypr-objac_partnc_part order_symbolsr#r5r(s @r.__new__AssocOp.__new__>s It,-Dnn ? .?$??? ACLL PQQ!#++- \\N+S **-.273M#$ "  (11H..&C66s;CJ94aCLL#849 t9><<  t9>7N),T):&$nnV-~>2237  $ 0-}- - :s 7F Fc>[U5S:Xa UR$[U5S:XaUS$[TU] "U/UQ76nUc[ SU55nX#lU$)zCreate new instance with already-processed args. If the args are not in canonical order, then a non-canonical result will be returned, so use with caution. The order of args may change if the sign of the args is changed.rr c38# UHoRv M g7fr*r")r,rHs r.r/%AssocOp._from_args..s&FA'7'7)rAr@superrLrr#)rDrEr#rG __class__s r.r>AssocOp._from_argsvsb t9><<  Y!^7Ngoc)D)  !&&F&FFN+ )reevalcnU(aURSLaSnO URnURX$5$)aCreate new instance of own class with args exactly as provided by caller but returning the self class identity if args is empty. Examples ======== This is handy when we want to optimize things, e.g. >>> from sympy import Mul, S >>> from sympy.abc import x, y >>> e = Mul(3, x, y) >>> e.args (3, x, y) >>> Mul(*e.args[1:]) x*y >>> e._new_rawargs(*e.args[1:]) # the same as above, but faster x*y Note: use this with caution. There is no checking of arguments at all. This is best used when you are rebuilding an Add or Mul after simply removing one or more args. If, for example, modifications, result in extra 1s being inserted they will show up in the result: >>> m = (x*y)._new_rawargs(S.One, x); m 1*x >>> m == x False >>> m.is_Mul True Another issue to be aware of is that the commutativity of the result is based on the commutativity of self. If you are rebuilding the terms that came from a commutative object then there will be no problem, but if self was non-commutative then what you are rebuilding may now be commutative. Although this routine tries to do as little as possible with the input, getting the commutativity right is important, so this level of safety is enforced: commutativity will always be recomputed if self is non-commutative and kwarg `reeval=False` has not been passed. FN)r#r>)selfrVrEkwargsr#s r. _new_rawargsAssocOp._new_rawargss4V d))U2!N!00Nt44rUc/nU(aUUR5nURULaURUR5 OUR U5 U(aMUUR 5 /US4$)zReturn seq so that none of the elements are of type `cls`. This is the vanilla routine that will be used if a class derived from AssocOp does not define its own flatten routine.N)poprSextendrEappendreverse)rDseqnew_seqos r.rBAssocOp.flattensa  A{{c! 166"q! c 7D  rUc@^^^SSKJn SSKJn [ X5(a[ TU5(dgUc0nUT:XaU$UR TU5nUbU$SSKJm SSKJm [URUUU4SjSS 9upxU(d1[[U55nUR(a [US S 9nOUR"U6n TR n U (aU R U - (agUR#TU 5n U(dWTR(dTR$(a5U n U"U 5(aU *n U R'5TR'5:agUR"U6n U R)X5$S n[+5nTU;GaUR-T5 [/[UR1T555nUR(a%TR(a[/[US S 95nUR24U-n[5U5HVn[5U5HDnUR)UU5nUcMUR7U5R)TU5nUcM@Us s $ MX US :XGaUR$(aTR8(aTR:R<(a~SSKJ n TR:S :a/U"TRBTRBTR:S- -/SS06mO1U"STRB- TRBTR:S--/SS06mUS- nGMOUR(aTRE5unn[GU5S:a6SSKJ$n US :aU"UUS- U-/SS06mOU"U*US-U-/SS06mUS- nGMS SK%J&n Tn[+5n[5U5HInUROT5unnUR U- n U (dM/URQU 5 U"TU 5mMK TU:waUS - nGMgTU;aGMg)a Matches Add/Mul "pattern" to an expression "expr". repl_dict ... a dictionary of (wild: expression) pairs, that get returned with the results This function is the main workhorse for Add/Mul. Examples ======== >>> from sympy import symbols, Wild, sin >>> a = Wild("a") >>> b = Wild("b") >>> c = Wild("c") >>> x, y, z = symbols("x y z") >>> (a+sin(b)*c)._matches_commutative(x+sin(y)*z) {a_: x, b_: y, c_: z} In the example above, "a+sin(b)*c" is the pattern, and "x+sin(y)*z" is the expression. The repl_dict contains parts that were already matched. For example here: >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z, repl_dict={a: x}) {a_: x, b_: y, c_: z} the only function of the repl_dict is to return it in the result, e.g. if you omit it: >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z) {b_: y, c_: z} the "a: x" is not returned in the result, but otherwise it is equivalent. r ) _coeff_isnegrN) WildFunction)Wildcb>URTT5=(a TRU5(+$r*)has)prhrgexprs r..AssocOp._matches_commutative..s# EE$ % 9dhhqk/ 9rUTbinarycUR(a-URSR(aURS$S$Nris_MulrE is_Numberxs r.rmrn0!"affQi.A.AAFF1IrU)keyrcUR(a-URSR(aURS$S$rrrsrvs r.rmrn-rxrUrr&Fr)collect))functionrfrlrr+_matches_simplergsymbolrhrrEr6ris_AddsortedrZ free_symbols_combine_inversert count_opsmatchessetaddtuple make_argsr@reversedxreplaceis_Powexp is_Integermulrbase as_coeff_Mulabsrsympy.simplify.radsimpr{ as_coeff_mulupdate)rXrl repl_dictoldrfrd wild_part exact_partexactfreenewexprcheck newpatternisawrE expr_listlast_opwd1d2rcerr{wasdidrhrgs ` @@r._matches_commutativeAssocOp._matches_commutativesN + d ! !*T4*@*@  I 4<   y 1 =H + $TYY1:! WY/0I{{#93 %%z2E$$D++d2++D%8GDKK4;;&&"FE??$t~~'77**I6J%%g9 9 e#o GGDM!567D{{t{{VD/(4/I#I.!),A7I6B~!]]2.66tR@>#%I -/Av;;{{txx':':,88a<#&DII1 4M(N#_Y^#_D#&499dii$((Q,6O(P#a[`#aDQ [[,,.DAq1vz,q5#&QUAI#G#GD#&!a!eQY#H%#HDQ ?C%C%i0 ~~d31 ~~34JJt,#*4#6D 1 s{Q w#ov rUcX^^^^^SmT"T5ummTRmUUUUU4SjnU$)zHelper for .has() that checks for containment of subexpressions within an expr by using sets of args of similar nodes, e.g. x + 1 in x + y + 1 checks to see that {x, 1} & {x, y, 1} == {x, 1} cL[URSSS9up[U5U4$)NcURSL$)NTr")r-s r.rm8AssocOp._has_matcher.._ncsplit..nsC..$6rUTro)rrEr)rlcpartncparts r._ncsplit&AssocOp._has_matcher.._ncsplitis+!6tEMEu:v% %rUc>[UT5(azUT:XagT"U5upTU-T:Xa`T(dg[T5[U5::a@[[U5[T5- S-5HnX#U[T5-T:XdM g g)NTr F)r+rArange) rl_c_ncrrrrDncrXs r.is_in#AssocOp._has_matcher..is_ints$$$4<"4.Fq=#RCH,!&s3x#b''9A'=!>A"QR[1R7'+"?rUrS)rXrrrrDrs` @@@@r. _has_matcherAssocOp._has_matchercs1  &2nn   rUc.SSKJn SSKJn SSKJn SSKJn [XU45(GaURXE5upgXpRLd[U[5(aUR(dX`RLa[U[5(dX`RLaURU5O URn/n[URR!U55n U H;n U R#U5n U cUR%U 5 M*UR%U 5 M= UR"U/UQ76$/nUR&H;n U R#U5n U cUR%U 5 M*UR%U 5 M= UR"U6$)a Evaluate the parts of self that are numbers; if the whole thing was a number with no functions it would have been evaluated, but it wasn't so we must judiciously extract the numbers and reconstruct the object. This is *not* simply replacing numbers with evaluated numbers. Numbers should be handled in the largest pure-number expression as possible. So the code below separates ``self`` into number and non-number parts and evaluates the number parts and walks the args of the non-number part recursively (doing the same thing). r rr)Symbol) AppliedUndef)rrrrr~rr|rr+as_independentr@r is_Function_evalfrfuncr _eval_evalfr_rE) rXprecrrrrrwtailrE tail_argsrHnewas r.rAssocOp._eval_evalfs> "* d#J ' '))&?GAMM)q'**q}}&:dG+D+D'(}}&>> from sympy import Symbol, Mul, Add >>> x, y = map(Symbol, 'xy') >>> Mul.make_args(x*y) (x, y) >>> Add.make_args(x*y) (x*y,) >>> set(Add.make_args(x*y + y)) == set([y, x*y]) True )r+rEr rs r.rrs&& d 99 DM# #rUc URSS5(a,URVs/sHo"R"S0UD6PM nnO URnUR"USS06$s snf)NdeepTr&r)getrEdoitr)rXhintstermtermss r.r AssocOp.doitsY 99VT " "48II>IDYY''IE>EIIEyy%/$//?sA"rr*)NF)rDz type[Add]rlrreturntuple[Expr, ...])rDz type[Mul]rlrrr)rDz type[And]rlrrtuple[Boolean, ...])rDztype[Or]rlrrr)rDz type[Basic]rlr rztuple[Basic, ...])r< __module__ __qualname____firstlineno____doc__r$__annotations__r%r rL classmethodr>rZrBrrrrrr__static_attributes__ __classcell__rs@r.r r s8"5I4%)J") %)D5 5n *./5b!!"Wr@2 hFF FF LL KK$$.00rUr c\rSrSrSrg) ShortCircuitirN)r<rrrrrrUr.rrsrUrcT^\rSrSrSrSrU4Sjr\SSj5r\S5r Sr U=r $) LatticeOpia Join/meet operations of an algebraic lattice[1]. Explanation =========== These binary operations are associative (op(op(a, b), c) = op(a, op(b, c))), commutative (op(a, b) = op(b, a)) and idempotent (op(a, a) = op(a) = a). Common examples are AND, OR, Union, Intersection, max or min. They have an identity element (op(identity, a) = a) and an absorbing element conventionally called zero (op(zero, a) = zero). This is an abstract base class, concrete derived classes must declare attributes zero and identity. All defining properties are then respected. Examples ======== >>> from sympy import Integer >>> from sympy.core.operations import LatticeOp >>> class my_join(LatticeOp): ... zero = Integer(0) ... identity = Integer(1) >>> my_join(2, 3) == my_join(3, 2) True >>> my_join(2, my_join(3, 4)) == my_join(2, 3, 4) True >>> my_join(0, 1, 4, 2, 3, 4) 0 >>> my_join(1, 2) 2 References ========== .. [1] https://en.wikipedia.org/wiki/Lattice_%28order%29 Tcj>SU5n[URU55nU(d[UR 5$[ U5S:Xa[U5R5$[[U]."U/[U5Q76nX4l U$![a [UR5s$f=f)Nc38# UHn[U5v M g7fr*)r8)r,r-s r.r/$LatticeOp.__new__..s/$3 #$rQr ) frozenset_new_args_filterrr zeror@rArr]rRr rLr_argset)rDrEoptions_argsrGrSs r.rLLatticeOp.__new__s/$/ % c22489E3<<( ( Z1_u:>># #-cCGENCCKJ %388$ $ %sBB21B2c## U=(d UnUHXnXCR:Xa [U5eXCR:XaM.URU:XaURShvN MTUv MZ gN7f)zGenerator filtering argsN)rrr@rrE)rD arg_sequencecall_clsnclsr-s r.rLatticeOp._new_args_filter&s_3Cii"3'' %T!88##  $sAA/A-A/cd[X5(a UR$[[U5/5$)z7 Return a set of args such that cls(*arg_set) == expr. )r+rrr rs r.rLatticeOp.make_args4s* d << gdm_- -rUrr*) r<rrrrr#rLrrrrrrs@r.rrs=$LN,  ..rUrcl\rSrSrSrS SjrSr\4Sjr\ SS.S j5r \ S 5r \ S 5rS r g)AssocOpDispatcheri?a Handler dispatcher for associative operators .. notes:: This approach is experimental, and can be replaced or deleted in the future. See https://github.com/sympy/sympy/pull/19463. Explanation =========== If arguments of different types are passed, the classes which handle the operation for each type are collected. Then, a class which performs the operation is selected by recursive binary dispatching. Dispatching relation can be registered by ``register_handlerclass`` method. Priority registration is unordered. You cannot make ``A*B`` and ``B*A`` refer to different handler classes. All logic dealing with the order of arguments must be implemented in the handler class. Examples ======== >>> from sympy import Add, Expr, Symbol >>> from sympy.core.add import add >>> class NewExpr(Expr): ... @property ... def _add_handler(self): ... return NewAdd >>> class NewAdd(NewExpr, Add): ... pass >>> add.register_handlerclass((Add, NewAdd), NewAdd) >>> a, b = Symbol('a'), NewExpr() >>> add(a, b) == NewAdd(a, b) True NcXlX lSU-Ul[UR5Ul[ U5Ulg)Nz _%s_handler)namedoc handlerattrr_handlergetterr _dispatcher)rXrrs r.__init__AssocOpDispatcher.__init__es9 (4/()9)9:%d+rUc SUR-$)Nz)r)rXs r.__repr__AssocOpDispatcher.__repr__ls 499,,rUcj[U5S:Xd&[S[U5<S[U5<S35e[[U55S:Xa[S[U5-5eURR [ U5X#S9 URR [ [U55X#S9 g) a; Register the handler class for two classes, in both straight and reversed order. Paramteters =========== classes : tuple of two types Classes who are compared with each other. typ: Class which is registered to represent *cls1* and *cls2*. Handler method of *self* must be implemented in this class. z+Only binary dispatch is supported, but got z types: .r z*Duplicate types <%s> cannot be dispatched.) on_ambiguityN)rA RuntimeErrorrrrrrr)rXclassesrFr s r.register_handlerclass'AssocOpDispatcher.register_handlerclassos7|q G mG4  s7|  !<}W?UU  U7^SL U8G#45sVrUT)r cU(a[[[U55n[[URU55nUR U5"USS0UD6$)zA Parameters ========== *args : Arguments which are operated r F)rr7r8rrdispatch)rXr rErYhandlerss r.__call__AssocOpDispatcher.__call__sO Y-.DS!4!4d;<}}X&GuGGGrUc[U5S:Xa5Uun[U[5(d[SR U55eU$[ U5Hup4[U[5(d[SR U55eUS:XaUnM>WnUR RXd5n[U[5(aMr[SR XdU55e W$)z: Select the handler class, and return its handler method. r zHandler {!r} is not a type.rz=Dispatcher for {!r} and {!r} must return a type, but got {!r})rAr+r=r format enumeraterr)rXrhrrFhandler prev_handlers r.rAssocOpDispatcher.dispatchs x=A BAa&&"#@#G#G#JKKH )FAc4(("#@#G#G#LMMAv& **33LF!'400&W^^$7*$rUcbSUR-S/nUR(aURUR5 SnUS[U5-- nURU5 /n[ [ 5nUR RSSS2H/nUR RUnXFRU5 M1 UR5H}upuSRSU55n[U[5(aURU5 MESU-nUS [U5-S -- nX'R- nURU5 M U(aFS nUS[U5-- nURU5 S RU5nURU5 S RU5$) Nz,Multiply dispatched associative operator: %szcNote that support for this is experimental, see the docs for :class:`AssocOpDispatcher` for detailszRegistered handler classes =z, c3># UHnS[U5-v M g7f)z<%s>N)r)r,sigs r.r/,AssocOpDispatcher.__doc__..s M-*rAs}"*#@3)*-- $""44D0eD0L 9 U.U.pf!f!rU