\h+8SrSSKJr SSKJr SSKJrJr SSKJ r SSK J r SSK J r Jr SS KJr SS KJr SS KJrJrJrJr SS KJr SS KJrJr SSKJr SSKJr SSK J!r! SSK"J#r#J$r$ SSK%J&r&J'r' \ (a#SSK J(r(J)r)J*r* SSK+J,r, SSKJ-r- SSK.J/r/ \)"SSS9r0Sr1/SQr2S+Sjr3\S5r4\S5r5"SS\5r6\6Rnr8\ "\6Rr5r:\"\65 "S S!\65r;S,S"jrJ?r? SS%K@JArBJCrCJDrD \"S&S'S(S)9"\B5rAg*)-z'Base class for all the objects in SymPy) annotations)Counter)MappingIterable) zip_longest) cmp_to_key) TYPE_CHECKINGoverload)_prepare_class_assumptions)cacheit)_sympifysympify SympifyError_external_converter)ordered)Kind UndefinedKind) Printable) deprecated)sympy_deprecation_warning)iterablenumbered_symbols) filldedent func_name)ClassVarTypeVarAny)Self) StdFactKBSymbolTbasicBasic)boundcd[U5$![a [S[U5-5ef=f)zReturn 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.z)Argument must be a Basic object, not `%s`)rr TypeErrorr)exprs H/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/basic.pyas_Basicr* s?~  7) ;  s "/)DZeroOneHalfInfinityNaN NegativeOneNegativeInfinityIntegerRationalFloatExp1Pi ImaginaryUnitr"WildPowMulAdd DerivativeIntegralAbsSignSqrtFloorCeilingReImArg ConjugateExpLogSinCosTanCotASinACosATanACotSinhCoshTanhCothASinhACoshATanhACothRisingFactorialFallingFactorial factorialbinomialGamma LowerGamma UpperGamma PolyGammaErf Chebyshev Chebyshev2Function WildFunctionLambdaOrderEquality UnequalityStrictGreaterThanStrictLessThan GreaterThanLessThancfURnURnX#:Xag[U[5(dg[[5S-n[R U5n[R U5nXT:XaXd:Xa X#:X#:- $XV:XV:- $![ a UnN@f=f![ a UnN>> from sympy import cos, tan, sin >>> from sympy.core import basic >>> save = basic.ordering_of_classes >>> basic.ordering_of_classes = () >>> basic._cmp_name(cos, tan) -1 >>> basic.ordering_of_classes = ["tan", "sin", "cos"] >>> basic._cmp_name(cos, tan) 1 >>> basic._cmp_name(sin, cos) -1 >>> basic.ordering_of_classes = save rr )__name__ issubclassr$lenordering_of_classesindex ValueError)xyn1n2UNKNOWNi1i2s r) _cmp_namer}Xs. B B x a  %&*G & &r * & &r * }BG$$ G      s$BB! BB! B0/B0c[5n[U5nUH+nURUS5nUcMURU5 M- U$N)set_get_postprocessors_for_typegetupdate)clsnamearg_typepostprocessorsmappingsmappingfs r)_get_postprocessorsrsJUN+H5H KK & =  ! !! $ cB[SUR555$)Nc3t# UH.nU[R;dM[RUv M0 g7fr)r$"_constructor_postprocessor_mapping).0clss r) /_get_postprocessors_for_type..s2!C %:: : 6005!s88)tuplemro)rs r)rrs" <<> rc^\rSrSr%SrSrS\S'S\S'\S5rU4S jr S r S r S r S r S rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS rS r S r!S r"S r#S r$S r%S r&S r'S \S 'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S'S \S 'S \S!'S \S"'S \S#'S \S$'S \S%'S \S&'S \S''S \S('S \S)'S \S*'S \S+'S \S,'\(r)S-\S.'S/r*S0r+S1r,S2r-S3r.U4S4jr/SoS5jr0S6r1\S75r2S8r3\4S95r5\4SpS:j5r6\7SqS;j5r8S<r9S=r:S>r;SqS?jr<\=SrS@j5r>\=SsSAj5r>StSBjr>\SrSCj5r?\SD5r@SuSEjrA\SvSFj5rBSGrCSHrD\SI5rESwSJjrF\SK5rG\SxSLj5rH\SM5rISySOjrJ\=SqSzSPjj5rK\=SqS{SQjj5rK\=S|SRj5rKSqS}SSjjrK\7ST5rLS~SUjrMSVrNSWrO\7SX5rPSSYjrQ\7SZ5rRS[rSSSS\jjrTSS]jrUS^rVSS_jrWSS`jrXSSajrYSbrZSScjr[SSdjr\Ser]SNSf.Sgjr^Shr_Sir`0ra\4Sj5rbSkrcSwSljrdSqSmjreSnrfU=rg$)r$aJ Base class for all SymPy objects. Notes and 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,) 3) By "SymPy object" we mean something that can be returned by ``sympify``. But not all objects one encounters using SymPy are subclasses of Basic. For example, mutable objects are not: >>> from sympy import Basic, Matrix, sympify >>> A = Matrix([[1, 2], [3, 4]]).as_mutable() >>> isinstance(A, Basic) False >>> B = sympify(A) >>> isinstance(B, Basic) True )_mhash_args _assumptionstuple[Basic, ...]rz int | Nonercg)NTselfs r) __sympy__Basic.__sympy__src8>[TU]5 [U5 gr)super__init_subclass__r )r __class__s r)rBasic.__init_subclass__s !#"3'rFzClassVar[StdFactKB]default_assumptionsz bool | None is_composite is_nonintegeris_extended_positive is_negative is_complexis_extended_nonpositive is_integer is_positive is_rationalis_extended_nonnegative is_infiniteis_antihermitianis_extended_negativeis_extended_real is_finiteis_polar is_imaginaryis_transcendentalis_extended_nonzero is_nonzerois_odd is_algebraicis_primeis_commutativeis_nonnegativeis_nonpositive is_hermitian is_irrationalis_realis_zerois_evenrkindcl[RU5nURUlSUlXlU$r)object__new__rrrr)rargsobjs r)r Basic.__new__ s/nnS!22   rc4UR"UR6$r)funcrrs r)copy Basic.copy(syy$))$$rcUR$rrrs r)__getnewargs__Basic.__getnewargs__+s yyrcgrrrs r) __getstate__Basic.__getstate__.rcNUR5Hup#[XU5 M gr)itemssetattr)rstatenamevalues r) __setstate__Basic.__setstate__1s ;;=KD D &)rcH>US:a Sn[U5e[TU] U5$)Nz6Only pickle protocol 2 or higher is supported by SymPy)NotImplementedErrorr __reduce_ex__)rprotocolmsgrs r)rBasic.__reduce_ex__5s* a<JC%c* *w$X..rcURnUc6[[U5R4UR 5-5nXlU$r)rhashtyperp_hashable_content)rhs r)__hash__Basic.__hash__;sA KK 9d4j))+d.D.D.FFGAKrcUR$)acReturn 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__.rrs r)rBasic._hashable_contentDszzrc0$)a9 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, 'extended_negative': False, 'extended_nonnegative': True, 'extended_nonpositive': False, 'extended_nonzero': True, 'extended_positive': True, 'extended_real': True, 'finite': True, 'hermitian': True, 'imaginary': False, 'infinite': False, 'negative': False, 'nonnegative': True, 'nonpositive': False, 'nonzero': True, 'positive': True, 'real': True, 'zero': False} rrs r) assumptions0Basic.assumptions0Ns < rc^XLagURnURn[X#5nU(aU$UR5nUR5n[U5n[U5nXx:Xx:- nU(aU$[ XV5Hup[ U [ 5(aU RU 5nOn[ U [5(aP[ U [5(a[ U 6OU n [ U [5(a[ U 6OU n U RU 5nO X:X:- nU(dMUs $ g)a Return -1, 0, 1 if the object is less than, equal, or greater than other in a canonical sense. Non-Basic are always greater than Basic. If both names of the classes being compared appear in the `ordering_of_classes` then the ordering will depend on the appearance of the names there. If either does not appear in that list, then the comparison is based on the class name. If the names are the same then a comparison is made on the length of the hashable content. Items of the equal-lengthed contents are then successively compared using the same rules. If there is never a difference then 0 is returned. Examples ======== >>> from sympy.abc import x, y >>> x.compare(y) -1 >>> x.compare(x) 0 >>> y.compare(x) 1 r) rr}rrrzip isinstancer$compare frozenset) rotherrxrycstotlen_stlen_otlrs r)r Basic.comparens< = ^^ __ b  H  # # %  $ $ &RR _ 1 HKDA!U##IIaLAy))!+Ay!9!9E1Iq!+Ay!9!9E1IqIIaLUqu%q rc $U"[U50UD6$)a 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) )r)rr assumptionss r)fromiterBasic.fromiters E$K/;//rc SSUR4$)zNice order of classes.rrprs r) class_keyBasic.class_keys!S\\!!rc ^U4SjnURn[U5[UVs/sH oB"U5PM sn54nUR5U[R R 5[R 4$s snf)a] Return a sort key. Examples ======== >>> from sympy 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] cT>[U[5(aURT5$U$r)rr$sort_key)argorders r) inner_key!Basic.sort_key..inner_keys$#u%%||E** r) _sorted_argsrrrr Sr,r)rrrrrs ` r)rBasic.sort_keysf*    4y%4 @4C34 @AA~~quu~~'7>>!AsA> c[U5RH(n[R"U5nUcMX"U5:Hs $ [ US5(aXR 5:H$[ $)aTReturns a boolean indicating whether a == b when either a or b is not a Basic. This is only done for types that were either added to `converter` by a 3rd party or when the object has `_sympy_` defined. This essentially reuses the code in `_sympify` that is specific for this use case. Non-user defined types that are meant to work with SymPy should be handled directly in the __eq__ methods of the `Basic` classes it could equate to and not be converted. Note that after conversion, `==` is used again since it is not necessarily clear whether `self` or `other`'s __eq__ method needs to be used._sympy_)r__mro__rrhasattrrNotImplemented)rr superclassconvs r)_do_eq_sympifyBasic._do_eq_sympifysau+--J&**:6DtE{**. 5) $ $==?* *rcXLag[U[5(dURU5$UR(aUR(d[ U5[ U5:wagUR 5UR 5p2X#:wag[ X#5HIup#[U[5(dMUR(dM/[ U5[ U5:wdMI g g)a@Return 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__ : Callable[[object], int] = .__hash__. Otherwise the inheritance of __hash__() will be blocked, just as if __hash__ had been explicitly set to None. References ========== from https://docs.python.org/dev/reference/datamodel.html#object.__hash__ TF)rr$r is_Numberrrr)rrabs r)__eq__ Basic.__eq__s* =%''&&u- -EOOT d5k)%%')@)@)B1 6IDAa''{{{tAw$q'1  rc X:X+$)z``a != b`` -> Compare two symbolic trees and see whether they are different this is the same as: ``a.compare(b) != 0`` but faster r)rrs r)__ne__ Basic.__ne__s   rcUR5n[U5nUR5nURVs/sHoUR(dMUPM nn[ U5S:XaUR 5nOX4:H$Uc0URn[ U5S:XaUR 5nOX4:H$UR 5n URXy05URX)05:H$s snf)a8 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 r )as_dummyr free_symbolsis_Dummyrrpoprxreplace) rrsymbolsoi dummy_symbolsdummysymbolstmps r)dummy_eqBasic.dummy_eq&s. MMO UO JJL$%NNANqjjN A }  "!%%'E6M >nnG7|q  v oozz5,'1::vm+DDD#Bs C&C&cgrrrs r)atoms Basic.atomsTs#&rcgrr)rtypess r)r:r;VsCFrc P[U5nU(aa[UVs/sH%n[U[5(aUO [U5PM' sn5nUVs1sHn[XT5(dMUiM sn$UVs1sHoUR(aMUiM sn$s snfs snfs snf)aReturns the atoms that form the current object. By default, only objects that are truly atomic and cannot 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)} )_preorder_traversalrrrr)rr=nodesttypes2nodes r)r:r;YsJ$D) 5Q5aAt!4!4A$q'A5QRF%*GUTj.FDUG G%*>> from sympy import Derivative, Integral, IndexedBase >>> from sympy.abc import x, y, n >>> (x + 1).free_symbols {x} >>> Integral(x, y).free_symbols {x, y} Not all free symbols are actually symbols: >>> IndexedBase('F')[0].free_symbols {F, F[0]} The symbols of differentiation are not included unless they appear in the expression being differentiated. >>> Derivative(x + y, y).free_symbols {x, y} >>> Derivative(x, y).free_symbols {x} >>> Derivative(x, (y, n)).free_symbols {n, x} If you want to know if a symbol is in the variables of the Derivative you can do so as follows: >>> Derivative(x, y).has_free(y) True c38# UHoRv M g7fr)r+)rr"s r)r%Basic.free_symbols..s?Y^^Ys)runionr)remptys r)r+Basic.free_symbolss%^ E{{?TYY?@@rc,[SSSS9 [5$)Nz The expr_free_symbols property is deprecated. Use free_symbols to get the free symbols of an expression. z1.9zdeprecated-expr-free-symbolsdeprecated_since_versionactive_deprecations_target)rrrs r)expr_free_symbolsBasic.expr_free_symbolss!!# &+'E  G u rct^SSKJmJn U4SjnURU5(dU$UR SUSS9$)aReturn 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. When applied to a symbol a new symbol having only the same commutativity will be returned. Examples ======== >>> from sympy import Integral, Symbol >>> from sympy.abc import x >>> r = Symbol('r', real=True) >>> Integral(r, (r, x)).as_dummy() Integral(_0, (_0, x)) >>> _.variables[0].is_real is None True >>> r.as_dummy() _r Notes ===== Any object that has structurally bound variables should have a property, ``bound_symbols`` that returns those symbols appearing in the object. r Dummyr"cN>URn[UR5nX!-Vs0sH o3T"5_M nnURU5nUR UR 5nUR UR 5VVs0sHupVXe_M snn5$s snfs snnfr)r+r bound_symbolssubsr.canonical_variablesr)rvfreer%r2dkvrRs r)canBasic.as_dummy..cans>>D(E%*\2\EG\A2q A 1001A:: : qt :; ; 3 ;s BB! c[US5$)NrT)r)rvs r) Basic.as_dummy.. s ga1rF) simultaneous)r/rRr"hasreplace)rr"r[rRs @r)r*Basic.as_dummysB8 * <xxK|| 1   rc\[USS5nUc0$[S5n0nUR[U5- Vs1sHoDRiM nnUHPn[ U5nUR (a-URU;a[ U5nURU;aMXsU'MR U$s snf)a Return a dictionary mapping any variable defined in ``self.bound_symbols`` to Symbols that do not clash with any free symbols in the expression. Examples ======== >>> from sympy import Lambda >>> from sympy.abc import x >>> Lambda(x, 2*x).canonical_variables {x: _0} rTN_)getattrrr+rrnext is_Symbol)rr%dumsrepsr2namesr#rXs r)rVBasic.canonical_variabless%,D/4$H =I$"&!2!2SZ!?@!?A!?@AT A{{ffoT AffoG   AsB)c[U5(aU"U6$UR(a7URVs/sHo"R"U6PM nnUR"U6$U$s snf)adApply 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 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 )callablerrcallr)rrsubnewargss r)ro Basic.rcall1sV D>>;  YY3799=9Cyy$'9G=99g& &K>sA c\SSKJn SSKJn UR U5(agU"X5SL$)Nr) hypersimp) Piecewise)sympy.simplify.simplifyrt$sympy.functions.elementary.piecewiserura)rrYrtrus r)is_hypergeometricBasic.is_hypergeometricHs*5B 88I  !--rc"UR5$)aLReturn 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 )_eval_is_comparablers r) is_comparableBasic.is_comparableOs6''))rcgNFrrs r)r{Basic._eval_is_comparablelsrcUR$)a! 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 rrs r)r Basic.funcps0~~rcUR$)aReturns 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. Do not override .args() from Basic (so that it is easy to change the interface in the future if needed). rrs r)r Basic.argss<zzrcUR$)z The same as ``args``. Derived classes which do not fix an order on their arguments should override this method to produce the sorted representation. rrs r)rBasic._sorted_argssyyrTc&[RU4$)zA 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 )rr,)rradicalclears r)as_content_primitiveBasic.as_content_primitivesuud{rc grrrarg1arg2kwargss r)rU Basic.subssnqrc grrrs r)rUrsvyrc grrrs r)rUrsZ]rc ^^SSKJn SSKJnJm SSKJn SnUcj[U[5(aUnSnOT[X[45(aSnUR5nO+[U5(d[[S55eUnOX4/nSU4Sjjn SS jn UV V s/sHupU "U 5U "U 54PM n n n U V V s/sHup[X5(aMX4PM n n n URS S5nU(aSS KJmJn ['U 5n[)[+USU4S jU4S 95nUVs/sH nUUU4PM n nU(d^[-U 5VVs/sHunnUSU;dMUPM nnn[/U5H$nU R1SU RU55 M& U(a0nUnSUS'U"S5nU HQunnUR2nUcSnU"SUS9nUR4"UUU-40UD6n[U[65(d O UUU'MS [8R:UU'UR=U5$UnU H2unnUR4"UU40UD6n[U[65(aM1 U$ U$s sn n fs sn n fs snfs snnf)a Substitutes old for new in an expression after sympifying args. `args` is either: - two arguments, e.g. foo.subs(old, new) - one iterable argument, e.g. foo.subs(iterable). The iterable may be o an iterable container with (old, new) pairs. In this case the replacements are processed in the order given with successive patterns possibly affecting replacements already made. o a dict or set whose key/value items correspond to old/new pairs. In this case the old/new pairs will be sorted by op count and in case of a tie, by number of args and the default_sort_key. The resulting sorted list is then processed as an iterable container (see previous). If the keyword ``simultaneous`` is True, the subexpressions will not be evaluated until all the substitutions have been made. Examples ======== >>> 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 sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision r )DictrQ)_illegalFTz When a single argument is passed to subs it should be a dictionary of old: new pairs or an iterable of (old, new) tuples.c>[U[5(aT"U5$[U[5(a [USS9$[USS9$NF)strictTrstrrr)oldr"s r) sympify_oldBasic.subs..sympify_oldQsA#s##c{"C&&s511s400rc`[U[[45(a [USS9$[USS9$rr)news r) sympify_newBasic.subs..sympify_new[s-#T{++s511s400rr`)_nodesdefault_sort_keyc>T"U5*$rr)rvrs r)r^Basic.subs..ss 6!9*r)defaultkeysrhack2subs_msubs_d) commutativereturnr$) containersrr/rRr"numbersrrrrrrrur_aresamer-sortingrrdictlistr enumeratereversedinsertr_subsr$rr,r.)rrrrrrRr unorderedrrrs1s2sequencer`r sequence_dictrYr2seqredorjrvmrrcomrXr"rs @@r)rUrsf %)% <$$$ D/22  d^^ -,"-.. \NE 1 1FKKU62[_k"o6UK,4L88B;KHRH8Lzz.%8  9 NMW]E$ AA899q!M!,-qH9(1((;R(;fas1v?Q(;R!$AOOAx||A7( DB"F7OhA$S((;C(4XXc1Q31&1!"e,,Q%eeDG;;t$ $B$SXXc31&1!"e,,I %IiLM":Ss$I5I;I;.JJ*Jc r^U4Sjn[X5(aU$URX5nUc U"XU5nU$)aj Substitutes an expression old -> new. If self is not equal to old then _eval_subs is called. If _eval_subs does not 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 does not 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. ct>Sn[UR5n[U5HFupV[US5(dMUR"X40T D6n[ XdU5(aM@SnXdU'MH U(aUR "U6nT RSS5nU(aUR(aUR(dw[Rn /n UH+nUR(aX-n MU RU5 M- UR "U 6n U [RLaU $UR XSS9$U$U$)z9 Try to replace old with new in any of self's arguments. F _eval_subsTr)evaluate) rrrrrrrris_Mulrr,r!append) rrrhitrr2rrrcoeff nonnumberhintss r)fallbackBasic._subs..fallbacks C ?D#D/sL11ii2E2!W--C!G *YY% '51T[[EEE "I!;;!JE%,,Q/ " !% 9 5I~((#yyEyJJ Kr)rr)rrrrrrs ` r)r Basic._subss@P @ D  J __S & :$S)B rcg)zOverride this stub if you want to do anything more than attempt a replacement of old with new in the arguments of self. See also ======== _subs Nr)rrrs r)rBasic._eval_subssrc,URU5up#U$)aV Replace occurrences of objects within the expression. Parameters ========== rule : dict-like Expresses a replacement rule Returns ======= xreplace : the result of the replacement Examples ======== >>> 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 does not 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. ) _xreplace)rrulerres r)r.Basic.xreplaces|>>$' rc.X;aXS4$U(a/nSnURHIn[USS5nUb%U"U5nURUS5 X6S-nM8URU5 MK [U5nU(aUR"U6S4$US4$)zF Helper for xreplace. Tracks whether a replacement actually occurred. TFrNrr )rrfrrr)rrrchangedr"ra_xrs r)rBasic._xreplaceTs <:t# # DGYY#A{D9 ($T?DKKQ(Aw&GKKN;Dyy$'--U{rc0UR"[/UQ76$)a 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 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 )_hasiterargs)rpatternss r)ra Basic.hasjs^yy-H--rcz^[T5[La [S5e[U4Sj[ U555$)aReturn True if self has any of the patterns in s as a free argument, else False. This is like `Basic.has_free` but this will only report exact argument matches. Examples ======== >>> from sympy import Function >>> from sympy.abc import x, y >>> f = Function('f') >>> f(x).has_xfree({f}) False >>> f(x).has_xfree({f(x)}) True >>> f(x + 1).has_xfree({x}) True >>> f(x + 1).has_xfree({x + 1}) True >>> f(x + y + 1).has_xfree({x + 1}) False zexpecting set argumentc3,># UH oT;v M g7frr)rr"r0s r)r"Basic.has_xfree..s6#5a6#5s)rrr'any iterfreeargs)rr0s `r) has_xfreeBasic.has_xfrees3. 7# 45 56<#5666rc$U(dgUSn[U5S:Xa9[U5(a)[U[5(d[ [ S55e[ U5nURU5nU(aU$UR"[/UQ76$)aReturn True if self has object(s) ``x`` as a free expression else False. Examples ======== >>> from sympy import Integral, Function >>> from sympy.abc import x, y >>> f = Function('f') >>> g = Function('g') >>> expr = Integral(f(x), (f(x), 1, g(y))) >>> expr.free_symbols {y} >>> expr.has_free(g(y)) True >>> expr.has_free(*(x, f(x))) False This works for subexpressions and types, too: >>> expr.has_free(g) True >>> (x + y + 1).has_free(y + 1) True Frr z Expecting 1 or more Basic args, not a single non-Basic iterable. Don't forget to unpack iterables: `eq.has_free(*patterns)`) rrrrr$r'rrrrr)rrp0r0rs r)has_freeBasic.has_frees6 a[ x=A (2,,z"e7L7LJ(789 9 M ^^A  Iyy111rcH^[5n[5nUHrn[U[5(a([U[5(aUR U5 M@[U[5(d [ U5nUR U5 Mt [U5nU"U5HnXt;a g[Xv5(dM g XC- HHn[US5(dMUR5m[U4SjU"U555(dMH g g![a GMf=f)NT _has_matcherc34># UH nT"U5v M g7frr)rrmatchs r)rBasic._has..s8#5::sF) rrrrqr$addrrrrrr) rrrtype_setp_setpr=r2rs @r)r Basic._hass5A!T""z!U';'; Qa''  A IIaLh$Az!##  !A1n--NN$E8$888 "-$s. D D! D!c:^^^^^ ^ ^ ^ [T5m[T5m[T[5(aDU4Sjm [T[5(aU4Sjm O[ T5(aU4Sjm O[ S5e[T[ 5(aU4Sjm Uc#SSKJn [TRU55S:n[T[ 5(aU(aU4Sjm OvU4S jm Oo[ T5(aU(aU4S jm OQU4S jm OJ[ S 5e[ T5(a$Tm [ T5(aU4S jm O[ S5e[ S5eUU 4Sjm 0m U U UU 4SjnT "X5nT(aUT 4$U$![a GNsf=f![a GNxf=f)a 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 does not 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 None it will be set to True so the match will only succeed if all non-zero values are received for each Wild that appears in the match pattern. Setting this to False accepts a match of 0; while setting it True accepts all matches that have a 0 in them. See example below for cautions. 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) When matching a single symbol, `exact` will default to True, but this may or may not be the behavior that is desired: Here, we want `exact=False`: >>> from sympy import Function >>> f = Function('f') >>> e = f(1) + f(0) >>> q = f(a), lambda a: f(a + 1) >>> e.replace(*q, exact=False) f(1) + f(2) >>> e.replace(*q, exact=True) f(0) + f(2) But here, the nature of matching makes selecting the right setting tricky: >>> e = x**(1 + y) >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False) x >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True) x**(-x - y + 1) >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False) x >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True) x**(1 - y) It is probably better to use a different form of the query that describes the target expression more precisely: >>> (1 + x**(1 + y)).replace( ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1, ... lambda x: x.base**(1 - (x.exp - 1))) ... x**(1 - 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 c>[UT5$rrr(querys r)r^Basic.replace..s *T5"9rc">T"UR6$rrr(resultrs r)r^reTYY.?rc">T"UR6$rrrs r)r^rrrz:given a type, replace() expects another type or a callablec&>URT5$rrrs r)r^rs$**U"3rr )r8cf>[UR55(aTRU5$U$r)allvaluesrUrs r)r^rs/v}}//49::f3E4:594:rc&>TRU5$r)rUrs r)r^rs%**V2Drc >[SUR555(a8T"S0UR5VVs0sHup#[U5SSU_M snnD6$U$s snnf)Nc3$# UHov M g7frr)rvals r)r2Basic.replace....s>ossosror)rrrrr(rrYrZrs r)r^rse>fmmo>>>494E4:LLNCNDAQaNC4E4IDH4ICsA!c >T"S0UR5VVs0sHup#[U5SSU_M snnD6$s snnf)Nror)rrr s r)r^rs<%3E4:LLNCNDAQaNC3ECs:zGgiven an expression, replace() expects another expression or a callablec>T"U5$rrrs r)r^rs eDkrz4given a callable, replace() expects another callablezGfirst argument to replace() must be a type, an expression or a callablec >[USS5nUbsU(ad[UVs/sH nT"X15PM sn5nX$:wa=UR"U6nT(a'[U5HupVX:XdM XdU:wdMUs $ U"U5nU$s snf)z4Apply ``F`` to args and then to result. rN)rfrrr) rFrr"rqr2er`walks r)rBasic.replace..walks2vt,D#$>AT!Z$>?GWWg.')2$#%7qAJ+-I)8rUI%?sBcn>T"U5nU(dU0:XaT"X5nUbX :waT(aUTU'UnU$rr)r(rrZ_query_valuemaprs r) rec_replace"Basic.replace..rec_replaces>D\F24(=QY() DKr) rrrrrnr'r$r/r8rrr:) rrrrr`exactr8rrrrrrs ```` @@@@r)rb Basic.replacesF UOE UOE eT " "9F%&&?%?)**u % %3F}(U[[./!3%'';FEF% JFEF 788e__F9'((45 5 &  $ $ #G}++w      s" E; F ; F F  FFc[U5n[[U[U555nU(d [ U5$[ [ U55$)z)Find all subexpressions matching a query.)_make_find_queryrfilterr?rrr)rrgroupresultss r)find Basic.finds@ 've%8%>?@w< GG$%%rcV^[T5m[U4Sj[U555$)z,Count the number of matching subexpressions.c3F># UHn[T"U55v M g7fr)bool)rrprs r)rBasic.count..sI/H4c ##/Hs!)rsumr?)rrs `r)count Basic.counts$ 'I/B4/HIIIrc[U5n[XR5(dgUc0nOUR5nX:XaU$[ UR 5[ UR 5:wagUn[ UR UR 5HbupVXV:XaM UR(a!URU5RXdUS9nOURU5RXdUS9nUbMb g U$![a SnNf=f)aS 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} Nr) rrrrrrrr is_Relationalr.matchesr')rr( repl_dictrrXr other_args r)r+ Basic.matchess t}$//  I!(I <  tyy>S^ + !$))TYY7NC   Q// #/FA Q// #/FAy8 !As1C;; D  D c6[U5nURXS9$)au 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, Sum >>> 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 Since match is purely structural expressions that are equivalent up to bound symbols will not match: >>> print(Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))) None An expression with bound symbols can be matched if the pattern uses a distinct ``Wild`` for each bound symbol: >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p))) {p_: 2, q_: x} 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} See Also ======== matches: pattern.matches(expr) is the same as expr.match(pattern) xreplace: exact structural replacement replace: structural replacement with pattern matching Wild: symbolic placeholders for expressions in pattern matching r))rr+)rpatternrs r)r Basic.matchDs v'"t--rcSSKJn U"X5$)z7Wrapper for count_ops that returns the operation count.r ) count_ops)functionr3)rvisualr3s r)r3Basic.count_opss'&&rc URSS5(aRURVs/sH,n[U[5(aUR"S0UD6OUPM. nnUR "U6$U$s snf)aEvaluate 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) deepTr)rrrr$doitr)rrtermtermss r)r9 Basic.doitsr& 99VT " "59YY@5>T,6dE+B+BTYY''L5> @99e$ $K @s3A,c  SSKJn U"U40UD6$)z+See the simplify function in sympy.simplifyr)simplify)rvr>)rrr>s r)r>Basic.simplifys4'''rcSSKJn U"X5$)z,See the refine function in sympy.assumptionsr)refine)sympy.assumptions.refinerA)r assumptionrAs r)rA Basic.refines3d''rcSSKJn [U[U45(a6Un[ U5H#nUnUR U5nUc gXF:XdM" U$ U$g)Nr )r2)rr2rintrange_eval_derivative)rr0nr2rr2prevs r)_eval_derivative_n_timesBasic._eval_derivative_n_timess_ % a#w ( (C1X**1-;[JJrr8c^U(dT$URUS9 USSnUSnU[LaSSKJn Un[ U[ 5(aSU-nO>[ US5(aURnSU-nOURRnSU-nU(a6[US5(aUSn[U4SjU55nU(dT$TR"XEU40UD6$) a( Rewrite *self* using a defined rule. Rewriting transforms an expression to another, which is mathematically equivalent but structurally different. For example you can rewrite trigonometric functions as complex exponentials or combinatorial functions as gamma function. This method takes a *pattern* and a *rule* as positional arguments. *pattern* is optional parameter which defines the types of expressions that will be transformed. If it is not passed, all possible expressions will be rewritten. *rule* defines how the expression will be rewritten. Parameters ========== args : Expr A *rule*, or *pattern* and *rule*. - *pattern* is a type or an iterable of types. - *rule* can be any object. deep : bool, optional If ``True``, subexpressions are recursively transformed. Default is ``True``. Examples ======== If *pattern* is unspecified, all possible expressions are transformed. >>> from sympy import cos, sin, exp, I >>> from sympy.abc import x >>> expr = cos(x) + I*sin(x) >>> expr.rewrite(exp) exp(I*x) Pattern can be a type or an iterable of types. >>> expr.rewrite(sin, exp) exp(I*x)/2 + cos(x) - exp(-I*x)/2 >>> expr.rewrite([cos,], exp) exp(I*x)/2 + I*sin(x) + exp(-I*x)/2 >>> expr.rewrite([cos, sin], exp) exp(I*x) Rewriting behavior can be implemented by defining ``_eval_rewrite()`` method. >>> from sympy import Expr, sqrt, pi >>> class MySin(Expr): ... def _eval_rewrite(self, rule, args, **hints): ... x, = args ... if rule == cos: ... return cos(pi/2 - x, evaluate=False) ... if rule == sqrt: ... return sqrt(1 - cos(x)**2) >>> MySin(MySin(x)).rewrite(cos) cos(-cos(-x + pi/2) + pi/2) >>> MySin(x).rewrite(sqrt) sqrt(1 - cos(x)**2) Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards compatibility reason. This may be removed in the future and using it is discouraged. >>> class MySin(Expr): ... def _eval_rewrite_as_cos(self, *args, **hints): ... x, = args ... return cos(pi/2 - x, evaluate=False) >>> MySin(x).rewrite(cos) cos(-x + pi/2) rMNror)r>z_eval_rewrite_as_%srpc3X># UHnTRU5(dMUv M! g7fr)rarrrs r)r Basic.rewrite..&s>w!$((1+AAws* *) rabs$sympy.functions.elementary.complexesr>rrrrprrr_rewrite) rr8rrr0rr>methodrs ` r)rewrite Basic.rewritesTK $ s)Bx 3; @D dC *T1F T: & &mmG*W4Fnn--G*W4F  ##!!*>w>>G }}WF# UHn[TU5v M g7frrrPs r)r!Basic._rewrite..4sC7ajq117s)r-rrTrrf _eval_rewriter) rr0rrUrr8r"rmeth rewrittens ` r)rTBasic._rewrite-syy& !YY(&JJwf>>& (D99D#C7CCC4.D $0%0  ..tCUC $  Kyy$(sCc grr)rrrrs r)r[Basic._eval_rewrite@rrc URRnURVVs1sH"n[U[ U55HnUiM M$ nnnUH nU"U5nM U$s snnfr)rrprrr)rrrr2rrs r) _exec_constructor_postprocessors&Basic._exec_constructor_postprocessorsEsl--((%(XXLX%8$q'%J%JXLAC&C  Ls)A%cURnSSKJn U"5 XR:Xa [S5eUR5$)zk Convert *self* to a symbolic expression of SageMath. This version of the method is merely a placeholder. r) sympy_initz)conversion to SageMath is not implemented)_sage_sage.interfaces.sympyrer)r old_methodres r)rf Basic._sage_Ws9 [[ 4  $%&QR R;;= rcgrrrs r)could_extract_minus_signBasic.could_extract_minus_signfsrcSSKJn SSKJn [ U"U5U"U55HcnSU;a gUup[ X5(a#[ X5(d gU(a U"X5s $X:XaUR UR :XaMc g g)aReturn True if a and b are structurally the same, else False. If `approx` is supplied, it will be used to test whether two numbers are the same or not. By default, only numbers of the same type will compare equal, so S.Half != Float(0.5). Examples ======== In SymPy (unlike Python) two numbers do not compare the same if they are not of the same type: >>> from sympy import S >>> 2.0 == S(2) False >>> 0.5 == S.Half False By supplying a function with which to compare two numbers, such differences can be ignored. e.g. `equal_valued` will return True for decimal numbers having a denominator that is a power of 2, regardless of precision. >>> from sympy import Float >>> from sympy.core.numbers import equal_valued >>> (S.Half/4).is_same(Float(0.125, 1), equal_valued) True >>> Float(1, 2).is_same(Float(1, 10), equal_valued) True But decimals without a power of 2 denominator will compare as not being the same. >>> Float(0.1, 9).is_same(Float(0.1, 10), equal_valued) False But arbitrary differences can be ignored by supplying a function to test the equivalence of two numbers: >>> import math >>> Float(0.1, 9).is_same(Float(0.1, 10), math.isclose) True Other objects might compare the same even though types are not the same. This routine will only return True if two expressions are identical in terms of class types. >>> from sympy import eye, Basic >>> eye(1) == S(eye(1)) # mutable vs immutable True >>> Basic.is_same(eye(1), S(eye(1))) False r )Number)postorder_traversalNFT)rrn traversalrorrr)r"r#approxrnpotrAs r)is_same Basic.is_sameiswl $9SVSV,AqyDA!$$!!,, !!<'Fq{{akk9-r)r)rrF)rztuple[int, int, str]r)r set[Basic])r=Tbasic | type[Tbasic]rz set[Tbasic])r=rvrzset[Basic] | set[Tbasic])rz'Self')rzdict[Basic, Symbol])rr#)rr)FT)rz)Mapping[Basic | complex, Basic | complex]rNonerrrr$)rz1Iterable[tuple[Basic | complex, Basic | complex]]rrwrrrr$)rBasic | complexrrxrrrr$)rzoMapping[Basic | complex, Basic | complex] | Iterable[tuple[Basic | complex, Basic | complex]] | Basic | complexrzBasic | complex | Nonerrrr$)rz Basic | None)r0ru)FTNrFr)T)hrp __module__ __qualname____firstlineno____doc__ __slots____annotations__propertyrr is_numberis_Atomrh is_symbol is_Indexedr,is_Wild is_Functionis_Addris_Powr!is_Float is_Rational is_Integeris_NumberSymbolis_Order is_Derivative is_Piecewiseis_Polyis_AlgebraicNumberr* is_Equality is_Booleanis_Not is_Matrix is_Vectoris_Point is_MatAdd is_MatMulrrrrrrrrrrrr classmethodrr r rrr$r'r7r r:r+rNr*rVrorxr|r{rrrrrUrrr.rrarrrrbrr&r+rr3r9r>rArKrVrTr[rrbrfrkrs__static_attributes__ __classcell__rs@r)r$r$s(*VI   (IGIIJHGK F F FIHKJOHMLGMKJ FIIHII,,%%((((!!%%!!""$$    D$%'/ >8t00""" ? ?<&(T !,E\&& FFJ=X/A/Ab, \B..**82> qq yy ]]-1Q)Q># # rc$URX5$r)r)rrrs r)r. Atom.xreplacesxx##rc U$rr)rrs r)r9 Atom.doit rc SSUR4$)Nrrr r s r)r Atom.class_keys!S\\!!rcUR5S[U544[RR 5[R4$)Nr )r rrr,r)rrs r)r Atom.sort_keys2~~!c$i\!2AEENN4DaeeKKrc U$rr)rrs r)_eval_simplifyAtom._eval_simplifyrrc[S5e)NzXAtoms have no args. It might be necessary to make a check for Atoms in the calling code.)AttributeErrorrs r)rAtom._sorted_argss :; ;rrryr)rprzr{r|r}rr~r+r.r9rr r rrrrrrrr)rrseGI$ $"" L L;;rrc[U5n[5n[U[5(a[ USS5nUcU1$O [5$SSKJn SSKJnJ n [5nUHn X;aUR5 MURU 5 [X5(aX;aURU 5 MS[XU45(dMgU(dUR5 URU 5 M U$)a Return atom-like quantities as far as substitution is concerned: Derivatives, Functions and Symbols. Do not 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)} r+Nr r!)r<rd) r?rrr$rfr/r"r4r<rdskipr) r recursiverrseenrWr"r<rdr:rs r)_atomicrs* a C 5D!Uq.$/ <3J u . EE  9 HHJ   a QY IIaL 1 2 2 IIaL Lrc^[T5m[T[5(aU4Sj$[T[5(aU4Sj$T$![a NDf=f)z4Convert the argument of Basic.find() into a callablec>[UT5$rrrs r)r^"_make_find_query.. s JtU3rc*>URT5SL$rrrs r)r^r sDJJu-T9r)rrrrr$)rs`r)rr sR %33 E5 ! !99 L    s A AA)r)preorder_traversalrrz Using preorder_traversal from the sympy.core.basic submodule is deprecated. Instead, use preorder_traversal from the top-level sympy namespace, like sympy.preorder_traversal z1.10z$deprecated-traversal-functions-movedrKN)rvrrwrrrFry)Er} __future__r collectionsrcollections.abcrr itertoolsr functoolsrtypingr r rr cacher rrrrrrrrr_print_helpersrsympy.utilities.decoratorrsympy.utilities.exceptionsrsympy.utilities.iterablesrrsympy.utilities.miscrrrrrtyping_extensionsrr r/r"r#r*rsr}rrr$rsrr _args_sortkeyrrr singletonrrprr?rrrrr)rs-"-! *3II%%0@@6--&& XW -F $$L+!^      P IP d@ ==5==) 5!-;5-;`+\  $E  r