U -e`@s$dZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z dd lmZmZdd lmZdd lmZdd lmZmZdd lmZmZmZmZddlmZddlm Z m!Z!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mZ>m?Z?m@Z@ddlAZAddlBmCZCddlDZDddlEmFZFddZGGdd d eHZIGd!d"d"eJZKGd#d$d$eLZMGd%d&d&eLZNd'd(ZOGd)d*d*ePZQGd+d,d,e eQd-ZRGd.d/d/eReZSGd0d1d1eSZTGd2d3d3ZUeUZVGd4d5d5eQZWGd6d7d7eSeZXGd8d9d9eZYd:d;ZZGdd?d?eZ\d@dAZ]d^dCdDZ^d_dFdGZ_d`dHdIZ`dadJdKZadbdLdMZbdcdNdOZcdddPdQZddedRdSZedfdTdUZfdgdVdWZgdhdXdYZhdid[d\Zidd]ljmkZkmlZldS)ja 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)Iterable)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_nameN) prec_to_dps)CountercCs,|jr|jd}|jr |jd}|jo*|jS)a(Return 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_NumberZis_extended_negativear5T/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/sympy/core/function.py _coeff_isnegCs   r7c@s eZdZdS) PoleErrorN)__name__ __module__ __qualname__r5r5r5r6r8esr8c@seZdZddZdS)ArgumentIndexErrorcCsd|jd|jdfS)Nz9Invalid operation with argument number %s for Function %srr)r0selfr5r5r6__str__jszArgumentIndexError.__str__N)r9r:r;r?r5r5r5r6r<isr<c@seZdZdZdS)BadSignatureErrorz9Raised when a Lambda is created with an invalid signatureNr9r:r;__doc__r5r5r5r6r@osr@c@seZdZdZdS)BadArgumentsErrorzDRaised when a Lambda is called with an incorrect number of argumentsNrAr5r5r5r6rCtsrCcCsvt|d|}t|j}dd|Dr.dSdd|D}ttt|dddd \}}|s`|Stt |||d S) aReturn 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 evalcSs g|]\}}|j|jkr|qSr5)kindVAR_POSITIONAL.0_pr5r5r6 s zarity..NcSs g|]\}}|j|jkr|qSr5)rEPOSITIONAL_OR_KEYWORDrGr5r5r6rKs cSs |j|jkSN)defaultempty)rJr5r5r6zarity..T)binaryr) getattrinspect signature parametersitemsmaplenr$tuplerange)clsZeval_rVZp_or_knoyesr5r5r6arityzs  r_c@sfeZdZdZejZddZeddZ eddZ edd Z ed d Z d d dddZ ddZdS) FunctionClassz Base class for function classes. FunctionClass is a subclass of type. Use Function('' [ , signature ]) to create undefined function classes. cOs|d|jdt|}|dkrPd|jkrP|jD]}t|dr2|j}qPq2q2q2t|r|sptt dt |t t t |}n|dk rt|f}||_t|dkr|d}d|krt|dtstddS)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`rDzPeval on Function subclasses should be a class method (defined with @classmethod))pop__dict__getr___mro__hasattrrbr& ValueErrorr+strrZrsetr*rY isinstance classmethod TypeError)r\r0kwargsraZsupcls namespacer5r5r6__init__s(    zFunctionClass.__init__cCs2zddlm}Wntk r&YdSX||jS)zp Allow Python 3's inspect.signature to give a useful signature for Function subclasses. r)rUN)rTrU ImportErrorrD)r>rUr5r5r6 __signature__s zFunctionClass.__signature__cCstSrM)rlr=r5r5r6 free_symbolsszFunctionClass.free_symbolscs fddS)Ncs |SrMrg)rulerIr=r5r6rPrQz(FunctionClass.xreplace..r5r=r5r=r6xreplaceszFunctionClass.xreplacecCs"ddlm}|jr||jStjS)a`Return 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.setsrzrbr Naturals0r>rzr5r5r6ras" zFunctionClass.nargsintbool)nreturncCs(|jr||jkS|j}|tjkp&||kS)z Return True if the specified integer is a valid number of arguments The number of arguments n is guaranteed to be an integer and positive )rbrarr|)r>rrar5r5r6 _valid_nargss zFunctionClass._valid_nargscCs|jSrM)r9r\r5r5r6__repr__szFunctionClass.__repr__N)r9r:r;rBtype__new___newrrpropertyrtrurxrarrr5r5r5r6r`s#    & r`csHeZdZdZdZefddZeddZe ddZ d d Z Z S) Applicationz Base class for applied functions. Explanation =========== Instances of Application represent the result of applying an application of any type to any object. Tc sddlm}ddlm}ttt|}|dtj }|dd|rPt d||rj|j |}|dk rj|St j |f||}t}t|d|} | |k rt| rttt| } q| dk rt| f} qd} n|j} | r|| n||_|S)Nrr|ryevaluaterazUnknown options: %s)sympy.sets.fancysetsr|r{rzlistrXrrerrrjrDsuperrobjectrSr&rZrrlr*rbra) r\r0optionsr|rzrZ evaluatedobjsentinelZobjnargsra __class__r5r6r$s.       zApplication.__new__cGsdS)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) Nr5)r\r0r5r5r6rDQszApplication.evalcCs|jSrMrr=r5r5r6funcqszApplication.funccsTjrPjrPtrPtrP|jkrPt|jjkrPfdd|jDSdS)Ncsg|]}|qSr5_subsrHinewoldr5r6rKysz*Application._eval_subs..) is_FunctioncallablerrYr0ra)r>rrr5rr6 _eval_subsus zApplication._eval_subs) r9r:r;rBrr rrnrDrrr __classcell__r5r5rr6rs ,  r) metaclasscseZdZUdZeddZefddZeddZ edd Z d d Z d d Z ddZ ddZdZded<eddZddZddZd#ddZd$dd Zd%d!d"ZZS)&Functionaj 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. cCsdSNFr5r=r5r5r6 _diff_wrtszFunction._diff_wrtc stkrt||St|}|sfd}t|tjdkr@dndtjdtjdk|d|dtj }t j f||}|rt |r|j rևfdd |j D}t|}|d krt|} |t| }t|S) NzE%(name)s takes %(qual)s %(args)s argument%(plural)s (%(given)s given)rZexactlyzat leasts)nameZqualr0pluralgivenrcsg|]}|qSr5) _should_evalfrHr4rr5r6rKsz$Function.__new__..r)rUndefinedFunctionrYrroraminrgrrrrrmr0maxevalfr-r) r\r0rrtemprresultrZpr2prrrr6rs*   zFunction.__new__cCs@|jr |jS|jsdSt|}|dkr*dSt|dj|djS)aw 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. Nrr)Zis_FloatZ_precis_Addr r)r\argmr5r5r6rszFunction._should_evalfcCstddlm}ddddddd d d d d dddd}|j}z ||}Wn(tk rht|j|r`dnd}YnXd||fS)Nrr  !()*+)explogsincostanZcotsinhcoshtanhZcoth conjugatereZimri')rr|r9KeyErrorrmra)r\r|funcsrrr5r5r6 class_keys,  zFunction.class_keyc sfdd}tdd}|dkr4|jj}j}n |\}}|dkrtdd}|dkr^dSz t|fddjDWSttfk rYdSXz8fdd|D}dd tfd d |DrtWntk rYdSXt ||}W5QRXt |S) Ncs:ttrdStt|s0t|d}|dkr0dStt|S)z$Lookup mpmath function based on nameN)rm AppliedUndefrimpmathr)rgrS)fnamer=r5r6_get_mpmath_funcs   z.Function._eval_evalf.._get_mpmath_func _eval_mpmathZ_imp_csg|]}|qSr5)rrprecr5r6rK+sz(Function._eval_evalf..csg|]}|dqS)) _to_mpmathrHrrr5r6rK5scSsddlm}m}t||r8|j}|ddko6|ddkSt||r||j\}}|ddkoz|ddkoz|ddkoz|ddkSdSdS)Nr)mpfmpcrrF)rrrrmZ_mpf_Z_mpc_)rrrrr5r5r6bad6s     z!Function._eval_evalf..badc3s|]}|VqdSrMr5r)rr5r6 Hsz'Function._eval_evalf..) rSrr9r0rrorjanyrZworkprecr _from_mpmath)r>rrrrr0impvr5)rrr>r6 _eval_evalfs0      zFunction._eval_evalfc Cstd}g}|jD]\}|d7}||}|jr,qz||}Wn tk rZt||}YnX|||qt|S)Nrr)r0diffis_zerofdiffr<rappendr)r>rrlr4daZdfr5r5r6_eval_derivativeRs  zFunction._eval_derivativecCstdd|jDS)Ncss|] }|jVqdSrM)is_commutativerr5r5r6rcsz0Function._eval_is_commutative..)rr0r=r5r5r6_eval_is_commutativebszFunction._eval_is_commutativecsb|js dStfdd|jddDr.dS|jd}||sHdStt|||S)NTc3s|]}|VqdSrMhasrxr5r6rhsz0Function._eval_is_meromorphic..rFr)r0r_eval_is_meromorphicrr is_singularsubs)r>rr4rr5rr6res   zFunction._eval_is_meromorphicNzFuzzyBool | tuple[Expr, ...]_singularitiescs(|j}|dkr|Stfdd|DS)z Tests whether the argument is an essential singularity or a branch point, or the functions is non-holomorphic. )TNFc3s(|] }|tjkrjn|jVqdSrM)rZComplexInfinity is_infiniter)rHrr3r5r6r}sz'Function.is_singular..)rr)r\r4ssr5r3r6rss  zFunction.is_singularcCs |tjfS)zE Returns the method as the 2-tuple (base, exponent). )rOner=r5r5r6 as_base_expszFunction.as_base_expcCsttdt||fdS)a 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. zQ Asymptotic expansion of %s around %s is not implemented.N)r8r+r)r>rargs0rlogxr5r5r6 _eval_aseriess zFunction._eval_aseriesrc"sddlm}ddlm}ddlm}|j}fdd|D} tdd | Drdd lm m m fd d|D} fd d| D} tfd d | Dr| | Sfdd|D} ddt | | D} dd| D} g}d}t | | | D]D\}}}|r8|dk r$t||||}n ||q|j|}|dkr^|S||}|}|}|||||j||}|S|jjtjks|jj|dkr| dstdd |jjDr|}|}||krt|jdkr"||jd}|tj}|jdksH|tjkrTt d||}tj!}|d|}||}t"dD]|}|t#|9}|$|}||tj}|tjkr|%|tj}|jdkrt d||||}|}||7}q~||S|j&dS|jd}g}d}d} ||'(}!|!dkrb|!)} t"| D].}|*|||}|j&d}||qjt+||S)ay 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_symbolrOrderrycsg|]}|dqSrlimitrHtrr5r6rKsz*Function._eval_nseries..css|]}|jdkVqdS)FN) is_finiterr5r5r6rsz)Function._eval_nseries..)oozoonancsg|]}|jdqS)ras_leading_termrrrr5r6rKscsg|]}|dqSrrrrr5r6rKsc3s |]}| VqdSrMrr)rrrr5r6rscsg|]}|qSr5) _eval_nseriesr)rrrr5r6rKscSsg|]\}}||qSr5r5)rHrZr0r5r5r6rKscSsg|] }tqSr5Dummy)rHrIr5r5r6rKsNcss|]}|dkVqdSrNr5)rHcr5r5r6rsFzCannot expand %s around 0xirrrd),symbolrsympy.series.orderrr{rzr0rnumbersrrrrziprNotImplementedErrorrrr getOremoveOrexpandexprrarr|rYcancelZerorNaNr8rr[rrrnseriesr ZgetnZceilingZ taylor_termr)"r>rrrcdirrrrzr0rr4Za0zrJqraiZzipie1roetermZseriesZfactZ_xrrrrgZntermscfr5)rrrrrrr6r s       $              zFunction._eval_nseriesrcCsd|krt|jks&nt|||d}|j|}|jrt|jdksR|js\t||St|jD]\}}||krf||jkrfqqft||Std|t |d}|jd||f|j|dd}t t |j ||||S)z? Returns the first derivative of the function. rxi_%i) dummy_indexN) rYr0r<r is_Symbol_derivative_dispatch enumeraterurhashSubs Derivativer)r>ZargindexixArrDr0r5r5r6rs    &zFunction.fdiffcsbddlm}fdd|jD}|dtfdd|DrTtd|jn |j|Sd S) aStub 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. rrcsg|]}|jdqSr r rr r5r6rKsz2Function._eval_as_leading_term..rc3s"|]}|jko|VqdSrM)rucontainsr)r(rr5r6rsz1Function._eval_as_leading_term..z'%s has no _eval_as_leading_term routineN)rrr0rrr)r>rrr"rr0r5)rr(rr6_eval_as_leading_terms  zFunction._eval_as_leading_term)r)r)Nr)r9r:r;rBrrr rrnrrrrrrr__annotations__rrrr rr9rr5r5rr6r|s* 9 !  B   l rcs:eZdZdZdZfddZd ddZed d ZZ S) rza Base class for expressions resulting from the application of an undefined function. FcsZttt|}dd|D}|rBtddt|dkd|ftj|f||}|S)NcSsg|]}t|tr|jqSr5)rmrrrr5r5r6rK<s z(AppliedUndef.__new__..zFInvalid argument: expecting an expression, not UndefinedFunction%s: %srr, )rrXrrorYjoinrr)r\r0rurrr5r6r:szAppliedUndef.__new__NrcCs|SrMr5)r>rrr"r5r5r6r9Csz"AppliedUndef._eval_as_leading_termcCsdS)a) 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) Tr5r=r5r5r6rFszAppliedUndef._diff_wrt)Nr) r9r:r;rB is_numberrr9rrrr5r5rr6r2s  rc@seZdZdZddZdS)UndefSageHelperz/ Helper to facilitate Sage conversion. csFddlmdkr"fddSddjDfddSdS)Nrcs jSrM)functionr9r5)sagetypr5r6rP`rQz)UndefSageHelper.__get__..cSsg|] }|qSr5)_sage_rr5r5r6rKbsz+UndefSageHelper.__get__..csjjSrM)r@rr9r5)r0insrAr5r6rPcrQ)Zsage.allallr0)r>rDrBr5)r0rDrArBr6__get__]s  zUndefSageHelper.__get__N)r9r:r;rBrFr5r5r5r6r?Ysr?csbeZdZUdZefdffdd ZddZiZded<d d Z d d Z d dZ e ddZ ZS)rz1 The (meta)class of undefined functions. Nc  sddlm}||\}}t|tr4||}|j}n@t|tsHtdn,|dd}t|f|j }|dkrt| d|pzi}| dd| D| || || d|id|d<t ||||}||_t|_|S) Nr)_filter_assumptionsz#expecting string or Symbol for name commutativecSsi|]\}}d||qS)zis_%sr5rHkrr5r5r6 |sz-UndefinedFunction.__new__.._kwargsr:)rrGrmSymbol_mergerrkrorgZ assumptions0reupdaterWrr_undef_sage_helperrC) ZmclrbasesrfrprG assumptionsrHrrr5r6rks*          zUndefinedFunction.__new__cCs|t|jkSrM)rrh)r\instancer5r5r6__instancecheck__sz#UndefinedFunction.__instancecheck__zdict[str, bool | None]rLcCst|t|jfSrM)r2r frozensetrLrWr=r5r5r6__hash__szUndefinedFunction.__hash__cCs(t||jo&||ko&|j|jkSrM)rmrrrLr>otherr5r5r6__eq__s   zUndefinedFunction.__eq__cCs ||k SrMr5rWr5r5r6__ne__szUndefinedFunction.__ne__cCsdSrr5r=r5r5r6rszUndefinedFunction._diff_wrt)r9r:r;rBrrrTrLr:rVrYrZrrrr5r5rr6rgs ! rc@s2eZdZUdZeZded<ddZd dd ZdS) WildFunctiona= 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]includecKslddlm}m}||_|dtj}t||sbt|rHt t t |}n|dk rZt |f}||}||_ dS)Nr)Setrzra)r{r]rzrrerr|rmr&rZrrlr*ra)r\rrRr]rzrar5r5r6rrs  zWildFunction.__init__NFcCsHt|ttfsdSt|j|jkr&dS|dkr4i}n|}|||<|SrM)rmrrrYr0racopy)r>rZ repl_dictrr5r5r6matchesszWildFunction.matches)NF) r9r:r;rBrlr\r:rrr_r5r5r5r6r[s 0 r[c@seZdZdZdZeddZddZeddZe d d Z d d Z d dZ ddZ ededdZeddZeddZeddZeddZeddZeddZed d!Zd"d#Zd3d%d&Zd4d'd(Zd5d*d+Zd6d-d.Ze d/d0Ze d1d2Zd)S)7r4aE 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 evalulate 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 TcCs|jjot|tS)a{An 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 )rrrmdoitr4r=r5r5r6rs zDerivative._diff_wrtc#Ost|}t|dd}t|t}|s2ttd||s|j}t|dkr|jrTt j St|dkrrttd|nttd|g}t t t f}ddlm}m} t|D]0\} } t| trtd| t| |rJt| dkrqt| d|r$t| dkr|| d} d} n| \} } || } n| \} } | dkr8q|t | | qt| } t| tr| dkrttd | | } |d \} }|dkrtd | |f| | dkr|nt | | |d <qd} |t | | qg}|D]p}|\} }|jrtd |rH|d d| krH||d d7}|s8|nt | ||d <n ||q|}|D]*\} }| js^d }ttd| |fq^t|dkr|S|dd}|rt|tr|j}dd|D}d}|j}ddlm}|D]\} }| j}|jr|rt| t r8t!}|"| |i#|sd}qnNt| |rPd}qn6t| t$rr| |krrd}qn||@sd}qq|r|%|S|&|}t|trt |j'|}|j(}t)|f||S|rt*|ds|r ||dfgkr |j+r t j,St-j.||f|Sd}g}ddl/m0}t|D]\} \} } |}d}| j1pft| t2t || f}|s| }t!d} |"|| i}t|tpt|t  }| |jkr|s|3| S|j+st*|ds||3|9}|4|| | } | dk r | j5r | S|| 7}|dk r6| dk r2| 6| |} |}| dkrR|| d}qZ| }q8|7dddd}|rt|trt |j'|}|j(}t-j.||f|}|dkdkr|ddrddl8m9}!ddl:m;}"|!|"|}|S)Nruzp Since there are no variables in the expression %s, it cannot be differentiated.rrz Since there are no variables in the expression, the variable(s) of differentiation must be supplied to differentiate %sz Since there is more than one variable in the expression, the variable(s) of differentiation must be supplied to differentiate %s)Array NDimArrayz.cannot differentiate wrt UndefinedFunction: %sz%First variable cannot be a number: %irztuple {} followed by number {}z,order of differentiation must be nonnegativez9 Can't calculate derivative wrt %s.%srFcSs(g|] \}}t|tr|jn||fqSr5)rmr4 canonicalrHrrr5r5r6rKDsz&Derivative.__new__.. MatrixExprTr MatrixCommonrcSs t|tSrM)rmr4rr5r5r6rPrQz$Derivative.__new__..cSs|jSrM)rdrr5r5r6rPrQsimplify) factor_terms)signsimp)rrrZrr sympy.tensor.arrayrarbr1rrorrformatreZ is_negativerrgr4rd"sympy.matrices.expressions.matexprrgZ is_positiverrrxrrM_get_zero_with_shape_like_sort_variable_countvariable_countrr0riZ is_scalarrrrsympy.matrices.commonri is_symbolrr!_dispatch_eval_derivative_n_timesrrreplaceZ exprtoolsrkZsympy.simplify.simplifyrl)#r\r variablesrpZsymbols_or_noneZhas_symbol_setrrZ array_likesrarbrrcountprevZ prevcountmergedrr__rzerofreergZvfreer7ZnderivsZ unhandledriZold_exprold_vrtZclashingrrkrlr5r5r6rsN                                                zDerivative.__new__cCs|j|jft|jSrM)rrr4rqrrrr5r5r6rds  zDerivative.canonicalc sLsgSttdkr*tdgSttt}g}fddtdfdd ttD]2}t|D]$}||rx|||fqxqltttt dd Dttt ||ffd dd }g}fd d |DD]D\}|r.|d dkr.|d d|7<q||gqdd |DS)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] rrcs |dSNrr5rvcr5r6rPrQz1Derivative._sort_variable_count..Fcs|kr |S|jrdSt|trBtfdd|jDr>dSdS|sTt|trTdSjrd|jkSttr|iS|jj@S)NFc3s|]}|ddVqdS)T)wrtNr5)rHrJ)_blockrr5r6rszBDerivative._sort_variable_count.._block..T)r/rmr4r_wrt_variablesrrurx)drr)r7r)rr6rs"   z/Derivative._sort_variable_count.._blockcSsg|] \}}|qSr5r5)rHrrr5r5r6rK sz3Derivative._sort_variable_count..cs |SrMr5r)Orr5r6rP!rQkeycsg|] }|qSr5r5rrr5r6rK$srcSsg|] }t|qSr5)r rr5r5r6rK)s)F) rrYr r[rrdictrrr'r() r\rVErjr5rzrr5)r7rrrrr6rqs,1   (zDerivative._sort_variable_countcCs|jjSrMrrr=r5r5r6r+szDerivative._eval_is_commutativecCs||jkrR|j|}t|tr:|j|jf|j|jS|j|f|jddiSt|j}| |df|j|jf|ddiS)NrTrF) rrrrmr4rrrrwrr)r>rZdedvrrr5r5r6r.s    zDerivative._eval_derivativecKs\|j}|ddr|jf|}d|d<|j|f|j|}||krX|trX|jf|}|S)NdeepTr)rrgr`rrrrr4)r>hintsrrvr5r5r6r`Bs   zDerivative.doitz0csbtjdkstjdkr$tdtjdfdd}tt|| tj j tj j S)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 derivativesrcs<jtj|tjjd}|ttjj}| tjjS)Nr) rrrrrmprrr-r)rZf0r>r#r5r6rDXsz)Derivative.doit_numerically..eval) rYrurwrrrrrrrrr)r>rrDr5rr6doit_numericallyLs  zDerivative.doit_numericallycCs |jdSr_argsr=r5r5r6r`szDerivative.exprcCsdd|jDS)NcSsg|] }|dqSrr5rr5r5r6rKhsz-Derivative._wrt_variables..)rrr=r5r5r6rdszDerivative._wrt_variablescCs>g}|jD]*\}}|js$ttd||g|q t|S)Nz Cannot give expansion for symbolic count. If you just want a list of all variables of differentiation, use _wrt_variables.)rr is_Integerror+extendrZ)r>rrrxr5r5r6rwjs  zDerivative.variablescCs|jddS)Nrrr=r5r5r6rryszDerivative.variable_countcCstdd|jDdS)NcSsg|] \}}|qSr5r5)rHrIrxr5r5r6rKsz/Derivative.derivative_count..r)sumrrr=r5r5r6derivative_count}szDerivative.derivative_countcCs(|jj}|jD]\}}||jq|SrM)rrurrrO)r>retrIrxr5r5r6ruszDerivative.free_symbolscCs |jdjSr)r0rEr=r5r5r6rEszDerivative.kindcs|jkr|j|jffdd|jD}||krB|Stddsttrdt|St d}t| |i|Sj rj|jkr|j j krSdd}t ttj}t tt|j}|||rtf||j St|j}fdd|D} |d kr&t| S| d |d krd d |jDfd d |jD} |d  j| @} j}  j} | | | @rt|Sddt| dd|ddD}tdd|Drt|jddD]X}tdt| D]B}| |\}}||kr|||d krt|Sqq| dd}|j}|j}g}t|D]N\}\}}|jsft d|}| |||i}||f||<|||fqf|r|}tt|f|ft|St| S)Ncs g|]\}}||fqSr5)rrerr5r6rKsz)Derivative._eval_subs..rFrcstfddDS)Nc3s"|]}||kdkVqdS)TNr5rr4br5r6rsz9Derivative._eval_subs.._subset..)rErr5rr6_subsetsz&Derivative._eval_subs.._subsetcsg|]}|qSr5r)rHrrr5r6rKsrcSsi|]}|js|tqSr5)r/rrHvir5r5r6rKsz)Derivative._eval_subs..csh|]}||qSr5rvr)symsr5r6 sz(Derivative._eval_subs..css"|]\\}}\}}||fVqdSrMr5)rHrrIrr5r5r6rsz(Derivative._eval_subs..rcss|]\}}||kVqdSrMr5)rHrrr5r5r6rsT) recursiver-)rrrrrrrSrmrMr3rrx is_Derivativerdr.rreversedr0rWrr0rurrrr[rYr1rrrr4)r>rrrrrZold_varsZ self_varsr0Znewargsr forbiddenZnfreeZofreeZviterr4rrrIrZoldvZnewercir5)rrrr6rsh            $     zDerivative._eval_subsrccs4|j}|jj|||dD]}|j|f|VqdS)N)rr")rwrlseriesr)r>rrr"dxr*r5r5r6 _eval_lseriesszDerivative._eval_lseriescsXjj|||d}|}jfddt|D}|rP|||t|S)Nrcsg|]}j|fqSr5)rrrr>r5r6rKsz,Derivative._eval_nseries..)rr!rrwr make_argsrr)r>rrrr"rr(rr5rr6r szDerivative._eval_nseriesNcCs<|j|}tj}|D] }t|f|j}|dkrq8q|Sr)rrrrrrw)r>rrr"Z series_genrZ leading_termr5r5r6r9s z Derivative._eval_as_leading_termrcCsddlm}|||||S)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)Zsympy.calculus.finite_diffr)r>ZpointsZx0rrr5r5r6as_finite_differencesV zDerivative.as_finite_differencecCstjSrM)rr)r\rr5r5r6rp`sz$Derivative._get_zero_with_shape_likecCs |||SrM)Z_eval_derivative_n_times)r\rrrxr5r5r6rudsz,Derivative._dispatch_eval_derivative_n_times)r)r)Nr)rNN)r9r:r;rBrrrrrdrnrqrrr`r rrrrrwrrrrurErrr r9rrprur5r5r5r6r4sN3 !w  _         c  Y r4csddlm}ddlm}ddlm}|||tttft |sTt fdd|Drpddl m }||f||St |f||S)Nrrhrf)rbc3s6|].}t|tttfr$t|dnt|VqdSrN)rmrZrr rZ array_typesr5r6rrsz'_derivative_dispatch..)ArrayDerivative)rsrirorgrmrbrrZr rmrZ$sympy.tensor.array.array_derivativesrr4)rrwrprirgrbrr5rr6r0ms     r0c@seZdZdZdZddZeddZeddZ ed d Z ed d Z ed dZ e Z eddZddZddZeddZddZdS)Lambdaa 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 TcCst|r,t|ttfs,tddddt|}t|r8|n|f}t|}||t|dkrn|d|krntj St ||t|S)Nz Using a non-tuple iterable as the first argument to Lambda is deprecated. Use Lambda(tuple(args), expr) instead. z1.5zdeprecated-non-tuple-lambdaZdeprecated_since_versionZactive_deprecations_targetrr) r%rmrZr r r_check_signaturerYrZIdentityFunctionrr)r\rUrsigr5r5r6rs zLambda.__new__cs6tfddt|ts*td||dS)NcsT|D]J}|jr.|kr"td||qt|trB|qtd|qdS)NzDuplicate symbol %sz:Lambda signature should be only tuples and symbols, not %s)rtr@addrmr )r0r4rcheckrr5r6rs    z'Lambda._check_signature..rcheckz)Lambda signature should be a tuple not %s)rlrmr r@)r\rr5rr6rs   zLambda._check_signaturecCs |jdS)z@The expected form of the arguments to be unpacked into variablesrrr=r5r5r6rUszLambda.signaturecCs |jdS)z The return value of the functionrrr=r5r5r6rsz Lambda.exprcsfddt|jS)zAThe variables used in the internal representation of the functionc3s.t|tr$|D]}|EdHqn|VdSrM)rmr )r0r _variablesr5r6rs z$Lambda.variables.._variables)rZrUr=r5rr6rws zLambda.variablescCsddlm}|t|jS)Nrry)r{rzrYrUr}r5r5r6ras z Lambda.nargscCs|jjt|jSrM)rrurlrwr=r5r5r6ruszLambda.free_symbolscGsbt|}||jkrHd}t||t|jddt|jddk|d||j|}|j|S)NzD%(name)s takes exactly %(args)s argument%(plural)s (%(given)s given)rrr)rr0rr)rYrarCr_match_signaturerUrrx)r>r0rrrr5r5r6__call__s   zLambda.__call__cs ifdd||S)Ncsjt||D]Z\}}|jr"||<q t|tr t|ttfrJt|t|krZtd||f||q dS)NzCan't match %s and %s)rrtrmr rZrYrC)Zparsr0parrrmatchZ symargmapr5r6rs  z'Lambda._match_signature..rmatchr5)r>rr0r5rr6rs zLambda._match_signaturecCs |j|jkS)zrr5r5r6rszLambda._eval_evalfN)r9r:r;rBrrrnrrrUrrwra bound_symbolsrurrrrr5r5r5r6rxs*%       rcseZdZdZddZddZddZd&d d ZeZe d d Z e Z e d dZ e ddZ e ddZe ddZddZddZfddZddZddZdd Zd'd"d#Zd(d$d%ZZS))r3a 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  szttsgttrPddtD}d|}ttd|tttr`ngttkrtdst St t rj j jnt dtttd}dd lm}Gd d d |fd d fdd|DfddtD} tfdd| DrRd7qqRqt|t} t| | _| S)NcSs g|]\}}|dkrt|qSr)rk)rHrrr5r5r6rKssz Subs.__new__..r;zU The following expressions appear more than once: %s zCNumber of point values must be the same as the number of variables.rIrr) StrPrinterc@seZdZddZdS)z&Subs.__new__..CustomStrPrintercSst|t|jSrM)rkr.)r>rr5r5r6 _print_Dummysz3Subs.__new__..CustomStrPrinter._print_DummyN)r9r:r;rr5r5r5r6CustomStrPrintersrcs|}||SrM)Zdoprint)rsettingsrJ)rr5r6mystrszSubs.__new__..mystrcsi|]}|t|qSr5)rMrHrJ)rprer5r6rKsz Subs.__new__..csg|]\}}||fqSr5r5rHrrJ)s_ptsr5r6rKsc3sB|]:\}}|jko8|ko8t||kVqdSrM)rurMindex)rHrIr)rrpointrrwr5r6rs  zSubs.__new__..)r&r r#r.rWr<rjr+rYrrmr3rwrrsortedrlrZsympy.printing.strrrrrrrxr_expr) r\rrwrrRZrepeatedr{Zptsrrepsrr5)rrrrrrrwr6rmsJ         z Subs.__new__cCs|jjSrMrr=r5r5r6rszSubs._eval_is_commutativecKs6|j\}}}tt||D]L\}\}}||kr|d|||dd}|d|||dd}q|sr|jSt|trg}t|D]6\}}t|tr||||}q||||fqt|ts| }t|trg} t } |jd} |D]F\}}| | || ij kr0| |r>|||}q| ||fq| }g} t } |j} | j }|jD]b\}}t|tr||kr| ||f} n2| | || j kr| ||f} n| ||fq`| |}| D]}||}qn ||}n|j f|tt||}|ddr2||kr2|j f|}|S)NrrrT)r0r1rrrmr4r`rrr`rrxrurrrrMrrrg)r>rr)rrJrrr&ZundoneZundone2r7rrrr}rrrr5r5r6r`sV           z Subs.doitNcKs|j|f|SrM)r`r)r>rrr5r5r6rsz Subs.evalfcCs |jdS)zThe variables to be evaluatedrrr=r5r5r6rwszSubs.variablescCs |jdS)z1The expression on which the substitution operatesrrr=r5r5r6rsz Subs.exprcCs |jdS)z8The values for which the variables are to be substitutedrdrr=r5r5r6rsz Subs.pointcCs|jjt|jt|jjBSrM)rrurlrwrr=r5r5r6ru s zSubs.free_symbolsc CsLtddddtt,|jjt|jt|jjBW5QRSQRXdS)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!rexpr_free_symbolsrlrwrr=r5r5r6r s  zSubs.expr_free_symbolscCst|tsdS||kSr)rmr3_hashable_contentrWr5r5r6rY s z Subs.__eq__cCs ||k SrMr5rWr5r5r6rZ sz Subs.__ne__cs tSrM)rrVr=rr5r6rV sz Subs.__hash__cs4jjfttfddtjjDS)Ncs$g|]\}}j|s||fqSr5)rrrr=r5r6rK s z*Subs._hashable_content..)rrxZcanonical_variablesrZrrrwrr=r5r=r6r s  zSubs._hashable_contentcst|j}|jkrthkrHtfdd|jDsH|iS|j}t|t |jD]}|| ||<qd| |j |j|Sfdd|jD}|t|jkr| |j |jf|gS|j }fdd|jD}| |||S)Nc3s|]}|VqdSrMrr)rr5r6r) sz"Subs._eval_subs..csg|]}|qSr5rrrr5r6rK3 sz#Subs._eval_subs..csg|]}|qSr5rrrr5r6rK7 s) rrrwrrr0rxrr[rYrrr)r>rrptrrrrr5rr6r" s    zSubs._eval_subsc s|j|j|jf\}}tfddt||D}j}dd|D}dd|D}tt||}|j|} | |B} | t |8} | dd| |@DO} | j@r|t |j|j 7}|S)Nc3s4|],\}}|t|fVqdSrM)rr3r`rfrZvpr5r6r> sz(Subs._eval_derivative..cSsh|]}t|jdkr|qSr)rYrurr5r5r6rE sz(Subs._eval_derivative..cSsh|] }tqSr5rrr5r5r6rG scSsh|]}|jD]}|qqSr5)ru)rHrrr5r5r6rO s) rrwrrZfromiterrrurxrrlr3rr`) r>rrPvalZefreeZcompoundZdumsZmaskedZifreer}r5rr6r: s    zSubs._eval_derivativerc s||jkr"j|}j|}n|}jj|||d}|}t|} tfdd| D} |rx| | ||7} | S)Nrcs&g|]}j|fjddqSr)rr0rr=r5r6rK_ sz&Subs._eval_nseries..) rrrwrr!rrrrr) r>rrrr"ZaposrXrr(Ztermsrr5r=r6r U s   zSubs._eval_nseriescCsF||jkr,|j|}|j|}|j|S||jkr:|S|j|SrM)rrrwrr )r>rrr"ZiposZxvarr5r5r6r9d s     zSubs._eval_as_leading_term)N)r)Nr)r9r:r;rBrrr`rrrrwrrrrurrYrZrVrrrr r9rr5r5rr6r3s2T><        r3cOs2t|dr|j||S|ddt|f||S)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 rrT)rir setdefaultr0)rsymbolsrpr5r5r6rq s@   rTc KsJ|| d<|| d<|| d<|| d<|| d<|| d<t|jf||d| S)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)rmodulusrr) r)rrrrrrrrrr5r5r6r sErFcCs6|dkr dSd}||kr2|tt|}}|sq2q|SrM) expand_mulexpand_multinomial)rrwasr5r5r6_mexpand src Cst|j|dddddddS)aY 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) TFrrrrrrrrrrr5r5r6r s rc Cst|j|dddddddS)aV 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) FTrrrr5r5r6r' s rc sXddlm|dkr8fdd}|fdd|}t|jdddddd|d S) aL 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) rrFcs0tt|dd}||kr,|S|S)NT)rforcefactor)r expand_logrx)rx1rrrr5r6_handleI szexpand_log.._handlecs |jotfdd|DS)Nc3s*|]"}tfddt|DVqdS)c3s$|]}t|o|jdjVqdSr)rmr0 is_Rationalrrr5r6rP sz9expand_log.....N)rrr)rHrrr5r6rP s z/expand_log....)r1rEZas_numer_denomrrr5r6rPP szexpand_log..T) rrrrrrrrr)Z&sympy.functions.elementary.exponentialrrvrr)rrrrrr5rr6r9 s  rc Cst|j|ddddddddS)a 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)rrrrrrrrrrr5r5r6 expand_funcY src Cst|j|ddddddddS)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)rZtrigrrrrrrrrr5r5r6 expand_trigk src Cst|j|ddddddddS)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 TFrcomplexrrrrrrrrr5r5r6expand_complex} src Cst|j|dddddd|dS)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)rrrrrrrrr)rrrr5r5r6expand_power_base sPrc Cst|j|ddddddddS)aK 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 FTrrrr5r5r6expand_power_exp srcsddlm}ddlm}ddlm}ddlm}ddlm }t |}t |t r|j sg}|g}td} td } td } td } td } |r|}|jr|tjk r|jdkr|| |jdkr|| qnx|js|jrt|r|| |jdtjkr|d}n| }||\}}|jr^|| |dkrP|| ||qn4|tjk rN|js||||| ||qn|js|jrNt|j}d}t |D]\\}}t|r|d7}|| |dkr|| n|||dkr|| q|t!|kr2|| qt|dr|| | q|j"r||j#tjkr||| ||j$q|tj%kr|| q|j"r|j$tj%kr|| ||j#q|jst |t&rt|j'j()}||t!|jdnz|jrz|j"s<|j*s>> 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)BooleanFunction)fractionNEGDIVSUBADDEXPZFUNC_cs(g|] \}}t|dt|dqSvisual count_opsrIrr5r6rK s  zcount_ops..csg|]}t|dqSrrrrr5r6rK sTr)shortzInvalid type of exprcss"|]}t|jpdgdVqdS)rrN)r~r0rr5r5r6r szcount_ops..)>Z relationalrZsympy.concrete.summationsrZsympy.integrals.integralsrZsympy.logic.boolalgrZsympy.simplify.radsimprrrmr is_RelationalrMrerrrrJrr$r1r/r7r0Z NegativeOneZ as_two_termsrrZ is_MatAddrr1rYis_PowrbaseZExp1rrr9upperrr4rr/rr rWr%rr,rrorZ is_Booleanrrr2r~rr)rrrrrrrZopsr0rrrrrr4rrZaargsZnegsrr%r(rr5rr6r sH                                                rc sddlm}|dt||r4|fddSt|tdrt|ttfr|rjfdd|D}nfd d|D}t|trt ||S|j |Sn$t|t r|j fd d|j DSt |fd d|DSt |}|jrt|S|jr(|}|jr$t|}n|S|jr4|S|jrZfd d |j D}|j |Sddlm}|fdd||D}ddlmsfdd|D} |t| }|}s|dd| D}n|tfdddd}|tfddddS)aCMake 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 r) MatrixBase)rexponentdkeyscs t|fSrMnfloat)r)kwr5r6rP rQznfloat..)excludecs"g|]}tfdd|DqS)c3s|]}t|fVqdSrMrrrr5r6r sz$nfloat...)rZrrr5r6rK sznfloat..cs g|]\}}|t|ffqSr5rrIrr5r6rK scsg|]}t|fqSr5rrrr5r6rK scsg|]}t|fqSr5rrrr5r6rK sc3s|]}t|fVqdSrMrrrr5r6r sznfloat..)RootOfcsi|]}||qSr5r)rHrorr5r6rK$ sznfloat..rPowcsg|]}||jtfqSr5)r rrrr5r6rK( scSsi|]\}}|j|jqSr5)r)rHrJrr5r5r6rK, scs|jt|jSrM)r rrr)rrr5r6rP1 rQcSs|jo |jjSrM)r rrrr5r5r6rP2 rQcs|jt|jSrM)rrr0r)rrr5r6rP5 rQcSst|tot|t SrM)rmrrrr5r5r6rP6 rQ)Zsympy.matrices.matricesr rmZ applyfuncr%rkrr rWrrrr0rr2rr>rZis_AtomrZsympy.polys.rootoftoolsrrxZatomspowerrr) rrrrr r0rZ args_nfloatrrr5)rrrrr6r s^                 r)rrM)TNTTTTTT)F)T)T)TFF)T)T)T)TF)T)F)r FF)mrB __future__rtypingrcollections.abcrrrrrrcacher containersr r Z decoratorsr rr rrrZlogicrrrrrrrrrr operationsrrVrrulesrZ singletonrrrZsortingrrZsympy.utilities.exceptionsr r!r"Zsympy.utilities.iterablesr#r$r%r&r'r(Zsympy.utilities.lambdifyr)Zsympy.utilities.miscr*r+r,rZmpmath.libmp.libmpfr-rT collectionsr.r7 Exceptionr8rjr<ror@rCr_rr`rrrr?rPrr[r4r0rr3rrrrrrrrrrrrrrrrMr5r5r5r6s                "~e9' COz ![F O       U  ] X