\h?SSKJrJr SSKJrJrJr SSKJrJ r SSK J r SSK J r SSKJr SSKJr SSKJr SS KJrJrJr SS KJr SS KJr SS KJr SS KJrJ r SSK!J"r"J#r# Sr$SSjr%SSjr&g))SPow) Derivative AppliedUndefdiff)EqualityEq)Dummy)sympify) BooleanAtom)exp)Order)simplifyposify besselsimp)trigsimp) sqrtdenest)solve) _preprocess ode_order)iterable is_sequencecX0nUR[5HQnURU:XaUR"UR6X4'M0UR X05R SS9X4'MS UR U5$)a% 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)deep)atomsrexprrvariable_countxreplacedoit)eqfuncnewrepsds S/var/www/auris/envauris/lib/python3.13/site-packages/sympy/solvers/ode/subscheck.py sub_func_doitr&sp* +D XXj ! 66T>hh 0 01DGjj$-222>DG " ;;t Nc [U5(a [XUS9$[U[5(d [ US5nUc[ UR 5upR[U[5(a[UR5S:wa[SU-5e[U[5(a*[!U5"UVs/sH n[#XX4S9PM sn5$[U[5(d [ X!5nOUR$U:Xa UR&nUS:Xa [)X5nUR U:H=(a UR$R+U5(+n U(aSU (dL[-X5n U (a:U V s/sHn [ X+5PM n n [U 5S:XaU Sn [#X USS9$URSn UR+[.5(GaUR U:XdeUR$R15nUR$R35nUR4n[U[65(deUR8nU[/U U-5:XdeUR UR$- R;X/5R=5R?5n[/U UU- -5nUU-nUR15U:XdeUR35nUS:HU4$S nSnU(GaUS:XaUR UR$- nUR U:Xa"[AUX!R$5n[CU5nOUS- nM`[EURG[855nU(aUR?S S 9nOSnUS- nGOUS:Xar[E[I[KUR X5[KUR$X5- 5[IUR 5- [IUR$5-5nUS- nGO~US :XGavUR U:Xa/UR$R+U5(dSUR$0nOAUR$U:Xa/UR R+U5(dSUR 0nO0nUR UR$- n[MSUS-5HhnUS:XaEURKU 5n[-UURKX55nU(d[NeUSUU'MNUUS- RKU 5UU'Mj US :aGM:UR UR$n nUS S 5HnUS:XaSU;a O[AUURKX5UU5nXRKX5UU5n [ UU 5n[EU5n[U[P[R45(aU(a[TRV=nn MMUR nUR$n M [IUU - RY5S5n[[S 5nUR;UU5n[]U5unn[EU5R_U5R_UU05nUS- nOO U(aGMU(dS U4$US La)[OS[aU5-S-[aU5-S-5eSU4$![a [U[5(aUOU/Vs/sHofR[5PM Os snfnn[5R"U6n[U5S:wa [S5eUR5nGNf=fs snfs sn f![Na US- n GM\f=f)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]) )r!rz0must pass func arg to checkodesol for this case./func must be a function of one variable, not %s)ordersolve_for_funcautoFTforcer!zUnable to test if z is a solution to .)1rchecksysodesol isinstancerr rlhs ValueErrorrsetrrunionlenpopargstype checkodesolrhsreversedrhasrrgetOremoveOrrr subsrexpandr&rrrewriterrrangeNotImplementedErrorboolr rZeroas_numer_denomr rrstr) odesolr!r+r,_sfuncsisolvedr>teqsxOtermsolrhsOexprsorderodesubsneworderresidualtestnumode_diffssdiffsolsdssdfr5 ode_or_boolnum_funcr#s r%r=r=0sB}}cT22 c8 $ $aj | !#''*GA dL ) )S^q-@ = DF F3Cycfgcf^_+cEYcfghh c8 $ $m Dll #$ WW_ 6SWW[[%6!6FfC (+,12d;C,3x1}!fsu$& & ! A wwu~~ww$ " %%%%%ai((((77377?((6;;=DDFVe^,-H$||~)))??$A x(( AG a<ww(Hww$!(D'':qM1 !))C.)BIIDI) qLG \cggq043JJK!"$,SWW$567A qLG \ww$sww{{4'8'8sww<DT):):sww<''CGG#C1eai( 6!B-#B !8""55 # '*!f #+1q5/"6"6q"9HQK%)*{77CGGSub"-AAv!8"3'TYYq_hqkJC'YYq_hqkJC"$S#,K"*;"7K!+k/BCC&().C#'*oo)oo.$c 99;A>?f hhtU+"3K TSM**40995$-H1  Q !T ay d!"6S"A #!#&s8#,.1#23 3qzO "3,,3%7:701WW\*7:E:EKK'E5zQ FHH99;D h-t/1 s=[ 7]:]"(]' &]/\ A ]]']<;]<c SnU"U5n[[U55H;n[X[5(dMXRXR - X'M= Uc/nUHcnUR [5n[5R"UVs/sHoR [5PM sn6nURU5 Me [[U55n[SW55(d7[UVs1sHo"RiM sn5S:wa[SW-5eUH0n [U R [55S:wdM'[S5e [U5[UV s1sHoRiM sn 5:wa [S5e0n UHn [U R [55SnU R U:Xa U R n U RU:H=(a U R R#U5(+n U (d[%X5n U (d[&eO U R n XU'M /n UHmnUHn[)XbX5nM [+U5nUS:wa/UR-SS 9nUS:wa[/U5R+5nOSnU R1U5 Mo [[U 55S:Xa[[U 55SS:XaSU 4$S U 4$s snfs snfs sn f) a 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]) cj[[[[U5(a U55$U/55$N)listmapr r)r s r%_sympify checksysodesol.._sympifyWs)Cx||>??">??r'c3# UH4n[U[5=(a [UR5S:Hv M6 g7f)r)N)r4rr9r;).0r!s r% !checksysodesol..ds.XRW$z$ -E#dii.A2EERWs<>r)r*z'solutions should have one function onlyzCnumber of solutions provided does not match the number of equationsrTr.F)rFr9r4rr5r>rrr7r8rextendriallr;r6r?r@rrGr&rrDrappend)rTsolsr!rkrQrPr derivsr$rMdictsolrRr>checkeqr_s r%r3r3#sh@ 3-C 3s8_ cfh ' 'VZZ#&**,CF |BXXj)F5;; G1!6 GHD LL SZ  XRWX X X 5 )54YY5 )*A-JTQRR syy& '1 ,FG G 5zST2Tc''T233^__GCIIl+,Q/ 77d?,,CD:T):%:"C))''C GDr7B b\ 7&BQw^,,.Br 3w<A$s7|"4Q"71"<gwO!H * 3sL L8L )Nr-Trh)' sympy.corerrsympy.core.functionrrrsympy.core.relationalrr sympy.core.symbolr sympy.core.sympifyr sympy.logic.boolalgr sympy.functionsr sympy.seriesrsympy.simplify.simplifyrrrsympy.simplify.trigsimprsympy.simplify.sqrtdenestr sympy.solversrsympy.solvers.deutilsrrsympy.utilities.iterablesrrr&r=r3r'r%rsG@@.#&+@@,08;