o 8Va+?@sddlmZmZddlmZmZddlmZmZm Z ddl m Z m Z ddl mZddlmZddlmZddlmZdd lmZdd lmZmZmZdd lmZdd lmZdd lm Z ddl!m"Z"m#Z#ddZ$dddZ%dddZ&dS))SPow)iterable is_sequence) Derivative AppliedUndefdiff)EqualityEq)Dummy)sympify) BooleanAtom)exp)Order)simplifyposify besselsimp)trigsimp) sqrtdenest)solve) _preprocess ode_ordercCsX||i}|tD]}|j|kr|j|j||<q |||ijdd||<q ||S)aa When replacing the func with something else, we usually want the derivative evaluated, so this function helps in making that happen. Examples ======== >>> from sympy import Derivative, symbols, Function >>> from sympy.solvers.ode.subscheck import sub_func_doit >>> x, z = symbols('x, z') >>> y = Function('y') >>> sub_func_doit(3*Derivative(y(x), x) - 1, y(x), x) 2 >>> sub_func_doit(x*Derivative(y(x), x) - y(x)**2 + y(x), y(x), ... 1/(x*(z + 1/x))) x*(-1/(x**2*(z + 1/x)) + 1/(x**3*(z + 1/x)**2)) + 1/(x*(z + 1/x)) ...- 1/(x**2*(z + 1/x)**2) F)Zdeep)atomsrexprrZvariable_countxreplacedoit)eqfuncnewrepsdr!=/usr/lib/python3/dist-packages/sympy/solvers/ode/subscheck.py sub_func_doits   r#NautoTc shtr t|dSttstddurOz tj\}Wn,tyNddt|t r3|n|gD}t j |}t |dkrHtd| Ynwtt r[t jdkratdt|t rut|fd d|DSt|tst|}n|jkr|j}d krt|jko|j }r|st|}|rÇfd d|D} t |dkr| d} t| d d Sjd} |tr#|jksJ|j} |j} | j} t| tsJ| j}| t| |ksJjj| }t| |}||}||ksJ|}|dk|fSd}d}|r|dkrfjj}|jkrGt||j}t |}n|d7}q't!|"t}|r^|jdd}nd}|d7}n+|dkrt!t#t$|j| t$|j| t#jt#j}|d7}n|dkr|jkr|jsd|ji}n|jkr|jsd|ji}ni}|j|j}t%ddD]@}|dkr|$| }zt|$| |}|st&Wnt&y|d7}Ynw|d||<q||d$| ||<q|dkrq'jj}}t%ddD]H}|dkr*d|vr*n;t|$| |||}t|$| |||}t||}t!|}t|t't(fr]|r[t)j*}}q|j}|j}qt#||+d}t,d}||}t-|\}}t!|.|.|i}|d7}nn|s*|sd|fS|durt&dt/|dt/dd |fS)a Substitutes ``sol`` into ``ode`` and checks that the result is ``0``. This works when ``func`` is one function, like `f(x)` or a list of functions like `[f(x), g(x)]` when `ode` is a system of ODEs. ``sol`` can be a single solution or a list of solutions. Each solution may be an :py:class:`~sympy.core.relational.Equality` that the solution satisfies, e.g. ``Eq(f(x), C1), Eq(f(x) + C1, 0)``; or simply an :py:class:`~sympy.core.expr.Expr`, e.g. ``f(x) - C1``. In most cases it will not be necessary to explicitly identify the function, but if the function cannot be inferred from the original equation it can be supplied through the ``func`` argument. If a sequence of solutions is passed, the same sort of container will be used to return the result for each solution. It tries the following methods, in order, until it finds zero equivalence: 1. Substitute the solution for `f` in the original equation. This only works if ``ode`` is solved for `f`. It will attempt to solve it first unless ``solve_for_func == False``. 2. Take `n` derivatives of the solution, where `n` is the order of ``ode``, and check to see if that is equal to the solution. This only works on exact ODEs. 3. Take the 1st, 2nd, ..., `n`\th derivatives of the solution, each time solving for the derivative of `f` of that order (this will always be possible because `f` is a linear operator). Then back substitute each derivative into ``ode`` in reverse order. This function returns a tuple. The first item in the tuple is ``True`` if the substitution results in ``0``, and ``False`` otherwise. The second item in the tuple is what the substitution results in. It should always be ``0`` if the first item is ``True``. Sometimes this function will return ``False`` even when an expression is identically equal to ``0``. This happens when :py:meth:`~sympy.simplify.simplify.simplify` does not reduce the expression to ``0``. If an expression returned by this function vanishes identically, then ``sol`` really is a solution to the ``ode``. If this function seems to hang, it is probably because of a hard simplification. To use this function to test, test the first item of the tuple. Examples ======== >>> from sympy import (Eq, Function, checkodesol, symbols, ... Derivative, exp) >>> x, C1, C2 = symbols('x,C1,C2') >>> f, g = symbols('f g', cls=Function) >>> checkodesol(f(x).diff(x), Eq(f(x), C1)) (True, 0) >>> assert checkodesol(f(x).diff(x), C1)[0] >>> assert not checkodesol(f(x).diff(x), x)[0] >>> checkodesol(f(x).diff(x, 2), x**2) (False, 2) >>> eqs = [Eq(Derivative(f(x), x), f(x)), Eq(Derivative(g(x), x), g(x))] >>> sol = [Eq(f(x), C1*exp(x)), Eq(g(x), C2*exp(x))] >>> checkodesol(eqs, sol) (True, [0, 0]) rrNcSg|]}|tqSr!rr).0sr!r!r" {zcheckodesol..z0must pass func arg to checkodesol for this case./func must be a function of one variable, not %scsg|] }t|dqS)ordersolve_for_func) checkodesol)r(i)oder/r0r!r"r*sr$csg|]}t|qSr!)r )r(tr%r!r"r*r+Fr.TZforcerzUnable to test if z is a solution to .)0rchecksysodesol isinstancer r rlhs ValueErrorrsetunionlenpoprargstyperhsreversedrhasrr1rZgetOZremoveOrrrZsubsrexpandr#rrZrewriterrrangeNotImplementedErrorboolr rZZeroZas_numer_denomr rrstr)r3solrr/r0_funcssolvedrCeqsxZOtermZsolrhsZOexprZsorderZodesubsZneworderZresidualr)ZtestnumZode_diffssZdiffsolsr2ZdsZsdfr;Z ode_or_boolZnumZ_funcrr!)rr3r/r0r"r11sA                                      j  r1cCs(dd}||}tt|D]}t||tr#||j||j||<q|durOg}|D]}|t}tj dd|D}|D]}| |q@q,t t|}t dd|Dsitdd |Dd krit d ||D]} t| td krzt d qkt|td d |Dkrt dt} |D]2} t | td}| j|kr| j} | j|ko| j| } | st| |} | stn| j} | | |<qg} |D]/}|D] }t||| |}qt|}|dkr|jdd}|dkrt|}nd}| |qtt| d krt t| ddkrd| fSd| fS)aw Substitutes corresponding ``sols`` for each functions into each ``eqs`` and checks that the result of substitutions for each equation is ``0``. The equations and solutions passed can be any iterable. This only works when each ``sols`` have one function only, like `x(t)` or `y(t)`. For each function, ``sols`` can have a single solution or a list of solutions. In most cases it will not be necessary to explicitly identify the function, but if the function cannot be inferred from the original equation it can be supplied through the ``func`` argument. When a sequence of equations is passed, the same sequence is used to return the result for each equation with each function substituted with corresponding solutions. It tries the following method to find zero equivalence for each equation: Substitute the solutions for functions, like `x(t)` and `y(t)` into the original equations containing those functions. This function returns a tuple. The first item in the tuple is ``True`` if the substitution results for each equation is ``0``, and ``False`` otherwise. The second item in the tuple is what the substitution results in. Each element of the ``list`` should always be ``0`` corresponding to each equation if the first item is ``True``. Note that sometimes this function may return ``False``, but with an expression that is identically equal to ``0``, instead of returning ``True``. This is because :py:meth:`~sympy.simplify.simplify.simplify` cannot reduce the expression to ``0``. If an expression returned by each function vanishes identically, then ``sols`` really is a solution to ``eqs``. If this function seems to hang, it is probably because of a difficult simplification. Examples ======== >>> from sympy import Eq, diff, symbols, sin, cos, exp, sqrt, S, Function >>> from sympy.solvers.ode.subscheck import checksysodesol >>> C1, C2 = symbols('C1:3') >>> t = symbols('t') >>> x, y = symbols('x, y', cls=Function) >>> eq = (Eq(diff(x(t),t), x(t) + y(t) + 17), Eq(diff(y(t),t), -2*x(t) + y(t) + 12)) >>> sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - S(5)/3), ... Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - S(46)/3)] >>> checksysodesol(eq, sol) (True, [0, 0]) >>> eq = (Eq(diff(x(t),t),x(t)*y(t)**4), Eq(diff(y(t),t),y(t)**3)) >>> sol = [Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), -sqrt(2)*sqrt(-1/(C2 + t))/2), ... Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), sqrt(2)*sqrt(-1/(C2 + t))/2)] >>> checksysodesol(eq, sol) (True, [0, 0]) cSs tttt|r |S|gSN)listmapr r)rr!r!r"_sympifyXs z checksysodesol.._sympifyNcSr&r!r')r(r r!r!r"r*br+z"checksysodesol..css(|]}t|tot|jdkVqdS)r,N)r:rr?rAr(rr!r!r" fs&z!checksysodesol..cSh|]}|jqSr!)rArVr!r!r" gz!checksysodesol..r,r-z'solutions should have one function onlycSrXr!)r;)r(rKr!r!r"rYlrZzCnumber of solutions provided does not match the number of equationsrTr5F)rGr?r:r r;rCrrr=r>appendrSallr<rdictrDrErrHr#rrFr)rOZsolsrrUr2rMrZderivsZfunc_rKZdictsolrNrCZcheckeqrQr!r!r"r9$sj4          (r9)Nr$TrR)'Z sympy.corerrZsympy.core.compatibilityrrZsympy.core.functionrrrZsympy.core.relationalr r Zsympy.core.symbolr Zsympy.core.sympifyr Zsympy.logic.boolalgr Zsympy.functionsrZ sympy.seriesrZsympy.simplify.simplifyrrrZsympy.simplify.trigsimprZsympy.simplify.sqrtdenestrZ sympy.solversrZsympy.solvers.deutilsrrr#r1r9r!r!r!r"s$         t