\h|tSSKJr SSKJrJr SSKJrJr SSKJ r SSK J r SSK J r Jr SSKJrJr SS KJrJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJrJ r SSK!J"r" SSK#r#SSK$r%SSK&r&SSK'J(r( SSK)J*r* "SS\5r+Sr,S%Sjr-S\.S4Sjr/\/r0"SS\\5r1"SS\15r2"SS\15r3\%Rh"S 5r5\1S!.S&S"jjr6S#r7S$r8g)') annotations) StdFactKB_assume_defined)BasicAtom)cacheit)Tuple)Expr AtomicExpr) AppliedUndef FunctionClass) NumberKind UndefinedKind) fuzzy_bool)S)ordered)sympify)Boolean)sift is_sequence) filldedentN)product)Anyc.\rSrSrSrSrSrSrSrSr g) Stra Represents string in SymPy. Explanation =========== Previously, ``Symbol`` was used where string is needed in ``args`` of SymPy objects, e.g. denoting the name of the instance. However, since ``Symbol`` represents mathematical scalar, this class should be used instead. namec [U[5(d [S[[ U55-5e[ R "U40UD6nXlU$)Nname should be a string, not %s) isinstancestr TypeErrorreprtyper __new__r)clsrkwargsobjs I/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/symbol.pyr' Str.__new__(sF$$$=T$Z@PPQ Qll3)&) cUR4$Nrselfs r+__getnewargs__Str.__getnewargs__/ |r-cUR4$r/rr0s r+_hashable_contentStr._hashable_content2r4r-N) __name__ __module__ __qualname____firstlineno____doc__ __slots__r'r2r6__static_attributes__r8r-r+rrs Ir-rc [[[UR5SSS95up[R U5 X4$)zSplit the given dict into assumptions and non-assumptions. Keys are taken as assumptions if they correspond to an entry in ``_assume_defined``. cUS[;$)Nr)r)is r+%_filter_assumptions..<s !A$/)r-T)binary)mapdictritemsSymbol _sanitize)r) assumptionsnonassumptionss r+_filter_assumptionsrM6sA #&dD)-#K [!  &&r-c [U[5(a%U(aURU:XaU$[U40UD6$[U[5(aU$[ S5e)a^Return s if s is a Symbol, else if s is a string, return either the matching_symbol if the names are the same or else a new symbol with the same assumptions as the matching symbol (or the assumptions as provided). Examples ======== >>> from sympy import Symbol >>> from sympy.core.symbol import _symbol >>> _symbol('y') y >>> _.is_real is None True >>> _symbol('y', real=True).is_real True >>> x = Symbol('x') >>> _symbol(x, real=True) x >>> _.is_real is None # ignore attribute if s is a Symbol True Below, the variable sym has the name 'foo': >>> sym = Symbol('foo', real=True) Since 'x' is not the same as sym's name, a new symbol is created: >>> _symbol('x', sym).name 'x' It will acquire any assumptions give: >>> _symbol('x', sym, real=False).is_real False Since 'foo' is the same as sym's name, sym is returned >>> _symbol('foo', sym) foo Any assumptions given are ignored: >>> _symbol('foo', sym, real=False).is_real True NB: the symbol here may not be the same as a symbol with the same name defined elsewhere as a result of different assumptions. See Also ======== sympy.core.symbol.Symbol z/symbol must be string for symbol name or Symbol)r"r#rrI ValueError)smatching_symbolrKs r+_symbolrRAsVr!S 33q8" "a';'' Av  JKKr-r8c ^^ SSjnSn[U5(aUupT"U5m U(d [T U40UD6$[U5(dU/n[5RUVVs/sH*owR [ 5HoR PM M, snnUVVs/sH4owR [5HoRR PM M6 snn-5n UcUn[UU 4SjU 55(a%U"T 5m [UU 4SjU 55(aM%[T U40UD6$s snnfs snnf)a Return a symbol whose name is derivated from *xname* but is unique from any other symbols in *exprs*. *xname* and symbol names in *exprs* are passed to *compare* to be converted to comparable forms. If ``compare(xname)`` is not unique, it is recursively passed to *modify* until unique name is acquired. Parameters ========== xname : str or Symbol Base name for the new symbol. exprs : Expr or iterable of Expr Expressions whose symbols are compared to *xname*. compare : function Unary function which transforms *xname* and symbol names from *exprs* to comparable form. modify : function Unary function which modifies the string. Default is appending the number, or increasing the number if exists. Examples ======== By default, a number is appended to *xname* to generate unique name. If the number already exists, it is recursively increased. >>> from sympy.core.symbol import uniquely_named_symbol, Symbol >>> uniquely_named_symbol('x', Symbol('x')) x0 >>> uniquely_named_symbol('x', (Symbol('x'), Symbol('x0'))) x1 >>> uniquely_named_symbol('x0', (Symbol('x1'), Symbol('x0'))) x2 Name generation can be controlled by passing *modify* parameter. >>> from sympy.abc import x >>> uniquely_named_symbol('x', x, modify=lambda s: 2*s) xx cU(d [U5$[U5S- nUS:wa%XR5(dO US-nUS:waM%[[XS-S=(d US- 5S-5nUSUS-U-$)Nr)r#lenisdigitint)rPstartrBns r+numbered_string_incr3uniquely_named_symbol..numbered_string_incrsu:  FQJ2g4<<>> FA2g A!efI*+a/ 0!a%y1}r-Nc3:># UHnTT"U5:Hv M g7fr/r8).0rPcomparexs r+ (uniquely_named_symbol..s -u!a71:ous)r) rrRsetunionatomsrIrr funcany) xnameexprsr_modifyrKr[defaulterBnamesr`s ` @r+uniquely_named_symbolrns^ G5A q'1[11 u   EKK8A18#CeWW\-B-BeC D EE~% -u - - - 1I  -u - - - 1g - -- 9Cs %1D5 ;D; c*\rSrSr%SrSrSrS\S'SrSr \ S5r \ S 5r \ SS j5rS rS r\ \S55r\ S5r\ \S55rSrSrSrSrSr\ S5r\SSj5rSrSSjrSr\ S5r\r Sr!Sr"g ) rIux Symbol class is used to create symbolic variables. Explanation =========== Symbolic variables are placeholders for mathematical symbols that can represent numbers, constants, or any other mathematical entities and can be used in mathematical expressions and to perform symbolic computations. Assumptions: commutative = True positive = True real = True imaginary = True complex = True complete list of more assumptions- :ref:`predicates` You can override the default assumptions in the constructor. Examples ======== >>> from sympy import Symbol >>> x = Symbol("x", positive=True) >>> x.is_positive True >>> x.is_negative False passing in greek letters: >>> from sympy import Symbol >>> alpha = Symbol('alpha') >>> alpha #doctest: +SKIP α Trailing digits are automatically treated like subscripts of what precedes them in the name. General format to add subscript to a symbol : `` = Symbol('_')`` >>> from sympy import Symbol >>> alpha_i = Symbol('alpha_i') >>> alpha_i #doctest: +SKIP αᵢ Parameters ========== AtomicExpr: variable name Boolean: Assumption with a boolean value(True or False) F)r_assumptions_orig _assumptions0r#rTc<UR(a[$[$r/)is_commutativerrr0s r+kind Symbol.kinds    r-cg)zyAllow derivatives wrt Symbols. Examples ======== >>> from sympy import Symbol >>> x = Symbol('x') >>> x._diff_wrt True Tr8r0s r+ _diff_wrtSymbol._diff_wrtsr-Nc[URSS55nUc&U(aSUR-OSn[SU-5e[ UR 55H*nXnUcUR U5 M[U5X'M, g)zMRemove None, convert values to bool, check commutativity *in place*. commutativeTNz%s z&%scommutativity must be True or False.)rgetr9rOlistkeyspopbool)rKr*rtwhosekeyvs r+rJSymbol._sanitize&s $KOOM4$HI  !,/ECLL(RE85@B B ((*+C Ay$#AwK  ,r-c URn[U5[U5-H1nXX#:wdM[[SU<SX#<SX<355e UR U5 U$)Nz2 non-matching assumptions for z(: existing value is z and new value is ) assumptions0rcrOrupdate)r1rKbaseks r+_merge Symbol._merge:sj  [!CI-A~( tw -0"122. K  r-c RURX 5 [R"X40UD6$)zSymbols are identified by name and assumptions:: >>> from sympy import Symbol >>> Symbol("x") == Symbol("x") True >>> Symbol("x", real=True) == Symbol("x", real=False) False )rJrI_Symbol__xnew_cached_r(rrKs r+r'Symbol.__new__Es& k'$$S>+>>r-c zUR5nURSS5 [U5n[U5nX!U4$)Nr{T)copy setdefaultrrG)rKassumptions_origassumptions_kbrs r+_canonical_assumptionsSymbol._canonical_assumptionsSsD'++- }d3";/N+ ==r-c @[U[5(d [S[[ U55-5e[ R "U5nXl[R"S0UD6upEnXCl XSl [[UR555UlU$)Nr!r8)r"r#r$r%r&r r'rrIr _assumptionsrqtuplesortedrHrr)r(rrKr*rrrs r+__xnew__Symbol.__xnew__gs$$$=T$Z@PPQ Qll39?9V9V9eYd9e6,) 0!&););)=">?& r-c 0[R"X40UD6$r/)rIrrs r+__xnew_cached_Symbol.__xnew_cached_ss8K88r-c4UR4UR4$r/)rrqr0s r+__getnewargs_ex__Symbol.__getnewargs_ex__s d4455r-cNUR5Hup#[XU5 M gr/)rHsetattr)r1statervalues r+ __setstate__Symbol.__setstate__s ;;=KD D &)r-c6UR4UR-$r/)rrrr0s r+r6Symbol._hashable_contents |d0000r-c|UR(a+SSKJn U"U[RSS9R X5$g)Nr)PowF)evaluate)is_Powsympy.core.powerrrOne _eval_subs)r1oldnewrs r+rSymbol._eval_subss/ :: ,tQUUU3>>sH H r-cU$r/r8)r1rKs r+ _eval_refineSymbol._eval_refines r-c,[UR5$r/)rGrrr0s r+rSymbol.assumptions0sD&&''r-cUR5SUR44[RR 5[R4$)Nr) class_keyrrrsort_keyr1orders r+rSymbol.sort_keys2~~!dii\!2AEENN4DaeeKKr-cURSLa[UR5$[URURS9$)NF)r{)rtDummyrr0s r+as_dummySymbol.as_dummys;#'#6#6e#CuTYY Ctyyd.A.AB Cr-c ^URS5U:XagSSKJnJn U"U5U"U54$)Nignorer)imre)r}$sympy.functions.elementary.complexesrr)r1deephintsrrs r+ as_real_imagSymbol.as_real_imags, 99X $ & CtHbh' 'r-cU(dgX;$NFr8)r1wrtflagss r+ is_constantSymbol.is_constantsr-cU1$r/r8r0s r+ free_symbolsSymbol.free_symbolss v r-c"[R$r/)r UniversalSetr0s r+as_set Symbol.as_sets ~~r-r8r/)T)#r9r:r;r<r= is_comparabler>__annotations__ is_Symbol is_symbolpropertyrurx staticmethodrJrr'r rrrrrr6rrrrrrrrbinary_symbolsrr?r8r-r+rIrIs(2hM>I III    ''&  ? > >$B 9 96'1I (( L LC ( "Nr-rIc\rSrSrSrSr\R"5r\RSS5r Sr Sr SS jr S r\SS j5rS rS rg)riaDummy symbols are each unique, even if they have the same name: Examples ======== >>> from sympy import Dummy >>> Dummy("x") == Dummy("x") False If a name is not supplied then a string value of an internal count will be used. This is useful when a temporary variable is needed and the name of the variable used in the expression is not important. >>> Dummy() #doctest: +SKIP _Dummy_10 ri@Bi@T) dummy_indexTNc 4Ub UcS5eUcS[[R5-nUc:[R[R-n[=RS- slUR X05 [ R "X40UD6nX$lU$)Nz:If you specify a dummy_index, you must also provide a nameDummy_r)r#r_count_base_dummy_indexrJrIrr)r(rrrKr*s r+r' Dummy.__new__s  "# a%a a# <c%,,//D  11ELL@K LLA L k'ooc7;7% r-cJURUR4UR4$r/)rrrqr0s r+rDummy.__getnewargs_ex__s"D,,-t/E/EFFr-cUR5SURUR44[RR 5[R4$)N)rrrrrrrs r+rDummy.sort_keysE~~  4++,"./0uu~~/?G Gr-cH[RU5UR4-$r/)rIr6rr0s r+r6Dummy._hashable_contents!''-1A1A0CCCr-r8)NNr/)r9r:r;r<r=rrandomRandom_prngrandintrr>is_Dummyr'rr rr6r?r8r-r+rrs[:F MMOE eW5 IH$G G GDr-rch^\rSrSrSrSrSrS SjrSr\ \ S55r U4S jr S S jr SrU=r$) Wildi a A Wild symbol matches anything, or anything without whatever is explicitly excluded. Parameters ========== name : str Name of the Wild instance. exclude : iterable, optional Instances in ``exclude`` will not be matched. properties : iterable of functions, optional Functions, each taking an expressions as input and returns a ``bool``. All functions in ``properties`` need to return ``True`` in order for the Wild instance to match the expression. Examples ======== >>> from sympy import Wild, WildFunction, cos, pi >>> from sympy.abc import x, y, z >>> a = Wild('a') >>> x.match(a) {a_: x} >>> pi.match(a) {a_: pi} >>> (3*x**2).match(a*x) {a_: 3*x} >>> cos(x).match(a) {a_: cos(x)} >>> b = Wild('b', exclude=[x]) >>> (3*x**2).match(b*x) >>> b.match(a) {a_: b_} >>> A = WildFunction('A') >>> A.match(a) {a_: A_} Tips ==== When using Wild, be sure to use the exclude keyword to make the pattern more precise. Without the exclude pattern, you may get matches that are technically correct, but not what you wanted. For example, using the above without exclude: >>> from sympy import symbols >>> a, b = symbols('a b', cls=Wild) >>> (2 + 3*y).match(a*x + b*y) {a_: 2/x, b_: 3} This is technically correct, because (2/x)*x + 3*y == 2 + 3*y, but you probably wanted it to not match at all. The issue is that you really did not want a and b to include x and y, and the exclude parameter lets you specify exactly this. With the exclude parameter, the pattern will not match. >>> a = Wild('a', exclude=[x, y]) >>> b = Wild('b', exclude=[x, y]) >>> (2 + 3*y).match(a*x + b*y) Exclude also helps remove ambiguity from matches. >>> E = 2*x**3*y*z >>> a, b = symbols('a b', cls=Wild) >>> E.match(a*b) {a_: 2*y*z, b_: x**3} >>> a = Wild('a', exclude=[x, y]) >>> E.match(a*b) {a_: z, b_: 2*x**3*y} >>> a = Wild('a', exclude=[x, y, z]) >>> E.match(a*b) {a_: 2, b_: x**3*y*z} Wild also accepts a ``properties`` parameter: >>> a = Wild('a', properties=[lambda k: k.is_Integer]) >>> E.match(a*b) {a_: 2, b_: x**3*y*z} T)exclude propertiesr8c [UVs/sHn[U5PM sn5n[U5nURX@5 [R"XX#40UD6$s snfr/)rrrJrr)r(rrrrKr`s r+r' Wild.__new__isPW5WW56:&  k'}}SK{KK6sAcHURURUR4$r/)rrrr0s r+r2Wild.__getnewargs__os 4<<99r-c L[R"X40UD6nX%lX5lU$r/)rIrrr)r(rrrrKr*s r+r Wild.__xnew__rs&ooc7;7 # r-cR>[TU]5URUR4-$r/)superr6rr)r1 __class__s r+r6Wild._hashable_contentzs#w(*dllDOO-LLLr-c^[U4SjUR55(ag[U4SjUR55(dgUc0nOUR 5nTX 'U$)Nc3F># UHnTRU5v M g7fr/)has)r^r`exprs r+raWild.matches..s1Lqtxx{{Ls!c32># UH o"T5v M g7fr/r8)r^frs r+rars4Oq1T77Os)rgrallrr)r1r repl_dictrs ` r+matches Wild.matches~sW 1DLL1 1 14DOO444  I!(I r-)r8r8r)r9r:r;r<r=is_Wildr>r'r2rr rr6r r? __classcell__)rs@r+rr sMWpG)IL :   M  r-rz"([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z]))r(c  ^/n[U[5(GauSnSn/mUHenX`;dM [U5U;aUS- n[U5U;aM[U5nUS- nURXg5nTR XvSS45 Mg U4SjnUR 5nUR S5n U (aUSSR5nU(d [S5eURS5V s/sHoR 5PM nn [S U55(d [S 5e[[U5S- SS5Hn X R5X U S-&M URS U 5n UGHn U (d [S 5eS U ;a"U"U"U 540UD6nUR U5 M>[RU 5n/n[[U5S- 5Hxn U (dM S X;dMXS :wdM XS- R S5(dM=XS-RS5(dMZXS- SSXS- 'XS-SSXS-'Mz UGHTnS U;Ga7UR S 5(a [S5eURS 5unnUS[ R";aUU(dSO [%U5n[%U5nUR [UU5Vs/sHn[U5PM sn5 OU=(d SnUR [[ R&R)U5[ R&R)U5S-5Vs/sHn[ R&UPM sn5 US(d GM)GMBUR U/5 GMW Sn [U5S:XaUSnO'[+U6Vs/sHnSR-U5PM nnT(a2UR/UVs/sHnU"U"U540UD6PM sn5 GMUR/UVs/sH nU"U40UD6PM sn5 GM U (d[U5S::a U(dgUS$[1U5$UH n UR [3U 4SU0UD65 M" [5U5"U5$s sn fs snfs snfs snfs snfs snf)a Transform strings into instances of :class:`Symbol` class. :func:`symbols` function returns a sequence of symbols with names taken from ``names`` argument, which can be a comma or whitespace delimited string, or a sequence of strings:: >>> from sympy import symbols, Function >>> x, y, z = symbols('x,y,z') >>> a, b, c = symbols('a b c') The type of output is dependent on the properties of input arguments:: >>> symbols('x') x >>> symbols('x,') (x,) >>> symbols('x,y') (x, y) >>> symbols(('a', 'b', 'c')) (a, b, c) >>> symbols(['a', 'b', 'c']) [a, b, c] >>> symbols({'a', 'b', 'c'}) {a, b, c} If an iterable container is needed for a single symbol, set the ``seq`` argument to ``True`` or terminate the symbol name with a comma:: >>> symbols('x', seq=True) (x,) To reduce typing, range syntax is supported to create indexed symbols. Ranges are indicated by a colon and the type of range is determined by the character to the right of the colon. If the character is a digit then all contiguous digits to the left are taken as the nonnegative starting value (or 0 if there is no digit left of the colon) and all contiguous digits to the right are taken as 1 greater than the ending value:: >>> symbols('x:10') (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) >>> symbols('x5:10') (x5, x6, x7, x8, x9) >>> symbols('x5(:2)') (x50, x51) >>> symbols('x5:10,y:5') (x5, x6, x7, x8, x9, y0, y1, y2, y3, y4) >>> symbols(('x5:10', 'y:5')) ((x5, x6, x7, x8, x9), (y0, y1, y2, y3, y4)) If the character to the right of the colon is a letter, then the single letter to the left (or 'a' if there is none) is taken as the start and all characters in the lexicographic range *through* the letter to the right are used as the range:: >>> symbols('x:z') (x, y, z) >>> symbols('x:c') # null range () >>> symbols('x(:c)') (xa, xb, xc) >>> symbols(':c') (a, b, c) >>> symbols('a:d, x:z') (a, b, c, d, x, y, z) >>> symbols(('a:d', 'x:z')) ((a, b, c, d), (x, y, z)) Multiple ranges are supported; contiguous numerical ranges should be separated by parentheses to disambiguate the ending number of one range from the starting number of the next:: >>> symbols('x:2(1:3)') (x01, x02, x11, x12) >>> symbols(':3:2') # parsing is from left to right (00, 01, 10, 11, 20, 21) Only one pair of parentheses surrounding ranges are removed, so to include parentheses around ranges, double them. And to include spaces, commas, or colons, escape them with a backslash:: >>> symbols('x((a:b))') (x(a), x(b)) >>> symbols(r'x(:1\,:2)') # or r'x((:1)\,(:2))' (x(0,0), x(0,1)) All newly created symbols have assumptions set according to ``args``:: >>> a = symbols('a', integer=True) >>> a.is_integer True >>> x, y, z = symbols('x,y,z', real=True) >>> x.is_real and y.is_real and z.is_real True Despite its name, :func:`symbols` can create symbol-like objects like instances of Function or Wild classes. To achieve this, set ``cls`` keyword argument to the desired type:: >>> symbols('f,g,h', cls=Function) (f, g, h) >>> type(_[0]) r)z\,z\:z\ rNcN>T(aTHupURX5nM U$r/)replace)rPclliteralss r+literalsymbols..literals$$DA !A%Hr-,rUzno symbols givenc3$# UHov M g7fr/r8)r^rZs r+rasymbols..s$e1eszmissing symbol between commasseqzmissing symbol:()zmissing end rangeaTr|r8r()r"r#chrrappendstripendswithrstriprOsplitr rangerVr_range startswithstringdigitsrX ascii_lettersindexrjoinextendrsymbolsr&)rmr(argsresultmarker splitterssplitterlit_charras_seqrZrBrrsymbolr% split_listrPrba_ib_irrs @r+r/r/sjhF%' *,!H &kU*aKF&kU*v;!  h9AB< 89"   $ #2J%%'E/0 0%*KK$45$4q$45$e$$$<= =s5zA~r2.A#hnn.EQUO/hhuf%D !122$WT]3d3 f%%||D1E*,J3u:>*1UX_!e --c22!e //44#(Q<#4Ea%L#(Q<#3Ea%L + !8zz#()<==773*%%qc*#&z?a'&qME18*1EF1EARWWQZ1EEFMME"JEq3wqz#:T#:E"JKMM5"A5a3q>D>5"AB[^s6{a'!9 V}D MM'$8C848 9E{6""E6F+L+@G"J"As$1S2S 0S SS S c 8^U4SjmSSKJn U"5Rn[U40UD6nUbd[ U[ 5(aXCR UR'O6[ U[5(aXCR UR'OT"XC5 AU$!Af=f)af Create symbols and inject them into the global namespace. Explanation =========== This calls :func:`symbols` with the same arguments and puts the results into the *global* namespace. It's recommended not to use :func:`var` in library code, where :func:`symbols` has to be used:: Examples ======== >>> from sympy import var >>> var('x') x >>> x # noqa: F821 x >>> var('a,ab,abc') (a, ab, abc) >>> abc # noqa: F821 abc >>> var('x,y', real=True) (x, y) >>> x.is_real and y.is_real # noqa: F821 True See :func:`symbols` documentation for more details on what kinds of arguments can be passed to :func:`var`. c>UHin[U[5(aX!RUR'M2[U[5(aX!RUR 'MaT"X!5 Mk g)z4Recursively inject symbols to the global namespace. N)r"r f_globalsrrr9)r/framer7traverses r+r@var..traversesOF&%((/5 ,FM22390' r-r) currentframe) inspectrBf_backr/r"rr>rrr9)rmr0rBr?symsr@s @r+varrFcsF(% N ! !E u%%  $&&-1 *D-0015 .%  K s A3BBc[U6nSn[URUS9n0nUH<nUR[ U5R S5/5R U5 M> 0nUHn[SU-40XGSRD6nXGSU:wa XXGS'Sn [S[XG55H9n SXzU -4-n X;aOU S- n MXGU n [U 40U RD6Xl'M; M URU5$)av Return a Tuple containing the passed expressions with symbols that appear the same when printed replaced with numerically subscripted symbols, and all Dummy symbols replaced with Symbols. Parameters ========== iter: list of symbols or expressions. Examples ======== >>> from sympy.core.symbol import disambiguate >>> from sympy import Dummy, Symbol, Tuple >>> from sympy.abc import y >>> tup = Symbol('_x'), Dummy('x'), Dummy('x') >>> disambiguate(*tup) (x_2, x, x_1) >>> eqs = Tuple(Symbol('x')/y, Dummy('x')/y) >>> disambiguate(*eqs) (x_1/y, x/y) >>> ix = Symbol('x', integer=True) >>> vx = Symbol('x') >>> disambiguate(vx + ix) (x + x_1,) To make your own mapping of symbols to use, pass only the free symbols of the expressions and create a dictionary: >>> free = eqs.free_symbols >>> mapping = dict(zip(free, disambiguate(*free))) >>> eqs.xreplace(mapping) (x_1/y, x/y) cZ[[URR555$r/)rrrrH)r`s r+rCdisambiguate..s5 4 4 678r-)r_z%srrz%s_%i) r rrrr#lstripr!rIrr&rVxreplace) iternew_iterrrEmappingrPrepsrmapk0skiprBrkis r+ disambiguaterTs#Pd|H 8C 8((s 3DG 3q6==-r299!< D tqz@WZ]%?%?@ :a=E !"'A q#gj/*A!X.&   ABd6boo6DH+   T ""r-r/)returnr)9 __future__rrKrrbasicrrcacher containersr rr r functionr rrurrlogicr singletonrsortingrrsympy.logic.boolalgrsympy.utilities.iterablesrrsympy.utilities.miscrr)r_rer itertoolsrtypingrrrMrRr#rn_uniquely_named_symbolrIrrcompiler'r/rFrTr8r-r+rfs"4"1+'7+  $8 '@LD(*3tI.T/qZqhADFADH|6|~ 9 :!R#j=~?#r-