\h1@SSKJr SSKJrJr SSKJrJr SSKJ r SSK r SSK J r J r SSK JrJr SS KJr SS KJrJrJr SS KJrJrJr SS KJr SS KJrJr SSKJ r SSK!J"r" SSK#J$r$ SSK%J&r& SSK'J(r(J)r)J*r* SSK+J,r,J-r- SSK.J/r/J0r0 SSK1J2r2 \(aSSKJ3r3 SSK4J5r5 SSK6J7r7 SSK8J9r9 Sr:\"SS\\55r;"SS\\;5rS"r?"S#S$5r@SS%KAJBrB SS&KCJDrD SS'KEJFrF SS(KGJHrHJIrI SS)KJJKrK SS*KLJMrM SS+K6JNrNJOrOJPrPJQrQJRrR g),) annotations) TYPE_CHECKINGoverload)IterableMapping)reduceN)sympify_sympify)BasicAtom)S) EvalfMixin pure_complexDEFAULT_MAXPREC)call_highest_prioritysympify_method_argssympify_return)cacheit)fuzzy_or fuzzy_not) mod_inverse)default_sort_key) NumberKindsympy_deprecation_warning)as_int func_name filldedent) has_varietysift)mpf_log prec_to_dps) giant_steps)Any)Self)Number) defaultdictc/n/n[R"U5H?nURU5nU(dURU5 M.URU5 MA [U6[U64$N)Add make_argscoeffappend)eqccononicis G/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/expr.py_coremr6!sZ B C ]]2  WWQZ JJqM IIbM  8S#Y c8 ^\rSrSr%SrSrS\S'\(arSSjr\ SSSjj5r \ SSS jj5r \ SS j5r \ SSS jj5r \ SSS jj5r \ SS j5r SSSjjr SSjr SSSjjr \ r Sr\S5r\SSj5rSrSr\S5r\S5rSSjrSSjrSSjr\"S/\5\"S5SSj55r\"S/\5\"S5SSj55r\"S/\5\"S 5SS!j55r\"S/\5\"S"5SS#j55r \"S/\5\"S$5SS%j55r!\"S/\5\"S&5SS'j55r"\"S/\5\"S(5S)55r#SSS*jjr$\"S/\5\"S+5SS,j55r%\"S/\5\"S-5SS.j55r&\"S/\5\"S/5SS0j55r'\"S/\5\"S15SS2j55r(\"S/\5\"S35SS4j55r)\"S/\5\"S55SS6j55r*\"S/\5\"S75SS8j55r+\"S/\5\"S95SS:j55r,\"S/\5\"S;5SS<j55r-SS=jr.SS>jr/SS?jr0\"S/\5S@5r1\"S/\5SA5r2\"S/\5SB5r3\"S/\5SC5r4SDr5SU4SEjjr6\7SF5r8\SG5r9SHr:SSIjr;SJrSMr?SNr@SOrASSPjrBSQrCSRrDSSrESTrFSUrGSVrHSWrI\JSX5rKSSYjrLSZrMSS[jrNS\rOSS]jrPSS^jrQS_rRSS`jrSSSajrTSSSbjjrUScrVSSdjrWSSejrXSSSfjjrYSgrZShr[SSijr\SSjjr]SSkjr^SSljr_SSmjr`SSnjraSorbSSpjrcSqrd\Sr5reSSsjrfSStjrgSurhSSvjriSwrjSSxjrkSyrlSSzjrmS{rnSS|jroSS~jrpSSjrqSrrSSjrsSSjrtSSjruSrvSSjrw\SS}S.Sj5rxSrySSjrzSSjr{SSSjjr|SSSjjr}SSjr~SSjrSrSr\7SSj5r\SSj5rSrSSjrSSjrSSjrSrSSjrSrSrSrSrSrSrSrSrSrSSjr\rSrSrU=r$)Expr.aZ Base class for algebraic expressions. Explanation =========== Everything that requires arithmetic operations to be defined should subclass this class, instead of Basic (which should be used only for argument storage and expression manipulation, i.e. pattern matching, substitutions, etc). If you want to override the comparisons of expressions: Should use _eval_is_ge for inequality, or _eval_is_eq, with multiple dispatch. _eval_is_ge return true if x >= y, false if x < y, and None if the two types are not comparable or the comparison is indeterminate See Also ======== sympy.core.basic.Basic ztuple[str, ...] __slots__cgr*r;)clsargss r5__new__ Expr.__new__J r7Ncgr*r;selfarg1arg2s r5subs Expr.subsMsadr7c gr*r;rErFrGkwargss r5rHrIOsx{r7cgr*r;rDs r5rHrIQsLOr7c gr*r;rKs r5rHrISsrur7c gr*r;rKs r5rHrIUsz}r7c gr*r;rKs r5rHrIWs^ar7c gr*r;rKs r5rHrIZs r7c gr*r;)rErLs r5simplify Expr.simplify^rBr7cgr*r;)rEnrHmaxnchopstrictquadverboses r5evalf Expr.evalfas r7Tcg)avReturn True if one can differentiate with respect to this object, else False. Explanation =========== Subclasses such as Symbol, Function and Derivative return True to enable derivatives wrt them. The implementation in Derivative separates the Symbol and non-Symbol (_diff_wrt=True) variables and temporarily converts the non-Symbols into Symbols when performing the differentiation. By default, any object deriving from Expr will behave like a scalar with self.diff(self) == 1. If this is not desired then the object must also set `is_scalar = False` or else define an _eval_derivative routine. Note, see the docstring of Derivative for how this should work mathematically. In particular, note that expr.subs(yourclass, Symbol) should be well-defined on a structural level, or this will lead to inconsistent results. Examples ======== >>> from sympy import Expr >>> e = Expr() >>> e._diff_wrt False >>> class MyScalar(Expr): ... _diff_wrt = True ... >>> MyScalar().diff(MyScalar()) 1 >>> class MySymbol(Expr): ... _diff_wrt = True ... is_scalar = False ... >>> MySymbol().diff(MySymbol()) Derivative(MySymbol(), MySymbol()) Fr;rEs r5 _diff_wrtExpr._diff_wrtjsRr7c UR5up#UR(aHUR5upEU[RLa [ S5"U5[R pTUnO[R nUR(aUR54nOUR(a [U54nOqUR(aURUS9nO-UR(aURUS9nO URn[!UVs/sH n[#XqS9PM sn5n[%U5[!U54nURUS9nUR'5XeU4$s snf)Nexporder) as_coeff_Mulis_Pow as_base_exprExp1FunctionOneis_Dummysort_keyis_Atomstris_Addas_ordered_termsis_Mulas_ordered_factorsr?tuplerlen class_key)rErer-exprbasercr?args r5rm Expr.sort_keys'')  ;;((*IDqvv~%UOC0!%%cD%%C ==MMO%D \\ILu$ $r7__rmod__c[X5$r*Modrs r5__mod__ Expr.__mod__1rr7rc[X5$r*rrs r5r Expr.__rmod__6rr7 __rfloordiv__c"SSKJn U"X- 5$Nr)floor#sympy.functions.elementary.integersrrErrs r5 __floordiv__Expr.__floordiv__;s >T\""r7rc"SSKJn U"X- 5$rrrs r5rExpr.__rfloordiv__As >U\""r7 __rdivmod__c8SSKJn U"X- 5[X54$rrrrrs r5 __divmod__Expr.__divmod__Hs >T\"C$444r7rc8SSKJn U"X- 5[X54$rrrs r5rExpr.__rdivmod__Ns >U\"C$444r7c0UR(d [S5eURS5nUR(d [S5eU[R [R [R4;a[SU-5e[U5nU(dU$[U5(agX:[RLaU$X:[RLaUS- $URU5nUc [S5eU(aU$X"S:aS- $S- $U$) NzCannot convert symbols to intzCannot convert complex to intzCannot convert %s to intr z#cannot compute int value accuratelyr) is_numberrround is_NumberrNaNInfinityNegativeInfinityint int_valuedtrueequals)rErr3oks r5__int__ Expr.__int__Ts~~;< < JJqM{{;< <  A$6$67 76:; ; FH a==QVV#QVV#1u QBz EFFU+ ++ +r7cUR5nUR(a [U5$UR(a#UR 5S(a [ S5e[ S5e)Nr zCannot convert complex to floatz"Cannot convert expression to float)r\rfloatr as_real_imagr)rEresults r5 __float__Expr.__float__nsS   =    3 3 5a 8=> ><==r7cUR5nUR5up#[[U5[U55$r*)r\rcomplexr)rErreims r5 __complex__Expr.__complex__ys2$$&uRy%),,r7cSSKJn U"X5$)Nr ) GreaterThan) relationalr)rErrs r5__ge__ Expr.__ge__~s+4''r7cSSKJn U"X5$)Nr )LessThan)rr)rErrs r5__le__ Expr.__le__s($$r7cSSKJn U"X5$)Nr )StrictGreaterThan)rr )rErr s r5__gt__ Expr.__gt__s1 --r7cSSKJn U"X5$)Nr )StrictLessThan)rr)rErrs r5__lt__ Expr.__lt__s.d**r7cPUR(d [S5e[U5$)Nz'Cannot truncate symbols and expressions)rrIntegerr_s r5 __trunc__Expr.__trunc__s~~EF F4= r7cZ>UR(a[R"SU5nU(am[UR S55nUR U5nUR (a[[U5U5$UR(a [XA5$[TU])U5$)Nz\+?\d*\.(\d+)fr ) rrmatchrgroupr is_Integerformatis_Floatsuper __format__)rE format_specmtprecrounded __class__s r5rExpr.__format__s| >>+[9B288A;'**T*%%!#g, <<##!'77w!+..r7c<[US5(a![R"URU5$[US5(aOURup#[R"X!5n[R"X15[ R -nX#-$[S5e)N_mpf__mpc_z#expected mpmath number (mpf or mpc))hasattrFloat_newr&r'r ImaginaryUnitr)xr!rrs r5 _from_mpmathExpr._from_mpmathst 1g  ::aggt, , Q WWFBB%BB%aoo5B7NAB Br7c:[SUR55$)aReturns True if ``self`` has no free symbols and no undefined functions (AppliedUndef, to be precise). It will be faster than ``if not self.free_symbols``, however, since ``is_number`` will fail as soon as it hits a free symbol or undefined function. Examples ======== >>> from sympy import Function, Integral, cos, sin, pi >>> from sympy.abc import x >>> f = Function('f') >>> x.is_number False >>> f(1).is_number False >>> (2*x).is_number False >>> (2 + Integral(2, x)).is_number False >>> (2 + Integral(2, (x, 1, 2))).is_number True Not all numbers are Numbers in the SymPy sense: >>> pi.is_number, pi.is_Number (True, False) If something is a number it should evaluate to a number with real and imaginary parts that are Numbers; the result may not be comparable, however, since the real and/or imaginary part of the result may not have precision. >>> cos(1).is_number and cos(1).is_comparable True >>> z = cos(1)**2 + sin(1)**2 - 1 >>> z.is_number True >>> z.is_comparable False See Also ======== sympy.core.basic.Basic.is_comparable c38# UHoRv M g7fr*)r).0objs r5 !Expr.is_number..s6IS==I)allr?r_s r5rExpr.is_numbersd6DII666r7clURnUSLagUR(dgUR5up#UR(d#UR S5nUR(dgUR(d#UR S5nUR(dgU(agUR S:g$)NFrr )is_extended_realrrrr\_prec)rEr9rVr3s r5_eval_is_comparableExpr._eval_is_comparables 00 u $~~   "{{ A;;{{ A;; 77a< r7cxURnSnU(a]SSKJn X$X54upp[[ [ UUV s/sH n U"XXSS9PM sn 555n[ URSUS95nO0n[ URS55n[US 5(dgURS:XaA[S[5H-n[ URX~S95nURS:wdM- O URS:waUc [US 5nURXS9$gs sn f![[4a gf=f) aReturn self evaluated, if possible, replacing free symbols with random complex values, if necessary. Explanation =========== The random complex value for each free symbol is generated by the random_complex_number routine giving real and imaginary parts in the range given by the re_min, re_max, im_min, and im_max values. The returned value is evaluated to a precision of n (if given) else the maximum of 15 and the precision needed to get more than 1 digit of precision. If the expression could not be evaluated to a number, or could not be evaluated to more than 1 digit of precision, then None is returned. Examples ======== >>> from sympy import sqrt >>> from sympy.abc import x, y >>> x._random() # doctest: +SKIP 0.0392918155679172 + 0.916050214307199*I >>> x._random(2) # doctest: +SKIP -0.77 - 0.87*I >>> (x + y/2)._random(2) # doctest: +SKIP -0.57 + 0.16*I >>> sqrt(2)._random(2) 1.4 See Also ======== sympy.core.random.random_complex_number r r)random_complex_numberTrationalrrHNr:) free_symbolssympy.core.randomr>dictlistzipabsr\rrr(r:r$rmax)rErVre_minim_minre_maxim_maxfreer!r>ar0bdzirepsnmags r5_random Expr._randomsBH    ?7JA!S%)(+%)r)>aASW(X%)(+,-.D 4::ad:34Dtzz!}%DtW%% ::? $A74::d:67::?8 ::?ybM::a:+ +G(+ *    sD!D&&D98D9c URSS5nUR(agURnU(dg[U5nU(a X-(dgU=(d UnUnU(aUR 5nUR (agUVs1sHofR [LdMUiM nnSnXt:XGaUR[[US/[U5-55SS9n U [RLaURSSSSS5n U Gb(U [RLGaUR[[US/[U5-55SS9n U [RLaURSSSSS5n U b(U [RLaU R!U 5SLagURSSSSS5n U b(U [RLaU R!U 5SLagUR5n U b=U [RLa*U R!U 5SLagU R(aU OU nUH]n UR#U 5n U(aU R 5n U S:wdM3[%U SS 9(dURS S5(aUs $ g SS KJn [+[-S U "U5555$s snf![a Sn GNf=f![a Sn GNlf=f) a Return True if self is constant, False if not, or None if the constancy could not be determined conclusively. Explanation =========== If an expression has no free symbols then it is a constant. If there are free symbols it is possible that the expression is a constant, perhaps (but not necessarily) zero. To test such expressions, a few strategies are tried: 1) numerical evaluation at two random points. If two such evaluations give two different values and the values have a precision greater than 1 then self is not constant. If the evaluations agree or could not be obtained with any precision, no decision is made. The numerical testing is done only if ``wrt`` is different than the free symbols. 2) differentiation with respect to variables in 'wrt' (or all free symbols if omitted) to see if the expression is constant or not. This will not always lead to an expression that is zero even though an expression is constant (see added test in test_expr.py). If all derivatives are zero then self is constant with respect to the given symbols. 3) finding out zeros of denominator expression with free_symbols. It will not be constant if there are zeros. It gives more negative answers for expression that are not constant. If neither evaluation nor differentiation can prove the expression is constant, None is returned unless two numerical values happened to be the same and the flag ``failing_number`` is True -- in that case the numerical value will be returned. If flag simplify=False is passed, self will not be simplified; the default is True since self should be simplified before testing. Examples ======== >>> from sympy import cos, sin, Sum, S, pi >>> from sympy.abc import a, n, x, y >>> x.is_constant() False >>> S(2).is_constant() True >>> Sum(x, (x, 1, 10)).is_constant() True >>> Sum(x, (x, 1, n)).is_constant() False >>> Sum(x, (x, 1, n)).is_constant(y) True >>> Sum(x, (x, 1, n)).is_constant(n) False >>> Sum(x, (x, 1, n)).is_constant(x) True >>> eq = a*cos(x)**2 + a*sin(x)**2 - a >>> eq.is_constant() True >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0 True >>> (0**x).is_constant() False >>> x.is_constant() False >>> (x**x).is_constant() False >>> one = cos(x)**2 + sin(x)**2 >>> one.is_constant() True >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1 True rSTNr) simultaneousr Fror_realfailing_number)denomsc38# UHoRv M g7fr*)is_zero)r1dens r5r3#Expr.is_constant..s!F#++r5)getrrCsetrSr^kindrrHrFrGrurrrUZeroDivisionErrorrdiffrsympy.solvers.solversr\rr)rEwrtflagsrSrNrwsym wrt_numberr[rOrPwderivr\s r5 is_constantExpr.is_constantTsV99Z. >>  #h szkT ==?D <<&)CScHH ,BcS C   IId3taST]#;a GM f=f!U[>4a NAf=f)aWReturn True if self == other, False if it does not, or None. If failing_expression is True then the expression which did not simplify to a 0 will be returned instead of None. Explanation =========== If ``self`` is a Number (or complex number) that is not zero, then the result is False. If ``self`` is a number and has not evaluated to zero, evalf will be used to test whether the expression evaluates to zero. If it does so and the result has significance (i.e. the precision is either -1, for a Rational result, or is greater than 1) then the evalf value will be used to return True or False. r) nsimplifyrS)solve NotAlgebraicminimal_polynomialFT)radicalr N)rSr[c"URS*$r)r?)r,s r5Expr.equals..HsaffQiZr7key)rSc38# UHoRv M g7fr*)r)r1sis r5r3Expr.equals..Us;s}}sr5c3<# UHoRSLv M g7f)FN) is_algebraic)r1r3s r5r3r~YsD1~~6sc3,># UH oT;v M g7fr*r;)r1r}surdss r5r3r~\s9SrU{Ssc3j># UH(nT"TU- 5S:H=(a T"TU- 5S:Hv M* g7f)rNr;r1r}rpsrSs r5r3r~`sBE@C" )R0A5 6 (R 0A 5 6@Cs03c3b># UH$nT"UT/5T:H=(a T"U5T:Hv M& g7fr*r;rs r5r3r~ds7#3.1$-R!#5#:#Px|q?P#P.1s,/)TN)!sympy.simplify.simplifyrprSrfrqsympy.polys.polyerrorsrssympy.polys.numberfieldsrur isinstancer9 factor_termshasr+r as_coeff_mulruranyrmrrU is_comparableatomsrr?rsortr6is_realNotImplementedError is_Symbol)rErfailing_expressionrqrsrurefactorsfacfac_zeroconstantndiffrsolmprprSrs ` @@@r5r Expr.equalss$ @/7?%&& = HT\2DAxxS!!##%a( w>> $ 3H166!93G3GQHE JJ/J 0  a%8C8#';s;;;$)DDDD#(9S999$)E@CEEE#'99"#3.1#3 3 3'+ 3%%F+D1B||#  < 'HM KA:RIB+%&9:sT&J!J :J J0J J"J>J-JJ# J J # J21J2cRSSKJn SSKJn UR(GagUR S5nUcg[USS5S:XagU[RLagURS5nUR(aU[R4nO [U5nUcgUupxUR(aUR(dgURS:wa<URS:wa,[!U(+=(a U(a US:5$US:5$URS:XacU(aURS:XaKUR#5(a5UR%[&5(dU"U5R((aggggggg![ a gf=f!U[*4a gf=f)Nrrtrrrr:r F)rrurrsr _eval_evalfrgetattrrrr\rZerorrr:bool_eval_is_algebraicrrjrr) rEpositiverursn2frrr3s r5#_eval_is_extended_positive_negative(Expr._eval_is_extended_positive_negativese?7 >>> %%a( zr7A&!+QUU{ 1 Azz166 $Q}DAKKAKKww!|1 EH(AIIQIIAqAGGqL++--dhhx6H6H)$/99$:7I--99   4%&9:s#F)F FF F&%F&c URSS9$)NTrrr_s r5_eval_is_extended_positiveExpr._eval_is_extended_positives777FFr7c URSS9$)NFrrr_s r5_eval_is_extended_negativeExpr._eval_is_extended_negatives777GGr7c ^^^^^^^SSKJm SSKJn SSKJmJm SSKJn SSK J n TcTc [S5eUUUUUUU4SjnTT:Xa[R$U"S S 9nU[RLaU$U"S S 9n T=(a TcX- $X- n TR(GaTR(Ga TT:a U"TT5n O U"TT5n U"TR!5R#5S TU S 9n TR%U5Hn X"U R&STU S 9-n M U HnU [RLa U $UR(dM,TU:UT:s=:XaS :Xa O OU T"TTUS5*T"TTUS5-- n M_TU:UT:s=:XaS :XdMtO MxU T"TTUS5T"TTUS5- - n M U $U $![(a U $f=f)a& Returns evaluation over an interval. For most functions this is: self.subs(x, b) - self.subs(x, a), possibly using limit() if NaN is returned from subs, or if singularities are found between a and b. If b or a is None, it only evaluates -self.subs(x, a) or self.subs(b, x), respectively. r AccumBoundslog)limitLimit)Interval)solvesetz"Both interval ends cannot be None.c>U(aTOTnUc[R$TRT U5nUR[R[R [R [RT5(aLTT:S:waT"TT X(aSOS5nOT"TT X(aSOS5n[UT5(a [S5eU$)NF+-zCould not compute limit) rrrHrrrrComplexInfinityrr) leftr0CrrrOrPrrEr,s r5_eval_endpoint+Expr._eval_interval.._eval_endpointsqAyvv IIaO55 A,>,>**K99A%'!$1TcsC!$1TcsC!!U++12KLLHr7T)rFr )domainrr)!sympy.calculus.accumulationboundsr&sympy.functions.elementary.exponentialrsympy.series.limitsrrsympy.sets.setsrsympy.solvers.solvesetrrrrrrcancelas_numer_denomrr?r)rEr,rOrPrrrrABvaluer singularitieslogtermrrrrs```` @@@r5_eval_intervalExpr._eval_intervals B>4,3 I!)AB B  " 666M  % :H  & G! 5L ???q1u!!Q!!Q%T[[]%A%A%CA%FM::c? -a!!1#!# + &A~ ?? A1q51T1%aC"8!85q!S;Q!QQa%QU3t33tQ3!7%aC:P!PP' u    s$G?AG"G GGcgr*r;)rEexpts r5 _eval_powerExpr._eval_powersr7cRUR(aU$UR(aU*$gr*)r9 is_imaginaryr_s r5_eval_conjugateExpr._eval_conjugates%  K   5Lr7cSSKJn U"U5$)z(Returns the complex conjugate of 'self'.r conjugate)rrrs r5rExpr.conjugatesGwr7cbUR(a[R$SSKJn [RnUnU(aU[R - nUR U5nURUS5nU[RLaURUS5nU[RLa;URU5upgURU"U55(a [5eU[R:waO U(aMWX$--$![a URUS5nNCf=f)Nrr)r^rrrrrkrerHrrrleadtermrr)rEr,cdirrminexpryr-_s r5dirExpr.dir s <<66M> aeeOF((1+CHHQNE~ !Q))),"||AHEyyQ(((l*)cT\!! ",IIaOE,s09DD.-D.cSSKJn UR(aU$UR(aU"U5$UR(a U"U5*$g)Nrr)rrr is_hermitianis_antihermitian)rErs r5_eval_transposeExpr._eval_transpose$sAB   K   T? "  " "dO# ##r7cSSKJn U"U5$)Nr) transpose)rr)rErs r5rExpr.transpose-sBr7cSSKJnJn UR(aU$UR(aU*$UR 5nUbU"U5$UR 5nUbU"U5$g)Nr)rr)rrrrrrr)rErrr2s r5 _eval_adjointExpr._eval_adjoint1sbM   K  " "5L""$ ?S> !""$ ?S> ! r7cSSKJn U"U5$)Nr)adjoint)rr)rErs r5r Expr.adjoint>s@t}r7c^^^SSKJn [TSS5nUcSnOU"S5nU(aTSSmU"T5mU4SjmUUU4S jnXT4$) z+Parse and configure the ordering of terms. r) monomial_key startswithNFzrev-c >[UVs/sH#n[U[5(aT"U5OU*PM% sn5$s snfr*)rtr)monommnegs r5rExpr._parse_order..negQs7%P%QJq%$8$8#a&qb@%PQ QPs*<c >Uunuup#pET "T"U55n[UVs/sHofRT S9PM sn5n[U5U4X#44nXEU4$s snf)Nrd)rtrmr) termrrrrncparter- monom_keyrres r5r{Expr._parse_order..keyTsj+/ (A(% %()EVDVJJUJ3VDEF2h^bX.E%' 'EsA)sympy.polys.orderingsrr)r>rerrreverser{rrs ` @@r5 _parse_orderExpr._parse_orderBsX 7UL$7  G (Gab  '  R (|r7cU/$)z4Return list of ordered factors (if Mul) else [self].r;)rEres r5rsExpr.as_ordered_factors_s v r7czSSKJnJn SSKJn U"U/UQ70UD6nUR (dgU$!X44a gf=f)aLConverts ``self`` to a polynomial or returns ``None``. Explanation =========== >>> 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 r)PolynomialErrorGeneratorsNeeded)PolyN)rrr sympy.polys.polytoolsr is_Poly)rEgensr?rr r polys r5as_poly Expr.as_polycsJ& M. ,t,t,D<< 2  s00::cn^^SSKJmJm UcUR(aUU4Sjn[ [ R "U5US9n[U5S:Xa[USTT45(a[US[5(an[ [R "US5US9n[U5S:Xa>[UST5(a*USR(aUSR(aU$URU5up6UR5upx[SU55(d [ XsUS9n OZ//pUH<upU R(dU R!X45 M*U R!X45 M> [ XS S9[ XS S9-n U(aX4$U V Vs/sHupU PM snn $s snn f) z Transform an expression to an ordered list of terms. Examples ======== >>> from sympy import sin, cos >>> from sympy.abc import x >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms() [sin(x)**2*cos(x), sin(x)**2, 1] r )r' NumberSymbolc*>[UTT45(+$r*)r)r,r'rs r5rx'Expr.as_ordered_terms..sz!fl-CDDr7rzrrc3># UHupURv M g7fr*)is_Order)r1rrs r5r3(Expr.as_ordered_terms..s6WT4==s)r{rT)numbersr'rrpsortedr+r,rurr is_positive is_negativeras_termsrrr.)rEredatar{add_argsmul_argsrtermsr ordered_terms_orderrreprrr'rs @@r5rqExpr.as_ordered_termssn 2 =T[[ECcmmD1s;HH "x{V\,BCCx{C00!#-- "<#FMQ&"8A;77  //  //#O((/ mmo 6666UW=GF# }}MM4,/MM4,/ $ Vd;$78G = (/0WTD0 00sF1czSSKJn [5/p2[R"U5HnUR 5upV[ U5n0/pU[RLa[R"U5Hhn U R(aU[ U 5-nM%U R(a!U"U 5upXU 'URU 5 MWURU 5 Mj UR UR"4n[%U5nURXEXx445 M ['U[(S9n[+U50p[-U5H upXU'M /nUHMunupWnS/U -nUR/5H upU UX'M URXE[%U5U445 MO UU4$![[4a GN f=f)z,Transform an expression to a list of terms. r )decompose_powerrzr) exprtoolsr'rbr+r,rfrrrkrrrrraddr.realimagrtrrru enumerateitems)rEr'r r rr-_termcpartrfactorrxrckindicesr3grrs r5r Expr.as_termss.eReMM$'D,,.LEENE6AEE!!mmE2F''%!WV_4E%,,$3F$; &)d  f-3"JJ *E6]F LL$ 67 87(:d 01Y7dODAAJ$,1 (D(5CEE"[[] '*gm$+ MM4uv!>? @ -2t|G!*:6! !s F&&F:9F:cU$)z1Removes the additive O(..) symbol if there is oner;r_s r5removeO Expr.removeOs r7cg)z=Returns the additive O(..) symbol if there is one, else None.Nr;r_s r5getO Expr.getOsr7c <UR5nUcgUR(GaiURnU[RLa[R $UR (a[R$UR(aURS$UR(aURHnUR (a[Rs $UR(dM9SSK J nJ n URU5n[U5S:XdMcUR5nUR!Xc"SSS95nUR"R (dMUR$R&(dM[)UR$5s $ [+SU-5e)a Returns the order of the expression. Explanation =========== The order is determined either from the O(...) term. If there is no O(...) term, it returns None. Examples ======== >>> from sympy import O >>> from sympy.abc import x >>> (1 + x + O(x**2)).getn() 2 >>> (1 + x).getn() Nr DummySymbolr,Trznot sure of order of %s)r9rrwrrkrrrgr?rrsymbolr=r>rrupoprHrxrc is_RationalrHr)rEooir=r>symsr,s r5getn Expr.getns( IIK 9 ZZZAAEEzvv {{uu xxvvay xx&&B|| uu yyy9!xx/t9> $ A!#E#,E!FB!ww000RVV5G5G5G'*266{ 2!"";a"?@@r7cSSKJn U"X5$)Nr ) count_ops)functionrH)rEvisualrHs r5rHExpr.count_ops's'&&r7c [[R"U55n[U5H!upVUR(aMUSUnXESn O Un/nU(a^U(aWUSR (aCUSR (a/US[RLa[RUS*/USS&U(a|[U5n [U5nU (a_U(aX[U5U :waI[SUV s/sH/n [UR5RU 5S:dM-U PM1 sn -5eXx/$s sn f)aReturn [commutative factors, non-commutative factors] of self. Explanation =========== self is treated as a Mul and the ordering of the factors is maintained. If ``cset`` is True the commutative factors will be returned in a set. If there were repeated factors (as may happen with an unevaluated Mul) then an error will be raised unless it is explicitly suppressed by setting ``warn`` to False. Note: -1 is always separated from a Number unless split_1 is False. Examples ======== >>> from sympy import symbols, oo >>> A, B = symbols('A B', commutative=0) >>> x, y = symbols('x y') >>> (-2*x*y).args_cnc() [[-1, 2, x, y], []] >>> (-2.5*x).args_cnc() [[-1, 2.5, x], []] >>> (-2*x*A*B*y).args_cnc() [[-1, 2, x, y], [A, B]] >>> (-2*x*A*B*y).args_cnc(split_1=False) [[-2, x, y], [A, B]] >>> (-2*x*y).args_cnc(cset=True) [{-1, 2, x, y}, []] The arg is always treated as a Mul: >>> (-2 + x + A).args_cnc() [[], [x - 2 + A]] >>> (-oo).args_cnc() # -oo is a singleton [[-1, oo], []] Nrr z"repeated commutative arguments: %s)rFrr,r,rris_extended_negativerrrurbrr?count) rEcsetwarnsplit_1r?r3mir0ncclenr4s r5args_cnc Expr.args_cnc+sLCMM$'(t_EA$$$!H"X % AB  aDNN aD % %!AMM)]]QqTE*AbqE q6DAAQ4 !E/0!RqDO4I4I"4MPQ4Q"q!R"STTw"Ss =,D? -D? c^^[U5n[U[5(d[R$[ U5nU(d[R$X:Xa&US:Xa[R $[R$U[R Laj[R"U5Vs/sH*oUR5S[R LdM(UPM, nnU(d[R$[U6$US:XaUR(aUR(aURXS9nU(d[R$U(d2U[[R"U5Vs/sHoUU-PM sn6- $U[[R"U5Vs/sHoQU-PM sn6- $URUSS9S$X-nSnSSjn /n/m[R"U5n URn URn U (aU (d[R$U(Ga0UR(GaU (GdU (Gd[R"U5n [[R"URU5S5V^s/sH!m[U4SjU 55(dMTPM# sn6nURXS S 9nUR(aU(dU$[!UR"Vs/sHoR%5PM sn6unn['U5(aU$[UVs/sHn[R("U5PM sn6$U =(d U nUR%S[+U (+5S 9un nU HnUR%S[+U (+5S 9unnUc/n[-U 5[-U5:aMCUR/U 5n[-U5[-U 5-[-U5:XdMzU(a%UR1[[3U5U-65 MTR1UU45 M U(a&U/:Xa[R$U(a[U6$g T(d[R$[U4S jT55(atU "TSSUU5nUbaU(d=[[TVVs/sHunn[U6PM snn6[TSSS U65$[TSSU[-U5-S 6$[5UST55nU(aU "UUU5nUbU(d[TSSn[-T55H#mUR9TTS5nU(aM# O [[3U5US U-6$U[-U5-n[TVVs/sHunn[[3U5UUS -6PM snn6$[3[;[5UST5555nU(akU "UUU5nUb^U(d@[TVVs/sH*unn[[3U5US [-U5*U--6PM, snn6$[UU[-U5-S 6$S n[=T5H5umunnU "UUU5nUcMU(dUUU4nM& [R$ U(a;UunnnU(d[[3U5US U-6$[UU[-U5-S 6$[R$s snfs snfs snfs snfs snfs snfs snnfs snnfs snnf)a Returns the coefficient from the term(s) containing ``x**n``. If ``n`` is zero then all terms independent of ``x`` will be returned. Explanation =========== When ``x`` is noncommutative, the coefficient to the left (default) or right of ``x`` can be returned. The keyword 'right' is ignored when ``x`` is commutative. Examples ======== >>> from sympy import symbols >>> from sympy.abc import x, y, z You can select terms that have an explicit negative in front of them: >>> (-x + 2*y).coeff(-1) x >>> (x - 2*y).coeff(-1) 2*y You can select terms with no Rational coefficient: >>> (x + 2*y).coeff(1) x >>> (3 + 2*x + 4*x**2).coeff(1) 0 You can select terms independent of x by making n=0; in this case expr.as_independent(x)[0] is returned (and 0 will be returned instead of None): >>> (3 + 2*x + 4*x**2).coeff(x, 0) 3 >>> eq = ((x + 1)**3).expand() + 1 >>> eq x**3 + 3*x**2 + 3*x + 2 >>> [eq.coeff(x, i) for i in reversed(range(4))] [1, 3, 3, 2] >>> eq -= 2 >>> [eq.coeff(x, i) for i in reversed(range(4))] [1, 3, 3, 0] You can select terms that have a numerical term in front of them: >>> (-x - 2*y).coeff(2) -y >>> from sympy import sqrt >>> (x + sqrt(2)*x).coeff(sqrt(2)) x The matching is exact: >>> (3 + 2*x + 4*x**2).coeff(x) 2 >>> (3 + 2*x + 4*x**2).coeff(x**2) 4 >>> (3 + 2*x + 4*x**2).coeff(x**3) 0 >>> (z*(x + y)**2).coeff((x + y)**2) z >>> (z*(x + y)**2).coeff(x + y) 0 In addition, no factoring is done, so 1 + z*(1 + y) is not obtained from the following: >>> (x + z*(x + x*y)).coeff(x) 1 If such factoring is desired, factor_terms can be used first: >>> from sympy import factor_terms >>> factor_terms(x + z*(x + x*y)).coeff(x) z*(y + 1) + 1 >>> n, m, o = symbols('n m o', commutative=False) >>> n.coeff(n) 1 >>> (3*n).coeff(n) 3 >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m 1 + m >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m m If there is more than one possible coefficient 0 is returned: >>> (n*m + m*n).coeff(n) 0 If there is only one possible coefficient, it is returned: >>> (n*m + x*m*n).coeff(m*n) x >>> (n*m + x*m*n).coeff(m*n, right=1) 1 See Also ======== as_coefficient: separate the expression into a coefficient and factor as_coeff_Add: separate the additive constant from an expression as_coeff_Mul: separate the multiplicative constant from an expression as_independent: separate x-dependent terms/factors from others sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used r r)rightT)as_AddcU(aU(d/$[[U5[U55n[U5HnXX:wdMUSUs $ USS$r*)minrurange)l1l2rVr3s r5incommonExpr.coeff..incommonsOR CGSW%A1X5BE>bq6Ma5Lr7c^^^T(aT(a[T5[T5:ag[T5nU(d TR5 TR5 [[T5U- S-5H*m[UUU4Sj[U555(dM* O SmU(d TR5 TR5 TbU(d[T5TU-- mT$)a&Find where list sub appears in list l. When ``first`` is True the first occurrence from the left is returned, else the last occurrence is returned. Return None if sub is not in l. Examples ======== >> l = range(5)*2 >> find(l, [2, 3]) 2 >> find(l, [2, 3], first=0) 7 >> find(l, [2, 4]) None Nr c3@># UHnTTU-TU:Hv M g7fr*r;)r1jr3lsubs r5r3+Expr.coeff..find..s"<8aqQx3q6)8s)rurr\r6)rdrefirstrVr3s`` @r5findExpr.coeff..finds"a3s8c!f#4CA  3q6A:>*<58<<<+  }UFa!e$Hr7c3T># UHo[R"T5;v M g7fr*)rr,)r1xir3s r5r3Expr.coeff..4s>"S]]1--s%(F)rX_first)rOrPNc3>># UHupUTSS:Hv M g7f)rr Nr;)r1rrVr1s r5r3rlUs0RTQ11a=Rsc3*# UH oSv M g7fr Nr;r1rVs r5r3rl\s#5"QaD"sc3P# UHn[[US55v M g7frp)rFreversedrqs r5r3rlks !C1$x!~"6"6s$&T)r rr rrrrkr+r,rfrpr-as_independentrrr6rGr?rUr rrru differencer.rFrr\ intersectionrsr,) rEr,rVrXrmrOco2r0r_rhr?self_cx_cxargsr3rQrvc_partnc_partone_cnxmargsrSresidiirbeggcdcrendhitr1s ` @r5r- Expr.coeffjs9` AJ!U##66M 1I66M 9Avuu 66M :!mmD1R1^^5Ea5HAEE5Q11CRvv 9  6xxDKKJJqJ.66M#S]]15E'F5E!5E'F"GGGcq1A#B1AAaC1A#BCCC&&q&6q9 9 D ! F13}}T"$$ #66M dkkk&MM!$Et/B/B1/Ea/H!I@!IA>>>!I@AA6B99E !"''#B'QJJL'#BCOFG6"" G "3R(@RTQaR(@#A31aQTRT CVWW"BqE!HR#b'\]$;<<#5"#56C#r5)> !!uQx!&q#b'!2A#'#4#4RU1X#>D#'4 %"3 #T$Z#cr(%:<<RL"$LAS47QqrU?%<$LMMxx!C!CDFGC#r5)> "VX$YVXdaQRS47QS B5G+G%IVX$YZZ"CSW $677C&r] 6Aq!R'> !Qh66M+"HB1 "T!Wq"v%577"Ab3r7lm$45566MsS(G#Bx@ $C=<)A %M%ZsB+'\\0\ "\ \"7\">\'9 \,\1;$\7 .1\= cU$)z Convert a polynomial to a SymPy expression. Examples ======== >>> from sympy import sin >>> from sympy.abc import x, y >>> f = (x**2 + x*y).as_poly(x, y) >>> f.as_expr() x**2 + x*y >>> sin(x).as_expr() sin(x) r;)rEr s r5as_expr Expr.as_exprs $ r7cdURU5nU(aURU5(dU$g)a Extracts symbolic coefficient at the given expression. In other words, this functions separates 'self' into the product of 'expr' and 'expr'-free coefficient. If such separation is not possible it will return None. Examples ======== >>> from sympy import E, pi, sin, I, Poly >>> from sympy.abc import x >>> E.as_coefficient(E) 1 >>> (2*E).as_coefficient(E) 2 >>> (2*sin(E)*E).as_coefficient(E) Two terms have E in them so a sum is returned. (If one were desiring the coefficient of the term exactly matching E then the constant from the returned expression could be selected. Or, for greater precision, a method of Poly can be used to indicate the desired term from which the coefficient is desired.) >>> (2*E + x*E).as_coefficient(E) x + 2 >>> _.args[0] # just want the exact match 2 >>> p = Poly(2*E + x*E); p Poly(x*E + 2*E, x, E, domain='ZZ') >>> p.coeff_monomial(E) 2 >>> p.nth(0, 1) 2 Since the following cannot be written as a product containing E as a factor, None is returned. (If the coefficient ``2*x`` is desired then the ``coeff`` method should be used.) >>> (2*E*x + x).as_coefficient(E) >>> (2*E*x + x).coeff(E) 2*x >>> (E*(x + 1) + x).as_coefficient(E) >>> (2*pi*I).as_coefficient(pi*I) 2 >>> (2*I).as_coefficient(pi*I) See Also ======== coeff: return sum of terms have a given factor as_coeff_Add: separate the additive constant from an expression as_coeff_Mul: separate the multiplicative constant from an expression as_independent: separate x-dependent terms/factors from others sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used N)extract_multiplicativelyr)rErwrs r5as_coefficientExpr.as_coefficients,@  ) )$ / QUU4[[Hr7cN^^SSKJn SSKJn SSKJn U[ RLaX4$URnURS[U[55(a[nO[n[5m/mUH7n[X5(aTRU5 M&TRU5 M9 UU4Sjn XvLdU[La1U[La(U "U5(aURU4$XR4$U[La[!UR"5n OUR%5up['X5nUSn USn U[La [U 6U"U 64$[)W 5H8upU "U5(aU R+XS 5 OU RU5 M: [U 6U"U 64$) a A mostly naive separation of a Mul or Add into arguments that are not are dependent on deps. To obtain as complete a separation of variables as possible, use a separation method first, e.g.: * separatevars() to change Mul, Add and Pow (including exp) into Mul * .expand(mul=True) to change Add or Mul into Add * .expand(log=True) to change log expr into an Add The only non-naive thing that is done here is to respect noncommutative ordering of variables and to always return (0, 0) for `self` of zero regardless of hints. For nonzero `self`, the returned tuple (i, d) has the following interpretation: * i will has no variable that appears in deps * d will either have terms that contain variables that are in deps, or be equal to 0 (when self is an Add) or 1 (when self is a Mul) * if self is an Add then self = i + d * if self is a Mul then self = i*d * otherwise (self, S.One) or (S.One, self) is returned. To force the expression to be treated as an Add, use the hint as_Add=True Examples ======== -- self is an Add >>> from sympy import sin, cos, exp >>> from sympy.abc import x, y, z >>> (x + x*y).as_independent(x) (0, x*y + x) >>> (x + x*y).as_independent(y) (x, x*y) >>> (2*x*sin(x) + y + x + z).as_independent(x) (y + z, 2*x*sin(x) + x) >>> (2*x*sin(x) + y + x + z).as_independent(x, y) (z, 2*x*sin(x) + x + y) -- self is a Mul >>> (x*sin(x)*cos(y)).as_independent(x) (cos(y), x*sin(x)) non-commutative terms cannot always be separated out when self is a Mul >>> from sympy import symbols >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False) >>> (n1 + n1*n2).as_independent(n2) (n1, n1*n2) >>> (n2*n1 + n1*n2).as_independent(n2) (0, n1*n2 + n2*n1) >>> (n1*n2*n3).as_independent(n1) (1, n1*n2*n3) >>> (n1*n2*n3).as_independent(n2) (n1, n2*n3) >>> ((x-n1)*(x-y)).as_independent(x) (1, (x - y)*(x - n1)) -- self is anything else: >>> (sin(x)).as_independent(x) (1, sin(x)) >>> (sin(x)).as_independent(y) (sin(x), 1) >>> exp(x+y).as_independent(x) (1, exp(x + y)) -- force self to be treated as an Add: >>> (3*x).as_independent(x, as_Add=True) (0, 3*x) -- force self to be treated as a Mul: >>> (3+x).as_independent(x, as_Add=False) (1, x + 3) >>> (-3+x).as_independent(x, as_Add=False) (1, x - 3) Note how the below differs from the above in making the constant on the dep term positive. >>> (y*(-3+x)).as_independent(x) (y, x - 3) -- use .as_independent() for true independence testing instead of .has(). The former considers only symbols in the free symbols while the latter considers all symbols >>> from sympy import Integral >>> I = Integral(x, (x, 1, 2)) >>> I.has(x) True >>> x in I.free_symbols False >>> I.as_independent(x) == (I, 1) True >>> (I + x).as_independent(x) == (I, x) True Note: when trying to get independent terms, a separation method might need to be used first. In this case, it is important to keep track of what you send to this routine so you know how to interpret the returned values >>> from sympy import separatevars, log >>> separatevars(exp(x+y)).as_independent(x) (exp(y), exp(x)) >>> (x + x*y).as_independent(y) (x, x*y) >>> separatevars(x + x*y).as_independent(y) (x, y + 1) >>> (x*(1 + y)).as_independent(y) (x, y + 1) >>> (x*(1 + y)).expand(mul=True).as_independent(y) (x, x*y) >>> a, b=symbols('a b', positive=True) >>> (log(a*b).expand(log=True)).as_independent(b) (log(a), log(b)) See Also ======== separatevars expand_log sympy.core.add.Add.as_two_terms sympy.core.mul.Mul.as_two_terms as_coeff_mul r )r>_unevaluated_Add_unevaluated_MulrYc~>UR"T6nT(dU$U=(d UR"URT-6$)zvreturn the standard has() if there are no literal symbols, else check to see that symbol-deps are in the free symbols.)rrC)r has_otherrris r5r Expr.as_independent..has~s8u I  >(< > >r7TFN)r?r>r)rmulrrrfuncrarr+rrbr.identityrFr?rUr!r,extend)rEdepshintr>rrrwantrQrr?rSdependindepr3rVrris @@r5ruExpr.as_independentskL #)) 166>< yy 88Hjs3 5 5DDeA!$$  Q   ?  CDO4yy t,,mm,,s{DII==? O4% 3;K!16!:; ;!" q66MM"R&) Q & ; 0& 99 9r7c ^URS5U:XagSSKJnJn U"U5U"U54$)a5Performs complex expansion on 'self' and returns a tuple containing collected both real and imaginary parts. This method cannot be confused with re() and im() functions, which does not perform complex expansion at evaluation. However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function. >>> from sympy import symbols, I >>> x, y = symbols('x,y', real=True) >>> (x + y*I).as_real_imag() (x, y) >>> from sympy.abc import z, w >>> (z + w*I).as_real_imag() (re(z) - im(w), re(w) + im(z)) ignoreNr)rr)rarrr)rEdeephintsrrs r5rExpr.as_real_imags.. 99X $ & CtHbh' 'r7cd[[5nURUR5/5 U$)agReturn self as a dictionary of factors with each factor being treated as a power. The keys are the bases of the factors and the values, the corresponding exponents. The resulting dictionary should be used with caution if the expression is a Mul and contains non- commutative factors since the order that they appeared will be lost in the dictionary. See Also ======== as_ordered_factors: An alternative for noncommutative applications, returning an ordered list of factors. args_cnc: Similar to as_ordered_factors, but guarantees separation of commutative and noncommutative factors. )r(rupdaterh)rErQs r5as_powers_dictExpr.as_powers_dicts+   $""$%&r7c[[5nU(d[R"U5H(nUR 5upEX%R U5 M* UR 5H'upg[U5S:Xa USX&'M[U6X&'M) GOUR"USS06up[R"U 5Hn U R(a[U R"U6upKU[RLaX*R U5 MMX*R"U 6R U5 MoU (dMxX*R [R5 M UVs0sH of[X&6_M nnU[RLa!UR[RU05 [[ 5n U RU5 U $s snf)aReturn a dictionary mapping terms to their Rational coefficient. Since the dictionary is a defaultdict, inquiries about terms which were not present will return a coefficient of 0. If symbols ``syms`` are provided, any multiplicative terms independent of them will be considered a coefficient and a regular dictionary of syms-dependent generators as keys and their corresponding coefficients as values will be returned. Examples ======== >>> from sympy.abc import a, x, y >>> (3*x + a*x + 4).as_coefficients_dict() {1: 4, x: 3, a*x: 1} >>> _[a] 0 >>> (3*a*x).as_coefficients_dict() {a*x: 3} >>> (3*a*x).as_coefficients_dict(x) {x: 3*a} >>> (3*a*x).as_coefficients_dict(y) {1: 3*a*x} r rrYT)r(rFr+r,rfr.r-rururrrrrk _new_rawargsrrr) rErDrQair0rr1vinddepr3r,dis r5as_coefficients_dictExpr.as_coefficients_dicts]4  mmD)( A* q6Q;Q4AD7AD " **D>>HC]]3'88>>40DAAEEz A..!,-44Q7QDKK&()**1CJA*!&& !%%&   !  +s!G c&U[R4$r*rrkr_s r5rhExpr.as_base_expsQUU{r7cfU(aUR"U6(dUS4$[RU44$)aReturn the tuple (c, args) where self is written as a Mul, ``m``. c should be a Rational multiplied by any factors of the Mul that are independent of deps. args should be a tuple of all other factors of m; args is empty if self is a Number or if self is independent of deps (when given). This should be used when you do not know if self is a Mul or not but you want to treat self as a Mul or if you want to process the individual arguments of the tail of self as a Mul. - if you know self is a Mul and want only the head, use self.args[0]; - if you do not want to process the arguments of the tail but need the tail then use self.as_two_terms() which gives the head and tail; - if you want to split self into an independent and dependent parts use ``self.as_independent(*deps)`` >>> from sympy import S >>> from sympy.abc import x, y >>> (S(3)).as_coeff_mul() (3, ()) >>> (3*x*y).as_coeff_mul() (3, (x, y)) >>> (3*x*y).as_coeff_mul(x) (3*y, (x,)) >>> (3*y).as_coeff_mul(x) (3*y, ()) r;)rrrk)rErrLs r5rExpr.as_coeff_mul s+< 88T?Rxuutg~r7cfU(aUR"U6(dUS4$[RU44$)aReturn the tuple (c, args) where self is written as an Add, ``a``. c should be a Rational added to any terms of the Add that are independent of deps. args should be a tuple of all other terms of ``a``; args is empty if self is a Number or if self is independent of deps (when given). This should be used when you do not know if self is an Add or not but you want to treat self as an Add or if you want to process the individual arguments of the tail of self as an Add. - if you know self is an Add and want only the head, use self.args[0]; - if you do not want to process the arguments of the tail but need the tail then use self.as_two_terms() which gives the head and tail. - if you want to split self into an independent and dependent parts use ``self.as_independent(*deps)`` >>> from sympy import S >>> from sympy.abc import x, y >>> (S(3)).as_coeff_add() (3, ()) >>> (3 + x).as_coeff_add() (3, (x,)) >>> (3 + x + y).as_coeff_add(x) (y + 3, (x,)) >>> (3 + y).as_coeff_add(x) (y + 3, ()) r;)has_freerr)rErs r5 as_coeff_addExpr.as_coeff_add,s,> ==$'Rxvvwr7cU(d [R[R4$URSS9upUR(aU*U*p!X4$)aReturn the positive Rational that can be extracted non-recursively from every term of self (i.e., self is treated like an Add). This is like the as_coeff_Mul() method but primitive always extracts a positive Rational (never a negative or a Float). Examples ======== >>> from sympy.abc import x >>> (3*(x + 1)**2).primitive() (3, (x + 1)**2) >>> a = (6*x + 2); a.primitive() (2, 3*x + 1) >>> b = (x/2 + 3); b.primitive() (1/2, x + 6) >>> (a*b).primitive() == (1, a*b) True Tr?)rrkrrfr)rEr0rs r5 primitiveExpr.primitivePsG&55!&&=   $ / ==2rqt r7c&[RU4$)aThis method should recursively remove a Rational from all arguments and return that (content) and the new self (primitive). The content should always be positive and ``Mul(*foo.as_content_primitive()) == foo``. The primitive need not be in canonical form and should try to preserve the underlying structure if possible (i.e. expand_mul should not be applied to self). Examples ======== >>> from sympy import sqrt >>> from sympy.abc import x, y, z >>> eq = 2 + 2*x + 2*y*(3 + 3*y) The as_content_primitive function is recursive and retains structure: >>> eq.as_content_primitive() (2, x + 3*y*(y + 1) + 1) Integer powers will have Rationals extracted from the base: >>> ((2 + 6*x)**2).as_content_primitive() (4, (3*x + 1)**2) >>> ((2 + 6*x)**(2*y)).as_content_primitive() (1, (2*(3*x + 1))**(2*y)) Terms may end up joining once their as_content_primitives are added: >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive() (11, x*(y + 1)) >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive() (9, x*(y + 1)) >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive() (1, 6.0*x*(y + 1) + 3*z*(y + 1)) >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive() (121, x**2*(y + 1)**2) >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive() (1, 4.84*x**2*(y + 1)**2) Radical content can also be factored out of the primitive: >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True) (2, sqrt(2)*(1 + 2*sqrt(5))) If clear=False (default is True) then content will not be removed from an Add if it can be distributed to leave one or more terms with integer coefficients. >>> (x/2 + y).as_content_primitive() (1/2, x + 2*y) >>> (x/2 + y).as_content_primitive(clear=False) (1, x/2 + y) r)rErvclears r5as_content_primitiveExpr.as_content_primitivejsnuud{r7c&U[R4$)zReturn the numerator and the denominator of an expression. expression -> a/b -> a, b This is just a stub that should be defined by an object's class methods to get anything else. See Also ======== normal: return ``a/b`` instead of ``(a, b)`` rr_s r5rExpr.as_numer_denomsQUU{r7cSSKJn UR5up#U[RLaU$UR (a U"USU- 5$X#- $)zReturn the expression as a fraction. expression -> a/b See Also ======== as_numer_denom: return ``(a, b)`` instead of ``a/b`` r r)rrrrrkr)rErrVrQs r5normal Expr.normalsF *""$ :H ;;#Aqs+ +3Jr7c SSKJn SSKJn [ U5nU[ R LagU[ RLaU$X:Xa[ R$UR(a/UR5upEU[ RLa [XESS9nUR(a9UR5upgURU5nUbURU5$U$X- n UR(GaU[ RLa#UR (a[ R$gU[ R"LaDUR$(a[ R$UR (a[ R"$gU[ R&La#UR((d[ R&$gUR*(a7U R*(dgUR (aU R$(agU $UR,(a7U R,(dgUR (aU R$(agU $UR.(a7U R.(dgUR (aU R$(agU $gUR0(d$UR2(dU[ R4LaU R(ak[7U R85S:XaRU R8SR*(a3U R8SR (aU R8SU:XaU $gU R*(aUR(aU $gUR(GaUR5upUR(aiU[ R:LaVU [ RLaBUR$(aU RU*5n U bU *n OU RU5n U bX-$gX:XaU $/n U R8H*nURU5nUc gU R=U5 M, U [ RLaU Vs/sHnU U-PM nnU"U6$[>R@"U 5$UR(aN[CUR85n[EU5H)unnURU5nUcMUUU'[U6s $ gURF(d[IX5(atURK5unnURK5unnUU:Xa"URMU5nUb [OUU5$gUU:Xa URMS5nUb [OUU5$gs snf) aReturn None if it's not possible to make self in the form c * something in a nice way, i.e. preserving the properties of arguments of self. Examples ======== >>> from sympy import symbols, Rational >>> x, y = symbols('x,y', real=True) >>> ((x*y)**3).extract_multiplicatively(x**2 * y) x*y**2 >>> ((x*y)**3).extract_multiplicatively(x**4 * y) >>> (2*x).extract_multiplicatively(2) x >>> (2*x).extract_multiplicatively(3) >>> (Rational(1, 2)*x).extract_multiplicatively(3) x/6 r)rcr rNF)evaluater)(rrcr)rr rrrkrprrrr as_two_termsrrrrrrrr^rrAris_NumberSymbolrr+rur?rr.r+rrFr,rgrrhextract_additivelyr)rEr0rcrccpcrOrPr,quotientcspsxcnewargsrynewargtr?r3sbsecbcenew_exps r5rExpr.extract_multiplicativelyse4 ?) AJ 155= :K Y55L 88[[]FB/ 88>>#DA--a0A}11!448 >>>qzz!==::%!nk+++==::%]]---#da***yy,,,!^[**%%(*>*>#O!!++%%(*>*>#O((%%(*>*>#O ~q ! !T^^tq7N3x}}#5#:==#..8==3C3O3OT\TaTabcTdhlTl#Oji$$fe[[[^^%FB{{q 5QUU?}}88!<>"$B88;~!u w Gww55a8>v&  &-.g1g.'..~~g.. [[#DIID#D/355a8%$DG:% *"[[Jt11%%'FB]]_FBRx//3&r7++' b//2&r7++1/s!Vc[U5nU[RLagUR(aU$X:Xa[R$U[R:XagUR (a=UR (dgUnX!- nUS:a US:aX2:dUS:a US::aX2:aU$gUR (a+UR 5up$URU5nUcgXT-$UR(aURSR (aURU5nURS5=(d SU-nU(a,XU-- nXcRU5=(d U-=(d S$UR 5uptUR 5upURU5nUcgU RU5n U cgXZ-$[X5up#URS5=(d SU-nU(a%XcRU5=(d U-=(d S$/n [R"U5Hvn U R5upURU5nU(d gUR 5unnURU 5nUc gXU--nU RUU-U-5 Mx U RU5 [U 6$)aReturn self - c if it's possible to subtract c from self and make all matching coefficients move towards zero, else return None. Examples ======== >>> from sympy.abc import x, y >>> e = 2*x + 3 >>> e.extract_additively(x + 1) x + 2 >>> e.extract_additively(3*x) >>> e.extract_additively(4) >>> (y*(x + 1)).extract_additively(x + 1) >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1) (x + 1)*(x + 2*y) + 3 See Also ======== extract_multiplicatively coeff as_coefficient Nrr )r rrr^rr as_coeff_Addrrpr?r-r6r+r,rfr.)rEr0r1rerxaxa0hshstxa2coeffsrOacatcoccots r5rExpr.extract_additivelyT sa2 AJ 155= 99K Y66M QVV^ >>;;B6DQ419FtqyTY  ;;%%'EB&&q)Bz6M 88q ++AB((+0q!3Cd{66q9ATBKtK>>#DA&&(FB&&q)Bz''*C{8O$?$$Q',1a/ 2215=>G4 Gq!A^^%FBBB(HC''+Bz rEMD MM38R- ("  dF|r7c[SSSS9 URVVs1sHoRHo"iM M snn$s snnf)a Like ``free_symbols``, but returns the free symbols only if they are contained in an expression node. Examples ======== >>> from sympy.abc import x, y >>> (x + y).expr_free_symbols # doctest: +SKIP {x, y} If the expression is contained in a non-expression object, do not return the free symbols. Compare: >>> from sympy import Tuple >>> t = Tuple(x + y) >>> t.expr_free_symbols # doctest: +SKIP set() >>> t.free_symbols {x, y} The expr_free_symbols property is deprecated. Use free_symbols to get the free symbols of an expression. 1.9deprecated-expr-free-symbolsdeprecated_since_versionactive_deprecations_target)rr?expr_free_symbols)rEr3rcs r5rExpr.expr_free_symbols sE. "# &+'E  G  99B9a.A.A.A9BBBs=cg)akReturn True if self has -1 as a leading factor or has more literal negative signs than positive signs in a sum, otherwise False. Examples ======== >>> from sympy.abc import x, y >>> e = x - y >>> {i.could_extract_minus_sign() for i in (e, -e)} {False, True} Though the ``y - x`` is considered like ``-(x - y)``, since it is in a product without a leading factor of -1, the result is false below: >>> (x*(y - x)).could_extract_minus_sign() False To put something in canonical form wrt to sign, use `signsimp`: >>> from sympy import signsimp >>> signsimp(x*(y - x)) -x*(x - y) >>> _.could_extract_minus_sign() True Fr;r_s r5could_extract_minus_signExpr.could_extract_minus_sign s8r7cSSKJn SSKJn [R n[R n[R"U5n/nUH(n[X5(aXxR/- nM$XX-nM* [R n /n [R[R-n U(ajUR5n U R(aX|R- nM8U R (aU R#U 5n U bX- n McX/- n U(aMjU R$(aU n SnOU R&"U R(6upU"U S- [R*- 5S-nXOS- - nX- nU(a)UR-S5nUbU[R*- nUnU [/U4U-6-[/U 6-nUS:wa XR"U5-nXT4$)a Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way. Return (z, n). >>> from sympy import exp_polar, I, pi >>> from sympy.abc import x, y >>> exp_polar(I*pi).extract_branch_factor() (exp_polar(I*pi), 0) >>> exp_polar(2*I*pi).extract_branch_factor() (1, 1) >>> exp_polar(-pi*I).extract_branch_factor() (exp_polar(I*pi), -1) >>> exp_polar(3*pi*I + x).extract_branch_factor() (exp_polar(x + I*pi), 1) >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor() (y*exp_polar(2*pi*x), -1) >>> exp_polar(-I*pi/2).extract_branch_factor() (exp_polar(-I*pi/2), 0) If allow_half is True, also extract exp_polar(I*pi): >>> exp_polar(I*pi).extract_branch_factor(allow_half=True) (1, 1/2) >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True) (1, 1) >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True) (1, 3/2) >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True) (1, -1/2) r) exp_polarceilingr;rr )rrrrrrrkrr,rrcPir+r@rpr?rrrrrrCHalfrr+)rE allow_halfrrrVresr?expsrypiimultextrasipircr-tail branchfactr0rSnewexps r5extract_branch_factorExpr.extract_branch_factor s> E? FFee}}T"C#)) !   &&dd1??"((*Czz zz**3/$$G eOFd   ED!..0D0DEKEU1Wqvv-.q0  \   %%a(B~QVV SA54<))CL8 Q; 9V$ $Cv r7cU(a[[[U55nOURnU(dgUR U5$)a: Return True if self is a polynomial in syms and False otherwise. This checks if self is an exact polynomial in syms. This function returns False for expressions that are "polynomials" with symbolic exponents. Thus, you should be able to apply polynomial algorithms to expressions for which this returns True, and Poly(expr, \*syms) should work if and only if expr.is_polynomial(\*syms) returns True. The polynomial does not have to be in expanded form. If no symbols are given, all free symbols in the expression will be used. This is not part of the assumptions system. You cannot do Symbol('z', polynomial=True). Examples ======== >>> from sympy import Symbol, Function >>> x = Symbol('x') >>> ((x**2 + 1)**4).is_polynomial(x) True >>> ((x**2 + 1)**4).is_polynomial() True >>> (2**x + 1).is_polynomial(x) False >>> (2**x + 1).is_polynomial(2**x) True >>> f = Function('f') >>> (f(x) + 1).is_polynomial(x) False >>> (f(x) + 1).is_polynomial(f(x)) True >>> (1/f(x) + 1).is_polynomial(f(x)) False >>> n = Symbol('n', nonnegative=True, integer=True) >>> (x**n + 1).is_polynomial(x) False This function does not attempt any nontrivial simplifications that may result in an expression that does not appear to be a polynomial to become one. >>> from sympy import sqrt, factor, cancel >>> y = Symbol('y', positive=True) >>> a = sqrt(y**2 + 2*y + 1) >>> a.is_polynomial(y) False >>> factor(a) y + 1 >>> factor(a).is_polynomial(y) True >>> b = (y**2 + 2*y + 1)/(y + 1) >>> b.is_polynomial(y) False >>> cancel(b) y + 1 >>> cancel(b).is_polynomial(y) True See also .is_rational_function() T)rbmapr rC_eval_is_polynomialrErDs r5 is_polynomialExpr.is_polynomial= s;B s7D)*D$$D''--r7c:X;agUR"U6(dggNTrr s r5r Expr._eval_is_polynomial s <}}d#r7cU(a[[[U55nOURnU(d U[;$UR U5$)a Test whether function is a ratio of two polynomials in the given symbols, syms. When syms is not given, all free symbols will be used. The rational function does not have to be in expanded or in any kind of canonical form. This function returns False for expressions that are "rational functions" with symbolic exponents. Thus, you should be able to call .as_numer_denom() and apply polynomial algorithms to the result for expressions for which this returns True. This is not part of the assumptions system. You cannot do Symbol('z', rational_function=True). Examples ======== >>> from sympy import Symbol, sin >>> from sympy.abc import x, y >>> (x/y).is_rational_function() True >>> (x**2).is_rational_function() True >>> (x/sin(y)).is_rational_function(y) False >>> n = Symbol('n', integer=True) >>> (x**n + 1).is_rational_function(x) False This function does not attempt any nontrivial simplifications that may result in an expression that does not appear to be a rational function to become one. >>> from sympy import sqrt, factor >>> y = Symbol('y', positive=True) >>> a = sqrt(y**2 + 2*y + 1)/y >>> a.is_rational_function(y) False >>> factor(a) (y + 1)/y >>> factor(a).is_rational_function(y) True See also is_algebraic_expr(). )rbr r rC_illegal_eval_is_rational_functionr s r5is_rational_functionExpr.is_rational_function sCf s7D)*D$$D8++..t44r7c>X;agURU5(dggr) has_xfreer s r5rExpr._eval_is_rational_function s <~~d##r7cUR(d[SRU55e[U5nUR X5$)aq This tests whether an expression is meromorphic as a function of the given symbol ``x`` at the point ``a``. This method is intended as a quick test that will return None if no decision can be made without simplification or more detailed analysis. Examples ======== >>> from sympy import zoo, log, sin, sqrt >>> from sympy.abc import x >>> f = 1/x**2 + 1 - 2*x**3 >>> f.is_meromorphic(x, 0) True >>> f.is_meromorphic(x, 1) True >>> f.is_meromorphic(x, zoo) True >>> g = x**log(3) >>> g.is_meromorphic(x, 0) False >>> g.is_meromorphic(x, 1) True >>> g.is_meromorphic(x, zoo) False >>> h = sin(1/x)*x**2 >>> h.is_meromorphic(x, 0) False >>> h.is_meromorphic(x, 1) True >>> h.is_meromorphic(x, zoo) True Multivalued functions are considered meromorphic when their branches are meromorphic. Thus most functions are meromorphic everywhere except at essential singularities and branch points. In particular, they will be meromorphic also on branch cuts except at their endpoints. >>> log(x).is_meromorphic(x, -1) True >>> log(x).is_meromorphic(x, 0) False >>> sqrt(x).is_meromorphic(x, -1) True >>> sqrt(x).is_meromorphic(x, 0) False z{} should be of symbol type) is_symbolrrr _eval_is_meromorphicrEr,rOs r5is_meromorphicExpr.is_meromorphic s=n{{9@@CD D AJ((..r7c>X:XagURU5(dggrrrs r5rExpr._eval_is_meromorphic s 9}}Qr7cU(a[[[U55nOURnU(dgUR U5$)a This tests whether a given expression is algebraic or not, in the given symbols, syms. When syms is not given, all free symbols will be used. The rational function does not have to be in expanded or in any kind of canonical form. This function returns False for expressions that are "algebraic expressions" with symbolic exponents. This is a simple extension to the is_rational_function, including rational exponentiation. Examples ======== >>> from sympy import Symbol, sqrt >>> x = Symbol('x', real=True) >>> sqrt(1 + x).is_rational_function() False >>> sqrt(1 + x).is_algebraic_expr() True This function does not attempt any nontrivial simplifications that may result in an expression that does not appear to be an algebraic expression to become one. >>> from sympy import exp, factor >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1) >>> a.is_algebraic_expr(x) False >>> factor(a).is_algebraic_expr() True See Also ======== is_rational_function References ========== .. [1] https://en.wikipedia.org/wiki/Algebraic_expression T)rbr r rC_eval_is_algebraic_exprr s r5is_algebraic_exprExpr.is_algebraic_expr s;V s7D)*D$$D++D11r7c:X;agUR"U6(dggrrr s r5r#Expr._eval_is_algebraic_exprM s <}}d#r7rc  ^^^^^Tc?URnU(dU$[U5S:a [S5eUR5mSSKJnJn [TU 5(aTUR;n O&U"5n XRTU 05R;n U (dUc SU45$U$[U5S:wdUS;a [S5eUb[U5nUS:a [S5e[T5m[T5mSS K J n J n TR(dCTR(aTR (aS OS nOU "T5R (aS OS nOT(a(TR"(aU "T5R%5mOd['U5S :Xa[(R*mOD['U5S :Xa[(R,mO$T[(R.:Xa[(R*mT[1T5- mT(abTR"(aQSS KJn UR7TTT- 5R9TUS SS 9nUc UU4SjU5$UR7TTT- 5$T(dTS:waXUR7TTTT--05R9TSUS USS9nUcUUU4SjU5$UR7TTT- TT- - 05$TR TR<s=LabO TR>SLaLU"SSS9mUR7TT5R9TTX4UTS9nUc UU4SjU5$UR7TT5$SSK J!m UGbURETX5TS9nURG5=(d [(R.nU(GaNURI5nUU:a6US:wa#UUR7TT[KUU5-5- nOUT"ST5- nOUU:aSSK&J'n [QSS5HnURETUU-UTS9nURI5nUU:wdM0UU"UU- U-UU- - 5-nURETUUTS9nURI5U:a-URETUUTS9nUS- nURI5U:aM- O [S['U5<SU<35eUT"TU-T5- nURG5nURS5nO\URUT5(aU$T"TU-T5nURW5nUU-RS5U:Xa[(R.nSSK-J.n U"UT5U-$UU4SjnU"URS5R_TUTS95$!Ua; UR7TTT-5R;TUS9nUR7TTT-5s$f=f![Xa Us$f=f![Xa UU-s$f=f)av Series expansion of "self" around ``x = x0`` yielding either terms of the series one by one (the lazy series given when n=None), else all the terms at once when n != None. Returns the series expansion of "self" around the point ``x = x0`` with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6). If ``x=None`` and ``self`` is univariate, the univariate symbol will be supplied, otherwise an error will be raised. Parameters ========== expr : Expression The expression whose series is to be expanded. x : Symbol It is the variable of the expression to be calculated. x0 : Value The value around which ``x`` is calculated. Can be any value from ``-oo`` to ``oo``. n : Value The value used to represent the order in terms of ``x**n``, up to which the series is to be expanded. dir : String, optional The series-expansion can be bi-directional. If ``dir="+"``, then (x->x0+). If ``dir="-", then (x->x0-). For infinite ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined from the direction of the infinity (i.e., ``dir="-"`` for ``oo``). logx : optional It is used to replace any log(x) in the returned series with a symbolic value rather than evaluating the actual value. cdir : optional It stands for complex direction, and indicates the direction from which the expansion needs to be evaluated. Examples ======== >>> from sympy import cos, exp, tan >>> from sympy.abc import x, y >>> cos(x).series() 1 - x**2/2 + x**4/24 + O(x**6) >>> cos(x).series(n=4) 1 - x**2/2 + O(x**4) >>> cos(x).series(x, x0=1, n=2) cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1)) >>> e = cos(x + exp(y)) >>> e.series(y, n=2) cos(x + 1) - y*sin(x + 1) + O(y**2) >>> e.series(x, n=2) cos(exp(y)) - x*sin(exp(y)) + O(x**2) If ``n=None`` then a generator of the series terms will be returned. >>> term=cos(x).series(n=None) >>> [next(term) for i in range(2)] [1, -x**2/2] For ``dir=+`` (default) the series is calculated from the right and for ``dir=-`` the series from the left. For smooth functions this flag will not alter the results. >>> abs(x).series(dir="+") x >>> abs(x).series(dir="-") -x >>> f = tan(x) >>> f.series(x, 2, 6, "+") tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) + (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 + 5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 + 2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2)) >>> f.series(x, 2, 3, "-") tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2)) + O((x - 2)**3, (x, 2)) For rational expressions this method may return original expression without the Order term. >>> (1/x).series(x, n=8) 1/x Returns ======= Expr : Expression Series expansion of the expression about x0 Raises ====== TypeError If "n" and "x0" are infinity objects PoleError If "x0" is an infinity object r z+x must be given for multivariate functions.r<c3$# UHov M g7fr*r;)r1rs r5r3Expr.series.. s*6a6sz+-zDir must be '+' or '-'rz%Number of terms should be nonnegative)rsignrr PoleError)rVrrc3L># UHoRTTT- 5v M g7fr*rA)r1r}rr,s r5r3r* s!;2GGAtAv..s!$)rV)x0rVrlogxrc3Z># UH oRTTT- TT- - 05v M" g7fr*rA)r1r}rr,r/s r5r3r* s-C2AdFRW$4 566s(+Tr,rr0rc3F># UHoRTT5v M g7fr*rA)r1rr,xposs r5r3r* s4AtQs!OrderrVr0rr zCould not calculate z terms for collectc3~># UHnUR(dUv MSnT"UT5T-nSn[UR5nX- U-R5nUT-nU(aUR(aM5UR(aU[UR5- nOUS- nUv XE:XaMX&- nMt g7f)z&Return terms of lseries one at a time.rr N)rprur?r6r) rr}yieldedrBndidndodor6r,s r5 yield_lseries"Expr.series..yield_lseriesI sB99   Gb! QADbgg,C lQ.779Q!R[[$99 CL0D AID ;! sB:B=)0rCrurr@r?r=r>rxreplacerr rrr+r^rr is_infiniterSrorrkrrrHrIr-rHseriesaseriesrrsympy.series.orderr6 _eval_nseriesr9rERationalrrr\r6rdoitrsympy.simplify.radsimpr: _eval_lseries)rEr,r/rVrr0rrDr=r>rrQrr+r-rr|s1rBngotrmorenewnr>s1doner:r@r6r4s `` ` @@r5rD Expr.seriesY scT 9$$D TQ !NOO A) a t(((CA}}aV,999Cy*D6** s8q=CtO56 6 =AA1u !HII R[t}A||||!--c3X11csbnnBx((*SSuuSS}}uuCI~ ".. + )IIaa(//QCa/H9;;;vvaa((  1b46k*+221aStZ[2\AyCCC661afr$w./0 0 ==AMM 1 1Q[[5Lt,D1d#**4Q$T*RBy444wwtQ'', =##AD#AB #QVVAvvx!8AvaffQ8At+<(<==eAqk)AX L %a !//QXDt/T!wwy4<"#gq4xotd{.K&L"LC!%!3!3A4d!3!SB"$'')a-%)%7%7StRV%7%W #q#%'')a-"!,),/FD*:;;%1a.(BGGIZZ\ !Q$N ++-7FF :r1~))  &6!!=!=adQU!=!VW WS )IIaa(00a08vvaa(( )H+I ' Av  s<4U:U:'V><W:>V;:V;> W  W W"!W"c^SSKJn URURs=Lac:O O7U"SSS9nUR X5R XbX45R Xa5$SSKJn SSKJ nJ n U"X5upSS K J n J n SS KJn X;asUR X"U55R XX45R X"U55nUR!5(a X"SX-- U["R$45-$U$U"S SS9mU "XUT5unnX ;aUS::aU$URR XUS 9nUR&"UR(Vs/sHnUR+5PM sn6nU "UR USU- 5R-U5R USU- 55nU "UR(SUR(S- 5T- nU "SU- 5nUR/TSU5nSS KJn U"U5nU(aUR TU "U55$UR!5n[5[6R8"UR+55U4SjS9n["R:nSnUHnUR=T5unnUR?U5(aUUR XUS- S 9nU(aUR!5(a O-UR!5(aSnUUTU--- nMUU- nM U(aU(aUR TU "U55$UU-R TU "U55$!Ua Us$f=fs snf!Ua UnGNf=f)a Asymptotic Series expansion of self. This is equivalent to ``self.series(x, oo, n)``. Parameters ========== self : Expression The expression whose series is to be expanded. x : Symbol It is the variable of the expression to be calculated. n : Value The value used to represent the order in terms of ``x**n``, up to which the series is to be expanded. hir : Boolean Set this parameter to be True to produce hierarchical series. It stops the recursion at an early level and may provide nicer and more useful results. bound : Value, Integer Use the ``bound`` parameter to give limit on rewriting coefficients in its normalised form. Examples ======== >>> from sympy import sin, exp >>> from sympy.abc import x >>> e = sin(1/x + exp(-x)) - sin(1/x) >>> e.aseries(x) (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x) >>> e.aseries(x, n=3, hir=True) -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo)) >>> e = exp(exp(x)/(1 - 1/x)) >>> e.aseries(x) exp(exp(x)/(1 - 1/x)) >>> e.aseries(x, bound=3) # doctest: +SKIP exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x)) For rational expressions this method may return original expression without the Order term. >>> (1/x).aseries(x, n=8) 1/x Returns ======= Expr Asymptotic series expansion of the expression. Notes ===== This algorithm is directly induced from the limit computational algorithm provided by Gruntz. It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first to look for the most rapidly varying subexpression w of a given expression f and then expands f in a series in w. Then same thing is recursively done on the leading coefficient till we get constant coefficients. If the most rapidly varying subexpression of a given expression f is f itself, the algorithm tries to find a normalised representation of the mrv set and rewrites f using this normalised representation. If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))`` where ``w`` belongs to the most rapidly varying expression of ``self``. References ========== .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series. In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993. pp. 239-244. .. [2] Gruntz thesis - p90 .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion See Also ======== Expr.aseries: See the docstring of this function for complete details of this wrapper. r r=r,Trr,r)mrvrewrite)rcrr5r1)bound) expand_mulc>>[URT5S5$)Nr )ras_coeff_exponent)r3r1s r5rxExpr.aseries.. sQEXEXYZE[\]E^A_r7rzF) r?r=rrrHrErIr-sympy.series.gruntzrTrUrrcrrFr6r9rrrr?r6as_leading_termrDsympy.core.functionrWrr+r,rrYr)rEr,rVrVhirr=r4r-rTrUomrrcrr6rrlogwrrrWrBr has_ordr-exposnewr1s @r5rE Expr.aseriesf sr " ==AMM 1 1t,D99Q%--duBGGP P'4 4|HB D, 7 !SV$,,Q5>CCAs1vNAvvxx514!QZZ999H # %Tq!, d :z ""1u"5Aaff5ff56A !&&AaC.88;@@AaCHItyy|chhqk12Q6Dqu:D KK1a 2 qM 66!SY' ' FFHs}}QYY[17_` FFA--a0KE4yy||}}Qq}9tyy{{YY[["GdQWn%QG66!SY' 'A||As4y))} K 06  s*. MM2=MM  M M! M!cSSKJn SSKJn [ U5nU"S5nUR X&5R Xa5R Xb5R US5X!--U"U5- $)zGeneral method for the taylor term. This method is slow, because it differentiates n-times. Subclasses can redefine it to make it faster by using the "previous_terms". r rSr) factorialr,)r?r=(sympy.functions.combinatorial.factorialsrfr rHre)rErVr,previous_termsr=rf_xs r5 taylor_termExpr.taylor_term s_ "F AJ 3Zyy$$R+007<>> from sympy import sin, log, Symbol >>> from sympy.abc import x, y >>> sin(x).nseries(x, 0, 6) x - x**3/6 + x**5/120 + O(x**6) >>> log(x+1).nseries(x, 0, 5) x - x**2/2 + x**3/3 - x**4/4 + O(x**5) Handling of the ``logx`` parameter --- in the following example the expansion fails since ``sin`` does not have an asymptotic expansion at -oo (the limit of log(x) as x approaches 0): >>> e = sin(log(x)) >>> e.nseries(x, 0, 6) Traceback (most recent call last): ... PoleError: ... ... >>> logx = Symbol('logx') >>> e.nseries(x, 0, 6, logx=logx) sin(logx) In the following example, the expansion works but only returns self unless the ``logx`` parameter is used: >>> e = x**y >>> e.nseries(x, 0, 2) x**y >>> e.nseries(x, 0, 2, logx=logx) exp(logx*y) r)rr7)rCrDrG)rEr,r/rVrr0rs r5nseries Expr.nseriesI sPx +++K 9cSj;;qa4;8 8%%a4%C Cr7cD[[SUR-55e)a Return terms of series for self up to O(x**n) at x=0 from the positive direction. This is a method that should be overridden in subclasses. Users should never call this method directly (use .nseries() instead), so you do not have to write docstrings for _eval_nseries(). z The _eval_nseries method should be added to %s to give terms up to O(x**n) at x=0 from the positive direction so it is available when nseries calls it.)rrrrEr,rVr0rs r5rGExpr._eval_nseries s+"*.*-1II .6#7 r7c SSKJn U"XX#5$)zCompute limit x->xlim. r)r)rr)rEr,xlimrrs r5r Expr.limit s .Td((r7r2ch[U5S:aUnUHnURXQUS9nM U$U(dU$[US5n[U5nUR(d[ SU-5eXPR ;aU$UR XQUS9nUbSSKJn U"USSS9$[S U<S U<S 35e) a8 Returns the leading (nonzero) term of the series expansion of self. The _eval_as_leading_term routines are used to do this, and they must always return a non-zero value. Examples ======== >>> from sympy.abc import x >>> (1 + x + x**2).as_leading_term(x) 1 >>> (1/x**2 + x + x**2).as_leading_term(x) x**(-2) r r2rzexpecting a Symbol but got %spowsimpTrc)rcombinezas_leading_term(, )) rur\r rrrC_eval_as_leading_termsympy.simplify.powsimpr|r)rEr0rsymbolsr0r,r2r|s r5r\Expr.as_leading_term s$ wHK GAJ t}{{ c,e`` where x can be any symbolic expression. rr9r )rJr:rrurhrr)rEr,r:rr0prPrs r5rYExpr.as_coeff_exponent sZ 3 D ~~a  q6Q;Q4##%DAvt !&&yr7c rSSKJn SSKJn UR XUS9nU"S5nUR U"U55(aUR U"U5U5nURU5upXR;a$[[SU<SU<S U<S U<355eUR Xu"U55nX4$) z Returns the leading term a*x**b as a tuple (a, b). Examples ======== >>> from sympy.abc import x >>> (1+x+x**2).leadterm(x) (1, 0) >>> (1/x**2+x+x**2).leadterm(x) (1, -2) r rSrrr2r0z) cannot compute leadterm(r~z<). The coefficient should have been free of z but got ) r?r=rrr\rrHrYrCrr) rEr,r0rr=rrdrQr0rs r5r Expr.leadterm s ">  D 9 &M 55Q==s1vq!A""1%  Z=A1a)LMN N FF1c!f t r7c&[RU4$)z1Efficiently extract the coefficient of a product.rrEr@s r5rfExpr.as_coeff_Mul suud{r7c&[RU4$)z3Efficiently extract the coefficient of a summation.)rrrs r5rExpr.as_coeff_Add svvt|r7c $SSKJn U"XX#XEXg5$)z Compute formal power power series of self. See the docstring of the :func:`fps` function in sympy.series.formal for more information. r)fps)sympy.series.formalr) rEr,r/rhyperrer@fullrs r5rExpr.fps s ,4BU8BBr7cSSKJn U"X5$)zCompute fourier sine/cosine series of self. See the docstring of the :func:`fourier_series` in sympy.series.fourier for more information. r)fourier_series)sympy.series.fourierr)rElimitsrs r5rExpr.fourier_seriess 8d++r7cDURSS5 [U/UQ70UD6$)NrT) setdefault_derivative_dispatch)rEr assumptionss r5re Expr.diffs'z40#DB7BkBBr7c VUR"S0UD6up#U[RU--$)Nr;)rrr+)rErr*r+s r5_eval_expand_complexExpr._eval_expand_complexs+&&// aood***r7c fSnU(a|[USS5(ajUR(dY/nURH1n[R"Xa40UD6upgXG-nUR U5 M3 U(aUR "U6n[X5(a[X5"S0UD6nX:waUS4$X4$)z Helper for ``expand()``. Recursively calls ``expr._eval_expand_hint()``. Returns ``(expr, hit)``, where expr is the (possibly) expanded ``expr`` and ``hit`` is ``True`` if ``expr`` was truly expanded and ``False`` otherwise. Fr?r;T)rrnr?r9 _expand_hintr.rr() rwrrrrsargsryarghitnewexprs r5rExpr._expand_hint#s GD&"--dllEyy"//CUC   S!! yy%( 4  d)2E2G&{r7c ^ ^SSKJm T RX4UXgUS9 Un UU 4Sjn T RSS5(a1U "U5V s/sHn U R"SXS.T D6PM sn upX- $T RSS5(a U "U5upXR"SXS.T D6- $T RS S5(a!U "U5upU R"SXS.T D6U- $S n[ T R 5US 9H3nT UnU(dMS U-n[R"U U4S U0T D6un nM5 U nT RSS5(a[R"U S4S U0T D6un nT RSS5(a[R"U S4S U0T D6un nT RSS5(a[R"U S4S U0T D6un nU U:XaOMUb[U5nUR(aUS::a[SU-5e/n[R"U 5H7nURSS9unnUU-nU(dM#UR!UU-5 M9 [U6n U $s sn f)z} Expand an expression using hints. See the docstring of the expand() function in sympy.core.function for more information. r)fraction) power_base power_exprr multinomialbasicc6>T"UTRSS55$)NexactF)ra)r,rrs r5rxExpr.expand..Rshq%))GU*CDr7fracF)rmodulusrnumercUS:XagU$)z Make multinomial come before mulrmulzr;)rs r5_expand_hint_key%Expr.expand.._expand_hint_keynsu}Kr7rz _eval_expand_rTr_eval_expand_multinomialr_eval_expand_mulr_eval_expand_logz*modulus must be a positive integer, got %sr?r;)rJrrr@expandrkeysr9rrar rrr+r,rfr.)rErrrrrrrrrrw _fractionrOrVrQrruse_hintrwasrr rr-rrs ` @r5r Expr.expandAs 4 S5  :D 99VU # #&t_.,HHA$A5A,.DA3J YYw & &T?DAXXB4BEBB B YYw & &T?DA88@@%@B B$  5::<-=>DT{Hx&- --dDMtMuM c ? Cyy..++4J;?JCHJayy&&++,B37B;@Bayy&&++,B37B;@Bas{  g&G%%A @7JLLE d+"///> t 5LLt, ,;D O.sI%c&SSKJn U"U/UQ70UD6$)z-See the integrate function in sympy.integralsr) integrate)sympy.integrals.integralsr)rEr?rLrs r5rExpr.integrates7////r7c SSKJn U"XX#5$)z,See the nsimplify function in sympy.simplifyr)rp)rrp)rE constants tolerancerrps r5rpExpr.nsimplifys5)::r7cSSKJn U"XUS9$)z+See the separate function in sympy.simplifyr )expand_power_base)rforce)rIr)rErrrs r5separate Expr.separates/ >>r7c"SSKJn U"XX#XE5$)z*See the collect function in sympy.simplifyrr9)rJr:)rErDrrrdistribute_order_termr:s r5r: Expr.collects2t45PPr7c&SSKJn U"U/UQ70UD6$)z(See the together function in sympy.polysr)together)sympy.polys.rationaltoolsr)rEr?rLrs r5r Expr.togethers6.t.v..r7c  SSKJn U"X40UD6$)z%See the apart function in sympy.polysr)apart)sympy.polys.partfracr)rEr,r?rs r5r Expr.aparts.T%%%r7cSSKJn U"U5$)z*See the ratsimp function in sympy.simplifyr)ratsimp)sympy.simplify.ratsimpr)rErs r5r Expr.ratsimps2t}r7c  SSKJn U"U40UD6$)z+See the trigsimp function in sympy.simplifyr)trigsimp)sympy.simplify.trigsimpr)rEr?rs r5r Expr.trigsimps4%%%r7c  SSKJn U"U40UD6$)z*See the radsimp function in sympy.simplifyr)radsimp)rJr)rErLrs r5r Expr.radsimps2t&v&&r7c&SSKJn U"U/UQ70UD6$)z*See the powsimp function in sympy.simplifyrr{)rr|)rEr?rLr|s r5r| Expr.powsimps2t-d-f--r7cSSKJn U"U5$)z+See the combsimp function in sympy.simplifyr)combsimp)sympy.simplify.combsimpr)rErs r5r Expr.combsimps4~r7cSSKJn U"U5$)z,See the gammasimp function in sympy.simplifyr) gammasimp)sympy.simplify.gammasimpr)rErs r5rExpr.gammasimps6r7c&SSKJn U"U/UQ70UD6$)z2See the factor() function in sympy.polys.polytoolsr)r0)r r0)rEr r?r0s r5r0 Expr.factor0d*T*T**r7c&SSKJn U"U/UQ70UD6$)z&See the cancel function in sympy.polysr)r)r r)rEr r?rs r5r Expr.cancelrr7cUR(a[USS5(a [X5$SSKJn U"X/UQ70UD6$)zReturn the multiplicative inverse of ``self`` mod ``g`` where ``self`` (and ``g``) may be symbolic expressions). See Also ======== sympy.core.intfunc.mod_inverse, sympy.polys.polytools.invert rTr)invert)rrrr r)rEr3r r?rs r5r Expr.inverts< >>gad;;t' '0d----r7c:UnUR(d [S5eUR(d6[UR S5SS9(d[S[ U5-5eO U[ ;aU$UR=n(drUR5upEUSLa4URU5[RURU5--$URS5(aURU5$U(dUc[R$U$[U=(d S5nUR(a[![[#U5U55$[%U5nXv-nUR'[(5V s/sHoR*PM n n U (a[-[/U 55OSn U c [/S U5n O [1X5nU*U -n S n UR X-5[3S U 5-nUR4(a<UR*S :Xa,URS5(a [)S5$[7S 5e[!U5nUS:aS OS nUX- R U 5-nUS:a [9S5eUS:aUU- nOUS:XaXS-(aUOU*- nXl- n[UR:U5n[=U[3S U 55nUR(aUcU$[)[?U5U 5$U(d UU:aUS - n[)UU5$s sn f)adReturn x rounded to the given decimal place. If a complex number would results, apply round to the real and imaginary components of the number. Examples ======== >>> from sympy import pi, E, I, S, Number >>> pi.round() 3 >>> pi.round(2) 3.14 >>> (2*pi + E*I).round() 6 + 3*I The round method has a chopping effect: >>> (2*pi + I/10).round() 6 >>> (pi/10 + 2*I).round() 2*I >>> (pi/10 + E*I).round(2) 0.31 + 2.72*I Notes ===== The Python ``round`` function uses the SymPy ``round`` method so it will always return a SymPy number (not a Python float or int): >>> isinstance(round(S(123), -2), Number) True z Cannot round symbolic expressionrTrYzExpected a number but got %s:FrNrBr znot computing with precisionrz)not expecting int(x) to round away from 0g?) rrrnrrVrrr9rrrr+rrrrrr_magrr)r:r#rIr[rrrrrrHro)rErVr,xrrr3rdigits_to_decimalallowrprecsdpsshiftextraxfrkr+dif2ipr|s r5r Expr.roundsF {{>? ?yyA53ilBDD6(]H((((>>#DAU{wwqzAOOAGGAJ$>>>xx{{wwqz!Y166 -A - 16N <<5Q+, , G!%"#''%.1.Q.1).k#e*%D ;b%.COE#"S(^SS c"en , <*$+9$&'8=)%*9%&'8:& '9 &'89% &9 &'8?+#,9#&'8>*#+9# &'8=)5*95&'8<(5)954 >- &'8(9(&'8%9%&'8.9.&'8+9+! / C C1717f  DL\XHtOb%NGHOb   ".$ "8 D41l4l,A\'=~Zx(DL}:~(:&4l!F"H47r (KZ]~CC<SSKJn SSKJn SSKJn [ XU[U45(a[TU]%X5$SSK J n SSK J n X:XaU"X"US54SU"US54S5$U"X"US54S5$) Nr )Tupler) MatrixExpr) MatrixBase)Eq) Piecewise)rT) containersr)r r*sympy.matrices.matrixbaser+rrr_eval_derivative_n_timesrr,$sympy.functions.elementary.piecewiser-) rErrVr)r*r+r,r-r#s r5r0#AtomicExpr._eval_derivative_n_timessw%A8 aeXzB C C73A9 9"B 9dBq!H-2a8}iH HdBq!H-y9 9r7cgrr;r s r5r AtomicExpr._eval_is_polynomialr7cU[;$r*)rr s r5r%AtomicExpr._eval_is_rational_functions 8##r7cSSKJn UR(+=(d UR=(a [ X5(+$)Nrr)rrr is_finiter)rEr,rOrs r5rAtomicExpr._eval_is_meromorphics(ANN"4dnn[j>[:[[r7cgrr;r s r5r#"AtomicExpr._eval_is_algebraic_exprr5r7cU$r*r;rus r5rGAtomicExpr._eval_nseriesrr7c[SSSS9 U1$)Nrrrrrr_s r5rAtomicExpr.expr_free_symbolss!!# &+'E  G v r7)r)rrrrrrrnr<r r0r rrr#rGrrr!r"r#s@r5r%r%sQ IGI :$\r7r%c SSKJnJnJn [ UR 55nU(d[ R$[U"U"U555nU[ S5U-- S:a&SU[ S5U-- s=::aS:de eUS- nU$![[4a: [U"[[URS55U"S5- 55nNf=f)zReturn integer $i$ such that $0.1 \le x/10^i < 1$ Examples ======== >>> from sympy.core.expr import _mag >>> from sympy import Float >>> _mag(Float(.1)) 0 >>> _mag(Float(.01)) -1 >>> _mag(Float(1234)) 4 r)log10ceilr5rr )mathrBrCrrHrVrrrr OverflowErrorr)r"r&)r,rBrCrr4 mag_first_digs r5rrs&% qssu:D vv JDt-.  QrUM !!a'T!B%..4"44444   &JDwtzz2'>!?B!GHI JsBACCc$\rSrSrSrSrSrSrg)UnevaluatedExpriz Expression that is not evaluated unless released. Examples ======== >>> from sympy import UnevaluatedExpr >>> from sympy.abc import x >>> x*(1/x) 1 >>> x*UnevaluatedExpr(1/x) x*1/x c J[U5n[R"X40UD6nU$r*)r r9r@)r>ryrLr2s r5r@UnevaluatedExpr.__new__s#smll3.v. r7c URSS5(aURSR"S0UD6$URS$)NrTrr;)rar?rI)rErs r5rIUnevaluatedExpr.doits= 99VT " "99Q<$$-u- -99Q< r7r;N)rrrrrr@rIr!r;r7r5rIrIs   r7rIcVU"U6nURU:H=(a URU:H$)awReturn True if `func` applied to the `args` is unchanged. Can be used instead of `assert foo == foo`. Examples ======== >>> from sympy import Piecewise, cos, pi >>> from sympy.core.expr import unchanged >>> from sympy.abc import x >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) True >>> unchanged(cos, pi) False Comparison of args uses the builtin capabilities of the object's arguments to test for equality so args can be defined loosely. Here, the ExprCondPair arguments of Piecewise compare as equal to the tuples that can be used to create the Piecewise: >>> unchanged(Piecewise, (x, x > 1), (0, True)) True )rr?)rr?rs r5 unchangedrO s(2 d A 66T> ,affn,r7cZ\rSrSrS Sjr\S5rSrS SjrS Sjr Sr S r S r S r g) ExprBuilderi&Nc[US5(d[SRU55eXlUc/UlOX lX0lUbU(aUR 5 ggg)N__call__zop {} needs to be callable)r(rropr? validatorvalidate)rErTr?rUchecks r5__init__ExprBuilder.__init__'sZr:&&8??CD D <DII"  !u MMO(- !r7c|UVs/sH*n[U[5(aUR5OUPM, sn$s snfr*)rrQbuild)r?r3s r5 _build_argsExprBuilder._build_args3s1HLM1Z;77 Q>MMMs19ctURcgURUR5nUR"U6 gr*)rUr\r?)rEr?s r5rVExprBuilder.validate7s/ >> !  * r7cURUR5nUR(aU(aUR"U6 UR"U6$r*)r\r?rUrT)rErWr?s r5r[ExprBuilder.build=s9 * >>e NND !ww~r7cURRU5 UR(a"U(aUR"UR6 gggr*)r?r.rUrV)rEryrWs r5append_argumentExprBuilder.append_argumentCs4  >>e MM499 %$>r7cJUS:Xa UR$URUS- $)Nrr )rTr?)rEitems r5 __getitem__ExprBuilder.__getitem__Hs% 1977N99T!V$ $r7c4[UR55$r*)ror[r_s r5__repr__ExprBuilder.__repr__Ns4::<  r7c[UR5HUup#[U[5(aUR U5nUbU4U-s $M8[ U5[ U5:XdMRU4s $ gr*)r,r?rrQ search_indexid)rEelemr3ryrets r5search_elementExprBuilder.search_elementQsf *FA#{++&&t,?4#:%#CBtH$t +r7)r?rTrU)NNTrt)rrrrrXrr\rVr[rcrgrjrqr!r;r7r5rQrQ&s; NN  & % !r7rQrrr)rjrr)r)r)rrHrr)S __future__rtypingrrcollections.abcrr functoolsrrr r rr r singletonrr\rrr decoratorsrrrcacherlogicrrintfuncrsortingrrcrsympy.utilities.exceptionsrsympy.utilities.miscrrrsympy.utilities.iterablesr r! mpmath.libmpr"r#mpmath.libmp.libintmathr$r%typing_extensionsr&rr' collectionsr(r6r9r%rrIrOrQrrr)r+rrrIrjrrrr(rr)rrHrrr;r7r5rs"*- &<<RR& %@>>7-/&# c=Q5*c=Qc=QL{6t6r< d :-:33l4#CCr7