~9\c@ sddlmZmZddlmZmZmZddlmZmZddl m Z ddl m Z m Z ddlmZmZddlmZdd lmZmZmZmZmZdd lmZmZdd lmZd ee fd YZdeefdYZdZ defdYZ!dZ"dZ#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3dS(i(tprint_functiontdivisioni(tsympifyt_sympifyt SympifyError(tBasictAtom(tS(t EvalfMixint pure_complex(t _sympifyittcall_highest_priority(tcacheit(treducetas_inttdefault_sort_keytrangetIterable(tmpf_logt prec_to_dps(t defaultdicttExprc B seZdZgZeZedZee dZ dZ dZ dZ dZedeedd Zedeed d Zedeed d ZedeeddZedeeddZedeeddZedeeddZe dZedeeddZedeeddZedeeddZeZeZedeeddZedeedd Z edeed!d"Z!edeed#d$Z"edeed%d&Z#edeed'd(Z$d)Z%e%Z&d*Z'd+Z(d,Z)d-Z*d.Z+d/Z,d0Z-e.d1Z/ed2Z0e d3d3d4d4d5Z1d6Z2e3d7Z4d8Z5d9Z6d:Z7d;Z8d<Z9d=Z:d>Z;d?Z<d@Z=dAZ>e?dBZ@e dCZAe e3dDZBdEZCdFZDdGZEdHZFe dIZGe3eedJZHd4e3dKZIdLZJdMZKdNZLedOZMdPZNdQZOdRZPdSZQdTZRdUZSe3edVZTdWZUdXZVdYZWdZZXed[ZYd\ZZe3d]Z[d^Z\d_Z]d`Z^daZ_dbZ`dcZae dddedfe dgZbdhZce dddfe diZde djZee dddedfe dkZfdlZgdfdmZhe dnZiedoZjdpZkdqZldrZme3dsZne3dtZoe ddd4eduee3dvZpe dwZqdxZrdyZse.edzZteee eeeeeed{Zud|Zvd}e e3e3d~Zwge e3dZxe3e3dZye ee3edZzdZ{e dZ|dZ}dZ~dZdZdZdZdZedZdZdZdddZdZRS(sZ Base class for algebraic expressions. 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). See Also ======== sympy.core.basic.Basic cC stS(sUReturn True if one can differentiate with respect to this object, else False. 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()) (tFalse(tself((s.lib/python2.7/site-packages/sympy/core/expr.pyt _diff_wrt!s&cC s#|j\}}|jr-|j\}}n|tj}}|jrX|jf}n|jrst|f}np|j r|j d|}n'|j r|j d|}n |j}t g|D]}t|d|^q}t|t |f}|jd|}|j|||fS(Ntorder(t as_coeff_Multis_PowtargsRtOnetis_Dummytsort_keytis_Atomtstrtis_Addtas_ordered_termstis_Multas_ordered_factorsttupleRtlent class_key(RRtcoefftexprtexpRtarg((s.lib/python2.7/site-packages/sympy/core/expr.pyRIs$      (g$@cC s|S(N((R((s.lib/python2.7/site-packages/sympy/core/expr.pyt__pos__vscC sttj|S(N(tMulRt NegativeOne(R((s.lib/python2.7/site-packages/sympy/core/expr.pyt__neg__yscC sddlm}||S(Ni(tAbs(tsympyR1(RR1((s.lib/python2.7/site-packages/sympy/core/expr.pyt__abs__|stothert__radd__cC s t||S(N(tAdd(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt__add__sR7cC s t||S(N(R6(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyR5st__rsub__cC st|| S(N(R6(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt__sub__sR9cC st|| S(N(R6(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyR8st__rmul__cC s t||S(N(R.(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt__mul__sR;cC s t||S(N(R.(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyR:st__rpow__cC s t||S(N(tPow(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt_powscC s|dkr|j|Sypt|t|t|}}}|dkr^t|||Sddlm}|t|| ||SWnAtk r|j|}y ||SWqtk rtSXnXdS(Nii(t mod_inverse( tNoneR>Rtpowtsympy.core.numbersR?t ValueErrort TypeErrortNotImplemented(RR4tmodt_selfR?tpower((s.lib/python2.7/site-packages/sympy/core/expr.pyt__pow__s  &    RIcC s t||S(N(R=(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyR<st__rdiv__cC st|t|tjS(N(R.R=RR/(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt__div__sRKcC st|t|tjS(N(R.R=RR/(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyRJst__rmod__cC s t||S(N(tMod(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt__mod__sRNcC s t||S(N(RM(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyRLst __rfloordiv__cC sddlm}|||S(Ni(tfloor(t#sympy.functions.elementary.integersRP(RR4RP((s.lib/python2.7/site-packages/sympy/core/expr.pyt __floordiv__sRRcC sddlm}|||S(Ni(RP(RQRP(RR4RP((s.lib/python2.7/site-packages/sympy/core/expr.pyROst __rdivmod__cC s-ddlm}|||t||fS(Ni(RP(RQRPRM(RR4RP((s.lib/python2.7/site-packages/sympy/core/expr.pyt __divmod__sRTcC s-ddlm}|||t||fS(Ni(RP(RQRPRM(RR4RP((s.lib/python2.7/site-packages/sympy/core/expr.pyRSscC s)ddlm}|js(tdn|jd}|jsOtdn|tjtjtj fkrtd|nt |}|sdS||kr%||j d r%|dkrdnd}|}||j dd i||6dkrdnd}||kr%||8}q%n|S( Ni(tDummyscan't convert symbols to intiscan't convert complex to intscan't convert %s to intiitsubs( R2RUt is_numberRDtroundt is_NumberRtNaNtInfinitytNegativeInfinitytinttequalstevalf(RRUtrtitisigntxt diff_sign((s.lib/python2.7/site-packages/sympy/core/expr.pyt__int__s$      2 cC sW|j}|jrt|S|jrG|jdrGtdntddS(Niscan't convert complex to floats!can't convert expression to float(R_RYtfloatRWt as_real_imagRD(Rtresult((s.lib/python2.7/site-packages/sympy/core/expr.pyt __float__s    cC s7|j}|j\}}tt|t|S(N(R_RgtcomplexRf(RRhtretim((s.lib/python2.7/site-packages/sympy/core/expr.pyt __complex__s cC s5ddlm}yt|}Wn'tk rItd||fnXx]||fD]O}|jr|jtkrtd|n|tj krWtdqWqWWt ||}|dk rt|dkS|js|jr"||}|j dk r"|j |j k r"t|j Sn|||dtS(Ni(t GreaterThansInvalid comparison %s >= %ss Invalid comparison of complex %ssInvalid NaN comparisonitevaluate(R2RnRRRDt is_complextis_realRRRZt_n2R@tis_nonnegativet is_negativeR(RR4Rntmetn2tdif((s.lib/python2.7/site-packages/sympy/core/expr.pyt__ge__s&   cC s5ddlm}yt|}Wn'tk rItd||fnXx]||fD]O}|jr|jtkrtd|n|tj krWtdqWqWWt ||}|dk rt|dkS|js|jr"||}|j dk r"|j |j k r"t|j Sn|||dtS(Ni(tLessThansInvalid comparison %s <= %ss Invalid comparison of complex %ssInvalid NaN comparisoniRo(R2RyRRRDRpRqRRRZRrR@tis_nonpositivet is_positiveR(RR4RyRuRvRw((s.lib/python2.7/site-packages/sympy/core/expr.pyt__le__4s&   cC s5ddlm}yt|}Wn'tk rItd||fnXx]||fD]O}|jr|jtkrtd|n|tj krWtdqWqWWt ||}|dk rt|dkS|js|jr"||}|j dk r"|j |j k r"t|j Sn|||dtS(Ni(tStrictGreaterThansInvalid comparison %s > %ss Invalid comparison of complex %ssInvalid NaN comparisoniRo(R2R}RRRDRpRqRRRZRrR@R{RzR(RR4R}RuRvRw((s.lib/python2.7/site-packages/sympy/core/expr.pyt__gt__Is&   cC s5ddlm}yt|}Wn'tk rItd||fnXx]||fD]O}|jr|jtkrtd|n|tj krWtdqWqWWt ||}|dk rt|dkS|js|jr"||}|j dk r"|j |j k r"t|j Sn|||dtS(Ni(tStrictLessThansInvalid comparison %s < %ss Invalid comparison of complex %ssInvalid NaN comparisoniRo(R2RRRRDRpRqRRRZRrR@RtRsR(RR4RRuRvRw((s.lib/python2.7/site-packages/sympy/core/expr.pyt__lt__^s&   cC s&|jstdn t|SdS(Ns&can't truncate symbols and expressions(RWRDtInteger(R((s.lib/python2.7/site-packages/sympy/core/expr.pyt __trunc__ss cC sddlm}t|dr2|j|j|St|dr|j\}}|j||}|j||tj}||StddS(Ni(tFloatt_mpf_t_mpc_s#expected mpmath number (mpf or mpc)( R2Rthasattrt_newRRRt ImaginaryUnitRD(RctprecRRkRl((s.lib/python2.7/site-packages/sympy/core/expr.pyt _from_mpmathyscC std|jDS(siReturns 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 log, Integral, cos, sin, pi >>> from sympy.core.function import Function >>> 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.is_comparable cs s|]}|jVqdS(N(RW(t.0tobj((s.lib/python2.7/site-packages/sympy/core/expr.pys s(tallR(R((s.lib/python2.7/site-packages/sympy/core/expr.pyRWs2iic C s|j}d}|rddlm}||||f\} } } } ttt|g|D]!} || | | | dt^qV}yt|jdd|}Wqt t fk rd SXni}t|jd}t |dsd S|j dkrkddlm}dd lm}xH|d|D]4}t|j|d|}|j dkr0Pq0q0Wn|j dkr|d krt|d }n|j|d|Sd S( sReturn self evaluated, if possible, replacing free symbols with random complex values, if necessary. 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.utilities.randtest.random_complex_number ii(trandom_complex_numbertrationaliRVt_prec(t giant_steps(tDEFAULT_MAXPRECiN(t free_symbolstsympy.utilities.randtestRtdicttlisttziptTruetabsR_RCRDR@RRtmpmath.libmp.libintmathRtsympy.core.evalfRtmax(Rtntre_mintim_mintre_maxtim_maxtfreeRRtatctbtdtzitrepstnmagRttarget((s.lib/python2.7/site-packages/sympy/core/expr.pyt_randoms6! 4  c O s|jdt}|jrtS|j}|s2tSt|}|rS||@ rStS|p\|}|}|rz|j}n|jrtSd}||kryb|jt t |dgt |dt}|t j kr|jddddd}nWntk rd}nX|dk r|t j k ryb|jt t |dgt |dt}|t j kr|jddddd}nWntk rd}nX|dk r|t j k r|j|tkrtS|jddddd}|dk r/|t j k r/|j|tkr/tS|j}|dk r|t j k r|j|tkrotS|jr~|n|}qqnxz|D]r} |j| } |r| j} n| dkrt| dts|jdtr|S| jrdSntSqWtS( s Return True if self is constant, False if not, or None if the constancy could not be determined conclusively. 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, two 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. 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 tsimplifyit simultaneousiitor_realtfailing_numberN(tgetRRWRtsetRtis_zeroR@RVRRR'RRZRtZeroDivisionErrorR^RtdiffR ( RtwrttflagsRRR*RRRtwtderiv((s.lib/python2.7/site-packages/sympy/core/expr.pyt is_constantslD      ( "  ( "  00    c  s}ddlmmddlm}ddlm}ddlm}t |}||krbt St ||dt }|st S|j t tstS|jdtdt }|tkrtS|d kr|j rd S|t kr|j}|rtSn|jrM|j} | sMg|jtD]jd jr0^q0} | jd d x| D]yyjrt||} n g} | r| krt Sjrtfd | Drt SqnWqltk rqlXqlWt rJy!||} | jr%t StSWqG|tfk rCqGXqJqMn|t d fkro|d krotS|ry|Sd S(sReturn True if self == other, False if it doesn't, or None. If failing_expression is True then the expression which did not simplify to a 0 will be returned instead of None. 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. i(t nsimplifyR(tsolveset(t NotAlgebraic(tminimal_polynomialtradicalRRNitkeycS s |jd S(Ni(R(Rc((s.lib/python2.7/site-packages/sympy/core/expr.pyttc3 s9|]/}|gko0|kVqdS(N((Rtsi(RtsR(s.lib/python2.7/site-packages/sympy/core/expr.pys s(tsympy.simplify.simplifyRRtsympy.solvers.solvesetRtsympy.polys.polyerrorsRtsympy.polys.numberfieldsRRRt factor_termsthasR6RMRRR@RWRtatomsR=Rt is_Integertsortt is_SymbolRRqtanytNotImplementedError( RR4tfailing_expressionRRRRtconstanttndifftapproxtsurdstsoltmp((RRRs.lib/python2.7/site-packages/sympy/core/expr.pyR^sj       2          cC sddlm}ddlm}|jr|jtkr<tSy|jd}Wntk rcdSX|dkrtdSt |dddkrdS|t j krdS|j dj\}}|j s|j rtS|jdkr |jdkr t| o|dkS|jdkr| s0|jdkr|jr|jt ry||jr_tSWq}|tfk ryq}XqndS(Ni(R(RiRii(RRRRRWRqRt _eval_evalfRCR@tgetattrRRZR_RgRYRtboolt is_algebraicRtFunctionRR(RRRRvRRa((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_is_positives6   %cC sddlm}ddlm}|jr|jtkr<tSy|jd}Wntk rcdSX|dkrtdSt |dddkrdS|t j krdS|j dj\}}|j s|j rtS|jdkr |jdkr t| o|dkS|jdkr| s0|jdkr|jr|jt ry||jr_tSWq}|tfk ryq}XqndS(Ni(R(RiRii(RRRRRWRqRRRCR@RRRZR_RgRYRRRRRRR(RRRRvRRa((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_is_negative)s6   %cC sddlm}m}ddlm}ddlm}ddlm}ddl m } |dkr}|dkr}t dn||krdS|dkrd} n|j ||} | jtjtjtjtj| rN||ktkr||||d } n||||d } | tjkr-| St| |rNtd qNn|dkrcd} n|j ||} | jtjtjtjtj| r||ktkr||||d } n||||d } t| |rtd qn|o|dkr| | S| | } |jr|jr||krP|||} n|||} ||jjd |d | }x7|j|D]&}|||jd|d | B}qWyx|D]}| tjkrPn|jsqn||k||kkotknrH| ||||d  ||||d 7} q||k||kkoktknr| ||||d ||||d 7} qqWWqtk rqXn| S(s^ 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. i(tlimittLimit(R(tInterval(tlog(t AccumBoundss"Both interval ends cannot be None.it+t-sCould not compute limititdomainN(t sympy.seriesRRRRtsympy.sets.setsRt&sympy.functions.elementary.exponentialRtsympy.calculus.utilRR@RCRVRRRZR[R\tComplexInfinityRt isinstanceRt is_comparabletcanceltas_numer_denomRRRRD(RRcRRRRRRRRtAtBtvalueRt singularitiestlogtermR((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_intervalLsl    '  '     (0(7 cC sdS(N(R@(RR4((s.lib/python2.7/site-packages/sympy/core/expr.pyt _eval_powerscC s|jr |S|jr| SdS(N(Rqt is_imaginary(R((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_conjugates  cC sddlm}||S(Ni(t conjugate(t$sympy.functions.elementary.complexesR(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyRscC sHddlm}|jr|S|jr0||S|jrD|| SdS(Ni(R(RRRpt is_hermitiantis_antihermitian(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_transposes    cC sddlm}||S(Ni(t transpose(RR(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyRscC syddlm}m}|jr#|S|jr1| S|j}|dk rS||S|j}|dk ru||SdS(Ni(RR(RRRRRRR@R(RRRR((s.lib/python2.7/site-packages/sympy/core/expr.pyt _eval_adjoints       cC sddlm}||S(Ni(tadjoint(RR(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyRsc sddlm}tdd}|dkr7t}n|d}|rVdn|fdfd}||fS( s+Parse and configure the ordering of terms. i(t monomial_keyt startswithsrev-ic sTg}xA|D]9}t|tr8|j|q |j| q Wt|S(N(RR&tappend(tmonomRhtm(tneg(s.lib/python2.7/site-packages/sympy/core/expr.pyRs  c s|\}\\}}}}|}tg|D]}|jd^q7}t||f||ff}|||fS(NR(R&RR(ttermt_RkRlRtncpartteR)(t monom_keyRR(s.lib/python2.7/site-packages/sympy/core/expr.pyRs +N(tsympy.polys.orderingsRRR@R(tclsRRRtreverseR((R RRs.lib/python2.7/site-packages/sympy/core/expr.pyt _parse_orders       cC s|gS(s4Return list of ordered factors (if Mul) else [self].((RR((s.lib/python2.7/site-packages/sympy/core/expr.pyR%sc s ddlmm|d kr|jrfd}ttj|d|}t|dkrt |dfrt |dt rtt j|dd|}t|dkrt |dr|dj r|dj r|Sqn|j |\}}|j\}}td|DsVt|d|d|} ngg} } xF|D]>\} } | js| j| | fqj| j| | fqjWt| d|dtt| d|dt} |r| |fSg| D]\} }| ^qSd S( s" 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] i(tNumbert NumberSymbolc st|f S(N(R(Rc(RR(s.lib/python2.7/site-packages/sympy/core/expr.pyR RRiics s|]\}}|jVqdS(N(tis_Order(RRR((s.lib/python2.7/site-packages/sympy/core/expr.pys sR N(tnumbersRRR@R"tsortedR6t make_argsR'RR.R{RtRtas_termsRRRR(RRtdataRtadd_argstmul_argsR ttermstgenstorderedt_termst_orderRtreprR((RRs.lib/python2.7/site-packages/sympy/core/expr.pyR#s6      cC sCddlm}ddlm}ddlm}tgg}}x'|j|D]}|j\}}t |}ig} } |t j k r/x|j|D]} | j ry|t | 9}Wqt tfk rqXqn| jr|| \} } | | | <|j| q| j| qWn|j|jf}t| } |j||| | ffqSWt|dt}t|i}}x$t|D]\}}|||>> from sympy import O >>> from sympy.abc import x >>> (1 + x + O(x**2)).getn() 2 >>> (1 + x).getn() i(RUtSymboliRctpositivesnot sure of order of %sN(R2RUR1R0R@RR*RRtZeroRRRR$RR'tpopRVRR+R+t is_RationalRR(RRUR1totoitsymsRc((s.lib/python2.7/site-packages/sympy/core/expr.pytgetnns0           cC sddlm}|||S(s7wrapper for count_ops that returns the operation count.i(t count_ops(tfunctionR:(RtvisualR:((s.lib/python2.7/site-packages/sympy/core/expr.pyR:sc C sO|jrt|j}n |g}xGt|D]-\}}|js1|| }||}Pq1q1W|}g}|r|r|djr|djr|dtjk rtj|d g|d*n|rEt |} t |}| rE|rEt || krEt dg|D]*} t|jj | dkr | ^q qEn||gS(srReturn [commutative factors, non-commutative factors] of self. 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. >>> 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], []] iis"repeated commutative arguments: %s( R$RRR&R#RYRtRR/R'RRCtcount( Rtcsettwarntsplit_1RRatmiRtnctclentci((s.lib/python2.7/site-packages/sympy/core/expr.pytargs_cncs,!          Ac sVt|}t|ts"tjSt|}|s;tjS||kra|dkrZtjStjS|tjkrgtj|D]%}|j dtjkr|^qstjStS|dkr{|j rd|j rd|j |d|}|stjS|s6|tgtj|D]}||^qS|tgtj|D]}||^qLS|j |dt dS||}d}t d}gtj|}|j} |j} | r| rtjS| r|jdt dtd} x|D]}|jdt dtd} t| t| kr>qn| j| } t| t| t| krjt| qqWgkrtjSrRtSn| r|jdt dtd} x|D]}|jdt \} }t| t| krqn| j| } t| t| t| krjtt| |qqWgkr|tjSrRtSn|jdt \} }x|D]}|jdt \} }t| t| krqn| j| } t| t| t| krj| |fqqWsBtjStfd Dr|dd||}|d k r|sttgD]\}}t|^qtdd| Stdd|t|Sqnt|d D}|r||||}|d k r|sdd}x>tdtD]'}|j|d}|s[Pq[q[Wtt||| S|t|}tgD]&\}}tt|||^qSqnttt|d D}|r||||}|d k r|s|tgD]1\}}tt||t| | ^qDSt||t|Sqnd }xtD]L\}\}}||||}|d k r|s|||f}qPqqW|rK|\}}}|s0tt||| St||t|SntjSd S( s Returns the coefficient from the term(s) containing ``x**n``. If ``n`` is zero then all terms independent of ``x`` will be returned. 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. 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.coeff_monomial: efficiently find the single coefficient of a monomial in Poly sympy.polys.polytools.nth: like coeff_monomial but powers of monomial terms are used 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 iitrighttas_AddcS se| s| rgStt|t|}x0t|D]"}||||kr:|| Sq:W|S(N(tminR'R(tl1tl2RRa((s.lib/python2.7/site-packages/sympy/core/expr.pytincommonjs c s s& s&ttkr*dSt}|sSjjnxWtdt|dD]2tfdt|DrqPqqqqWd|sjjndk r| rt|nS(s 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. >> l = range(5)*2 >> find(l, [2, 3]) 2 >> find(l, [2, 3], first=0) 7 >> find(l, [2, 4]) None iic3 s'|]}||kVqdS(N((Rtj(Ratltsub(s.lib/python2.7/site-packages/sympy/core/expr.pys sN(R'R@R RR(RMRNtfirstR((RaRMRNs.lib/python2.7/site-packages/sympy/core/expr.pytfindss &   $(  R>R?c3 s)|]\}}|ddkVqdS(iiN((RR`R(tco(s.lib/python2.7/site-packages/sympy/core/expr.pys scs s|]}|dVqdS(iN((RR((s.lib/python2.7/site-packages/sympy/core/expr.pys scs s%|]}tt|dVqdS(iN(Rtreversed(RR((s.lib/python2.7/site-packages/sympy/core/expr.pys sN(RRRRR3RRR6RRR"R)tas_independentRR#RERR't differenceRR.RRR@R Rt intersectionRRR&(RRcRRFRRRKRPRtself_ctx_ctxargstmargstresidRBtnxtiiR`tbegtgcdcRaRtendthit((RQs.lib/python2.7/site-packages/sympy/core/expr.pyR)sn    %  ..      "   "$   " D& = B cG s|S(s/ 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) ((RR((s.lib/python2.7/site-packages/sympy/core/expr.pytas_exprscC s-|j|}|r)|j| r)|SdS(s" 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.coeff_monomial: efficiently find the single coefficient of a monomial in Poly sympy.polys.polytools.nth: like coeff_monomial but powers of monomial terms are used N(textract_multiplicativelyR(RR*R`((s.lib/python2.7/site-packages/sympy/core/expr.pytas_coefficients@c s2ddlm}ddlm}ddlm}ddlm}|jrYt j t j fS|j }|j dt |trt}nt}tgx:|D]2} t | |rj| qj| qWfd||k s|tk r7|tk r7|r'|j|fS||jfSn0|tkrUt|j} n|j\} } || fd } | t} | t} |tkrt| || fSxHt| D]:\}}|r| j| |Pn| j|qWt| | r!td t| n || fSd S( s 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=True), Add.as_two_terms(), Mul.as_two_terms(), .as_coeff_add(), .as_coeff_mul() i(R1(t_unevaluated_Add(t_unevaluated_Muli(tsiftRGc s3|j}s|S|p2|j|j@S(sreturn the standard has() if there are no literal symbols, else check to see that symbol-deps are in the free symbols.(RR(R t has_other(R4tsym(s.lib/python2.7/site-packages/sympy/core/expr.pyRsc s |S(N((Rc(R(s.lib/python2.7/site-packages/sympy/core/expr.pyRRRoN(tsymbolR1R RdR!Retsympy.utilities.iterablesRfRRR3tfuncRRR6R.RRtidentityRRRERRR&textend(RtdepsthintR1RdReRfRktwantRRRBtdependtindepRaR((RR4Rhs.lib/python2.7/site-packages/sympy/core/expr.pyRSJsL              cK sIddlm}m}|jd|kr/dS||||fSdS(sPerforms complex expansion on 'self' and returns a tuple containing collected both real and imaginary parts. This method can't 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)) i(RlRktignoreN(R2RlRkRR@(RtdeepthintsRlRk((s.lib/python2.7/site-packages/sympy/core/expr.pyRgscC s,tt}|jt|jg|S(sReturn 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. (RR]tupdateRt as_base_exp(RR((s.lib/python2.7/site-packages/sympy/core/expr.pytas_powers_dict$s cC sQ|j\}}|js-tj}|}ntt}|ji||6|S(sReturn 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 an expression is not an Add it is considered to have a single term. Examples ======== >>> from sympy.abc import a, x >>> (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} (RR5RRRR]Rv(RRRR((s.lib/python2.7/site-packages/sympy/core/expr.pytas_coefficients_dict7s    cC s |tjfS(N(RR(R((s.lib/python2.7/site-packages/sympy/core/expr.pyRwQscO s5|r%|j|s%|tfSntj|ffS(sReturn 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 don't 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 don't 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, ()) (RR&RR(RRntkwargs((s.lib/python2.7/site-packages/sympy/core/expr.pyt as_coeff_mulUscG s5|r%|j|s%|tfSntj|ffS(sReturn 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 don't 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 don't 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, ()) (RR&RR3(RRn((s.lib/python2.7/site-packages/sympy/core/expr.pyt as_coeff_addxscC sS|stjtjfS|jdt\}}|jrI| | }}n||fS(sRReturn 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 R(RRR3RRRt(RRR`((s.lib/python2.7/site-packages/sympy/core/expr.pyt primitives  cC s tj|fS(sThis 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) >>> ((5*(x*(1 + y)) + 2.0*x*(3 + 3*y))**2).as_content_primitive() (1, 121.0*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) (RR(RRtclear((s.lib/python2.7/site-packages/sympy/core/expr.pytas_content_primitives7cC s |tjfS(s 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(R((s.lib/python2.7/site-packages/sympy/core/expr.pyRs cC s[ddlm}|j\}}|tjkr5|S|jrO||d|S||SdS(Ni(Re(R!ReRRRRY(RReRR((s.lib/python2.7/site-packages/sympy/core/expr.pytnormals cC st|}|tjkrdS|tjkr2|S||krEtjS|jr|j\}}|tjk rt||dt}qn|j r|j \}}|j |}|dk r|j |Sn||}|j r|tj kr|jrtj Sq|tjkr7|jr$tj S|jrtjSq|tjkrY|jstjSq|jr|jsodS|jr|jrdS|Sq|jr|jsdS|jr|jrdS|Sq|jr|jsdS|jr|jrdS|Sqn|js|js|tjkr|j rnt|jdkrn|jdjr|jdjr|jd|kr|Sq|jr|j r|Sn|jr|j\}} |j r|tjk r|tjk r |jr|j |  } n|j |} | dk r | | SndS|| kr |Sg} x=| jD]2} | j |} | dkrUdS| j| q0W|tjk rtjg| D]}||^qStj| Sn|j rt|j}xt |D];\}} | j |} | dk r| ||>> 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 RoiiiN(%RRRZR@RR"R}R.RR$t as_two_termsRbRYR[R{R\RtRRRR5tis_Floattis_NumberSymbolRRR'RR/RR6t _from_argsRR&RR+R+textract_additively(RRtcctpcRRRctquotienttcstpstxctnewargsR,tnewargttRRatnew_exp((s.lib/python2.7/site-packages/sympy/core/expr.pyRbs                     !3      $      cC st|}|tjkrdS|tjkr2|S||krEtjS|tjkrXdS|jr|jsndS|}||}|dkr|dkr||ks|dkr|dkr||kr|SdS|jr|j\}}|j|}|dkrdS||S|jr|j djr|j |}|jdpJd|}|r|||}||j|pz|pdS|j\}}|j\}} |j|}|dkrdS| j|} | dkrdS|| S|j |}|jdp d|}|rE|||}||j|p=|pDdSg} xt j |D]} | j \} }|j |}|sdS|j\}}|j| }|dkrdS|||8}| j|||q[W| j|t | S(sReturn 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 Sometimes auto-expansion will return a less simplified result than desired; gcd_terms might be used in such cases: >>> from sympy import gcd_terms >>> (4*x*(y + 1) + y).extract_additively(x) 4*x*(y + 1) + x*(4*y + 3) - x*(4*y + 4) + y >>> gcd_terms(_) x*(4*y + 3) + y See Also ======== extract_multiplicatively coeff as_coefficient iiN(RRRZR@R3RYt as_coeff_AddRR"RR)R6RRR(RRRQRRtxatxa0thtshtsttxa2tcoeffsRtactattcoctcot((s.lib/python2.7/site-packages/sympy/core/expr.pyRst"     $$      cC sd|jDS(s 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 {x, y} If the expression is contained in a non-expression object, don't return the free symbols. Compare: >>> from sympy import Tuple >>> t = Tuple(x + y) >>> t.expr_free_symbols set() >>> t.free_symbols {x, y} cS s&h|]}|jD] }|qqS((texpr_free_symbols(RRaRL((s.lib/python2.7/site-packages/sympy/core/expr.pys  s (R(R((s.lib/python2.7/site-packages/sympy/core/expr.pyRsc C sc| }||krtS|jddk }|jddk }||krQ|S|jrt|j}tg|jD]}|jrvt^qv}||}||krtS||krCtSn|jrC|j \}} t j |t j | } g| D]}|j^q} t t d| }t|ddkSt|j|jkSdS(sReturn True if self is not in a canonical form with respect to its sign. For most expressions, e, there will be a difference in e and -e. When there is, True will be returned for one and False for the other; False will be returned if there is no difference. Examples ======== >>> from sympy.abc import x, y >>> e = x - y >>> {i.could_extract_minus_sign() for i in (e, -e)} {False, True} iiiN(RRbR@R"R'Rtcould_extract_minus_signRR$RR.RRtfilterRR( Rt negative_selftself_has_minustnegative_self_has_minustall_argsR,t negative_argst positive_argstnumtdenRt arg_signs((s.lib/python2.7/site-packages/sympy/core/expr.pyR s,   .    cC sddlm}m}m}m}m}td}td}tj|} g} x:| D]2} t | |r| | j g7} q\|| 9}q\Wtd} g} xz| r | j }|j r| |j 7} qn|jr|j||}|dk r| |7} qqn| |g7} qW| jr9| }d}n| j| j\}}||dtddd}||d7}||}|r|jd}|dk r|tdd7}|}qn||||f||| }|dkr|||9}n||fS(sc 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) i(t exp_polartpitItceilingR6iiiN((R2RRRRR6RR.RRR+R4R"RR$RcR@RWR|RR(Rt allow_halfRRRRR6RtresRtexpsR,tpiimulttextrasR+R)ttailt branchfactRRBtnewexp((s.lib/python2.7/site-packages/sympy/core/expr.pytextract_branch_factor6 sL(              "   % cC s&|jj|tgkr"tStS(N(RRURRR(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_is_polynomial scG sZ|rttt|}n |j}|j|jtgkrItS|j|SdS(s 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 >>> 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 >>> 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() N(RtmapRRRURR(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyt is_polynomial s 9 cC s&|jj|tgkr"tStS(N(RRURRR(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_is_rational_function scG s|tjtjtj tjgkr)tS|rGttt|}n |j}|j |jtgkrrt S|j |SdS(s  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(). N( RRZR[RRRRRRRURR(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pytis_rational_function s3% cC s&|jj|tgkr"tStS(N(RRURRR(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_is_algebraic_expr scG sZ|rttt|}n |j}|j|jtgkrItS|j|SdS(s 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 ========== - https://en.wikipedia.org/wiki/Algebraic_expression N(RRRRRURR(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pytis_algebraic_expr s * iiRc  sddlm}m}mm}m} m} dkr}|j} | sM|St | dkrnt dn| j nt | r|jk} n(|} | |j i| 6jk} | s|dkrd|gDS|Snt |dks|dkrt dn|tjtjgkr|tjkrJdnd|jjd|d d }|dkrfd |DS|jS|s|d kro|d kr |} |n|}| |j|jd dd|d d d|}|dkr[fd|DS|jSjjkodknsjtk r|ddtdt|jj|||d|}|dkrfd|DS|jSn|dk rW|jd|d|}|jpQtj}|r|j}||kr|dkr||j|||7}q|d7}n||krxtddD]}|jd||d|}|j}||kr|| |||||}|jd|d|}x;|j|kr|jd|d|}|d7}qQWPqqWt dt||f||7}n|j}|j}nA|}|j}||j|kr&tj}ny|||SWqtk rS||SXn1fd}||jj d|SdS(s 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. >>> from sympy import cos, exp >>> 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 i(tcollectRUtOrdertRationalR1Ris+x must be given for multivariate functions.cs s|] }|VqdS(N((RR((s.lib/python2.7/site-packages/sympy/core/expr.pys ss+-sDir must be '+' or '-'RtdirRc3 s%|]}|jVqdS(N(RV(RR(tsgnRc(s.lib/python2.7/site-packages/sympy/core/expr.pys sRtx0itlogxc3 s%|]}|jVqdS(N(RV(RR(trep2trep2bRc(s.lib/python2.7/site-packages/sympy/core/expr.pys sRcR2tfinitec3 s!|]}|jVqdS(N(RV(RR(Rctxpos(s.lib/python2.7/site-packages/sympy/core/expr.pys si s#Could not calculate %s terms for %sc3 sx|D]}|js!|Vqnd}|}d}t|j}x|||j}|9}| sR|jrqRn|jr|t|j7}n |d7}|V||krPn||7}qRWqWdS(s&Return terms of lseries one at a time.iiN(R"R'RR/R(RRtyieldedR6tndidtndotdo(RRc(s.lib/python2.7/site-packages/sympy/core/expr.pyt yield_lseries s(      N(!R2RRURRR1RR@RR'RCR4RtxreplaceRR[R\RVtseriesR{RtRRt _eval_nseriesR0R3R9RR!R/tdoitRt _eval_lseries(RRcRRRRRRURR1RR8tdepRRtreptrvts1R6tngottmoretnewnRts1doneR((RRRRRcRs.lib/python2.7/site-packages/sympy/core/expr.pyRL s*.    +     3 1*     &         cG stddlm}m}t|}|d}|j||j||j||j|d||||S(sGeneral 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". i(RUt factorialRci(R2RURRRVR(RRRctprevious_termsRURt_x((s.lib/python2.7/site-packages/sympy/core/expr.pyt taylor_term s  c C s"|j||ddd|d|S(s Wrapper for series yielding an iterator of the terms of the series. Note: an infinite series will yield an infinite iterator. The following, for exaxmple, will never terminate. It will just keep printing terms of the sin(x) series:: for term in sin(x).lseries(x): print term The advantage of lseries() over nseries() is that many times you are just interested in the next term in the series (i.e. the first term for example), but you don't know how many you should ask for in nseries() using the "n" parameter. See also nseries(). RRRN(RR@(RRcRRR((s.lib/python2.7/site-packages/sympy/core/expr.pytlseries scc sd}|j|d|d|}|jsJ|jrA|jVn|VdSx2|jr~|d7}|j|d|d|}qMW|j}|VxUx?|d7}|j|d|d|j}||krPqqW||V|}qWdS(NiRRi(RRR"R/(RRcRRRR ((s.lib/python2.7/site-packages/sympy/core/expr.pyR s(      !  cC sj|r||jkr|S|dks7|s7|dkrM|j||||S|j|d|d|SdS(s- Wrapper to _eval_nseries if assumptions allow, else to series. If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is called. This calculates "n" terms in the innermost expressions and then builds up the final series just by "cross-multiplying" everything out. The optional ``logx`` parameter can be used to replace any log(x) in the returned series with a symbolic value to avoid evaluating log(x) at 0. A symbol to use in place of log(x) should be provided. Advantage -- it's fast, because we don't have to determine how many terms we need to calculate in advance. Disadvantage -- you may end up with less terms than you may have expected, but the O(x**n) term appended will always be correct and so the result, though perhaps shorter, will also be correct. If any of those assumptions is not met, this is treated like a wrapper to series which will try harder to return the correct number of terms. See also lseries(). Examples ======== >>> 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 gives only an Order term unless the ``logx`` parameter is used: >>> e = x**y >>> e.nseries(x, 0, 2) O(log(x)**2) >>> e.nseries(x, 0, 2, logx=logx) exp(logx*y) RRRN(RR@RR(RRcRRRR((s.lib/python2.7/site-packages/sympy/core/expr.pytnseries7 s <cC s-ddlm}t|d|jdS(s@ 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 don't have to write docstrings for _eval_nseries(). i(t filldedents 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.N(tsympy.utilities.miscRRRk(RRcRRR((s.lib/python2.7/site-packages/sympy/core/expr.pyRz s cC s#ddlm}|||||S(s Compute limit x->xlim. i(R(tsympy.series.limitsR(RRctxlimRR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC sddlm}m}ddlm}|jdkr<|S|dkr{|d}||||j|||}n||||}|j|S(s as_leading_term is only allowed for results of .series() This is a wrapper to compute a series first. i(RUR(tcalculate_seriesiRN( R2RURtsympy.series.gruntzRR/R@RVtas_leading_term(RRcRRURRRR((s.lib/python2.7/site-packages/sympy/core/expr.pytcompute_leading_term s  'cG sddlm}t|dkrL|}x|D]}|j|}q/W|S|sV|St|d}|jstd|n||jkr|S|j|}|d k r||dt ddSt d ||fd S( s 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) i(tpowsimpiisexpecting a Symbol but got %sRttcombineR+sas_leading_term(%s, %s)N( R2RR'RRt is_symbolRCRt_eval_as_leading_termR@RR(RtsymbolsRRRcR((s.lib/python2.7/site-packages/sympy/core/expr.pyR s"   cC s|S(N((RRc((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC sddlm}|||}|j|\}}t|dkru|dj\}}||kru||fSn|tjfS(sC ``c*x**e -> c,e`` where x can be any symbolic expression. i(Rii(R2RR{R'RwRR3(RRcRRRtpRR ((s.lib/python2.7/site-packages/sympy/core/expr.pytas_coeff_exponent s  c C sddlm}m}|j|}|d}|j||ra|j|||}n|j|\}}||jkrddlm }t |d|||fn|j|||}||fS(s 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) i(RURR(Rsw cannot compute leadterm(%s, %s). The coefficient should have been free of x but got %s( R2RURRRRVRRRRRC( RRcRURRMRRR R((s.lib/python2.7/site-packages/sympy/core/expr.pytleadterm s cC s tj|fS(s2Efficiently extract the coefficient of a product. (RR(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC s tj|fS(s4Efficiently extract the coefficient of a summation. (RR3(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyR sic C s/ddlm}|||||||||S(s Compute formal power power series of self. See the docstring of the :func:`fps` function in sympy.series.formal for more information. i(tfps(tsympy.series.formalR( RRcRRthyperRRtfullR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC sddlm}|||S(sCompute fourier sine/cosine series of self. See the docstring of the :func:`fourier_series` in sympy.series.fourier for more information. i(tfourier_series(tsympy.series.fourierR(RtlimitsR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scO s |jdtt|||S(NRo(t setdefaultRt Derivative(RRt assumptions((s.lib/python2.7/site-packages/sympy/core/expr.pyR scK s$|j|\}}|tj|S(N(RgRR(RRuR$R%((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_expand_complex sc K st}|rt|ddr|j rg}xC|jD]8}tj|||\}}||O}|j|q8W|r|j|}qnt||rt|||}||kr|t fSn||fS(s  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. R(( RRR RRt _expand_hintRRkRR( R*RoRtRuR`tsargsR,targhittnewexpr((s.lib/python2.7/site-packages/sympy/core/expr.pyR$ s "   c  K sddlm} | jd|d|d|d|d|d||} | jd trg| |D]!} | jd |d || ^qc\} }| |S| jd tr| |\} }| |jd |d || S| jd tr| |\} }| jd |d || |Sd}x^t| jd|D]D}| |}|r<d|}tj | |d || \} }q<q<Wxt rH| }| j dtrtj | dd || \} }n| j dtrtj | dd || \} }n| j dtr5tj | dd || \} }n| |krPqqW|dk rt |}|j sw|dkrtd|ng}xStj| D]B}|jdt \}}||;}|r|j||qqWt|} n| S(s Expand an expression using hints. See the docstring of the expand() function in sympy.core.function for more information. i(tfractiont power_baset power_expR!Rt multinomialtbasictfracRttmodulustdenomtnumercS s|dkrdS|S(s Make multinomial come before mulR!tmulz((Ro((s.lib/python2.7/site-packages/sympy/core/expr.pyt_expand_hint_keym s Rt _eval_expand_t_eval_expand_multinomialt_eval_expand_mult_eval_expand_logis*modulus must be a positive integer, got %sRN(tsympy.simplify.radsimpRRvR4RtexpandRtkeysRRRRR@RRRCR6RRR(RRtRRRR!RRRRuRR*RRRRRotuse_hintR`twasRRRR)R((s.lib/python2.7/site-packages/sympy/core/expr.pyRB s\ 7   (     cO s ddlm}||||S(s-See the integrate function in sympy.integralsi(t integrate(tsympy.integralsR(RRRzR((s.lib/python2.7/site-packages/sympy/core/expr.pyR sg333333?cC s<ddlm}ddlm}|p)|}||||S(s+See the simplify function in sympy.simplifyi(R(R:(tsympy.simplifyRtsympy.core.functionR:(RtratiotmeasureRtinverseRR:((s.lib/python2.7/site-packages/sympy/core/expr.pyR s cC s#ddlm}|||||S(s,See the nsimplify function in sympy.simplifyi(R(RR(Rt constantst toleranceRR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC s&ddlm}||d|d|S(s+See the separate function in sympy.simplifyi(texpand_power_baseRttforce(RR(RRtRR((s.lib/python2.7/site-packages/sympy/core/expr.pytseparate scC s)ddlm}|||||||S(s*See the collect function in sympy.simplifyi(R(RR(RR8RkRotexacttdistribute_order_termR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scO s ddlm}||||S(s(See the together function in sympy.polysi(ttogether(t sympy.polysR (RRRzR ((s.lib/python2.7/site-packages/sympy/core/expr.pyR  scK s ddlm}||||S(s%See the apart function in sympy.polysi(tapart(R!R"(RRcRR"((s.lib/python2.7/site-packages/sympy/core/expr.pyR" scC sddlm}||S(s*See the ratsimp function in sympy.simplifyi(tratsimp(RR#(RR#((s.lib/python2.7/site-packages/sympy/core/expr.pyR# scK sddlm}|||S(s+See the trigsimp function in sympy.simplifyi(ttrigsimp(RR$(RRR$((s.lib/python2.7/site-packages/sympy/core/expr.pyR$ scK sddlm}|||S(s*See the radsimp function in sympy.simplifyi(tradsimp(RR%(RRzR%((s.lib/python2.7/site-packages/sympy/core/expr.pyR% scO s ddlm}||||S(s*See the powsimp function in sympy.simplifyi(R(RR(RRRzR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC sddlm}||S(s+See the combsimp function in sympy.simplifyi(tcombsimp(RR&(RR&((s.lib/python2.7/site-packages/sympy/core/expr.pyR& scC sddlm}||S(s,See the gammasimp function in sympy.simplifyi(t gammasimp(RR'(RR'((s.lib/python2.7/site-packages/sympy/core/expr.pyR' scO s ddlm}||||S(s2See the factor() function in sympy.polys.polytoolsi(R*(R!R*(RRRR*((s.lib/python2.7/site-packages/sympy/core/expr.pyR* scC sddlm}|||S(s,See the refine function in sympy.assumptionsi(trefine(tsympy.assumptionsR((Rt assumptionR(((s.lib/python2.7/site-packages/sympy/core/expr.pyR( scO s ddlm}||||S(s&See the cancel function in sympy.polysi(R(R!R(RRRR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scO s[ddlm}ddlm}|jrHt|dtrH|||S|||||S(sReturn the multiplicative inverse of ``self`` mod ``g`` where ``self`` (and ``g``) may be symbolic expressions). See Also ======== sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert i(tinvert(R?RW(tsympy.polys.polytoolsR+RBR?RWRR(RR.RRR+R?((s.lib/python2.7/site-packages/sympy/core/expr.pyR+ s  cC sddlm}|}|js.tdn|js|jd}t|dtstdtt|d|dt |qn(|t j t j t j t jfkr|S|js|j\}}|j|t j|j|S|s|St|}g|j|D]}|j^q}|rCtt|nd } t|} | |} } | d k r| | kr| } ntd |} |}|d d| 7}d | |j| d k r| n| d }|jr5|d d| }d | |j| d k r| n| d }t| d  }nt|d }d }|d kr`| }n|d kry|| }nt||}|jr|t|| S| r||kr| d 7} n||| Sd S( sReturn 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, Add, Mul, Number >>> S(10.5).round() 11. >>> 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 ===== Do not confuse the Python builtin function, round, with the SymPy method of the same name. The former always returns a float (or raises an error if applied to a complex value) while the latter returns either a Number or a complex number: >>> isinstance(round(S(123), -2), Number) False >>> isinstance(S(123).round(-2), Number) True >>> isinstance((3*I).round(), Mul) True >>> isinstance((1 + 3*I).round(), Add) True i(Rscan't round symbolic expressioniRsExpected a number but got %s:Rkt__name__i iiN( R2RRWRDR RR RRttypeRRZR[R\RRqRgRXRR]RRRRR@t_magR=RtRRRR!(RRRRctxnRaR`tftprecstdpst mag_first_digtallowt digits_neededtmagtxwasti10Rtq((s.lib/python2.7/site-packages/sympy/core/expr.pyRX sV.  .$ ! %  - -      cC s5ddlm}|tjtjd|j|gS(Ni(t_LeftRightArgsthigher(t"sympy.matrices.expressions.matexprR;RRt_eval_derivative(RRcR;((s.lib/python2.7/site-packages/sympy/core/expr.pyt_eval_derivative_matrix_lines_ s(R-t __module__t__doc__t __slots__Rt is_scalartpropertyRR R@Rt _op_priorityR-R0R3R RER R7R5R9R8R;R:R>RIR<RKRJt __truediv__t __rtruediv__RNRLRRRORTRSRet__long__RiRmRxR|R~RRt staticmethodRRWRRRR^RRRRRRRRRRt classmethodRR%R#RR/R0R9R:RER)RaRcRSRgRxRyRwR{R|R}RRRRbRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR R"R#R$R%RR&R'R*R(RR+RXR?(((s.lib/python2.7/site-packages/sympy/core/expr.pyRs& (*                     $       4N l # # V     % 6 8   + <  D     # $ 9 i . I  D  A  9  C   $       \              _t AtomicExprcB seeZdZeZeZgZdZdZ dZ dZ dZ dZ edZRS(s A parent class for object which are both atoms and Exprs. For example: Symbol, Number, Rational, Integer, ... But not: Add, Mul, Pow, ... cC s||krtjStjS(N(RRR3(RR((s.lib/python2.7/site-packages/sympy/core/expr.pyR>p s cC sddlm}m}ddlm}m}ddlm}t|||t|frpt t |j ||S||kr||||dfd||dfdt fS||||dfdt fSdS(Ni(t PiecewisetEq(tTuplet MatrixExpr(t MatrixCommonii( R2RLRMRNROtsympy.matrices.commonRPRRtsuperRKt_eval_derivative_n_timesR(RRRRLRMRNRORP((s.lib/python2.7/site-packages/sympy/core/expr.pyRSu s 4cC stS(N(R(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC stS(N(R(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC stS(N(R(RR8((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC s|S(N((RRcRR((s.lib/python2.7/site-packages/sympy/core/expr.pyR scC s|hS(N((R((s.lib/python2.7/site-packages/sympy/core/expr.pyR s(R-R@RARRWRR RBR>RSRRRRRDR(((s.lib/python2.7/site-packages/sympy/core/expr.pyRKd s     cC sddlm}m}m}ddlm}t|j}|sKtj Syt |||}WnEt t fk rt ||t |jd|d}nX|d|dkrd|d|kodknst|d7}n|S(sReturn integer ``i`` such that .1 <= 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 i(tlog10tceilR(Ri5i i(tmathRTRURR2RRRRR3R]RCt OverflowErrorRRtAssertionError(RcRTRURRRR4((s.lib/python2.7/site-packages/sympy/core/expr.pyR/ s2* tUnevaluatedExprcB s eZdZdZdZRS(s Expression that is not evaluated unless released. Examples ======== >>> from sympy import UnevaluatedExpr >>> from sympy.abc import a, b, x, y >>> x*(1/x) 1 >>> x*UnevaluatedExpr(1/x) x*1/x cK s%t|}tj|||}|S(N(RRt__new__(R R,RzR((s.lib/python2.7/site-packages/sympy/core/expr.pyRZ s cK s5|jdtr&|jdj|S|jdSdS(NRti(RRRR(RRz((s.lib/python2.7/site-packages/sympy/core/expr.pyR s(R-R@RARZR(((s.lib/python2.7/site-packages/sympy/core/expr.pyRY s cC s9|jr5|jr5||jd}|jr5|SndS(sReturn (a - b).evalf(2) if a and b are comparable, else None. This should only be used when a and b are already sympified. iN(RR_(RRRw((s.lib/python2.7/site-packages/sympy/core/expr.pyRr s cG sG||}|j|koF|jtg|D]}t|^q+kS(sReturn True if `func` applied to the `args` is unchanged. Can be used instead of `assert foo == foo`. Examples ======== >>> from sympy.core.expr import unchanged >>> from sympy.functions.elementary.trigonometric import cos >>> from sympy.core.numbers import pi >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) True >>> unchanged(cos, pi) False (RkRR&R(RkRR1R((s.lib/python2.7/site-packages/sympy/core/expr.pyt unchanged s (R.(R6(R=(RR(RM(R(RRN(4t __future__RRRRRRRRt singletonRR_RR t decoratorsR R tcacheR t compatibilityR RRRRt mpmath.libmpRRt collectionsRRRKR/RYRrR[R!R.R R6RHR=R;RRRFRMR"RRRR(((s.lib/python2.7/site-packages/sympy/core/expr.pytsF(c-