\c@ sQdZddlmZmZddlmZddlmZddlm Z m Z ddl m Z ddl mZm Z mZdd lmZmZmZmZmZmZmZmZmZdd lmZdd lmZd Zd ee fdYZdefdYZ dZ!e"dZ#defdYZ$dZ%dS(s'Base class for all the objects in SymPyi(tprint_functiontdivision(t defaultdict(tchaini(t BasicMetatManagedProperties(tcacheit(t_sympifytsympifyt SympifyError( titerabletIteratortorderedt string_typestwith_metaclasst zip_longesttrangetPY3tMapping(tS(tgetmrocC sLddlm}yt|SWn'tk rGtd||nXdS(sReturn expr as a Basic instance using strict sympify or raise a TypeError; this is just a wrapper to _sympify, raising a TypeError instead of a SympifyError.i(t func_names)Argument must be a Basic object, not `%s`N(tsympy.utilities.miscRRR t TypeError(texprR((s/lib/python2.7/site-packages/sympy/core/basic.pytas_Basics tBasiccB sYeZdZdddgZeZeZeZeZeZ eZ eZ eZ eZ eZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZ eZ!eZ"dZ#dZ$dZ%dZ&dZ'd Z(d Z)d Z*e+d Z,d Z-e.dZ/e0dZ1e0dZ2e3d<dZ5dZ6dZ7d<dZ8dZ9dZ:dZ;e;Z<dZ=e+dZ>e+dZ?dZ@e+dZAdZBe.dZCdZDe+d ZEe+d!ZFe+d"ZGe+d#ZHd$ZIeeJd%ZKd&ZLe3d'ZMd(ZNd)ZOd*ZPe3d+ZQd,ZRd-ZSeeJd<d.ZTed/ZUd0ZVied1ZWed2ZXd<d3ZYd4ZZd5Z[d6Z\d7Z]d8Z^d9Z_d:Z`iZae0d;ZbRS(=s Base class for all objects in SymPy. Conventions: 1) Always use ``.args``, when accessing parameters of some instance: >>> from sympy import cot >>> from sympy.abc import x, y >>> cot(x).args (x,) >>> cot(x).args[0] x >>> (x*y).args (x, y) >>> (x*y).args[1] y 2) Never use internal methods or variables (the ones prefixed with ``_``): >>> cot(x)._args # do not use this, use cot(x).args instead (x,) t_mhasht_argst _assumptionscG s1tj|}|j|_d|_||_|S(N(tobjectt__new__tdefault_assumptionsRtNoneRR(tclstargstobj((s/lib/python2.7/site-packages/sympy/core/basic.pyR`s    cC s|j|jS(N(tfuncR#(tself((s/lib/python2.7/site-packages/sympy/core/basic.pytcopyhscC st||j|jfS(s Pickling support.(ttypet__getnewargs__t __getstate__(R&tproto((s/lib/python2.7/site-packages/sympy/core/basic.pyt __reduce_ex__kscC s|jS(N(R#(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyR)oscC siS(N((R&((s/lib/python2.7/site-packages/sympy/core/basic.pyR*rscC s1x*|jD]\}}t|||q WdS(N(titemstsetattr(R&tstatetktv((s/lib/python2.7/site-packages/sympy/core/basic.pyt __setstate__uscC sG|j}|dkrCtt|jf|j}||_n|S(N(RR!thashR(t__name__t_hashable_content(R&th((s/lib/python2.7/site-packages/sympy/core/basic.pyt__hash__ys   " cC s|jS(sReturn a tuple of information about self that can be used to compute the hash. If a class defines additional attributes, like ``name`` in Symbol, then this method should be updated accordingly to return such relevant attributes. Defining more than _hashable_content is necessary if __eq__ has been defined by a class. See note about this in Basic.__eq__.(R(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyR5scC siS(s Return object `type` assumptions. For example: Symbol('x', real=True) Symbol('x', integer=True) are different objects. In other words, besides Python type (Symbol in this case), the initial assumptions are also forming their typeinfo. Examples ======== >>> from sympy import Symbol >>> from sympy.abc import x >>> x.assumptions0 {'commutative': True} >>> x = Symbol("x", positive=True) >>> x.assumptions0 {'commutative': True, 'complex': True, 'hermitian': True, 'imaginary': False, 'negative': False, 'nonnegative': True, 'nonpositive': False, 'nonzero': True, 'positive': True, 'real': True, 'zero': False} ((R&((s/lib/python2.7/site-packages/sympy/core/basic.pyt assumptions0sc C s9||krdS|j}|j}||k||k}|rB|S|j}|j}t|t|kt|t|k}|r|Sxt||D]\}}t|trt|n|}t|trt|n|}t|tr|j|}n||k||k}|r|SqWdS(s Return -1, 0, 1 if the object is smaller, equal, or greater than other. Not in the mathematical sense. If the object is of a different type from the "other" then their classes are ordered according to the sorted_classes list. Examples ======== >>> from sympy.abc import x, y >>> x.compare(y) -1 >>> x.compare(x) 0 >>> y.compare(x) 1 i(t __class__R5tlentzipt isinstancet frozensetRtcompare( R&tothertn1tn2tctsttottltr((s/lib/python2.7/site-packages/sympy/core/basic.pyR>s*     .!!cC spddlm}t||r3t|| r3dSt|| rVt||rVdS|jr|jr|j|j}|j|j}||k||kSddlm}|d|d|d}}}|j|||} | r`|| kr`| |} |j|||} | r`|| kr`| |} t j | | } | dkr]| Sq`nt j ||S( Ni(tOrderi(tWildtp1tp2tp3i( tsympy.series.orderRGR<t is_Rationaltptqtsympy.core.symbolRHtmatchRR>(tatbRGRERFRHRIRJRKtr_ata3tr_btb3RB((s/lib/python2.7/site-packages/sympy/core/basic.pyt_compare_prettys*&    cK s|t||S(sa Create a new object from an iterable. This is a convenience function that allows one to create objects from any iterable, without having to convert to a list or tuple first. Examples ======== >>> from sympy import Tuple >>> Tuple.fromiter(i for i in range(5)) (0, 1, 2, 3, 4) (ttuple(R"R#t assumptions((s/lib/python2.7/site-packages/sympy/core/basic.pytfromiterscC sdd|jfS(sNice order of classes. ii(R4(R"((s/lib/python2.7/site-packages/sympy/core/basic.pyt class_keysc skfd}|j}t|tg|D]}||^q+f}|j|tjjtjfS(s Return a sort key. Examples ======== >>> from sympy.core import S, I >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key()) [1/2, -I, I] >>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]") [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)] >>> sorted(_, key=lambda x: x.sort_key()) [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2] c s$t|tr|jS|SdS(N(R<Rtsort_key(targ(torder(s/lib/python2.7/site-packages/sympy/core/basic.pyt inner_keys (t _sorted_argsR:RYR\RtOneR](R&R_R`R#R^((R_s/lib/python2.7/site-packages/sympy/core/basic.pyR] s 1cC s||krtSt|}t|}||k ryt|}t|}Wntk rdtSXtst|jtjk r||krtSq||k rtSn|j|jkS(sReturn a boolean indicating whether a == b on the basis of their symbolic trees. This is the same as a.compare(b) == 0 but faster. Notes ===== If a class that overrides __eq__() needs to retain the implementation of __hash__() from a parent class, the interpreter must be told this explicitly by setting __hash__ = .__hash__. Otherwise the inheritance of __hash__() will be blocked, just as if __hash__ had been explicitly set to None. References ========== from http://docs.python.org/dev/reference/datamodel.html#object.__hash__ ( tTrueR(RR tNotImplementedRt__ne__tFalseR5(R&R?ttselfttother((s/lib/python2.7/site-packages/sympy/core/basic.pyt__eq__)s         cC s ||k S(sa != b -> Compare two symbolic trees and see whether they are different this is the same as: a.compare(b) != 0 but faster ((R&R?((s/lib/python2.7/site-packages/sympy/core/basic.pyReWs c C s|j}t|}|j}g|jD]}|jr.|^q.}t|dkrj|j}n ||kS|dkr|j}t|dkr|j}q||kSn|j} |j|| |j|| kS(s Compare two expressions and handle dummy symbols. Examples ======== >>> from sympy import Dummy >>> from sympy.abc import x, y >>> u = Dummy('u') >>> (u**2 + 1).dummy_eq(x**2 + 1) True >>> (u**2 + 1) == (x**2 + 1) False >>> (u**2 + y).dummy_eq(x**2 + y, x) True >>> (u**2 + y).dummy_eq(x**2 + y, y) False iN( tas_dummyRt free_symbolstis_DummyR:tpopR!R9tsubs( R&R?tsymboltstotit dummy_symbolstdummytsymbolsttmp((s/lib/python2.7/site-packages/sympy/core/basic.pytdummy_eqbs   %     cC s ddlm}||ddS(s_Method to return the string representation. Return the expression as a string. i(tsstrR_N(tsympy.printingRxR!(R&Rx((s/lib/python2.7/site-packages/sympy/core/basic.pyt__repr__scC s ddlm}||ddS(Ni(RxR_(RyRxR!(R&Rx((s/lib/python2.7/site-packages/sympy/core/basic.pyt__str__scC s*ddlm}||dd}d|S(s^ IPython/Jupyter LaTeX printing To change the behavior of this (e.g., pass in some settings to LaTeX), use init_printing(). init_printing() will also enable LaTeX printing for built in numeric types like ints and container types that contain SymPy objects, like lists and dictionaries of expressions. i(tlatextmodetplains$\displaystyle %s$(tsympy.printing.latexR|(R&R|Rp((s/lib/python2.7/site-packages/sympy/core/basic.pyt _repr_latex_s cG s|rCtg|D]'}t|tr+|n t|^q}n tf}t}x3t|D]%}t||rb|j|qbqbW|S(s Returns the atoms that form the current object. By default, only objects that are truly atomic and can't be divided into smaller pieces are returned: symbols, numbers, and number symbols like I and pi. It is possible to request atoms of any type, however, as demonstrated below. Examples ======== >>> from sympy import I, pi, sin >>> from sympy.abc import x, y >>> (1 + x + 2*sin(y + I*pi)).atoms() {1, 2, I, pi, x, y} If one or more types are given, the results will contain only those types of atoms. >>> from sympy import Number, NumberSymbol, Symbol >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol) {x, y} >>> (1 + x + 2*sin(y + I*pi)).atoms(Number) {1, 2} >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol) {1, 2, pi} >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I) {1, 2, I, pi} Note that I (imaginary unit) and zoo (complex infinity) are special types of number symbols and are not part of the NumberSymbol class. The type can be given implicitly, too: >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol {x, y} Be careful to check your assumptions when using the implicit option since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type of sympy atom, while ``type(S(2))`` is type ``Integer`` and will find all integers in an expression: >>> from sympy import S >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1)) {1} >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2)) {1, 2} Finally, arguments to atoms() can select more than atomic atoms: any sympy type (loaded in core/__init__.py) can be listed as an argument and those types of "atoms" as found in scanning the arguments of the expression recursively: >>> from sympy import Function, Mul >>> from sympy.core.function import AppliedUndef >>> f = Function('f') >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function) {f(x), sin(y + I*pi)} >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef) {f(x)} >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul) {I*pi, 2*sin(y + I*pi)} (RYR<R(tAtomtsettpreorder_traversaltadd(R&ttypestttresultR((s/lib/python2.7/site-packages/sympy/core/basic.pytatomssE:  cC s)tjg|jD]}|j^qS(sOReturn from the atoms of self those which are free symbols. For most expressions, all symbols are free symbols. For some classes this is not true. e.g. Integrals use Symbols for the dummy variables which are bound variables, so Integral has a method to return all symbols except those. Derivative keeps track of symbols with respect to which it will perform a derivative; those are bound variables, too, so it has its own free_symbols method. Any other method that uses bound variables should implement a free_symbols method.(RtunionR#Rk(R&RR((s/lib/python2.7/site-packages/sympy/core/basic.pyRks cC s tgS(N(R(R&((s/lib/python2.7/site-packages/sympy/core/basic.pytexpr_free_symbolssc s%d|jdfdS(sReturn the expression with any objects having structurally bound symbols replaced with unique, canonical symbols within the object in which they appear and having only the default assumption for commutativity being True. Examples ======== >>> from sympy import Integral, Symbol >>> from sympy.abc import x, y >>> r = Symbol('r', real=True) >>> Integral(r, (r, x)).as_dummy() Integral(_0, (_0, x)) >>> _.variables[0].is_real is None True Notes ===== Any object that has structural dummy variables should have a property, `bound_symbols` that returns a list of structural dummy symbols of the object itself. Lambda and Subs have bound symbols, but because of how they are cached, they already compare the same regardless of their bound symbols: >>> from sympy import Lambda >>> Lambda(x, x + 1) == Lambda(y, y + 1) True cS scd|jD}|j|}|j}|j|}|jtd|jD}|S(NcS si|]}|j|qS((Rj(t.0Rr((s/lib/python2.7/site-packages/sympy/core/basic.pys 4s cs s!|]\}}||fVqdS(N((RR0R1((s/lib/python2.7/site-packages/sympy/core/basic.pys ;s(t bound_symbolsRntcanonical_variablestxreplacetdictR-(txtdRB((s/lib/python2.7/site-packages/sympy/core/basic.pytcan3s  %cS s t|dS(NR(thasattr(R((s/lib/python2.7/site-packages/sympy/core/basic.pyt>tc s |S(N((R(R(s/lib/python2.7/site-packages/sympy/core/basic.pyR?R(treplace(R&((Rs/lib/python2.7/site-packages/sympy/core/basic.pyRjs c C sddlm}ddlm}t|ds3iS|d}i}|j}tg|j|t|D]}|j^qk}xd|D]\}t |}|j rx4|j|jks|j|krt |}qWn|||>> from sympy import Lambda >>> from sympy.abc import x >>> Lambda(x, 2*x).canonical_variables {x: _0} i(tSymbol(tnumbered_symbolsRt_( RPRtsympy.utilities.iterablesRRRRRtnametnextt is_Symbol( R&RRtdumstrepsR1RrtfreeR((s/lib/python2.7/site-packages/sympy/core/basic.pyRAs  5   $cG stj||S(sApply on the argument recursively through the expression tree. This method is used to simulate a common abuse of notation for operators. For instance in SymPy the the following will not work: ``(x+Lambda(y, 2*y))(z) == x+2*z``, however you can use >>> from sympy import Lambda >>> from sympy.abc import x, y, z >>> (x + Lambda(y, 2*y)).rcall(z) x + 2*z (Rt_recursive_call(R&R#((s/lib/python2.7/site-packages/sympy/core/basic.pytrcallascC sddlm}d}t|rQ||rQt||rD|S||SnE|jrg|jD]}tj||^qd}t||S|SdS(s!Helper for rcall method. i(RcS s:x3tt|D]}d|jkr|tkSqWdS(Nt__call__(RR(t__dict__R(RR"((s/lib/python2.7/site-packages/sympy/core/basic.pytthe_call_method_is_overriddenwsN(tsympyRtcallableR<R#RRR((t expr_to_callton_argsRRtsubR#((s/lib/python2.7/site-packages/sympy/core/basic.pyRrs   %cC s#ddlm}|||dk S(Ni(t hypersimp(tsympy.simplifyRR!(R&R0R((s/lib/python2.7/site-packages/sympy/core/basic.pytis_hypergeometricscC s|j}|tkrtS|js&tSg|jD]$}|jsQ|jdn|^q3\}}|jor|jsytS|rtS|jdkSdS(sReturn True if self can be computed to a real number (or already is a real number) with precision, else False. Examples ======== >>> from sympy import exp_polar, pi, I >>> (I*exp_polar(I*pi/2)).is_comparable True >>> (I*exp_polar(I*pi*2)).is_comparable False A False result does not mean that `self` cannot be rewritten into a form that would be comparable. For example, the difference computed below is zero but without simplification it does not evaluate to a zero with precision: >>> e = 2**pi*(1 + 2**pi) >>> dif = e - e.expand() >>> dif.is_comparable False >>> dif.n(2)._prec 1 iiN(tis_realRft is_numbert as_real_imagt is_Numbertevalft_prec(R&RRNtnRr((s/lib/python2.7/site-packages/sympy/core/basic.pyt is_comparables   :cC s|jS(s The top-level function in an expression. The following should hold for all objects:: >> x == x.func(*x.args) Examples ======== >>> from sympy.abc import x >>> a = 2*x >>> a.func >>> a.args (2, x) >>> a.func(*a.args) 2*x >>> a == a.func(*a.args) True (R9(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyR%scC s|jS(s>Returns a tuple of arguments of 'self'. Examples ======== >>> from sympy import cot >>> from sympy.abc import x, y >>> cot(x).args (x,) >>> cot(x).args[0] x >>> (x*y).args (x, y) >>> (x*y).args[1] y Notes ===== Never use self._args, always use self.args. Only use _args in __new__ when creating a new function. Don't override .args() from Basic (so that it's easy to change the interface in the future if needed). (R(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyR#scC s|jS(s The same as ``args``. Derived classes which don't fix an order on their arguments should override this method to produce the sorted representation. (R#(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyRascO sVddlm}m}y'||||}|js8dS|SWn|k rQdSXdS(sConverts ``self`` to a polynomial or returns ``None``. >>> from sympy import sin >>> from sympy.abc import x, y >>> print((x**2 + x*y).as_poly()) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + x*y).as_poly(x, y)) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + sin(y)).as_poly(x, y)) None i(tPolytPolynomialErrorN(t sympy.polysRRtis_PolyR!(R&tgensR#RRtpoly((s/lib/python2.7/site-packages/sympy/core/basic.pytas_polys  cC s tj|fS(sA stub to allow Basic args (like Tuple) to be skipped when computing the content and primitive components of an expression. See Also ======== sympy.core.expr.Expr.as_content_primitive (RRb(R&tradicaltclear((s/lib/python2.7/site-packages/sympy/core/basic.pytas_content_primitives c O s9ddlm}ddlm}ddlm}m}t}t|dkr|d}t |t rpt }qt ||t frt }|j }qt|sddlm} t| dqn*t|d kr|g}n td t|}xt|D]\} } t | dtrM|| d| df} ny3g| D]"} t| d t | t ^qW} Wntk rd|| >> from sympy import pi, exp, limit, oo >>> from sympy.abc import x, y >>> (1 + x*y).subs(x, pi) pi*y + 1 >>> (1 + x*y).subs({x:pi, y:2}) 1 + 2*pi >>> (1 + x*y).subs([(x, pi), (y, 2)]) 1 + 2*pi >>> reps = [(y, x**2), (x, 2)] >>> (x + y).subs(reps) 6 >>> (x + y).subs(reversed(reps)) x**2 + 2 >>> (x**2 + x**4).subs(x**2, y) y**2 + y To replace only the x**2 but not the x**4, use xreplace: >>> (x**2 + x**4).xreplace({x**2: y}) x**4 + y To delay evaluation until all substitutions have been made, set the keyword ``simultaneous`` to True: >>> (x/y).subs([(x, 0), (y, 0)]) 0 >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True) nan This has the added feature of not allowing subsequent substitutions to affect those already made: >>> ((x + y)/y).subs({x + y: y, y: x + y}) 1 >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True) y/(x + y) In order to obtain a canonical result, unordered iterables are sorted by count_op length, number of arguments and by the default_sort_key to break any ties. All other iterables are left unsorted. >>> from sympy import sqrt, sin, cos >>> from sympy.abc import a, b, c, d, e >>> A = (sqrt(sin(2*x)), a) >>> B = (sin(2*x), b) >>> C = (cos(2*x), c) >>> D = (x, d) >>> E = (exp(x), e) >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x) >>> expr.subs(dict([A, B, C, D, E])) a*c*sin(d*e) + b The resulting expression represents a literal replacement of the old arguments with the new arguments. This may not reflect the limiting behavior of the expression: >>> (x**3 - 3*x).subs({x: oo}) nan >>> limit(x**3 - 3*x, x, oo) oo If the substitution will be followed by numerical evaluation, it is better to pass the substitution to evalf as >>> (1/x).evalf(subs={x: 3.0}, n=21) 0.333333333333333333333 rather than >>> (1/x).subs({x: 3.0}).evalf(21) 0.333333333333333314830 as the former will ensure that the desired level of precision is obtained. See Also ======== replace: replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements xreplace: exact node replacement in expr tree; also capable of using matching rules evalf: calculates the given formula to a desired level of precision i(tDict(tdefault_sort_key(tDummyRii(t filldedents When a single argument is passed to subs it should be a dictionary of old: new pairs or an iterable of (old, new) tuples.is$subs accepts either 1 or 2 argumentststrictcs s|]}|jVqdS(N(tis_Atom(RR0((s/lib/python2.7/site-packages/sympy/core/basic.pys streversetkeyt simultaneousthack2t commutativeN(ii(,tsympy.core.containersRtsympy.utilitiesRRRRRfR:R<RRcRR-R RRt ValueErrortlistt enumerateR RR R!t_aresameRYtfilterRtallt count_opsR#Rt setdefaulttappendtsortedtkeystextendRmtis_commutativet_subsRRRbR(R&R#tkwargsRRRRt unorderedtsequenceRRrRpRRRqRtopstnewseqR0R1Rtrvtmtoldtnew((s/lib/python2.7/site-packages/sympy/core/basic.pyRn&sq      0  &   #2# .     c sYfd}t||r"|S|j||}|dkrU||||}n|S(s Substitutes an expression old -> new. If self is not equal to old then _eval_subs is called. If _eval_subs doesn't want to make any special replacement then a None is received which indicates that the fallback should be applied wherein a search for replacements is made amongst the arguments of self. >>> from sympy import Add >>> from sympy.abc import x, y, z Examples ======== Add's _eval_subs knows how to target x + y in the following so it makes the change: >>> (x + y + z).subs(x + y, 1) z + 1 Add's _eval_subs doesn't need to know how to find x + y in the following: >>> Add._eval_subs(z*(x + y) + 3, x + y, 1) is None True The returned None will cause the fallback routine to traverse the args and pass the z*(x + y) arg to Mul where the change will take place and the substitution will succeed: >>> (z*(x + y) + 3).subs(x + y, 1) z + 3 ** Developers Notes ** An _eval_subs routine for a class should be written if: 1) any arguments are not instances of Basic (e.g. bool, tuple); 2) some arguments should not be targeted (as in integration variables); 3) if there is something other than a literal replacement that should be attempted (as in Piecewise where the condition may be updated without doing a replacement). If it is overridden, here are some special cases that might arise: 1) If it turns out that no special change was made and all the original sub-arguments should be checked for replacements then None should be returned. 2) If it is necessary to do substitutions on a portion of the expression then _subs should be called. _subs will handle the case of any sub-expression being equal to old (which usually would not be the case) while its fallback will handle the recursion into the sub-arguments. For example, after Add's _eval_subs removes some matching terms it must process the remaining terms so it calls _subs on each of the un-matched terms and then adds them onto the terms previously obtained. 3) If the initial expression should remain unchanged then the original expression should be returned. (Whenever an expression is returned, modified or not, no further substitution of old -> new is attempted.) Sum's _eval_subs routine uses this strategy when a substitution is attempted on any of its summation variables. c  sHt}t|j}xjt|D]\\}}t|dsCq"n|j||}t|||s"t}|||>> from sympy import symbols, pi, exp >>> x, y, z = symbols('x y z') >>> (1 + x*y).xreplace({x: pi}) pi*y + 1 >>> (1 + x*y).xreplace({x: pi, y: 2}) 1 + 2*pi Replacements occur only if an entire node in the expression tree is matched: >>> (x*y + z).xreplace({x*y: pi}) z + pi >>> (x*y*z).xreplace({x*y: pi}) x*y*z >>> (2*x).xreplace({2*x: y, x: z}) y >>> (2*2*x).xreplace({2*x: y, x: z}) 4*z >>> (x + y + 2).xreplace({x + y: 2}) x + y + 2 >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y}) x + exp(y) + 2 xreplace doesn't differentiate between free and bound symbols. In the following, subs(x, y) would not change x since it is a bound symbol, but xreplace does: >>> from sympy import Integral >>> Integral(x, (x, 1, 2*x)).xreplace({x: y}) Integral(y, (y, 1, 2*y)) Trying to replace x with an expression raises an error: >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP ValueError: Invalid limits given: ((2*y, 1, 4*y),) See Also ======== replace: replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements subs: substitution of subexpressions as defined by the objects themselves. (t _xreplace(R&truletvalueR((s/lib/python2.7/site-packages/sympy/core/basic.pyRbs<cC s||kr||tfS|rg}t}xj|jD]_}t|dd}|dk r||}|j|d||dO}q6|j|q6Wt|}|r|j|tfSn|tfS(sV Helper for xreplace. Tracks whether a replacement actually occurred. RiiN(RcRfR#tgetattrR!RRYR%(R&RR#tchangedRRRta_xr((s/lib/python2.7/site-packages/sympy/core/basic.pyRs     c stfd|DS(s Test whether any subexpression matches any of the patterns. Examples ======== >>> from sympy import sin >>> from sympy.abc import x, y, z >>> (x**2 + sin(x*y)).has(z) False >>> (x**2 + sin(x*y)).has(x, y, z) True >>> x.has(x) True Note ``has`` is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval: >>> from sympy.sets import Interval >>> i = Interval.Lopen(0, 5); i Interval.Lopen(0, 5) >>> i.args (0, 5, True, False) >>> i.has(4) # there is no "4" in the arguments False >>> i.has(0) # there *is* a "0" in the arguments True Instead, use ``contains`` to determine whether a number is in the interval or not: >>> i.contains(4) True >>> i.contains(0) False Note that ``expr.has(*patterns)`` is exactly equivalent to ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is returned when the list of patterns is empty. >>> x.has() False c3 s|]}j|VqdS(N(t_has(Rtpattern(R&(s/lib/python2.7/site-packages/sympy/core/basic.pys s(tany(R&tpatterns((R&s/lib/python2.7/site-packages/sympy/core/basic.pythass/c sddlm}m}t|rKtfd|j||DStttrtfdt|DSt dd}|dk r|tfdt|DStfdt|DSdS( sHelper for .has()i(tUndefinedFunctiontFunctionc3 s*|] }|jkp!|kVqdS(N(R%(Rtf(R(s/lib/python2.7/site-packages/sympy/core/basic.pys sc3 s|]}t|VqdS(N(R<(RR^(R(s/lib/python2.7/site-packages/sympy/core/basic.pys st _has_matcherc3 s|]}|VqdS(N((RR^(RQ(s/lib/python2.7/site-packages/sympy/core/basic.pys sc3 s|]}|kVqdS(N((RR^(R(s/lib/python2.7/site-packages/sympy/core/basic.pys sN( tsympy.core.functionRRR<RRRRRRR!(R&RRRR((RQRs/lib/python2.7/site-packages/sympy/core/basic.pyRs    c s fdS(sHelper for .has()c s |kS(N((R?(R&(s/lib/python2.7/site-packages/sympy/core/basic.pyRR((R&((R&s/lib/python2.7/site-packages/sympy/core/basic.pyRsc  sddlmm}ddlm}ytWntk rInXytWntk rmnXttrfdttrfdqt rfdqt dntt rfd|dkrt j|d kn|}tt r^|rLfd qfd qt r|rfd qfd qt dnKt rt rfdqt dn t digfd}|||dt} r{ttx3D](\} } i| | 6| j} qLWn|s| Srx@D]5\} } i| | 6fdjDqWn| fSdS(s3 Replace matching subexpressions of ``self`` with ``value``. If ``map = True`` then also return the mapping {old: new} where ``old`` was a sub-expression found with query and ``new`` is the replacement value for it. If the expression itself doesn't match the query, then the returned value will be ``self.xreplace(map)`` otherwise it should be ``self.subs(ordered(map.items()))``. Traverses an expression tree and performs replacement of matching subexpressions from the bottom to the top of the tree. The default approach is to do the replacement in a simultaneous fashion so changes made are targeted only once. If this is not desired or causes problems, ``simultaneous`` can be set to False. In addition, if an expression containing more than one Wild symbol is being used to match subexpressions and the ``exact`` flag is True, then the match will only succeed if non-zero values are received for each Wild that appears in the match pattern. The list of possible combinations of queries and replacement values is listed below: Examples ======== Initial setup >>> from sympy import log, sin, cos, tan, Wild, Mul, Add >>> from sympy.abc import x, y >>> f = log(sin(x)) + tan(sin(x**2)) 1.1. type -> type obj.replace(type, newtype) When object of type ``type`` is found, replace it with the result of passing its argument(s) to ``newtype``. >>> f.replace(sin, cos) log(cos(x)) + tan(cos(x**2)) >>> sin(x).replace(sin, cos, map=True) (cos(x), {sin(x): cos(x)}) >>> (x*y).replace(Mul, Add) x + y 1.2. type -> func obj.replace(type, func) When object of type ``type`` is found, apply ``func`` to its argument(s). ``func`` must be written to handle the number of arguments of ``type``. >>> f.replace(sin, lambda arg: sin(2*arg)) log(sin(2*x)) + tan(sin(2*x**2)) >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args))) sin(2*x*y) 2.1. pattern -> expr obj.replace(pattern(wild), expr(wild)) Replace subexpressions matching ``pattern`` with the expression written in terms of the Wild symbols in ``pattern``. >>> a, b = map(Wild, 'ab') >>> f.replace(sin(a), tan(a)) log(tan(x)) + tan(tan(x**2)) >>> f.replace(sin(a), tan(a/2)) log(tan(x/2)) + tan(tan(x**2/2)) >>> f.replace(sin(a), a) log(x) + tan(x**2) >>> (x*y).replace(a*x, a) y Matching is exact by default when more than one Wild symbol is used: matching fails unless the match gives non-zero values for all Wild symbols: >>> (2*x + y).replace(a*x + b, b - a) y - 2 >>> (2*x).replace(a*x + b, b - a) 2*x When set to False, the results may be non-intuitive: >>> (2*x).replace(a*x + b, b - a, exact=False) 2/x 2.2. pattern -> func obj.replace(pattern(wild), lambda wild: expr(wild)) All behavior is the same as in 2.1 but now a function in terms of pattern variables is used rather than an expression: >>> f.replace(sin(a), lambda a: sin(2*a)) log(sin(2*x)) + tan(sin(2*x**2)) 3.1. func -> func obj.replace(filter, func) Replace subexpression ``e`` with ``func(e)`` if ``filter(e)`` is True. >>> g = 2*sin(x**3) >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2) 4*sin(x**9) The expression itself is also targeted by the query but is done in such a fashion that changes are not made twice. >>> e = x*(x*y + 1) >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x) 2*x*(2*x*y + 1) See Also ======== subs: substitution of subexpressions as defined by the objects themselves. xreplace: exact node replacement in expr tree; also capable of using matching rules i(RRH(t bottom_upc s t|S(N(R<(R(tquery(s/lib/python2.7/site-packages/sympy/core/basic.pyRRc s |jS(N(R#(RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRRc s |jS(N(R#(RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRRs:given a type, replace() expects another type or a callablec s |jS(N(RQ(R(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRRic s#t|jrj|S|S(N(RtvaluesRn(RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRsc s j|S(N(Rn(RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRRc s:td|jDr6d|jDS|S(Ncs s|] }|VqdS(N((Rtval((s/lib/python2.7/site-packages/sympy/core/basic.pys scS s)i|]\}}|t|d qS(i(tstr(RR0R1((s/lib/python2.7/site-packages/sympy/core/basic.pys s (RRR-(RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRsc sd|jDS(NcS s)i|]\}}|t|d qS(i(R(RR0R1((s/lib/python2.7/site-packages/sympy/core/basic.pys s (R-(RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRssGgiven an expression, replace() expects another expression or a callablec s |S(N((RR(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRRs4given a callable, replace() expects another callablesGfirst argument to replace() must be a type, an expression or a callablec s|}|s|ikr||}|dk r||kr||<rt|dt}|dkr|t}nd|}j||f|}q|}qn|S(NRR(R!RRcR(RRRtcomR(Rt_queryt_valuetmappingtmaskR(s/lib/python2.7/site-packages/sympy/core/basic.pyt rec_replaces      Rc s1i|]'\}}|j|jqS((R(RR0R1(RF(s/lib/python2.7/site-packages/sympy/core/basic.pys s N(RPRRHtsympy.simplify.simplifyRRR R<R(RRRR!R:RRcRtreversedRR-( R&RRtmapRtexactRHRRRRqR(( RRRRRRRFRRs/lib/python2.7/site-packages/sympy/core/basic.pyRspy    -         cC st|}tt|t|}|s7t|Si}x7|D]/}||kri||cd7s(R tsumR(R&R((Rs/lib/python2.7/site-packages/sympy/core/basic.pytcounts cC st|}t||js"dS||kr2|St|jt|jkrTdS|j}xft|j|jD]O\}}||krqvn|j|j ||d|}|dkrvdSqvW|S(s Helper method for match() that looks for a match between Wild symbols in self and expressions in expr. Examples ======== >>> from sympy import symbols, Wild, Basic >>> a, b, c = symbols('a b c') >>> x = Wild('x') >>> Basic(a + x, x).matches(Basic(a + b, c)) is None True >>> Basic(a + x, x).matches(Basic(a + b + c, b + c)) {x_: b + c} RN( RR<R9R!R:R#R'R;Rtmatches(R&Rt repl_dictRRR^t other_arg((s/lib/python2.7/site-packages/sympy/core/basic.pyRs   " ! cC st|}|j|d|S(s Pattern matching. Wild symbols match all. Return ``None`` when expression (self) does not match with pattern. Otherwise return a dictionary such that:: pattern.xreplace(self.match(pattern)) == self Examples ======== >>> from sympy import Wild >>> from sympy.abc import x, y >>> p = Wild("p") >>> q = Wild("q") >>> r = Wild("r") >>> e = (x+y)**(x+y) >>> e.match(p**p) {p_: x + y} >>> e.match(p**q) {p_: x + y, q_: x + y} >>> e = (2*x)**2 >>> e.match(p*q**r) {p_: 4, q_: x, r_: 2} >>> (p*q**r).xreplace(e.match(p*q**r)) 4*x**2 The ``old`` flag will give the old-style pattern matching where expressions and patterns are essentially solved to give the match. Both of the following give None unless ``old=True``: >>> (x - 2).match(p - x, old=True) {p_: 2*x - 2} >>> (2/x).match(p*x, old=True) {p_: 2/x**2} R(RR(R&RR((s/lib/python2.7/site-packages/sympy/core/basic.pyRQs( cC sddlm}|||S(s7wrapper for count_ops that returns the operation count.i(R(RR(R&tvisualR((s/lib/python2.7/site-packages/sympy/core/basic.pyRDscK sa|jdtrYg|jD]*}t|tr@|j|n|^q}|j|S|SdS(s5Evaluate objects that are not evaluated by default like limits, integrals, sums and products. All objects of this kind will be evaluated recursively, unless some species were excluded via 'hints' or unless the 'deep' hint was set to 'False'. >>> from sympy import Integral >>> from sympy.abc import x >>> 2*Integral(x, x) 2*Integral(x, x) >>> (2*Integral(x, x)).doit() x**2 >>> (2*Integral(x, x)).doit(deep=False) 2*Integral(x, x) tdeepN(RRcR#R<RtdoitR%(R&Rttermtterms((s/lib/python2.7/site-packages/sympy/core/basic.pyRIs 7 cK s|jr,t||r(t||S|S|jdtrg|jD]0}t|trr|j|||n|^qH}n |j}|dkst||rt||rt||||}|dk r|Sqn|jdtr|j |S|S(NRR( RRRRRcR#R<Rt _eval_rewriteR!R%(R&RRRRRR#t rewritten((s/lib/python2.7/site-packages/sympy/core/basic.pyRcs @   cC s |j|S(N(t_visit_eval_derivative_scalar(R&Rp((s/lib/python2.7/site-packages/sympy/core/basic.pyt_accept_eval_derivativexscC s |j|S(N(t_eval_derivative(R&tbase((s/lib/python2.7/site-packages/sympy/core/basic.pyR|scC s |j|S(N(R (R&R!((s/lib/python2.7/site-packages/sympy/core/basic.pyt_visit_eval_derivative_arrayscC sddlm}t|t|frw|}xEt|D]7}|j|}||kse|dkriPn|}q8W|SdSdS(Ni(tInteger(RR#R<tintRRR!(R&RpRR#R$Rrtobj2((s/lib/python2.7/site-packages/sympy/core/basic.pyt_eval_derivative_n_timess cO s|s |S|d }t|dtr8d|d}n3yd|dj}Wnd|djj}nX|s|jd||St|dr|d}ng|D]}|j|r|^q}|r|jt|||S|SdS(s Rewrite functions in terms of other functions. Rewrites expression containing applications of functions of one kind in terms of functions of different kind. For example you can rewrite trigonometric functions as complex exponentials or combinatorial functions as gamma function. As a pattern this function accepts a list of functions to to rewrite (instances of DefinedFunction class). As rule you can use string or a destination function instance (in this case rewrite() will use the str() function). There is also the possibility to pass hints on how to rewrite the given expressions. For now there is only one such hint defined called 'deep'. When 'deep' is set to False it will forbid functions to rewrite their contents. Examples ======== >>> from sympy import sin, exp >>> from sympy.abc import x Unspecified pattern: >>> sin(x).rewrite(exp) -I*(exp(I*x) - exp(-I*x))/2 Pattern as a single function: >>> sin(x).rewrite(sin, exp) -I*(exp(I*x) - exp(-I*x))/2 Pattern as a list of functions: >>> sin(x).rewrite([sin, ], exp) -I*(exp(I*x) - exp(-I*x))/2 it_eval_rewrite_as_iN( R<R R4R9RR!R RRY(R&R#RRRRN((s/lib/python2.7/site-packages/sympy/core/basic.pytrewrites"(  (c C s|jj}tt}x|jD]}ytdt|jD}xQtj|D]@\}}||j g|D]}|||krt|^qtqWWWq"t k rq"Xq"Wx&|j |gD]} | |}qW|S(Ncs s1|]'}|tjkrtj|jVqdS(N(Rt"_constructor_postprocessor_mappingR-(RR"((s/lib/python2.7/site-packages/sympy/core/basic.pys s( R9R4RRR#R(tmroRt from_iterableRRR( R"R$tclsnametpostprocessorsRrtpostprocessor_mappingsR0R1tjR((s/lib/python2.7/site-packages/sympy/core/basic.pyt _exec_constructor_postprocessorss  < N(cR4t __module__t__doc__t __slots__RfRRRt is_symbolt is_IndexedRltis_Wildt is_Functiontis_AddRtis_PowRtis_FloatRMt is_Integertis_NumberSymboltis_Ordert is_Derivativet is_PiecewiseRtis_AlgebraicNumbert is_Relationalt is_Equalityt is_Booleantis_Nott is_Matrixt is_Vectortis_Pointt is_MatAddt is_MatMulRR'R,R)R*R2R7R5tpropertyR8R>t staticmethodRXt classmethodR[R\RR!R]RiReRwRzR{Rt_repr_latex_origRRkRRjRRRRRR%R#RaRRcRRnRRRRRRRRRRRRQRRRRRR"R&R(R)R0(((s/lib/python2.7/site-packages/sympy/core/basic.pyRs         . . 0    P .  /   p  ? 1    # +        ARcB sweZdZeZgZiedZedZdZ e dZ e ddZdZedZRS( s A parent class for atomic things. An atom is an expression with no subexpressions. Examples ======== Symbol, Number, Rational, Integer, ... But not: Add, Mul, Pow, ... cC s||kr|SdS(N((R&RRR((s/lib/python2.7/site-packages/sympy/core/basic.pyR s cC s|j||S(N(R(R&RR((s/lib/python2.7/site-packages/sympy/core/basic.pyRscK s|S(N((R&R((s/lib/python2.7/site-packages/sympy/core/basic.pyRscC sdd|jfS(Nii(R4(R"((s/lib/python2.7/site-packages/sympy/core/basic.pyR\scC s1|jdt|fftjjtjfS(Ni(R\RRRbR](R&R_((s/lib/python2.7/site-packages/sympy/core/basic.pyR]scC s|S(N((R&tratiotmeasuretrationaltinverse((s/lib/python2.7/site-packages/sympy/core/basic.pyt_eval_simplifyscC stddS(NsXAtoms have no args. It might be necessary to make a check for Atoms in the calling code.(tAttributeError(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyRasN(R4R1R2RcRR3RfRRRRLR\RR!R]RRRJRa(((s/lib/python2.7/site-packages/sympy/core/basic.pyRs    cC sddlm}m}xtt|t|D]\}}||ksbt|t|kr2t||rt||st||rt||r|j|jkrtSqtSq2q2Wt S(s{Return True if a and b are structurally the same, else False. Examples ======== To SymPy, 2.0 == 2: >>> from sympy import S >>> 2.0 == S(2) True Since a simple 'same or not' result is sometimes useful, this routine was written to provide that query: >>> from sympy.core.basic import _aresame >>> _aresame(S(2.0), S(2)) False i(t AppliedUndefR( tfunctionRTRRRR(R<R\RfRc(RRRSRTt UndefFuncRrR/((s/lib/python2.7/site-packages/sympy/core/basic.pyR)s($ c C sddlm}m}m}t|}t}t|trht|dd}|dkro|hSntSt}x|D]} | |kr|j qn|j | t| |r| |kr|j | qt| ||fr|s|j n|j | qqW|S(sLReturn atom-like quantities as far as substitution is concerned: Derivatives, Functions and Symbols. Don't return any 'atoms' that are inside such quantities unless they also appear outside, too, unless `recursive` is True. Examples ======== >>> from sympy import Derivative, Function, cos >>> from sympy.abc import x, y >>> from sympy.core.basic import _atomic >>> f = Function('f') >>> _atomic(x + y) {x, y} >>> _atomic(x + f(y)) {x, f(y)} >>> _atomic(Derivative(f(x), x) + cos(x) + y) {y, cos(x), Derivative(f(x), x)} i(t DerivativeRRRkN( RRWRRRRR<RRR!tskipR( tet recursiveRWRRtpottseenRRRN((s/lib/python2.7/site-packages/sympy/core/basic.pyt_atomicIs*          RcB s>eZdZddZdZdZdZdZRS(s Do a pre-order traversal of a tree. This iterator recursively yields nodes that it has visited in a pre-order fashion. That is, it yields the current node then descends through the tree breadth-first to yield all of a node's children's pre-order traversal. For an expression, the order of the traversal depends on the order of .args, which in many cases can be arbitrary. Parameters ========== node : sympy expression The expression to traverse. keys : (default None) sort key(s) The key(s) used to sort args of Basic objects. When None, args of Basic objects are processed in arbitrary order. If key is defined, it will be passed along to ordered() as the only key(s) to use to sort the arguments; if ``key`` is simply True then the default keys of ordered will be used. Yields ====== subtree : sympy expression All of the subtrees in the tree. Examples ======== >>> from sympy import symbols >>> from sympy.core.basic import preorder_traversal >>> x, y, z = symbols('x y z') The nodes are returned in the order that they are encountered unless key is given; simply passing key=True will guarantee that the traversal is unique. >>> list(preorder_traversal((x + y)*z, keys=None)) # doctest: +SKIP [z*(x + y), z, x + y, y, x] >>> list(preorder_traversal((x + y)*z, keys=True)) [z*(x + y), z, x + y, x, y] cC s"t|_|j|||_dS(N(Rft _skip_flagt_preorder_traversalt_pt(R&tnodeR((s/lib/python2.7/site-packages/sympy/core/basic.pyt__init__s cc s |V|jrt|_dSt|tr| rLt|drL|j}n |j}|r|tkrt||dt}qt|}nxu|D](}x|j ||D] }|VqWqWnBt |rx3|D](}x|j ||D] }|VqWqWndS(Nt_argsettdefault( R^RfR<RRRcR#RcR R_R (R&RaRR#R^tsubtreetitem((s/lib/python2.7/site-packages/sympy/core/basic.pyR_s&        cC s t|_dS(s Skip yielding current node's (last yielded node's) subtrees. Examples ======== >>> from sympy.core import symbols >>> from sympy.core.basic import preorder_traversal >>> x, y, z = symbols('x y z') >>> pt = preorder_traversal((x+y*z)*z) >>> for i in pt: ... print(i) ... if i == x+y*z: ... pt.skip() z*(x + y*z) z x + y*z N(RcR^(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyRXscC s t|jS(N(RR`(R&((s/lib/python2.7/site-packages/sympy/core/basic.pyt__next__scC s|S(N((R&((s/lib/python2.7/site-packages/sympy/core/basic.pyt__iter__sN( R4R1R2R!RbR_RXRgRh(((s/lib/python2.7/site-packages/sympy/core/basic.pyRvs -    c s`ytWntk r#nXttr@fdSttr\fdSS(s4Convert the argument of Basic.find() into a callablec s t|S(N(R<(R(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRRc s|jdk S(N(RQR!(R(R(s/lib/python2.7/site-packages/sympy/core/basic.pyRR(RR R<R(R(R((Rs/lib/python2.7/site-packages/sympy/core/basic.pyR s   N(&R2t __future__RRt collectionsRt itertoolsRRZRRtcacheRRRR t compatibilityR R R R RRRRRt singletonRtinspectRRRRRRfR]RR (((s/lib/python2.7/site-packages/sympy/core/basic.pyts,@ . -g