ó ¡¼™\c@ sØddlmZmZddlmZmZddlmZddlm Z ddl m Z m Z ddl mZddlmZddlmZd efd „ƒYZd efd „ƒYZd efd„ƒYZdS(iÿÿÿÿ(tprint_functiontdivision(t_sympifytsympify(tBasic(tcacheit(torderedtrange(t fuzzy_and(tglobal_evaluate(tsifttAssocOpcB s€eZdZdgZed„ƒZed d„ƒZd„Z ed„ƒZ ie d„Z d„Z d„Zed „ƒZRS( s 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`. tis_commutativec O s1ddlm}ttt|ƒƒ}g|D]}||jk r,|^q,}|jdƒ}|dkrutd}n|s|j |ƒ}|j |ƒ}|St |ƒdkr¶|jSt |ƒdkrÐ|dS|j |ƒ\}}} | } |j ||| ƒ}|j |ƒ}| dk r-||| ŒS|S(Niÿÿÿÿ(tOrdertevaluateii( tsympyR tlisttmapRtidentitytgettNoneR t _from_argst _exec_constructor_postprocessorstlentflatten( tclstargstoptionsR taRtobjtc_parttnc_partt order_symbolsR ((s4lib/python2.7/site-packages/sympy/core/operations.pyt__new__s*(    cC s€t|ƒdkr|jSt|ƒdkr3|dStt|ƒj||Œ}|dkrstd„|Dƒƒ}n||_|S(s/Create new instance with already-processed argsiics s|]}|jVqdS(N(R (t.0R((s4lib/python2.7/site-packages/sympy/core/operations.pys BsN(RRtsuperR R!RRR (RRR R((s4lib/python2.7/site-packages/sympy/core/operations.pyR8s  cO sC|jdtƒr*|jtkr*d}n |j}|j||ƒS(sCreate new instance of own class with args exactly as provided by caller but returning the self class identity if args is empty. 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 (as when collecting an expression's numerators and denominators) they will not show up in the result but a Mul will be returned nonetheless: >>> m = (x*y)._new_rawargs(S.One, x); m 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. treevalN(tpoptTrueR tFalseRR(tselfRtkwargsR ((s4lib/python2.7/site-packages/sympy/core/operations.pyt _new_rawargsFs*!  cC s[g}xE|rM|jƒ}|j|kr=|j|jƒq |j|ƒq Wg|dfS(sÁReturn 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(R%t __class__textendRtappendR(Rtseqtnew_seqto((s4lib/python2.7/site-packages/sympy/core/operations.pyRvs  c sddlm}m}ddlm}t||ƒrItˆ|ƒ rId S|ˆkrY|S|jˆ|ƒ}|d k r{|Sddlm ‰ddl m ‰t |j ‡‡‡fd†dtƒ\}} | sãtt|ƒƒ}n˜|j| Œ} ˆj} | r| j| rd S|jˆ| ƒ} | r\ˆjs=ˆjr\| jƒˆjƒkr\d Sn|j|Œ} | j| |ƒSd }tƒ}xŽˆ|kr|jˆƒ|jftt|jˆƒƒƒ}xwt|ƒD]i}x`t|ƒD]R}|j||ƒ}|d k rë|j|ƒjˆ|ƒ}|d k r=|SqëqëWqØW|d kr|jrêˆjrˆj j!rˆj d krª|d t"ˆj#ˆj#ˆj dgŒ‰n-|d t"dˆj#ˆj#ˆj dgŒ‰|d7}qqn)|jrˆj$ƒ\}}t%|ƒdkrw|d krF|d t"||d|gŒ‰n!|d t"| |d|gŒ‰|d7}qndd l&m'}ˆ}tƒ}x[t|ƒD]M}|j(ˆƒ\}}|j|} | r£|j)| ƒ|ˆ| ƒ‰q£q£Wˆ|kr|d 7}qqnPqqWd S( sR 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. For instance: >>> 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. i(tAddtExpriÿÿÿÿ(tMul(t WildFunction(tWildc s |jˆˆƒoˆj|ƒ S(N(thas(tp(R5R4texpr(s4lib/python2.7/site-packages/sympy/core/operations.pyt½stbinaryiR(tcollectN(*R8R1R2RR3t isinstanceRt_matches_simpletfunctionR4tsymbolR5R RR&RRR*t free_symbolst_combine_inversetis_Addtis_Mult count_opstmatchestsettaddRttuplet make_argstreversedtxreplacetis_Powtexpt is_IntegerR'tbaset as_coeff_Multabstsympy.simplify.radsimpR;t as_coeff_multupdate(R(R8t repl_dicttoldR1R2R3tdt wild_partt exact_parttexacttfreetnewexprt newpatterntitsawt expr_listtlast_optwtd1td2tcteR;twastdid((R5R4R8s4lib/python2.7/site-packages/sympy/core/operations.pyt_matches_commutative†s†'     %    ,-    #!       c sCd„‰ˆˆƒ\‰‰ˆj‰‡‡‡‡‡fd†}|S(sHelper for .has()cS s1t|jd„dtƒ\}}t|ƒ|fS(NcS s |jtkS(N(R R&(targ((s4lib/python2.7/site-packages/sympy/core/operations.pyR9tR:(R RR&RF(R8tcparttncpart((s4lib/python2.7/site-packages/sympy/core/operations.pyt_ncsplit s c sÏ|ˆkrtSt|tƒs#tSt|ˆƒrˈ|ƒ\}}ˆ|@ˆkrˈs^tStˆƒt|ƒkrÈxLtt|ƒtˆƒdƒD]'}|||tˆƒ!ˆkr—tSq—WqÈqËntS(Ni(R&R<RR'RR(R8t_ct_ncR^(RnReRtncR((s4lib/python2.7/site-packages/sympy/core/operations.pytis_ins '(R+(R(Rr((RnReRRqR(s4lib/python2.7/site-packages/sympy/core/operations.pyt _has_matchers   c C s²ddlm}ddlm}ddlm}ddlm}t|||fƒrS|j ||ƒ\}}||j kp¯t|t ƒr”|j p¯||j ko¯t|t ƒsS||j k rÐ|j |ƒn|j }g}t|jj|ƒƒ} xF| D]>} | j|ƒ} | dkr/|j| ƒqþ|j| ƒqþW|j||ŒSng}xI|jD]>} | j|ƒ} | dkr”|j| ƒqc|j| ƒqcW|j|ŒS(sc 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. Nunmbers 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). i(R1(R3(tSymbol(t AppliedUndefN(RGR1tmulR3R?RtR>RuR<tas_independentRR t is_Functiont_evalfRHtfuncRIt _eval_evalfRR-R( R(tprecR1R3RtRutxttailRt tail_argsRtnewa((s4lib/python2.7/site-packages/sympy/core/operations.pyR{%s2 '   cC s't||ƒr|jSt|ƒfSdS(sL Return a sequence of elements `args` such that cls(*args) == expr >>> 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 N(R<RR(RR8((s4lib/python2.7/site-packages/sympy/core/operations.pyRIYsN(t__name__t __module__t__doc__t __slots__RR!t classmethodRRR*RR'RiRsR{RI(((s4lib/python2.7/site-packages/sympy/core/operations.pyR s   0  4t ShortCircuitcB seZRS((RR‚(((s4lib/python2.7/site-packages/sympy/core/operations.pyR†ost LatticeOpcB sbeZdZeZd„Zedd„ƒZed„ƒZ e e d„ƒƒZ e d„ƒZRS(sô Join/meet operations of an algebraic lattice[1]. 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. >>> 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 cO s¨d„|Dƒ}yt|j|ƒƒ}Wntk rFt|jƒSX|sZt|jƒSt|ƒdkr|t|ƒjƒSt t |ƒj ||ƒ}||_ |SdS(Ncs s|]}t|ƒVqdS(N(R(R"Rj((s4lib/python2.7/site-packages/sympy/core/operations.pys –si( t frozensett_new_args_filterR†RtzeroRRRFR%R#R R!t_argset(RRRt_argsR((s4lib/python2.7/site-packages/sympy/core/operations.pyR!•s   cc s„|p |}xq|D]i}||jkr7t|ƒ‚q||jkrLqq|j|krwx|jD] }|VqeWq|VqWdS(sGenerator filtering argsN(RŠR†RRzR(Rt arg_sequencetcall_clstnclsRjR}((s4lib/python2.7/site-packages/sympy/core/operations.pyR‰«s   cC s-t||ƒr|jStt|ƒgƒSdS(sG Return a set of args such that cls(*arg_set) == expr. N(R<R‹RˆR(RR8((s4lib/python2.7/site-packages/sympy/core/operations.pyRIºscC stt|jƒƒS(N(RHRR‹(R(((s4lib/python2.7/site-packages/sympy/core/operations.pyRÄscC s,t|ƒt|ƒkt|ƒt|ƒkS(N(tstr(Rtb((s4lib/python2.7/site-packages/sympy/core/operations.pyt_compare_prettyÉsN(RR‚RƒR&R R!R…RR‰RItpropertyRRt staticmethodR’(((s4lib/python2.7/site-packages/sympy/core/operations.pyR‡ss  N(t __future__RRtsympy.core.sympifyRRtsympy.core.basicRtsympy.core.cacheRtsympy.core.compatibilityRRtsympy.core.logicRtsympy.core.evaluateR tsympy.utilities.iterablesR R t ExceptionR†R‡(((s4lib/python2.7/site-packages/sympy/core/operations.pytsÿd