\hnSrSSKJr SSKJr SSKJr SSKrSSKJ r SSK J r J r SS K Jr SS KJrJr SS KJr SS KJr SS KJrJr SSKJrJrJrJr SSKJr SSK J!r!J"r"J#r# SSK$J%r% SSK&J'r' SSK(J)r) SSK*J+r+ SSK,J,r,J-r- SSK.J/r/J0r0 SSK1J2r2J3r3J4r4 SSK5J6r6J7r7J8r8J9r9J:r:J;r; SSKJ?r?J@r@JArA SSKBrBSSKCJDrD SSKErESSKFJGrG SrH"SS\I5rJ"S S!\K5rL"S"S#\M5rN"S$S%\M5rOS&rP"S'S(\Q5rR"S)S*\ \RS+9rS"S,S-\S\5rT"S.S/\T5rU"S0S1\T5rV"S2S35rW\W"5rX"S4S5\R5rYS6rZS7r[\R"\Y\Z5 "S8S9\T\5r]"S:S;\5r^S<r_"S=S>\5r`"S?S@\5raSArbSOSBjrcSPSCjrdSQSDjreSQSEjrfSRSFjrgSQSGjrhSQSHjriSQSIjrjSSSJjrkSQSKjrlSPSLjrmSTSMjrnSSNKoJprpJqrq g)Ua There are three types of functions implemented in SymPy: 1) defined functions (in the sense that they can be evaluated) like exp or sin; they have a name and a body: f = exp 2) undefined function which have a name but no body. Undefined functions can be defined using a Function class as follows: f = Function('f') (the result will be a Function instance) 3) anonymous function (or lambda function) which have a body (defined with dummy variables) but have no name: f = Lambda(x, exp(x)*x) f = Lambda((x, y), exp(x)*y) The fourth type of functions are composites, like (sin + cos)(x); these work in SymPy core, but are not yet part of SymPy. Examples ======== >>> import sympy >>> f = sympy.Function("f") >>> from sympy.abc import x >>> f(x) f(x) >>> print(sympy.srepr(f(x).func)) Function('f') >>> f(x).args (x,) ) annotations)Any)IterableN)Add)Basic_atomic)cacheit)TupleDict) _sympifyit) pure_complex)Expr AtomicExpr) fuzzy_andfuzzy_or fuzzy_not FuzzyBool)Mul)RationalFloatInteger) LatticeOp)global_parameters) Transform)S)sympify_sympify)default_sort_keyordered)sympy_deprecation_warningSymPyDeprecationWarningignore_warnings)has_dupssiftiterable is_sequenceuniqtopological_sort)MPMATH_TRANSLATIONS)as_int filldedent func_name) prec_to_dps)CountercUR(aURSnUR(aURSnUR=(a UR$)aReturn True if the leading Number is negative. Examples ======== >>> from sympy.core.function import _coeff_isneg >>> from sympy import S, Symbol, oo, pi >>> _coeff_isneg(-3*pi) True >>> _coeff_isneg(S(3)) False >>> _coeff_isneg(-oo) True >>> _coeff_isneg(Symbol('n', negative=True)) # coeff is 1 False For matrix expressions: >>> from sympy import MatrixSymbol, sqrt >>> A = MatrixSymbol("A", 3, 3) >>> _coeff_isneg(-sqrt(2)*A) True >>> _coeff_isneg(sqrt(2)*A) False r) is_MatMulargsis_Mul is_Numberis_extended_negative)as K/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/function.py _coeff_isnegr8EsA6 {{ FF1Ixx FF1I ;; 11111c\rSrSrSrg) PoleErrorgN)__name__ __module__ __qualname____firstlineno____static_attributes__r=r9r7r;r;gsr9r;c\rSrSrSrSrg)ArgumentIndexErrorkcJSURS<SURS<3$)Nz'Invalid operation with argument number rz for Function r)r2selfs r7__str__ArgumentIndexError.__str__ls! ! diil, -r9r=N)r>r?r@rArIrBr=r9r7rDrDks-r9rDc\rSrSrSrSrg)BadSignatureErrorqz9Raised when a Lambda is created with an invalid signaturer=Nr>r?r@rA__doc__rBr=r9r7rLrLqsCr9rLc\rSrSrSrSrg)BadArgumentsErrorvzDRaised when a Lambda is called with an incorrect number of argumentsr=NrNr=r9r7rQrQvsNr9rQc [USU5n[R"U5RR 5nUVVs/sH#up4UR UR :XdM!UPM% snn(agUVVs/sH#up4UR UR:XdM!UPM% nnn[[[USSS95upgU(dU$[[XfU-S-55$s snnfs snnf)aeReturn the arity of the function if it is known, else None. Explanation =========== When default values are specified for some arguments, they are optional and the arity is reported as a tuple of possible values. Examples ======== >>> from sympy import arity, log >>> arity(lambda x: x) 1 >>> arity(log) (1, 2) >>> arity(lambda *x: sum(x)) is None True evalNc4URUR:H$N)defaultempty)ps r7arity..sagg%r9T)binaryr) getattrinspect signature parametersitemskindVAR_POSITIONALPOSITIONAL_OR_KEYWORDmaplenr%tuplerange)clseval_r`_rYp_or_knoyess r7arityro|s( C %E""5)44::.>$>j??& LJDA!&&A4K4K*KaJF L#tF%d45GB2' [ , signature ]) to create undefined function classes. c JURSURRS[U555nUcBSUR;a2URH"n[ US5(aUR n OM$ [U5(aEU(d [[S[U5-55e[[[U555nOUb [U54nX0l[U5S:Xa0USnSU;a$[!US["5(d [%S5eggg)Nnargs_nargsa Incorrectly specified nargs as %s: if there are no arguments, it should be `nargs = 0`; if there are any number of arguments, it should be `nargs = None`rTzPeval on Function subclasses should be a class method (defined with @classmethod))pop__dict__getro__mro__hasattrrur' ValueErrorr,strrgr setr+rf isinstance classmethod TypeError)rir2kwargsrtsupcls namespaces r7__init__FunctionClass.__init__s 7CLL$4$4WeCj$IJ =WCLL8++68,,"MME & u   -& ),E -3"455'#e*-.E  E]$E t9>QI":i6G+U+U rss,V" r9cTSSKJn U"UR5$![a gf=f)zX Allow Python 3's inspect.signature to give a useful signature for Function subclasses. r)r_N)r^r_ ImportErrorrT)rHr_s r7 __signature__FunctionClass.__signature__s/  ) ##   s  ''c[5$rV)rrGs r7 free_symbolsFunctionClass.free_symbolss u r9c^U4Sj$)Nc(>URTT5$rV)rz)rulerkrHs r7rZ(FunctionClass.xreplace..s$!5r9r=rGs`r7xreplaceFunctionClass.xreplaces 65r9cnSSKJn UR(aU"UR6$[R$)aReturn a set of the allowed number of arguments for the function. Examples ======== >>> from sympy import Function >>> f = Function('f') If the function can take any number of arguments, the set of whole numbers is returned: >>> Function('f').nargs Naturals0 If the function was initialized to accept one or more arguments, a corresponding set will be returned: >>> Function('f', nargs=1).nargs {1} >>> Function('f', nargs=(2, 1)).nargs {1, 2} The undefined function, after application, also has the nargs attribute; the actual number of arguments is always available by checking the ``args`` attribute: >>> f = Function('f') >>> f(1).nargs Naturals0 >>> len(f(1).args) 1 r FiniteSet)sympy.sets.setsrrur Naturals0rHrs r7rtFunctionClass.nargss(D .+/++y$++&F1;;Fr9cUR(aXR;$URnU[RL=(d X;$)zReturn True if the specified integer is a valid number of arguments The number of arguments n is guaranteed to be an integer and positive )rurtrr)rHnrts r7 _valid_nargsFunctionClass._valid_nargs s7 ;; # #  #1qz1r9cUR$rV)r>ris r7__repr__FunctionClass.__repr__s ||r9r=N)rintreturnbool)r>r?r@rArOtype__new___newrpropertyrrrrtrrrBr=r9r7rqrqsv <SSKJn SSKJn [ [ [ U55nURS[R5nURSS5 U(a[SU-5eU(aUR"U6nUbU$[T U]4"U/UQ70UD6n[5n[USU5n XLaA[!U 5(a[#[%['U 555n OU b [)U 54n OSn O UR*n U (a U"U 6UlU$U"5UlU$)NrrrevaluatertzUnknown options: %s)sympy.sets.fancysetsrrrlistrerrxrrr}rTsuperrobjectr]r'rgr rr+rurt) rir2optionsrrr evaluatedobjsentinelobjnargsrt __class__s r7rApplication.__new__&s 2-C&';;z+<+E+EF  GT" 2W<= = $I$  goc4D4G4832  # 8$$gc(m45%)+ JJE).Iu%  5>K  r9cg)a  Returns a canonical form of cls applied to arguments args. Explanation =========== The ``eval()`` method is called when the class ``cls`` is about to be instantiated and it should return either some simplified instance (possible of some other class), or if the class ``cls`` should be unmodified, return None. Examples of ``eval()`` for the function "sign" .. code-block:: python @classmethod def eval(cls, arg): if arg is S.NaN: return S.NaN if arg.is_zero: return S.Zero if arg.is_positive: return S.One if arg.is_negative: return S.NegativeOne if isinstance(arg, Mul): coeff, terms = arg.as_coeff_Mul(rational=True) if coeff is not S.One: return cls(coeff) * cls(terms) Nr=)rir2s r7rTApplication.evalSs< r9cUR$rVrrGs r7funcApplication.funcss ~~r9c \UR(aUR(a[U5(as[U5(abXR:XaR[UR5UR ;a.U"URVs/sHo3R X5PM sn6$ggggggs snfrV) is_Functioncallablerrfr2rt_subs)rHoldnewis r7 _eval_subsApplication._eval_subsws} OO SMMhsmm 99 TYY399!<DII>Iq*I>? ?"= ,M!0O?sB)r=)r>r?r@rArOrr rrrTrrrrB __classcell__rs@r7rrsVK * *X>@@r9r) metaclassc^\rSrSr%Sr\S5r\SSj5r\ SU4Sjj5r \ S5r \ S5r Sr S rS rS rS rS \S'\ S5rSrSSjrSSjrSrSrU=r$)Functioni~a Base class for applied mathematical functions. It also serves as a constructor for undefined function classes. See the :ref:`custom-functions` guide for details on how to subclass ``Function`` and what methods can be defined. Examples ======== **Undefined Functions** To create an undefined function, pass a string of the function name to ``Function``. >>> from sympy import Function, Symbol >>> x = Symbol('x') >>> f = Function('f') >>> g = Function('g')(x) >>> f f >>> f(x) f(x) >>> g g(x) >>> f(x).diff(x) Derivative(f(x), x) >>> g.diff(x) Derivative(g(x), x) Assumptions can be passed to ``Function`` the same as with a :class:`~.Symbol`. Alternatively, you can use a ``Symbol`` with assumptions for the function name and the function will inherit the name and assumptions associated with the ``Symbol``: >>> f_real = Function('f', real=True) >>> f_real(x).is_real True >>> f_real_inherit = Function(Symbol('f', real=True)) >>> f_real_inherit(x).is_real True Note that assumptions on a function are unrelated to the assumptions on the variables it is called on. If you want to add a relationship, subclass ``Function`` and define custom assumptions handler methods. See the :ref:`custom-functions-assumptions` section of the :ref:`custom-functions` guide for more details. **Custom Function Subclasses** The :ref:`custom-functions` guide has several :ref:`custom-functions-complete-examples` of how to subclass ``Function`` to create a custom function. cgNFr=rGs r7 _diff_wrtFunction._diff_wrtr9cNU[La [U0UD6$UR"U0UD6$rV)rUndefinedFunction_new_rir2rs r7rFunction.__new__s/ (?$d6g6 699d.g. .r9c >[U5nURU5(d]Sn[UU[UR5S:XaSOS[ UR5S[ UR5S:g-US.-5eUR S[ R5n[T U]$"U/UQ70UD6nU(a[X`5(aqUR(a`URVs/sHopRU5PM nn[ U5n U S:a%[U5n UR[U 55n[!U5$s snf) NzE%(name)s takes %(qual)s %(args)s argument%(plural)s (%(given)s given)rexactlyzat leasts)namequalr2pluralgivenrr)rfrrrtminrzrrrrrr2 _should_evalfmaxevalfr.r) rir2rrtemprresultr6rpr2prrs r7rFunction._new_s I"" :DD%(^q%8 jCIIs399~23 $ ;;z+<+E+EF7t7w7  6//FKK;A;;G;a..q1;MGm$CQw'k"o6 Hs*EcUR(a UR$UR(dg[U5nUcg[ USRUSR5$)a7 Decide if the function should automatically evalf(). Explanation =========== By default (in this implementation), this happens if (and only if) the ARG is a floating point number (including complex numbers). This function is used by __new__. Returns the precision to evalf to, or -1 if it should not evalf. rr)is_Float_precis_Addrr)riargms r7rFunction._should_evalfsN <<99 zz   91Q4::qtzz**r9cSSKJn SSSSSSS S S S S SSSS.nURnX#nSXC4$![a" [ UR U5(aSOSnN/f=f)Nrr  !()*+)explogsincostancotsinhcoshtanhcoth conjugatereimri')rrr>KeyErrorrrt)rirfuncsrrs r7 class_keyFunction.class_keys2  || A A!z A 9555A As-)AAc ^^ U4Sjn[TSS5nUc)U"TRR5nTRnO U"5upEUcJ[TSS5nUcg[ U"TRVs/sHowR U5PM sn6U5$UVs/sHoRUS-5PM nnSm [U 4SjU55(a[e[R"U5 U"U6n SSS5 [R"W U5$s snf![ [4a gf=fs snf![a gf=f!,(df  NU=f)Nc>[T[5(ag[[U5(d[R "US5nUcg[ [U5$)z$Lookup mpmath function based on nameN)r AppliedUndefr|mpmathr*rzr])fnamerHs r7_get_mpmath_func.Function._eval_evalf.._get_mpmath_funcsG$ --65))+//t<=65) )r9 _eval_mpmath_imp_c SSKJnJn [X5(a#URnUSS:g=(a USS:H$[X5(aCUR upUSS:g=(a& USS:H=(a USS:g=(a USS:H$g)Nr)mpfmpcrrF)rrrr_mpf__mpc_)rrrrs r7bad!Function._eval_evalf..bad<s+a%%AQ4!82" 2''77DAQ4!80" 0!q0%&rUaZ0!r9c34># UH nT"U5v M g7frVr=).0r6r s r7 'Function._eval_evalf..Ns(4a3q664)r]rr>r2rrrr} _to_mpmathanyrworkprecr _from_mpmath) rHprecrrrr2imprrvr s ` @r7 _eval_evalfFunction._eval_evalfsH *t^T:  #DII$6$67D99D%JD <$.C{ S$))"D)Q774=)"DEtLL 8<=NN4!8,D= !$(4(((  ) __T "d A#  D))K#Ez*  >*   # "sT D 5D D D;D6:%D;6E D D32D36D;; EE Ec&Sn/nURHQnUS- nURU5nUR(aM,URU5nUR Xe-5 MS [U6$![a [ RX5nN@f=f)Nrr)r2diffis_zerofdiffrDrappendr)rHrrlr6dadfs r7_eval_derivativeFunction._eval_derivativeXs  A FABzz -ZZ] HHRW Aw& -^^D, -sA..BBc:[SUR55$)Nc38# UHoRv M g7frV)is_commutativer#r6s r7r$0Function._eval_is_commutative..is=9a))9s)rr2rGs r7_eval_is_commutativeFunction._eval_is_commutativehs=499===r9c,^UR(dg[U4SjURSS55(agURSnURTU5(dg[[ U5R UR TU555$)NTc3D># UHoRT5v M g7frVhas)r#rxs r7r$0Function._eval_is_meromorphic..ns3]cwwqzz] rFr)r2r(_eval_is_meromorphicrr is_singularsubs)rHrEr6rs ` r7rHFunction._eval_is_meromorphicksryy 3TYYqr]3 3 3iil''1--d//A?@@r9NzFuzzyBool | tuple[Expr, ...]_singularitiescV^URnUS;aU$[U4SjU55$)zp Tests whether the argument is an essential singularity or a branch point, or the functions is non-holomorphic. )TNFc3># UH3nU[RLa TROTU- Rv M5 g7frV)rComplexInfinity is_infiniter2)r#rr6s r7r$'Function.is_singular..s9:68*+a.?.?)? !e__-68s;>)rLr)rir6sss ` r7rIFunction.is_singularys8    $ $I:68:: :r9c N[[S[U5<SU<S355e)z Compute an asymptotic expansion around args0, in terms of self.args. This function is only used internally by _eval_nseries and should not be called directly; derived classes can overwrite this to implement asymptotic expansions. z% Asymptotic expansion of z around z is not implemented.)r;r,r)rHrargs0rElogxs r7 _eval_aseriesFunction._eval_aseriess& #':u$678 8r9cJ ^&^'^(SSKJn SSKJn SSKJn UR nUV s/sHoRUS5PM n n [SU 55(GaSSK J m'J m(J m& UV s/sHoRXS9PM n n U V s/sHoRUS5PM n n [U&U'U(4S jU 55(aURX*X5$UV s/sHoRXU5PM n n [!X5V Vs/sH upX- PM nn nUVs/sH n[#5PM nn/nS n[!XU5HOunnnUR%U5(a!Ub[&eUR)UU-5 UnM>UR)U5 MQ UR*"U6nUcU$URUX#5nUR-5nUR/5nUR1UW5R35U"UR4R1UU5U5-nU$UR*R6[8R:LdVUR*R6U"S5:Xa U S(d,[S UR*R655(GaUnUR35nUU:XGa[=UR 5S:Xa,UR+UR SR?55nUR1U[8R@5nURBS LdUDLa[GS U-5eUn[8RHnU"SU5nUR1UU5n[KSU5HnU[MU5-nUROU5nUR1U[8R@5n U [8RDLa URU[8R@5n U RBS La[GS U-5eU UU--U- nUR35nUU- nM UU"X-U5-$URQXUS9$UR Sn!/n"S n#US-n$U"U!RU5U5RS5n%U%S:waUU%- RU5n$[KU$5H7nURWUU!U#5n#U#RQXUS9n#U"R)U#5 M9 [YU"6U"X-U5-$s sn fs sn fs sn fs sn fs snn fs snf)a This function does compute series for multivariate functions, but the expansion is always in terms of *one* variable. Examples ======== >>> from sympy import atan2 >>> from sympy.abc import x, y >>> atan2(x, y).series(x, n=2) atan2(0, y) + x/y + O(x**2) >>> atan2(x, y).series(y, n=2) -y/x + atan2(x, 0) + O(y**2) This function also computes asymptotic expansions, if necessary and possible: >>> from sympy import loggamma >>> loggamma(1/x)._eval_nseries(x,0,None) -1/x - log(x)/x + log(x)/2 + O(1) r)uniquely_named_symbolrOrderrc3<# UHoRSLv M g7f)FN) is_finite)r#ts r7r$)Function._eval_nseries..s3U{{e#Us)oozoonanrVc3L># UHoRTT*TT5v M g7frVrC)r#r_rcrarbs r7r$r`s#8R55bS#s++Rs!$Nc3*# UH oS:v M g7f)rNr=)r#cs r7r$r`s6o1uosFzCannot expand %s around 0xirrVrw)-symbolrZsympy.series.orderr\rrr2limitr(numbersrarbrcas_leading_termrW _eval_nserieszipDummyrDNotImplementedErrorr4rgetOremoveOrJexpandexprrtrrrfcancelZeror^NaNr;Onerhrr1nseriesgetnceiling taylor_termr))rHrErrVcdirrZr\rr2r_rUr6a0rr0zrkrYqr-aizipie1roetermseriesfact_xrrJrr5gntermscfrcrarbs) @@@r7roFunction._eval_nseriessQ. 2,-yy(,-1A- 3U3 3 3 - -:>?$Q""1"0$A?)*+A''!Q-B+8R888))!A<<7;;dt,dA;'*1z2zGQzA2"#$!Q!A$AA!"m B66!99}11HHR"W%AHHRL,ABy   A,AA Aq" $$&qvv{{1b/A1)EEAH IIOOq{{ *IIOOy|3a6diioo666ABBwqvv;!#qvvay//12Avva(>>U*daeem#$?4$HIIuu*46FF1bMq!AHQK'Dr A66"aff-Dquu} wwr1662~~.'(Ct(LMMA;t+D;;=DdNF%adA..::a4:0 0iil  Q 3&&q)1 - 2 2 4 7d^^%FvA  C+A !t ,A HHQKAwqtQ''_.@+<2$s#T)T TTTT cPSUs=::a[UR5::d O [X5eUS- nURUnUR(av[UR5S:XdUR(d [ X5$[ UR5HupEXB:wdM X5R;dM O [ X5$[SU-[U5S9nURSUU4-URUS-S-n[[UR"U6U5Xc5$)z/ Returns the first derivative of the function. rxi_%i) dummy_indexN) rfr2rDr is_Symbol_derivative_dispatch enumeraterrqhashSubs Derivativer)rHargindexixArr-Dr2s r7r3Function.fdiffsX/TYY/$T4 4 \ IIbM ;;499~"!+++D44!$)),7qNN2 - ,D44 'H$$q' :yy"~$tyya'99Jtyy$/3Q::r9c^^SSKJn URVs/sHoURTUS9PM nnU"ST5m[ UU4SjU55(a[ SUR -5eU$s snf)zStub that should be overridden by new Functions to return the first non-zero term in a series if ever an x-dependent argument whose leading term vanishes as x -> 0 might be encountered. See, for example, cos._eval_as_leading_term. rr[rdrc3r># UH,nTUR;=(a TRU5v M. g7frV)rcontains)r#r6rrEs r7r$1Function._eval_as_leading_term..s*CdqANN"4qzz!}4ds47z'%s has no _eval_as_leading_term routine)rkr\r2rnr(rrr)rHrErVrr\r6r2rs ` @r7_eval_as_leading_termFunction._eval_as_leading_termst -9=CA!!!$!/C !QK CdC C C&9DIIEG GK'DsA0r=rztype[AppliedUndef]rrr)r)r>r?r@rArOrrr rrrrrr.r8r?rHrL__annotations__rIrWror3rrBrrs@r7rr~s7r / /  :++.6@*D > A48N07 : : 8j(X;0r9rc,\rSrSrSr\SSj5rSrg)DefinedFunctioni2z;Base class for defined functions like ``sin``, ``cos``, ...c&UR"U0UD6$rV)rrs r7rDefinedFunction.__new__5syy$*'**r9r=Nr)r>r?r@rArOr rrBr=r9r7rr2sE + +r9rcV^\rSrSr%SrSrS\S'S U4SjjrSr\ S5r S r U=r $) ri:zU Base class for expressions resulting from the application of an undefined function. Fr~rcB>[[[U55nUVs/sH&n[U[5(dMUR PM( nnU(a1[ SS[U5S:-<SSRU5<35e[TU]("U/UQ70UD6nU$s snf)Nz@Invalid argument: expecting an expression, not UndefinedFunctionrrz: , ) rgrerrrrrrfjoinrr)rir2rr6urrs r7rAppliedUndef.__new__DsS$'(! FTZ3D%EVQVVT F SVaZ $))A,01 1GOC:$:': Gs BBcU$rVr=)rHrErVrs r7r"AppliedUndef._eval_as_leading_termMs r9cg)z Allow derivatives wrt to undefined functions. Examples ======== >>> from sympy import Function, Symbol >>> f = Function('f') >>> x = Symbol('x') >>> f(x)._diff_wrt True >>> f(x).diff(x) Derivative(f(x), x) Tr=rGs r7rAppliedUndef._diff_wrtPs r9r=r) r>r?r@rArO is_numberrrrrrrBrrs@r7rr:s2 I Ir9rc\rSrSrSrSrSrg)UndefSageHelpericz' Helper to facilitate Sage conversion. c^^^^SSKJm TcUU4Sj$TRVs/sHo3R5PM snmUUU4Sj$s snf)Nrc:>TRTR5$rV)functionr>)sagetypsr7rZ)UndefSageHelper.__get__..js4==6r9cT>TRTRR5"T6$rV)rrr>)r2insrsr7rZrmsDMM#--*@*@A4Hr9)sage.allallr2_sage_)rHrrrr2rs `` @@r7__get__UndefSageHelper.__get__gs8 ;6 6,/HH5HSJJLH5DH H6sAr=N)r>r?r@rArOrrBr=r9r7rrcs Ir9rc^\rSrSr%SrS\S'S\S'\4S4SU4SjjjrS r0r S \S 'S r S r Sr \ S5rSrU=r$)rirz) The (meta)class of undefined functions. r~rrrNc >SSKJn U"U5upd[U[5(aUR U5nUR nO\[U[ 5(d [S5eURSS5n[U40UD6RnUcURS5 U=(d 0nURUR5VV s0sH upSU-U _M sn n5 URU5 URU5 URSU05 SUS'[T U]9XX#5n Xl[U lU $s sn nf)Nr)_filter_assumptionsz#expecting string or Symbol for name commutativezis_%s_kwargsr?)rjrrSymbol_mergerr~rrz assumptions0rxupdaterarr_undef_sage_helperr) mclrbasesryrr assumptionsrkr-rrs r7rUndefinedFunction.__new__ys/2&9 dF # #++k2K99DD#&&AB B%//->K 55BBK" .>rK4E4E4GH4GDA1a4GHI  k"F+,!%goc9'  Is E c2U[U5R;$rV)rr{)riinstances r7__instancecheck__#UndefinedFunction.__instancecheck__sd8n,,,,r9zdict[str, bool | None]rcz[UR5[URR 5545$rV)rr frozensetrrarGs r7__hash__UndefinedFunction.__hash__s+T^^%y1C1C1E'FGHHr9c[XR5=(aA UR5UR5:H=(a URUR:H$rV)rrrrrHothers r7__eq__UndefinedFunction.__eq__sC5..1* NN  1 1* LLEMM ) +r9c X:X+$rVr=rs r7__ne__UndefinedFunction.__ne__s   r9cgrr=rGs r7rUndefinedFunction._diff_wrtrr9r=r)r>r?r@rArOrrrrrrrrrrrBrrs@r7rrrs] I ".4B-')G #(I+ !r9rc>[URUR44$rV)_rebuild_undefrr)fs r7 _reduce_undefrs QVVQYY/ 00r9c[U40UD6$rV)r)rrs r7rrs D #F ##r9cB\rSrSr%Sr\"5rS\S'SrS Sjr Sr g) WildFunctionia A WildFunction function matches any function (with its arguments). Examples ======== >>> from sympy import WildFunction, Function, cos >>> from sympy.abc import x, y >>> F = WildFunction('F') >>> f = Function('f') >>> F.nargs Naturals0 >>> x.match(F) >>> F.match(F) {F_: F_} >>> f(x).match(F) {F_: f(x)} >>> cos(x).match(F) {F_: cos(x)} >>> f(x, y).match(F) {F_: f(x, y)} To match functions with a given number of arguments, set ``nargs`` to the desired value at instantiation: >>> F = WildFunction('F', nargs=2) >>> F.nargs {2} >>> f(x).match(F) >>> f(x, y).match(F) {F_: f(x, y)} To match functions with a range of arguments, set ``nargs`` to a tuple containing the desired number of arguments, e.g. if ``nargs = (1, 2)`` then functions with 1 or 2 arguments will be matched. >>> F = WildFunction('F', nargs=(1, 2)) >>> F.nargs {1, 2} >>> f(x).match(F) {F_: f(x)} >>> f(x, y).match(F) {F_: f(x, y)} >>> f(x, y, 1).match(F) zset[Any]includec SSKJnJn XlUR S[ R 5n[XS5(dB[U5(a[[[U555nOUb [U54nU"U6nXPl g)Nr)Setrrt)rrrrrxrrrr'rgr rr+rt)rirrrrrts r7rWildFunction.__init__sh25%%%5!!gc%j12"(u%E r9Nc[U[[45(dg[UR5UR ;agUc0nOUR 5nXU'U$rV)rrrrfr2rtcopy)rHrv repl_dictrs r7matchesWildFunction.matchessR$x 899 tyy> +  I!(I$r9r=r) r>r?r@rArOrrrrrrBr=r9r7rrs -`GX  r9rc<\rSrSrSrSr\S5rSr\S5r \ S5r Sr S r S r\"S \5S 5r\S 5r\S5r\S5r\S5r\S5r\S5r\S5rSrSSjrSSjrSrSSjr\ S5r\ S5rSr g)ria@ Carries out differentiation of the given expression with respect to symbols. Examples ======== >>> from sympy import Derivative, Function, symbols, Subs >>> from sympy.abc import x, y >>> f, g = symbols('f g', cls=Function) >>> Derivative(x**2, x, evaluate=True) 2*x Denesting of derivatives retains the ordering of variables: >>> Derivative(Derivative(f(x, y), y), x) Derivative(f(x, y), y, x) Contiguously identical symbols are merged into a tuple giving the symbol and the count: >>> Derivative(f(x), x, x, y, x) Derivative(f(x), (x, 2), y, x) If the derivative cannot be performed, and evaluate is True, the order of the variables of differentiation will be made canonical: >>> Derivative(f(x, y), y, x, evaluate=True) Derivative(f(x, y), x, y) Derivatives with respect to undefined functions can be calculated: >>> Derivative(f(x)**2, f(x), evaluate=True) 2*f(x) Such derivatives will show up when the chain rule is used to evaluate a derivative: >>> f(g(x)).diff(x) Derivative(f(g(x)), g(x))*Derivative(g(x), x) Substitution is used to represent derivatives of functions with arguments that are not symbols or functions: >>> f(2*x + 3).diff(x) == 2*Subs(f(y).diff(y), y, 2*x + 3) True Notes ===== Simplification of high-order derivatives: Because there can be a significant amount of simplification that can be done when multiple differentiations are performed, results will be automatically simplified in a fairly conservative fashion unless the keyword ``simplify`` is set to False. >>> from sympy import sqrt, diff, Function, symbols >>> from sympy.abc import x, y, z >>> f, g = symbols('f,g', cls=Function) >>> e = sqrt((x + 1)**2 + x) >>> diff(e, (x, 5), simplify=False).count_ops() 136 >>> diff(e, (x, 5)).count_ops() 30 Ordering of variables: If evaluate is set to True and the expression cannot be evaluated, the list of differentiation symbols will be sorted, that is, the expression is assumed to have continuous derivatives up to the order asked. Derivative wrt non-Symbols: For the most part, one may not differentiate wrt non-symbols. For example, we do not allow differentiation wrt `x*y` because there are multiple ways of structurally defining where x*y appears in an expression: a very strict definition would make (x*y*z).diff(x*y) == 0. Derivatives wrt defined functions (like cos(x)) are not allowed, either: >>> (x*y*z).diff(x*y) Traceback (most recent call last): ... ValueError: Can't calculate derivative wrt x*y. To make it easier to work with variational calculus, however, derivatives wrt AppliedUndef and Derivatives are allowed. For example, in the Euler-Lagrange method one may write F(t, u, v) where u = f(t) and v = f'(t). These variables can be written explicitly as functions of time:: >>> from sympy.abc import t >>> F = Function('F') >>> U = f(t) >>> V = U.diff(t) The derivative wrt f(t) can be obtained directly: >>> direct = F(t, U, V).diff(U) When differentiation wrt a non-Symbol is attempted, the non-Symbol is temporarily converted to a Symbol while the differentiation is performed and the same answer is obtained: >>> indirect = F(t, U, V).subs(U, x).diff(x).subs(x, U) >>> assert direct == indirect The implication of this non-symbol replacement is that all functions are treated as independent of other functions and the symbols are independent of the functions that contain them:: >>> x.diff(f(x)) 0 >>> g(x).diff(f(x)) 0 It also means that derivatives are assumed to depend only on the variables of differentiation, not on anything contained within the expression being differentiated:: >>> F = f(x) >>> Fx = F.diff(x) >>> Fx.diff(F) # derivative depends on x, not F 0 >>> Fxx = Fx.diff(x) >>> Fxx.diff(Fx) # derivative depends on x, not Fx 0 The last example can be made explicit by showing the replacement of Fx in Fxx with y: >>> Fxx.subs(Fx, y) Derivative(y, x) Since that in itself will evaluate to zero, differentiating wrt Fx will also be zero: >>> _.doit() 0 Replacing undefined functions with concrete expressions One must be careful to replace undefined functions with expressions that contain variables consistent with the function definition and the variables of differentiation or else insconsistent result will be obtained. Consider the following example: >>> eq = f(x)*g(y) >>> eq.subs(f(x), x*y).diff(x, y).doit() y*Derivative(g(y), y) + g(y) >>> eq.diff(x, y).subs(f(x), x*y).doit() y*Derivative(g(y), y) The results differ because `f(x)` was replaced with an expression that involved both variables of differentiation. In the abstract case, differentiation of `f(x)` by `y` is 0; in the concrete case, the presence of `y` made that derivative nonvanishing and produced the extra `g(y)` term. Defining differentiation for an object An object must define ._eval_derivative(symbol) method that returns the differentiation result. This function only needs to consider the non-trivial case where expr contains symbol and it should call the diff() method internally (not _eval_derivative); Derivative should be the only one to call _eval_derivative. Any class can allow derivatives to be taken with respect to itself (while indicating its scalar nature). See the docstring of Expr._diff_wrt. See Also ======== _sort_variable_count TcxURR=(a [UR5[5$)aAn expression may be differentiated wrt a Derivative if it is in elementary form. Examples ======== >>> from sympy import Function, Derivative, cos >>> from sympy.abc import x >>> f = Function('f') >>> Derivative(f(x), x)._diff_wrt True >>> Derivative(cos(x), x)._diff_wrt False >>> Derivative(x + 1, x)._diff_wrt False A Derivative might be an unevaluated form of what will not be a valid variable of differentiation if evaluated. For example, >>> Derivative(f(f(x)), x).doit() Derivative(f(x), x)*Derivative(f(f(x)), f(x)) Such an expression will present the same ambiguities as arise when dealing with any other product, like ``2*x``, so ``_diff_wrt`` is False: >>> Derivative(f(f(x)), x)._diff_wrt False )rvrrdoitrrGs r7rDerivative._diff_wrts'@yy""Jz$))+z'JJr9c [U5n[U[5(d[S[ U535e[ USS5n[U[ 5nU(d[[SU-55eU(dyURn[U5S:wa^UR(a[R$[U5S:Xa[[SU-55e[[SU-55e/n[[[ 4nSSKJnJn [)U5GHUup[U [*5(a[S U -5e[X5(aw[U 5S:XaMJ[U SU5(a*[U 5S:XaU"U S5n Sn OU upU"U 5n OU upU S:XaMUR-[!X55 M[U 5n [U [.5(aiU S:Xa[S U -5eU n US upUS:wa[S R1X4U 55eU S:XaUR35 GM([!X5US 'GM9Sn UR-[!X55 GMX /nUH}nUun nUR4(a [S 5eU(aAUS SU :Xa5UUS S- nU(dUR35 M[[!U U5US 'MlUR-U5 M UnUH5un nU R6(aMSn[[SU <SU<355e [U5S:XaU$UR9SS5nU(GaZ[U[:5(a UR<nUV Vs/sH+un n[U [:5(a U R<OU U4PM- nn nSnURnSSKJ n UHun nU RnURB(dM%U(dM.[U [D5(a7[G5nURIU U05RKU5(dSn OHMz[U U5(aSn O1[U [L5(a U U;aSn OUU-(aMSn O U(aUROU5$URQU5n[U[:5(a3[URR5U-nURTn[WU/UQ70UD6$U(a[YUS5(dGU(a)XaS4/:Xa!URZ(a[R\$[^R`"X/UQ76$Sn/nSSK1J2n [)U5GH-un upUnSnU Rf=(d [U [h[ UU 45nU(dU n[GS5n URIUU 05n[U[:[D45(+nXR;aU(dURkU 5s $URZ(d%[YUS5(dUURkU5-nURmXU 5n U bU Rn(aU s $UU - nUbU bU RqU U5n UnU cXjSn OU nGM0 URsSS5nU(aP[U[:5(a$[URR5U-nURTn[^R`"X/UQ76nUS:S:Xa1UR9SS5(aSSK:J;n! SSK.s jJ/r9cUR$rV) canonicalrs r7rZr sakkr9simplify) factor_terms)signsimp)>rrrrrr]rr}r,rrfrrrxrgrr sympy.tensor.arrayrrrrr4rformatrx is_negativerrzrr "sympy.matrices.expressions.matexprr is_positiverrqrrDr_get_zero_with_shape_like_sort_variable_countvariable_countrvrr| is_scalarrzrrsympy.matrices.matrixbaser is_symbolrr1!_dispatch_eval_derivative_n_timesr2rJreplace exprtoolsr sympy.simplify.simplifyr)#rirv variablesrsymbols_or_nonehas_symbol_setr array_likesrrrr-countprev prevcountmergedr_rg__rzerofreervfreernderivs unhandledrold_exprold_vrclashingrr rs# r7rDerivative.__new__st}$&&=d4j\JK K!$=#OS9Z)026)789 9 ))I9~">>66My>Q&$Z1/2616&788 %Z1@CG1G&HIIdE* 7i(DA!.//,./011!))q6Q;adK001v{!!A$K !#$!!H HAA:%%eAo6 A!W%%6$%Lq%PQQ"0"4>#$D$K$KTL]_`$abbA:"&&().t);N2&%%eAo6O)VADAq}} BDD&*Q-1,VBZ]"JJL!&q!F2J a    #DAq;;; ?@-" # ~ ! #K::j%0 $ ++~~+,*DAq!+1j 9 9q!D* ,D$$D E&1===UU!!\22"G#}}aV488;;#'D! <$Az22$#Av..1D=##e||#'D!+',44T::!55nEN dJ ' '!$"5"56GN99D'H~HH Hwt-?@@Nayk9dnnuu <<;N; ;  8&~6MAzHE :z!5*i8(:I$K}}eQZ0!+5:|2L MN---h99Q<'w10303 EJJu--D77GC3;; u G ?((1e,C{ +2. D]7b|| / !# $ ++ !4!45 A yy<<6I6D aKD VZZ D%A%A / 8/D ,s2]cvUR"UR/[RUR5Q76$rV)rrvrrrrs r7r Derivative.canonicals5xxB  , ,S-?-? @B Br9cR^^ ^ ^ ^ T(d/$[T5m[T5S:Xa [TS6/$[[[T555n/nU4Sjm [ 5m SU U 4Sjjm [[T55HCn[U5H1nT "T "U5T "U55(dMUR XT45 M3 ME [ [[[TVVs/sHupFUPM snn55[[T5555m [X#4U U 4SjS9n/nUVs/sHnTUPM snH>um nU(aUSST :XaUSS==U- ss'M+UR T U/5 M@ UVs/sH n[U6PM sn$s snnfs snfs snf) a  Sort (variable, count) pairs into canonical order while retaining order of variables that do not commute during differentiation: * symbols and functions commute with each other * derivatives commute with each other * a derivative does not commute with anything it contains * any other object is not allowed to commute if it has free symbols in common with another object Examples ======== >>> from sympy import Derivative, Function, symbols >>> vsort = Derivative._sort_variable_count >>> x, y, z = symbols('x y z') >>> f, g, h = symbols('f g h', cls=Function) Contiguous items are collapsed into one pair: >>> vsort([(x, 1), (x, 1)]) [(x, 2)] >>> vsort([(y, 1), (f(x), 1), (y, 1), (f(x), 1)]) [(y, 2), (f(x), 2)] Ordering is canonical. >>> def vsort0(*v): ... # docstring helper to ... # change vi -> (vi, 0), sort, and return vi vals ... return [i[0] for i in vsort([(i, 0) for i in v])] >>> vsort0(y, x) [x, y] >>> vsort0(g(y), g(x), f(y)) [f(y), g(x), g(y)] Symbols are sorted as far to the left as possible but never move to the left of a derivative having the same symbol in its variables; the same applies to AppliedUndef which are always sorted after Symbols: >>> dfx = f(x).diff(x) >>> assert vsort0(dfx, y) == [y, dfx] >>> assert vsort0(dfx, x) == [dfx, x] rrc>TUS$Nrr=)rvcs r7rZ1Derivative._sort_variable_count.. s beAhr9c>^UT:XaU$UR(ag[U[5(a'[UU4SjUR55(aggU(d[U[ 5(agTR(aTUR ;$[T[ 5(aT"URTT05T5$UR TR -$)NFc34># UH nT"UTSS9v M g7f)T)wrtNr=)r#r_blockr-s r7r$BDerivative._sort_variable_count.._block..-s!3!1Aa-!1r&T)rrrr(_wrt_variablesrrr)dr-r9rr:s ` r7r:/Derivative._sort_variable_count.._block"sAv {{!Z(( 3!"!1!1333:a66{{ANN**!\**ajj!Q0!44>>ANN2 2r9c>TT"U5$rVr=)rOr-s r7rZr6>s AadGr9keyrF) rrfr rhrqr4dictrpr r(r)) rir5VErjrgrr%rr@r:r-s ` @@@@r7rDerivative._sort_variable_countslbI "X r7a<2a5M? " s2w    G 3 3,s2wA1X!A$!%%HHaUO WT"41"456c"gG H qf*; <$&'BqRUB'DAq&*Q-1,r 1 "  q!f% ( $**6aq 6**#5( +s!F,FF$c.URR$rVrvr<rGs r7r?Derivative._eval_is_commutativeHyy'''r9cXR;aURRU5n[U[5(a4UR "UR/UR UR -Q76$UR "U/URQ7SS06$[UR 5nURUS45 UR "UR/UQ7SS06$)NrTrF) r<rvr1rrrrrrr4)rHr-dedvrs r7r8Derivative._eval_derivativeKs '' '99>>!$D$ ++yyYd.A.ADDWDW.WYY 99TBDNNBTB Bd112q!f%yyD^DeDDr9c URnURSS5(aUR"S0UD6nSUS'UR"U/URQ70UD6nX0:wa,UR [ 5(aUR"S0UD6nU$)NdeepTrr=)rvrzrrrrDr)rHhintsrvrvs r7rDerivative.doit_s~yy 99VT " "99%u%D j YYt ;d11 ;U ; 9 ++''"E"B r9z0c^^[TR5S:wd[TR5S:wa [S5e[ TR5SmUU4Sjn[ R "[R"UUR[RR55[RR5$)z Evaluate the derivative at z numerically. When we can represent derivatives at a point, this should be folded into the normal evalf. For now, we need a special method. rz%partials and higher order derivativesrcH>TRRT[R"U[R R S95nUR[[R R 55nUR[R R 5$)N)r+) rvrJrr*rmpr+rr.r')rEf0rHrs r7rT)Derivative.doit_numerically..evalus^4#4#4QVYY^^#LMB+fiinn56B==0 0r9) rfrrrrrrr*rr1r'rXr+)rHrUrTrs` @r7doit_numericallyDerivative.doit_numericallyis t  !Q &#dnn*=*B%&MN N "" #A & 1  T-/]]699>>-J"L!'1 1r9c URS$r4_argsrGs r7rvDerivative.expr}szz!}r9cJURVs/sHoSPM sn$s snfr4)r)rHrs r7r<Derivative._wrt_variabless&#1121!1222s c/nURH?up#UR(d[[S55eUR U/U-5 MA [ U5$)Nz Cannot give expansion for symbolic count. If you just want a list of all variables of differentiation, use _wrt_variables.)r is_Integerrr,extendrg)rHrSr-r"s r7rDerivative.variabless] ++HA## ,#!$%% IIqc%i ,Ryr9c URSS$)Nrr^rGs r7rDerivative.variable_countszz!"~r9cd[URVVs/sHupUPM snnS5$s snnfr4)sumr)rHrkr"s r7derivative_countDerivative.derivative_counts+$*=*=>*=haE*=>BB>s, cURRnURH up#URUR5 M" U$rV)rvrrr)rHretrkr"s r7rDerivative.free_symbolss:ii$$++HA JJu)) *, r9c4URSR$r4)r2rbrGs r7rbDerivative.kindsyy|   r9c LXR;aUR"UR/URVVs/sHup4X4R X54PM snnQ76nXP:waUR X5$[ USS5(dH[U[5(a [XU5$[S5n[URX05Xb5$UR(aURUR:XaURUR:XaU$Sn[[[!UR555n[[[!UR555n U"X5(a&[#U/X- R%5Q76R$['UR(5n U V s/sHoR+X5PM n n U SU:Xa[#U 6$U SU S:waURV s0sH!n U R,(aMU [5_M# nn URV s1sHoR/X5iM nn U SRU5R0U-nURU5R0nURU5R0nUU- U-(a [XU5$S[3U SSU SS55n[5SU55(Ga[7URS S 9HJn[9S[;U 55H.nU Uun nUU :XdMXUS:wdM [XU5s s $ ML U SSnURnURn/n[=U5HYunun nU R>(aM[S U-5nURUUU05nUU4UU'URAXm45 M[ U(a-UR+X5n[[CU/UQ76/[3U6Q76$[#U 6$s snnfs sn fs sn fs sn f) NrFrhc2^^[UU4SjT55$)Nc3@># UHnTUTU:*S:Hv M g7f)TNr=)r#rr6bs r7r$9Derivative._eval_subs.._subset..s"=1aAaDAaDLT11s)r)r6rus``r7_subset&Derivative._eval_subs.._subsets=1===r9rc36# UHuupup2X4v M g7frVr=)r#rrkrGs r7r$(Derivative._eval_subs..sK0J,VaVa!0Jsrc3.# UH upX:gv M g7frVr=)r#rrGs r7r$rzs(%$!qv%sT) recursiver)"r<rrvrrJrr]rrrrqr is_Derivativer r/rDreversedrrarr2rrrzrrpr(r rhrfrrr4r)rHrrr-rgrvrhrwold_vars self_varsr2rEnewargsvisymsr9 forbiddennfreeofreeviterr6rrkr5oldvnewerJcis r7rDerivative._eval_subss %% %99TYY2 //*1/DA,-ffS.>*?/*12D|s003 U33c6**3//tB si 8"BB   TYY!6~~.  >tHS-?-?$@ABHXd.A.A%B CDIx+++CQ93G2N2N2PQ[[[DII.23d773$d3 7c>(1 1 1:a +/*=*=%*=B|| BK*=D%.2.A.AB.A88B#.ACBQ((.;;cAILL&33ELL&33E *Ds++KGABKab0JK (%( ( ( TYY$7q#g,/A#AJEBBw2a#3#Ds3308 B&&D99DD(} 8B|||w{+B ==$q'27DHBqEKK) -zz#+Jt1b1?CJ??$W--w*1>4%BsP 0P7PP/P!c## URnURRXUS9HnUR"U/UQ76v M g7f)N)rVr)rrvlseriesr)rHrErVrdxrs r7 _eval_lseriesDerivative._eval_lseries s@ ^^II%%a%>D))D&2& &?sAAcDURRXUS9nUR5nURn[R "UR 55Vs/sHoR"U/UQ76PM n nU(aU RXa- 5 [ U 6$s snf)Nri) rvr{rsrr make_argsrtrr4) rHrErrVrrrrr6rSs r7roDerivative._eval_nseriessiiT2 HHJ ^^),s{{})E F)EAiiB)E F IIacNBxGsBcURRU5n[RnUH"n[ U/UR Q76nUS:wdM! U$ U$r4)rvrrrxr1r)rHrErVr series_genr= leading_terms r7r Derivative._eval_as_leading_termsRYY&&q) FF&L\3DNN3AAv 'r9Nc SSKJn U"XX#5$)a Expresses a Derivative instance as a finite difference. Parameters ========== points : sequence or coefficient, optional If sequence: discrete values (length >= order+1) of the independent variable used for generating the finite difference weights. If it is a coefficient, it will be used as the step-size for generating an equidistant sequence of length order+1 centered around ``x0``. Default: 1 (step-size 1) x0 : number or Symbol, optional the value of the independent variable (``wrt``) at which the derivative is to be approximated. Default: same as ``wrt``. wrt : Symbol, optional "with respect to" the variable for which the (partial) derivative is to be approximated for. If not provided it is required that the derivative is ordinary. Default: ``None``. Examples ======== >>> from sympy import symbols, Function, exp, sqrt, Symbol >>> x, h = symbols('x h') >>> f = Function('f') >>> f(x).diff(x).as_finite_difference() -f(x - 1/2) + f(x + 1/2) The default step size and number of points are 1 and ``order + 1`` respectively. We can change the step size by passing a symbol as a parameter: >>> f(x).diff(x).as_finite_difference(h) -f(-h/2 + x)/h + f(h/2 + x)/h We can also specify the discretized values to be used in a sequence: >>> f(x).diff(x).as_finite_difference([x, x+h, x+2*h]) -3*f(x)/(2*h) + 2*f(h + x)/h - f(2*h + x)/(2*h) The algorithm is not restricted to use equidistant spacing, nor do we need to make the approximation around ``x0``, but we can get an expression estimating the derivative at an offset: >>> e, sq2 = exp(1), sqrt(2) >>> xl = [x-h, x+h, x+e*h] >>> f(x).diff(x, 1).as_finite_difference(xl, x+h*sq2) # doctest: +ELLIPSIS 2*h*((h + sqrt(2)*h)/(2*h) - (-sqrt(2)*h + h)/(2*h))*f(E*h + x)/... To approximate ``Derivative`` around ``x0`` using a non-equidistant spacing step, the algorithm supports assignment of undefined functions to ``points``: >>> dx = Function('dx') >>> f(x).diff(x).as_finite_difference(points=dx(x), x0=x-h) -f(-h + x - dx(-h + x)/2)/dx(-h + x) + f(-h + x + dx(-h + x)/2)/dx(-h + x) Partial derivatives are also supported: >>> y = Symbol('y') >>> d2fdxdy=f(x,y).diff(x,y) >>> d2fdxdy.as_finite_difference(wrt=x) -Derivative(f(x - 1/2, y), y) + Derivative(f(x + 1/2, y), y) We can apply ``as_finite_difference`` to ``Derivative`` instances in compound expressions using ``replace``: >>> (1 + 42**f(x).diff(x)).replace(lambda arg: arg.is_Derivative, ... lambda arg: arg.as_finite_difference()) 42**(-f(x - 1/2) + f(x + 1/2)) + 1 See also ======== sympy.calculus.finite_diff.apply_finite_diff sympy.calculus.finite_diff.differentiate_finite sympy.calculus.finite_diff.finite_diff_weights r)_as_finite_diff)sympy.calculus.finite_diffr)rHpointsx0r9rs r7as_finite_differenceDerivative.as_finite_difference$sl ?tR55r9c"[R$rV)rrx)rirvs r7r$Derivative._get_zero_with_shape_like}s vv r9c$URX#5$rV)_eval_derivative_n_times)rirvr-r"s r7r,Derivative._dispatch_eval_derivative_n_timess ,,Q66r9r=r)rNN)!r>r?r@rArOr}rrrr rrr?r8rr rrr[rvr<rrrkrrbrrrorrrrrBr=r9r7rrsXpdM KKBunBB]+]+~(E()*1+1&33   CC!!a.F' W6r77r9rc^SSKJn SSKJn SSKJn X4U[ [[4m[UT5(d[U4SjU55(aSSK J n U"U/UQ70UD6$[U/UQ70UD6$)Nrrr)rc3># UH@n[U[[[45(a[UST5O [UT5v MB g7frN)rrgrr )r#r array_typess r7r$'_derivative_dispatch..sg,e[dVWZXY\acgin[oMpMpJqt[,IwABCEPwQ-Q[dsAA )ArrayDerivative)rrrrrrrrgr rr($sympy.tensor.array.array_derivativesrr)rvrrrrrrrs @r7rrsw4=,9dE5IK$ $$,e[d,e)e)eHt:i:6:: d 1Y 1& 11r9c\rSrSrSrSrSSjr\S5r\ S5r \ S5r \ S5r \ S 5r \ r\ S 5rS rS r\ S 5rSrSrg)Lambdaia~ Lambda(x, expr) represents a lambda function similar to Python's 'lambda x: expr'. A function of several variables is written as Lambda((x, y, ...), expr). Examples ======== A simple example: >>> from sympy import Lambda >>> from sympy.abc import x >>> f = Lambda(x, x**2) >>> f(4) 16 For multivariate functions, use: >>> from sympy.abc import y, z, t >>> f2 = Lambda((x, y, z, t), x + y**z + t**z) >>> f2(1, 2, 3, 4) 73 It is also possible to unpack tuple arguments: >>> f = Lambda(((x, y), z), x + y + z) >>> f((1, 2), 3) 6 A handy shortcut for lots of arguments: >>> p = x, y, z >>> f = Lambda(p, x + y*z) >>> f(*p) x + y*z Tcv[U5(a1[U[[45(d[ SSSS9 [U5n[U5(aUOU4n[ U5nUR U5 [U5S:XaUSU:Xa[R$[R"X[ U55$)Nz Using a non-tuple iterable as the first argument to Lambda is deprecated. Use Lambda(tuple(args), expr) instead. z1.5zdeprecated-non-tuple-lambdadeprecated_since_versionactive_deprecations_targetrr) r&rrgr r!r_check_signaturerfrIdentityFunctionrr)rir_rv_sigsigs r7rLambda.__new__s I  z)eU^'L'L %*/+H  i(I$Y//yi\T] S! s8q=SVt^%% %||Cgdm44r9c^^[5mUU4Sjm[U[5(d[SU-5eT"U5 g)Nc>UHfnUR(a'UT;a[SU-5eTRU5 M;[U[5(a T"U5 MZ[SU-5e g)NzDuplicate symbol %sz:Lambda signature should be only tuples and symbols, not %s)rrLaddrr )r2r6rcheckrs r7r'Lambda._check_signature..rcheckse;;Dy/0E0IJJHHQK5))1I+-/12-344r9z)Lambda signature should be a tuple not %s)rrr rL)rirrrs @@r7rLambda._check_signatures7u 4#u%%#$ORU$UV Vs r9c URS$)z@The expected form of the arguments to be unpacked into variablesrr^rGs r7r_Lambda.signaturezz!}r9c URS$)z The return value of the functionrr^rGs r7rv Lambda.exprrr9cF^U4Sjm[T"UR55$)zAThe variables used in the internal representation of the functionc3x># [U[5(aUHnT"U5ShvN M gUv gN7frV)rr )r2r _variabless r7r$Lambda.variables.._variabless6$&&C)#..  /s &:8:)rgr_)rHrs @r7rLambda.variabless  Z/00r9cDSSKJn U"[UR55$)Nrr)rrrfr_rs r7rt Lambda.nargss-T^^,--r9cZURR[UR5- $rV)rvrrrrGs r7rLambda.free_symbolss yy%%DNN(;;;r9c 2[U5nX R;aGSn[UU[UR5SS[UR5SS:g-US.-5eUR UR U5nUR RU5$)NzD%(name)s takes exactly %(args)s argument%(plural)s (%(given)s given)rrr)rr2rr)rfrtrQr_match_signaturer_rvr)rHr2rrr=s r7__call__Lambda.__call__s I JJ :D#DTZZ(+tDJJ/2a78 ,%   ! !$..$ 7yy!!!$$r9c,^^0mUU4SjmT"X5 T$)Nc(>[X5Hup#UR(aUTU'M[U[5(dM4[U[[45(a[ U5[ U5:wa[ SU<SU<35eT"X#5 M g)Nz Can't match z and )rprrr rgrfrQ)parsr2parrrmatch symargmaps r7r'Lambda._match_signature..rmatchsiO==%(IcNU++%cE5>::c$i3t9>T/4QU0VWW3$ ,r9r=)rHrr2rrs @@r7rLambda._match_signatures  % sr9c4URUR:H$)zr?r@rArOrrrrrr_rvrrt bound_symbolsrrrrr.rBr=r9r7rrs$JK5((11..M <<%*"++Pr9rc^\rSrSrSrSrSrSrSSjr\r \ S5r \ r \ S5r \ S 5r\ S 5r\ S 5rS rS rU4SjrSrSrSrSSjrSrSrU=r$)ri5a Represents unevaluated substitutions of an expression. ``Subs(expr, x, x0)`` represents the expression resulting from substituting x with x0 in expr. Parameters ========== expr : Expr An expression. x : tuple, variable A variable or list of distinct variables. x0 : tuple or list of tuples A point or list of evaluation points corresponding to those variables. Examples ======== >>> from sympy import Subs, Function, sin, cos >>> from sympy.abc import x, y, z >>> f = Function('f') Subs are created when a particular substitution cannot be made. The x in the derivative cannot be replaced with 0 because 0 is not a valid variables of differentiation: >>> f(x).diff(x).subs(x, 0) Subs(Derivative(f(x), x), x, 0) Once f is known, the derivative and evaluation at 0 can be done: >>> _.subs(f, sin).doit() == sin(x).diff(x).subs(x, 0) == cos(0) True Subs can also be created directly with one or more variables: >>> Subs(f(x)*sin(y) + z, (x, y), (0, 1)) Subs(z + f(x)*sin(y), (x, y), (0, 1)) >>> _.doit() z + f(0)*sin(1) Notes ===== ``Subs`` objects are generally useful to represent unevaluated derivatives calculated at a point. The variables may be expressions, but they are subjected to the limitations of subs(), so it is usually a good practice to use only symbols for variables, since in that case there can be no ambiguity. There's no automatic expansion - use the method .doit() to effect all possible substitutions of the object and also of objects inside the expression. When evaluating derivatives at a point that is not a symbol, a Subs object is returned. One is also able to calculate derivatives of Subs objects - in this case the expression is always expanded (for the unevaluated form, use Derivative()). In order to allow expressions to combine before doit is done, a representation of the Subs expression is used internally to make expressions that are superficially different compare the same: >>> a, b = Subs(x, x, 0), Subs(y, y, 0) >>> a + b 2*Subs(x, x, 0) This can lead to unexpected consequences when using methods like `has` that are cached: >>> s = Subs(x, x, 0) >>> s.has(x), s.has(y) (True, False) >>> ss = s.subs(x, y) >>> ss.has(x), ss.has(y) (True, False) >>> s, ss (Subs(x, x, 0), Subs(y, y, 0)) c Z^^^^^^[T[5(dT/m[T6m[T5(af[T5R 5VVs/sHupVUS:dM [ U5PM nnnSR U5n[[SU-55e[[T[5(aTOT/6m[T5[T5:wa [S5eT(d [T5$[T[5(a+TRT-mTRT-mTRmO [T5mSm[![#T5[$S9n SSKJn "S S U 5mU4S jmU V s0sHo[+TT"U 5-5_M n n [-TT5VV s/sH up[X\U 4PM n nn [/UUUUU4S jU 55(aTS- mMn[0R2"UT[T6T5nTR5[7U 55UlU$s snnfs sn fs sn nf) NrrzU The following expressions appear more than once: %s zCNumber of point values must be the same as the number of variables.rkrAr) StrPrinterc\rSrSrSrSrg)&Subs.__new__..CustomStrPrintericD[U5[UR5-$rV)r~r)rHrvs r7 _print_Dummy3Subs.__new__..CustomStrPrinter._print_Dummys4y3t'7'7#888r9r=N)r>r?r@rArrBr=r9r7CustomStrPrinterrs 9r9rc6>T"U5nURU5$rV)doprint)rvsettingsrYrs r7mystrSubs.__new__..mystrs *A99T? "r9c 3># UHRupUTR;=(a5 UT;=(a) [TT"TTRU55-5U:gv MT g7frV)rrindex)r#rkrrvrpointprers r7r$Subs.__new__..sg% $tq)))G >G#eIOOA,>&? @@AQFG $sAA)r'r r$r/rar~rr}r,rfrrrrrrvsortedrrsympy.printing.strrrrpr(rrrrD_expr)rirvrrrr-rrepeatedr&ptsrrYs_ptsrepsrrrrs ``` @@@r7r Subs.__new__s9e,," I9% I  +29+=+C+C+EO+E41QA+EHO8$BZ)) UE!:!:I u:Y '89 94=  dD ! !2IJJ&E99D4=DSZ%561 9z 9 #8;<1sU1X~..E< 5131DAaM1 3%% $%%%s  ll3eY&7?MM$t*-  mPF=3s H#H2H"!H'c.URR$rVrJrGs r7r?Subs._eval_is_commutativerLr9c URup#n[[X455H)unupgXg:XdMUSUX5S-S-nUSUXES-S-nM+ U(d UR$[ U[ 5(Ga/n[U5HEupV[ U[ 5(aURXdU5nM0URXdU45 MG [ U[ 5(dUR5n[ U[ 5(Ga[/n [5n URSn UHaupgXRXj05R;a+U RU5(aURXg5nMMMOU RXg45 Mc U n/n [5n URn U RnURHwupo[ U[5(aXn;aU R!Xo45n M3XRXj5R;aU R!Xo45n MeU RXo45 My U RU5nU HnUR!U5nM OEURU5nO3UR"S0UD6R[#[X4555nUR%SS5(aUU:waUR"S0UD6nU$)NrrrQTr=)r2rrprvrrrqrJr4rrqrrrDrrr1rrz)rHrRrr-rYrrrundoneundone2rrr9rvr(rrSr5s r7r Subs.doitse))a%SY/KAxxbqEA!efI%bqEA!efI%099  a $ $F"1b-00rQ4(AMM2t*- & a,,FFH!Z((GffQi$FB B7 3 @ @@772;; !rA' x0 % !Gvv((..FB!"f--"*#yy"2ii.;;;#yy"2 B8, /YYv&BBVVF^%%%d3q9o6B 99VT " "rTz!5!B r9c DUR5R"U40UD6$rV)rr)rHr+rs r7r Subs.evalf syy{  111r9c URS$)zThe variables to be evaluatedrr^rGs r7rSubs.variables rr9c URS$)z1The expression on which the substitution operatesrr^rGs r7rv Subs.expr rr9c URS$)z8The values for which the variables are to be substitutedrwr^rGs r7r Subs.point rr9cURR[UR5- [URR5-$rV)rvrrrrrGs r7rSubs.free_symbols s9 &&T^^)<<  '' () *r9c[SSSS9 [[5 URR[ UR 5- [ URR5-sSSS5 $!,(df  g=f)Nz The expr_free_symbols property is deprecated. Use free_symbols to get the free symbols of an expression. z1.9zdeprecated-expr-free-symbolsr)r!r#r"rvexpr_free_symbolsrrrrGs r7rSubs.expr_free_symbols" sa!# &+'E  G4 5II//#dnn2EE 44566 5 5s A A11 A?cp[U[5(dgUR5UR5:H$r)rr_hashable_contentrs r7r Subs.__eq__/ s/%&&%%'5+B+B+DDDr9c X:X+$rVr=rs r7r Subs.__ne__4 s !!r9c >[TU]5$rV)rr)rHrs r7r Subs.__hash__7 sw!!r9c 0URRUR54[[ [ UR UR5VVs/sH*upURRU5(aM'X4PM, snn55-$s snnfrV) rrcanonical_variablesrgr rprrrvrD)rHr-rYs r7r Subs._hashable_content: s ##D$<$<=g  +E ++/!3799==3C &v +EFGG GEs &B=Bc^[UR5nXR;a[T5T1:Xa7[ U4SjUR 55(dUR UT05$URRU5n[U[UR55HnX5RUT5X5'M URURURU5$URVs/sHoDRUT5PM nnU[UR5:wa/URURURU4-UT/-5$URRUT5nURVs/sHoDRUT5PM nnURXvU5$s snfs snf)Nc3D># UHoRT5v M g7frVrC)r#rrs r7r$"Subs._eval_subs..F s13(11EE#JJ rG) rrrr r(r2rrrhrfrrrv)rHrrptrrGr-rvs ` r7rSubs._eval_subs? sf $**  .. s|u$S13(, 13.3.3}}c3Z00$$S)A1c$..12 C-399TYY; ;(, 71WWS#  7 T^^$ $99TYY#(?seL LyysC()- 4Aggc3 4yy"%% 85s 9F7F<c^^ ^URm URUR4=mup#[R"U UU4Sj[ X#555nT R nUVs1sH n[UR 5S:dMUiM" nnUVs1sH n[5iM nnT R[[ Xx555n U R U- n X-n U [U5-n XU-V Vs1sHoR HofiM M snn -n U TR -(aAU[T RT5URUR5R5- nU$s snfs snfs snn f)Nc3># UHBupURT5[TRU5/TQ76R5-v MD g7frV)r1rr)r#r-rYrrvps r7r$(Subs._eval_derivative..[ sB#!66!9T!&&)%9b%9%>%>%@@!sA A r)rvrrrfromiterrprrfrqrrDrrr1r)rHrrEPvalefreercompounddumsmaskedifreer(rGrrs ` @@r7r8Subs._eval_derivativeW s9 IINNDJJ..TQll#A ## %@u!ANN(;a(?Au@!)*A*DX!456##d* A 8ODOq^^^ODD !.. 4q 4>>4::>CCE EC A*Es'E1E1E66E;c XR;a+URRU5nURUnOUnURR XbUS9nUR 5n[ R"UR55n [ U V s/sH"oR"U /URSSQ76PM$ sn 6n U(aXRXa5- n U $s sn f)Nrir) rrrrvr{rsrrrtrr2rJ) rHrErrVraposrrrtermsr6rSs r7roSubs._eval_nseriesr s ?::##A&DNN4(EEii6 HHJ ckkm, ?A99Q/12/? @ &&" "B @s)CcXR;aEURRU5nURUnURR U5$XR;aU$URR U5$rV)rrrrvrn)rHrErVriposxvars r7rSubs._eval_as_leading_term sh ?::##A&D>>$'D99,,T2 2  Kyy((++r9r=rVr)r>r?r@rArOrr?rrrrrrrvrrrrrrr rr8rorrBrrs@r7rr5sSh<|(:x2 A M ** 7 7E ""G &06  , ,r9rc[US5(aUR"U0UD6$URSS5 [U/UQ70UD6$)a  Differentiate f with respect to symbols. Explanation =========== This is just a wrapper to unify .diff() and the Derivative class; its interface is similar to that of integrate(). You can use the same shortcuts for multiple variables as with Derivative. For example, diff(f(x), x, x, x) and diff(f(x), x, 3) both return the third derivative of f(x). You can pass evaluate=False to get an unevaluated Derivative class. Note that if there are 0 symbols (such as diff(f(x), x, 0), then the result will be the function (the zeroth derivative), even if evaluate=False. Examples ======== >>> from sympy import sin, cos, Function, diff >>> from sympy.abc import x, y >>> f = Function('f') >>> diff(sin(x), x) cos(x) >>> diff(f(x), x, x, x) Derivative(f(x), (x, 3)) >>> diff(f(x), x, 3) Derivative(f(x), (x, 3)) >>> diff(sin(x)*cos(y), x, 2, y, 2) sin(x)*cos(y) >>> type(diff(sin(x), x)) cos >>> type(diff(sin(x), x, evaluate=False)) >>> type(diff(sin(x), x, 0)) sin >>> type(diff(sin(x), x, 0, evaluate=False)) sin >>> diff(sin(x)) cos(x) >>> diff(sin(x*y)) Traceback (most recent call last): ... ValueError: specify differentiation variables to differentiate sin(x*y) Note that ``diff(sin(x))`` syntax is meant only for convenience in interactive sessions and should be avoided in library code. References ========== .. [1] https://reference.wolfram.com/legacy/v5_2/Built-inFunctions/AlgebraicComputation/Calculus/D.html See Also ======== Derivative idiff: computes the derivative implicitly r1rT)r|r1 setdefaultr)rsymbolsrs r7r1r1 sK@q&vvw)&)) j$'  6G 6v 66r9c  lX9S'XIS'XYS'XiS'XyS'XS'[U5R"SXS.U D6$) a:& Expand an expression using methods given as hints. Explanation =========== Hints evaluated unless explicitly set to False are: ``basic``, ``log``, ``multinomial``, ``mul``, ``power_base``, and ``power_exp`` The following hints are supported but not applied unless set to True: ``complex``, ``func``, and ``trig``. In addition, the following meta-hints are supported by some or all of the other hints: ``frac``, ``numer``, ``denom``, ``modulus``, and ``force``. ``deep`` is supported by all hints. Additionally, subclasses of Expr may define their own hints or meta-hints. The ``basic`` hint is used for any special rewriting of an object that should be done automatically (along with the other hints like ``mul``) when expand is called. This is a catch-all hint to handle any sort of expansion that may not be described by the existing hint names. To use this hint an object should override the ``_eval_expand_basic`` method. Objects may also define their own expand methods, which are not run by default. See the API section below. If ``deep`` is set to ``True`` (the default), things like arguments of functions are recursively expanded. Use ``deep=False`` to only expand on the top level. If the ``force`` hint is used, assumptions about variables will be ignored in making the expansion. Hints ===== These hints are run by default mul --- Distributes multiplication over addition: >>> from sympy import cos, exp, sin >>> from sympy.abc import x, y, z >>> (y*(x + z)).expand(mul=True) x*y + y*z multinomial ----------- Expand (x + y + ...)**n where n is a positive integer. >>> ((x + y + z)**2).expand(multinomial=True) x**2 + 2*x*y + 2*x*z + y**2 + 2*y*z + z**2 power_exp --------- Expand addition in exponents into multiplied bases. >>> exp(x + y).expand(power_exp=True) exp(x)*exp(y) >>> (2**(x + y)).expand(power_exp=True) 2**x*2**y power_base ---------- Split powers of multiplied bases. This only happens by default if assumptions allow, or if the ``force`` meta-hint is used: >>> ((x*y)**z).expand(power_base=True) (x*y)**z >>> ((x*y)**z).expand(power_base=True, force=True) x**z*y**z >>> ((2*y)**z).expand(power_base=True) 2**z*y**z Note that in some cases where this expansion always holds, SymPy performs it automatically: >>> (x*y)**2 x**2*y**2 log --- Pull out power of an argument as a coefficient and split logs products into sums of logs. Note that these only work if the arguments of the log function have the proper assumptions--the arguments must be positive and the exponents must be real--or else the ``force`` hint must be True: >>> from sympy import log, symbols >>> log(x**2*y).expand(log=True) log(x**2*y) >>> log(x**2*y).expand(log=True, force=True) 2*log(x) + log(y) >>> x, y = symbols('x,y', positive=True) >>> log(x**2*y).expand(log=True) 2*log(x) + log(y) basic ----- This hint is intended primarily as a way for custom subclasses to enable expansion by default. These hints are not run by default: complex ------- Split an expression into real and imaginary parts. >>> x, y = symbols('x,y') >>> (x + y).expand(complex=True) re(x) + re(y) + I*im(x) + I*im(y) >>> cos(x).expand(complex=True) -I*sin(re(x))*sinh(im(x)) + cos(re(x))*cosh(im(x)) Note that this is just a wrapper around ``as_real_imag()``. Most objects that wish to redefine ``_eval_expand_complex()`` should consider redefining ``as_real_imag()`` instead. func ---- Expand other functions. >>> from sympy import gamma >>> gamma(x + 1).expand(func=True) x*gamma(x) trig ---- Do trigonometric expansions. >>> cos(x + y).expand(trig=True) -sin(x)*sin(y) + cos(x)*cos(y) >>> sin(2*x).expand(trig=True) 2*sin(x)*cos(x) Note that the forms of ``sin(n*x)`` and ``cos(n*x)`` in terms of ``sin(x)`` and ``cos(x)`` are not unique, due to the identity `\sin^2(x) + \cos^2(x) = 1`. The current implementation uses the form obtained from Chebyshev polynomials, but this may change. See `this MathWorld article `_ for more information. Notes ===== - You can shut off unwanted methods:: >>> (exp(x + y)*(x + y)).expand() x*exp(x)*exp(y) + y*exp(x)*exp(y) >>> (exp(x + y)*(x + y)).expand(power_exp=False) x*exp(x + y) + y*exp(x + y) >>> (exp(x + y)*(x + y)).expand(mul=False) (x + y)*exp(x)*exp(y) - Use deep=False to only expand on the top level:: >>> exp(x + exp(x + y)).expand() exp(x)*exp(exp(x)*exp(y)) >>> exp(x + exp(x + y)).expand(deep=False) exp(x)*exp(exp(x + y)) - Hints are applied in an arbitrary, but consistent order (in the current implementation, they are applied in alphabetical order, except multinomial comes before mul, but this may change). Because of this, some hints may prevent expansion by other hints if they are applied first. For example, ``mul`` may distribute multiplications and prevent ``log`` and ``power_base`` from expanding them. Also, if ``mul`` is applied before ``multinomial`, the expression might not be fully distributed. The solution is to use the various ``expand_hint`` helper functions or to use ``hint=False`` to this function to finely control which hints are applied. Here are some examples:: >>> from sympy import expand, expand_mul, expand_power_base >>> x, y, z = symbols('x,y,z', positive=True) >>> expand(log(x*(y + z))) log(x) + log(y + z) Here, we see that ``log`` was applied before ``mul``. To get the mul expanded form, either of the following will work:: >>> expand_mul(log(x*(y + z))) log(x*y + x*z) >>> expand(log(x*(y + z)), log=False) log(x*y + x*z) A similar thing can happen with the ``power_base`` hint:: >>> expand((x*(y + z))**x) (x*y + x*z)**x To get the ``power_base`` expanded form, either of the following will work:: >>> expand((x*(y + z))**x, mul=False) x**x*(y + z)**x >>> expand_power_base((x*(y + z))**x) x**x*(y + z)**x >>> expand((x + y)*y/x) y + y**2/x The parts of a rational expression can be targeted:: >>> expand((x + y)*y/x/(x + 1), frac=True) (x*y + y**2)/(x**2 + x) >>> expand((x + y)*y/x/(x + 1), numer=True) (x*y + y**2)/(x*(x + 1)) >>> expand((x + y)*y/x/(x + 1), denom=True) y*(x + y)/(x**2 + x) - The ``modulus`` meta-hint can be used to reduce the coefficients of an expression post-expansion:: >>> expand((3*x + 1)**2) 9*x**2 + 6*x + 1 >>> expand((3*x + 1)**2, modulus=5) 4*x**2 + x + 1 - Either ``expand()`` the function or ``.expand()`` the method can be used. Both are equivalent:: >>> expand((x + 1)**2) x**2 + 2*x + 1 >>> ((x + 1)**2).expand() x**2 + 2*x + 1 API === Objects can define their own expand hints by defining ``_eval_expand_hint()``. The function should take the form:: def _eval_expand_hint(self, **hints): # Only apply the method to the top-level expression ... See also the example below. Objects should define ``_eval_expand_hint()`` methods only if ``hint`` applies to that specific object. The generic ``_eval_expand_hint()`` method defined in Expr will handle the no-op case. Each hint should be responsible for expanding that hint only. Furthermore, the expansion should be applied to the top-level expression only. ``expand()`` takes care of the recursion that happens when ``deep=True``. You should only call ``_eval_expand_hint()`` methods directly if you are 100% sure that the object has the method, as otherwise you are liable to get unexpected ``AttributeError``s. Note, again, that you do not need to recursively apply the hint to args of your object: this is handled automatically by ``expand()``. ``_eval_expand_hint()`` should generally not be used at all outside of an ``_eval_expand_hint()`` method. If you want to apply a specific expansion from within another method, use the public ``expand()`` function, method, or ``expand_hint()`` functions. In order for expand to work, objects must be rebuildable by their args, i.e., ``obj.func(*obj.args) == obj`` must hold. Expand methods are passed ``**hints`` so that expand hints may use 'metahints'--hints that control how different expand methods are applied. For example, the ``force=True`` hint described above that causes ``expand(log=True)`` to ignore assumptions is such a metahint. The ``deep`` meta-hint is handled exclusively by ``expand()`` and is not passed to ``_eval_expand_hint()`` methods. Note that expansion hints should generally be methods that perform some kind of 'expansion'. For hints that simply rewrite an expression, use the .rewrite() API. Examples ======== >>> from sympy import Expr, sympify >>> class MyClass(Expr): ... def __new__(cls, *args): ... args = sympify(args) ... return Expr.__new__(cls, *args) ... ... def _eval_expand_double(self, *, force=False, **hints): ... ''' ... Doubles the args of MyClass. ... ... If there more than four args, doubling is not performed, ... unless force=True is also used (False by default). ... ''' ... if not force and len(self.args) > 4: ... return self ... return self.func(*(self.args + self.args)) ... >>> a = MyClass(1, 2, MyClass(3, 4)) >>> a MyClass(1, 2, MyClass(3, 4)) >>> a.expand(double=True) MyClass(1, 2, MyClass(3, 4, 3, 4), 1, 2, MyClass(3, 4, 3, 4)) >>> a.expand(double=True, deep=False) MyClass(1, 2, MyClass(3, 4), 1, 2, MyClass(3, 4)) >>> b = MyClass(1, 2, 3, 4, 5) >>> b.expand(double=True) MyClass(1, 2, 3, 4, 5) >>> b.expand(double=True, force=True) MyClass(1, 2, 3, 4, 5, 1, 2, 3, 4, 5) See Also ======== expand_log, expand_mul, expand_multinomial, expand_complex, expand_trig, expand_power_base, expand_power_exp, expand_func, sympy.simplify.hyperexpand.hyperexpand power_base power_expmulr multinomialbasic)rQmodulusr=rru) rrQr7r2r3r4rr5r6rRs r7ruru sOF %,"+%L%L&-'N 1:   A$ A5 AAr9chUcgSnX :wa&U[[U55pU(dU$X :waM&U$rV) expand_mulexpand_multinomial)rvr|wass r7_mexpandr=! sA | C +*%7%=>T  K + Kr9c >[U5RUSSSSSSS9$)a5 Wrapper around expand that only uses the mul hint. See the expand docstring for more information. Examples ======== >>> from sympy import symbols, expand_mul, exp, log >>> x, y = symbols('x,y', positive=True) >>> expand_mul(exp(x+y)*(x+y)*log(x*y**2)) x*exp(x + y)*log(x*y**2) + y*exp(x + y)*log(x*y**2) TFrQr4r3r2r6r5rr8rvrQs r7r:r:2 s1 4=  TtuEu%  AAr9c >[U5RUSSSSSSS9$)a2 Wrapper around expand that only uses the multinomial hint. See the expand docstring for more information. Examples ======== >>> from sympy import symbols, expand_multinomial, exp >>> x, y = symbols('x y', positive=True) >>> expand_multinomial((x + exp(x + 1))**2) x**2 + 2*x*exp(x + 1) + exp(2*x + 2) FTr?r8r@s r7r;r;D s1 4=  TuEt  @@r9c ^^^^SSKJm SSKJm USLaUUUU4SjnUR U4SjU5n[ U5R TSSSSSSTUS9 $) a( Wrapper around expand that only uses the log hint. See the expand docstring for more information. Examples ======== >>> from sympy import symbols, expand_log, exp, log >>> x, y = symbols('x,y', positive=True) >>> expand_log(exp(x+y)*(x+y)*log(x*y**2)) (x + y)*(log(x) + 2*log(y))*exp(x + y) r)rfractionFc >T "U5upURT 5Vs/sH$o3RSR(dM"UPM& nnURT 5Vs/sH$o3RSR(dM"UPM& nn[U5S:Xa[U5S:Xa|USnUSnSSKJn U"URSURS5nU(aBUT "URSURSU--5U- -nUR XU-5n[[UTT SS95nURT 5URT 5::aU$U$s snfs snf)Nrr) multiplicityT)rQforcefactor) atomsr2rdrfsympyrFrJr: expand_logr") rErr=rrFrrx1rQrGrDrs r7 _handleMulexpand_log.._handleMulg s)A;DAGGCLALqFF1I,@,@LAAGGCLALqFF1I,@,@LAA1v{s1v{aDaD. AFF1I6Cq 166!9a< 78::AqA#AJqt5NOBxx} , HBAs!E#E#!E(E(cp>UR=(a# [U4SjUR555$)Nc3v># UH.n[U4Sj[R"U555v M0 g7f)c3|># UH1n[UT5=(a URSRv M3 g7fr)rr2 is_Rational)r#rrs r7r$9expand_log.....z s5'#!A(2!S'9'SaffQi>S>S'S!s9<N)r(rr)r#rGrs r7r$/expand_log....z s9#@,>q$''#q!'#$#$#,>s69)r3ras_numer_denom)rErs r7rZexpand_log..z s5!((@s#@,-,<,<,>#@ @@r9T) rQrr4r3r2r5r6rGrH)&sympy.functions.elementary.exponentialrsympy.simplify.radsimprDrrru)rvrQrGrHrMrDrs `` @@r7rKrKV sg;/   $|| @ 4=  TtEu5  11r9c @[U5RUSSSSSSSS9$)z Wrapper around expand that only uses the func hint. See the expand docstring for more information. Examples ======== >>> from sympy import expand_func, gamma >>> from sympy.abc import x >>> expand_func(gamma(x + 2)) x*(x + 1)*gamma(x) TF)rQrr6rr4r3r2r5r8r@s r7 expand_funcrZ 3 4=  TE 5Ee  PPr9c @[U5RUSSSSSSSS9$)a Wrapper around expand that only uses the trig hint. See the expand docstring for more information. Examples ======== >>> from sympy import expand_trig, sin >>> from sympy.abc import x, y >>> expand_trig(sin(x+y)*(x+y)) (x + y)*(sin(x)*cos(y) + sin(y)*cos(x)) TF)rQtrigr6rr4r3r2r5r8r@s r7 expand_trigr^ r[r9c @[U5RUSSSSSSSS9$)a Wrapper around expand that only uses the complex hint. See the expand docstring for more information. Examples ======== >>> from sympy import expand_complex, exp, sqrt, I >>> from sympy.abc import z >>> expand_complex(exp(z)) I*exp(re(z))*sin(im(z)) + exp(re(z))*cos(im(z)) >>> expand_complex(sqrt(I)) sqrt(2)/2 + sqrt(2)*I/2 See Also ======== sympy.core.expr.Expr.as_real_imag TFrQcomplexr6rr4r3r2r5r8r@s r7expand_complexrb s3( 4=  T4u 5Ee  PPr9c @[U5RUSSSSSSUS9$)a Wrapper around expand that only uses the power_base hint. A wrapper to expand(power_base=True) which separates a power with a base that is a Mul into a product of powers, without performing any other expansions, provided that assumptions about the power's base and exponent allow. deep=False (default is True) will only apply to the top-level expression. force=True (default is False) will cause the expansion to ignore assumptions about the base and exponent. When False, the expansion will only happen if the base is non-negative or the exponent is an integer. >>> from sympy.abc import x, y, z >>> from sympy import expand_power_base, sin, cos, exp, Symbol >>> (x*y)**2 x**2*y**2 >>> (2*x)**y (2*x)**y >>> expand_power_base(_) 2**y*x**y >>> expand_power_base((x*y)**z) (x*y)**z >>> expand_power_base((x*y)**z, force=True) x**z*y**z >>> expand_power_base(sin((x*y)**z), deep=False) sin((x*y)**z) >>> expand_power_base(sin((x*y)**z), force=True) sin(x**z*y**z) >>> expand_power_base((2*sin(x))**y + (2*cos(x))**y) 2**y*sin(x)**y + 2**y*cos(x)**y >>> expand_power_base((2*exp(y))**x) 2**x*exp(y)**x >>> expand_power_base((2*cos(x))**y) 2**y*cos(x)**y Notice that sums are left untouched. If this is not the desired behavior, apply full ``expand()`` to the expression: >>> expand_power_base(((x+y)*z)**2) z**2*(x + y)**2 >>> (((x+y)*z)**2).expand() x**2*z**2 + 2*x*y*z**2 + y**2*z**2 >>> expand_power_base((2*y)**(1+z)) 2**(z + 1)*y**(z + 1) >>> ((2*y)**(1+z)).expand() 2*2**z*y**(z + 1) The power that is unexpanded can be expanded safely when ``y != 0``, otherwise different values might be obtained for the expression: >>> prev = _ If we indicate that ``y`` is positive but then replace it with a value of 0 after expansion, the expression becomes 0: >>> p = Symbol('p', positive=True) >>> prev.subs(y, p).expand().subs(p, 0) 0 But if ``z = -1`` the expression would not be zero: >>> prev.subs(y, 0).subs(z, -1) 1 See Also ======== expand FT)rQrr4r3r2r5r6rGr8)rvrQrGs r7expand_power_baserd s3` 4=  Tu%De5  ""r9c @[U5RUSSSSSSSS9$)a  Wrapper around expand that only uses the power_exp hint. See the expand docstring for more information. Examples ======== >>> from sympy import expand_power_exp, Symbol >>> from sympy.abc import x, y >>> expand_power_exp(3**(y + 2)) 9*3**y >>> expand_power_exp(x**(y + 2)) x**(y + 2) If ``x = 0`` the value of the expression depends on the value of ``y``; if the expression were expanded the result would be 0. So expansion is only done if ``x != 0``: >>> expand_power_exp(Symbol('x', zero=False)**(y + 2)) x**2*x**y FTr`r8r@s r7expand_power_exprf s3. 4=  T5 5DU  OOr9c DSSKJn SSKJn SSKJn SSKJn SSKJ n [U5n[U[5(GatUR(Gdb/nU/n[S5n [S 5n [S 5n [S 5n [S 5n U(GaUR5nUR (aYU["R$LaDUR&S:aUR)U 5 UR*S:waUR)U 5 MGO3UR,(dUR.(Ga [1U5(aHUR)U 5 UR2S["R4LaUR75SnOU*nU"U5unnUR8(a<UR)U 5 US:aUR)U 5 UR)U5 GMUU["R$LaGUR8(dUR)U5 UR)U 5 UR)U5 GMGOUR:(dUR<(a[?UR25nSn[AU5Hrunn[1U5(a2US- nUR)U*5 US:aUR)U 5 MFMHUR)U5 US:dMaUR)U 5 Mt U[CU5:XaUR)U 5 O&[1US5(aUR)X- 5 GMURD(aLURF["R4La/UR)U 5 UR)URH5 GMU["RJ:XaUR)U 5 GM:URD(aMURH["RJ:Xa/UR)U 5 UR)URF5 GMUR,(d[U[L5(aX[URNRPRS55nUR)U[CUR25S- -5 OUR2(aURD(d(URT(d[U[VXC45(a[URN[X5(a1[S URNRPRS5-5nO-[URNRPRS55nUR)U5 URZ(dUR]UR25 U(aGMGO[U[^5(a:URa5VVs/sHunn[cUUS9[cUUS9-PM nnnGO[eU5(aUVs/sH n[cUUS9PM nnGOv[XU45(ab/nUR2HnUR)[cUSS95 M [[gUSS9RS55nUR)U5 GO[U[h5(d/nO[U[h5(d [kS5e/nU/nU(aUR5nUR2(a[[mU5RPRS55nURn(a+UR)U[CUR25S- -5 OUR)U5 UR]UR25 U(aMU(dU(a["Rp$g[sU6nU(aU$URt(a [wU5$[yS[rRz"U555$s snnfs snf)a0 Return a representation (integer or expression) of the operations in expr. Parameters ========== expr : Expr If expr is an iterable, the sum of the op counts of the items will be returned. visual : bool, optional If ``False`` (default) then the sum of the coefficients of the visual expression will be returned. If ``True`` then the number of each type of operation is shown with the core class types (or their virtual equivalent) multiplied by the number of times they occur. Examples ======== >>> from sympy.abc import a, b, x, y >>> from sympy import sin, count_ops Although there is not a SUB object, minus signs are interpreted as either negations or subtractions: >>> (x - y).count_ops(visual=True) SUB >>> (-x).count_ops(visual=True) NEG Here, there are two Adds and a Pow: >>> (1 + a + b**2).count_ops(visual=True) 2*ADD + POW In the following, an Add, Mul, Pow and two functions: >>> (sin(x)*x + sin(x)**2).count_ops(visual=True) ADD + MUL + POW + 2*SIN for a total of 5: >>> (sin(x)*x + sin(x)**2).count_ops(visual=False) 5 Note that "what you type" is not always what you get. The expression 1/x/y is translated by sympy into 1/(x*y) so it gives a DIV and MUL rather than two DIVs: >>> (1/x/y).count_ops(visual=True) DIV + MUL The visual option can be used to demonstrate the difference in operations for expressions in different forms. Here, the Horner representation is compared with the expanded form of a polynomial: >>> eq=x*(1 + x*(2 + x*(3 + x))) >>> count_ops(eq.expand(), visual=True) - count_ops(eq, visual=True) -MUL + 3*POW The count_ops function also handles iterables: >>> count_ops([x, sin(x), None, True, x + 2], visual=False) 2 >>> count_ops([x, sin(x), None, True, x + 2], visual=True) ADD + SIN >>> count_ops({x: sin(x), x + 2: y + 1}, visual=True) 2*ADD + SIN r) Relationalr)Sum)Integral)BooleanFunctionrCNEGDIVSUBADDEXPFUNC_)visualT)shortzInvalid type of exprc3f# UH'n[UR=(d S/S5v M) g7f)rrN)rr2r=s r7r$count_ops.. s)C0B1sAFFMqc1%&&0Bs/1)> relationalrhsympy.concrete.summationsrisympy.integrals.integralsrjsympy.logic.boolalgrkrXrDrrr is_RelationalrrxrRrrzrYr4rr3r1r8r2 NegativeOne as_two_termsrdr is_MatAddrrrfis_PowrbaseExp1rrr>upperrrrrrer ra count_opsr&r-rrr is_Booleanrxrr4rrjr)rvrrrhrirjrkrDopsr2rlrmrnrorpr6rr=aargsnegsrrrrr-rs r7rr/ sP'-23/ 4=D$d&8&8&8vUmUmUmUmUm A }}AEE>ssQw 3ssax 3 " Q[[[??JJsOvvayAMM1NN,Q/B{1<<JJsO1u 3KKNaee^<< AJJsOKKN $ Q[[QVV &u-EAr#B''  RC(q5JJsO! Bq5JJsO.3u:%JJsO!%(++JJsy)xxAEEQ]]2 3 AFF#AFF{ 3xxAFFaff, 3 AEE"xx:a33166??0023 1c!&&kAo./HH A H?Z1[1[aff&788w)>)>)@@AAqvv4467A 1 ;; AFF#add D$  7;zz|E7Ctq!6*6*+7C E $489Dqy6*D9 D7 8 899C JJyT2 3 9T.446 7 1 e $ $$&&23 3C6DHHJ66tAw//5578A|| 1c!&&k!m#45 1 KK'$  66M s)C   }}3x C c0BC CCUE:s "``c B^^^^SSKJn TTUS.m[X5(aURU4Sj5$[ U[ S9(Ga0[U[ [45(aU(a4UR5Vs/sHn[U4SjU55PM nnO0UR5VVs/sHupxU[U40TD64PM nnn[U[ 5(a[U5"U5$UR"U6$[U[5(a4UR"URVs/sHn[U40TD6PM sn6$[U5"UVs/sHn[U40TD6PM sn5$[U5n U R (a [#U T5$U R$(aBU R'T5n U R (a[#U R'T5T5n U $U $U R((aU $U R*(a%U4SjU R5n U R"U 6$SSKJn U R1U R3U 5V s0sHoU R'T5_M sn 5n S S KJm T(dUU R3T5V s/sHoT"U R8[;554PM! nn U R1[ U55n U R'T5n T(d<U R1WV Vs0sHupUR<U R<_M snn 5n O!U R1[?UU4S jS 55n U R1[?UU4S jS55$s snfs snnfs snfs snfs sn fs sn fs snn f)aMake all Rationals in expr Floats except those in exponents (unless the exponents flag is set to True) and those in undefined functions. When processing dictionaries, do not modify the keys unless ``dkeys=True``. Examples ======== >>> from sympy import nfloat, cos, pi, sqrt >>> from sympy.abc import x, y >>> nfloat(x**4 + x/2 + cos(pi/3) + 1 + sqrt(y)) x**4 + 0.5*x + sqrt(y) + 1.5 >>> nfloat(x**4 + sqrt(y), exponent=True) x**4.0 + y**0.5 Container types are not modified: >>> type(nfloat((1, 2))) is tuple True rr)rexponentdkeysc>[U40TD6$rVnfloat)rkws r7rZnfloat..! s qBr9)excludec3<># UHn[U40TD6v M g7frVr)r#rrs r7r$nfloat..' s:1va2c3<># UHn[U40TD6v M g7frVr)r#rrs r7r$rB sT"UR[URT55$rV)rrr)rErrs r7rZrW sc!&&%q/2r9cTUR=(a URR$rV)r~rrdrs r7rZrX sahh3155#3#33r9cL>UR"[URTT56$rV)rrr2)rErrs r7rZr[ s!&&&H56r9cZ[U[5=(a [U[5(+$rV)rrrrs r7rZr\ s*Q)M*Q 2M.MMr9) rrr applyfuncr&r~rDr rargrrrrr2rr4rrris_Atomrzsympy.polys.rootoftoolsrrrIpowerrrrqrr)rvrrrrr6r2rr-rS args_nfloatrrorYrr=rrs `` @@r7rr s*5h 7B$##~~788c"" dT4L ) )!ZZ\+)::;)+:>FF1OO,F$%%Dz$''yy$'' e $ $99 B 1va2 BC CDzD9Dq6!?r?D9:: B ||R|  TT!W <<rttAw"B     B 3588C=A=aC()=A [[d $ aB  [[48441!%%,48 9[[ 2 356 ;;y6MO PPg+G C92>B9s*>M<3N4NN "N$&N#N )rqr)TNTTTTTTrC)T)TFF)TF)FF)rrO __future__rtypingrcollections.abcrcopyregrrr6rr cacher containersr r decoratorsr rrrvrrlogicrrrrr4rrmrrr operationsrr`rrulesr singletonrrrsortingrr sympy.utilities.exceptionsr!r"r#sympy.utilities.iterablesr$r%r&r'r(r)sympy.utilities.lambdifyr*sympy.utilities.miscr+r,r-rmpmath.libmp.libmpfr.r^ collectionsr/r8 Exceptionr;r}rDrrLrQrorrqrrrrrrrrrpicklerrrrrr1rur=r:r;rKrZr^rbrdrfrrrjrqrr=r9r7rs@#$!#""<<--!)&.RR))8>> +2D  --     =>{D{|b@%=b@Jq{Dqh +h+&8&R I I%&: :D1$ -0L8ZL^r 7r 7j2]PT]P@V,4V,r C7LCG48IBZ "A$@$*1ZP$P$P0R"jO6UDpUPp"!r9