gaddlmZddlmZddlmZddlmZddlm Z mZddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZmZGdde ZGddeZGddeZGddZ y)) annotations) attrgetter) defaultdict)sympy_deprecation_warning)_sympifysympify)Basic)cacheit)ordered) fuzzy_and)global_parameters)sift) Dispatcher#ambiguity_register_error_ignore_dup str_signatureRaiseNotImplementedErrorceZdZUdZdZded<dZded<eddd d Ze dfd Z dd d Z e dZ ddZ dZdZe dZdZxZS)AssocOpa Associative 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)evaluaterc  |rttt|}|j}|yddlm t fd|Drtd|jz|D]B}t||rtd|jdt|jddd d D|tj}|s$|j|}|j|}|S|Dcgc]}||j us|}}t#|d k(r |j St#|dk(r|d S|j%|\}} } | } |j|| z| }|j|}| d d lm} | |g| S|Scc}w)Nr) Relationalc36K|]}t|ywN) isinstance).0argrs J/var/www/openai/venv/lib/python3.12/site-packages/sympy/core/operations.py z"AssocOp.__new__..?s?$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 relationalrany TypeError__name__rrtyperr _from_args _exec_constructor_postprocessorsidentitylenflattensympy.series.orderr()clsrrargstypr!objac_partnc_part order_symbolsrr(rs @r"__new__zAssocOp.__new__4s It,-Dnn ? .?$?? ACLL PQQ!#s+- \\N+S **-.273M#$ "  (11H..&C66s;CJ94a1CLL#849 t9><<  t9>7N),T):&$nnVg-~>2237  $ 0-}- - :s E84E8ct|dk(r |jSt|dk(r|dSt| |g|}|t d|D}||_|S)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.rrc34K|]}|jywrr)r r;s r"r#z%AssocOp._from_args..ys&FAq'7'7s)r4r3superr?r r)r7r8rr: __class__s r"r1zAssocOp._from_argslsd t9><<  Y!^7Ngoc)D)  !&&F&FFN+ )reevalcd|r|jdurd}n |j}|j||S)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)rr1)selfrEr8kwargsrs r" _new_rawargszAssocOp._new_rawargs}s6V d))U2!N!00Nt^44rDcg}|rN|j}|j|ur|j|jn|j ||rN|j g|dfS)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)poprCextendr8appendreverse)r7seqnew_seqos r"r5zAssocOp.flattens_  A{{c! 166"q!  7D  rDcxddlm}ddlm}t ||r t |sy|i}|k(r|S|j |}||Sddlmddlmt|jfdd \}}|s/tt|}|jrt|d }n|j|} j } | r| j | z ry|j#| } |sGjs j$r/| } || r| } | j'j'kDry|j|} | j)| |Sd }t+}|vrZ|j-t/t|j1}|jr#jrt/t|d }|j2f|z}t5|D]P}t5|D]@}|j)||}||j7|j)|}|<|ccSR|d k(r}|j$rj8rbj:j<rKddlm }j:d kDr/|jBjBj:dz zgddin1|djBz jBj:dzzgddi|dz }|jrÉjE\}}tG|dkDr4ddlm$}|d kDr|||dz |zgddin|| |dz|zgddi|dz }d dl%m&}}t+}t5|D]B}|jO\}}|j |z } | s)|jQ| || D|k7r|d z }W y|vrZy)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_isneg)ExprN) WildFunction)WildcP|jxrj| Sr)has)prVrUexprs r"z.AssocOp._matches_commutative..s# EE$ % 9dhhqk/ 9rDTbinarycn|jr(|jdjr|jdSdSNris_Mulr8 is_Numberxs r"r[z.AssocOp._matches_commutative..0!"affQi.A.AAFF1IrD)keyrcn|jr(|jdjr|jdSdSr_r`rcs r"r[z.AssocOp._matches_commutative..#rerDMulrFAdd)collect))functionrSrZrTr_matches_simplerUsymbolrVrr8r)r is_AddsortedrI free_symbols_combine_inversera count_opsmatchessetaddtuple make_argsr3reversedxreplaceis_Powexp is_Integermulribase as_coeff_Mulabsrksympy.simplify.radsimprl as_coeff_mulupdate)rGrZ repl_dictoldrSrTd wild_part exact_partexactfreenewexprcheck newpatternisawr8 expr_listlast_opwd1d2ricerkrlwasdidrVrUs ` @@r"_matches_commutativezAssocOp._matches_commutativesN + dD !*T4*@  I 4<   y 1 =H + $TYY1:! :WY/0I{{#93 &D%%z2E$$D++d2++D%8GDKK4;;&"FE??$t~~'77***I6J%%gy9 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 ~~3JJt,#*4#6D 1 s{Q w#ov rDcVd\jfd}|S)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} cTt|jdd\}}t||fS)Nc|jduS)NTr)r!s r"r[z8AssocOp._has_matcher.._ncsplit..dsC..$6rDTr\)rr8rv)rZcpartncparts r"_ncsplitz&AssocOp._has_matcher.._ncsplit_s-!6tEME6u:v% %rDct|rq|k(ry|\}}|zk(rXsytt|kr>tt|tz dzD]}|||tzk(syy)NTrF)rr4range) rZ_c_ncrrrr7ncrGs r"is_inz#AssocOp._has_matcher..is_injs$$4<"4.CFq=#RCH,!&s3x#b''9A'=!>A"1QR[1R7'+"?rDrC)rGrrrr7rs` @@@@r" _has_matcherzAssocOp._has_matcherYs1  &2nn   rDcddlm}ddlm}ddlm}ddlm}t|||fr|j||\}}||just|tr |js||jurt|ts||jur|j|n |j}g}t|jj!|} | D]8} | j#|} | |j%| (|j%| :|j|g|Sg}|j&D]8} | j#|} | |j%| (|j%| :|j|S)ab 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). rrjrh)Symbol) AppliedUndef)rwrkrrirorrmrras_independentr3r is_Function_evalfrxfuncry _eval_evalfrMr8) rGprecrkrirrrdtailr8 tail_argsr;newas r"rzAssocOp._eval_evalfysE "* dS#J '))&,?GAtDMM)q'*q}}&:dG+D'(t}}&>> 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 )rr8r r7rZs r"ryzAssocOp.make_argss%& dC 99 DM# #rDc |jddr*|jDcgc]}|jdi|}}n |j}|j|ddiScc}w)NdeepTr)getr8doitr)rGhintstermtermss r"rz AssocOp.doitsZ 99VT "48II>IDYTYY''IE>IIEtyy%/$//?sAr)NF)r/ __module__ __qualname____doc__r__annotations__rr r? classmethodr1rIr5rrrryr __classcell__rs@r"rrs8"5I4%)J") %)D5 5n *./5b!!"Wr@2 h$$.0rDrc eZdZy) ShortCircuitN)r/rrrrDr"rrsrDrcHeZdZdZdZfdZeddZedZxZ S) LatticeOpa? 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 Tc\d|D} t|j|}|st|j St |dk(rt|jStt|.|gt|}||_ |S#t$rt|jcYSwxYw)Nc32K|]}t|ywr)r+)r r!s r"r#z$LatticeOp.__new__..s/$3 #$sr) frozenset_new_args_filterrr zeror3r4rvrKrBrr?r _argset)r7r8options_argsr:rCs r"r?zLatticeOp.__new__s/$/ % c22489E3<<( ( Z1_u:>># #-cCGENCCCKJ %388$ $ %sB B+*B+c#K|xs|}|D]T}||jk(r t|||jk(r-|j|k(r|jEd{Q|Vy7 w)zGenerator filtering argsN)rrr3rr8)r7 arg_sequencecall_clsnclsr!s r"rzLatticeOp._new_args_filtersd3Cdii"3'' %T!88##  $sAA%A# A%c\t||r |jStt|gS)zG Return a set of args such that cls(*arg_set) == expr. )rrrr rs r"ryzLatticeOp.make_argss) dC << gdm_- -rDr) r/rrrrr?rrryrrs@r"rrs=$LN,  ..rDrc^eZdZdZd dZdZefdZedddZ ed Z e d Zy) AssocOpDispatchera 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 Nc||_||_d|z|_t|j|_t ||_y)Nz _%s_handler)namedoc handlerattrr_handlergetterr _dispatcher)rGrrs r"__init__zAssocOpDispatcher.__init__Ns= (4/()9)9:%d+rDc d|jzS)Nz)r)rGs r"__repr__zAssocOpDispatcher.__repr__Us 499,,rDcrt|dk(s$tdt|dt|dtt|dk(rtdt|z|jj t ||||jj t t|||y) 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: .rz*Duplicate types <%s> cannot be dispatched.) on_ambiguityN)r4 RuntimeErrorrrvrrwrxrz)rGclassesr9rs r"register_handlerclassz'AssocOpDispatcher.register_handlerclassXs7|q G mG4  s7|  !<}W?UU  U7^S|L U8G#45sVrDT)rc|rttt|}tt|j|}|j ||ddi|S)zi Parameters ========== *args : Arguments which are operated rF)rxr*r+rrdispatch)rGrr8rHhandlerss r"__call__zAssocOpDispatcher.__call__rsQ Y-.DS!4!4d;<'t}}X&GuGGGrDct|dk(r0|\}t|tstdj ||St |D]\}}t|tstdj ||dk(r|}8}|j j||}t|trgtdj |||S)zJ Select the handler class, and return its handler method. rzHandler {!r} is not a type.rz=Dispatcher for {!r} and {!r} must return a type, but got {!r})r4rr0rformat enumeraterr)rGrhrr9handler prev_handlers r"rzAssocOpDispatcher.dispatchs x=A BAa&"#@#G#G#JKKH )FAsc4("#@#G#G#LMMAv& **33L#F!'40&W^^$c7*$rDc@d|jzdg}|jr|j|jd}|dt|zz }|j|g}t t }|j jdddD]/}|j j|}||j|1|jD]x\}}djd|D}t|tr|j|@d|z}|d t|zd zz }||jz }|j|z|rFd }|dt|zz }|j|d j|}|j|d j|S) Nz,Multiply dispatched associative operator: %szcNote that support for this is experimental, see the docs for :class:`AssocOpDispatcher` for detailszRegistered handler classes =z, c38K|]}dt|zyw)z<%s>N)r)r sigs r"r#z,AssocOpDispatcher.__doc__..s M-*rsf"#@3)*-- w0ew0r  9 U.U.pf!f!rD