\h+SSKJrJrJr SSKJr SSKJr SSKJ r SSK J r J r SSK JrJr SSKJrJr SSKJrJrJrJrJrJr SS KJrJrJrJrJrJ r J!r!J"r"J#r# SS K$J%r% SS K&J'r'J(r(J)r)J*r*J+r+ SS K,J-r-J.r. SS K/J0r0J1r1J2r2 SSK3J4r4J5r5 SSK6J7r7 SSK8J9r9 SSK:J;r; SSKJ?r?J@r@ SSKAJBrBJCrCJDrD SSKEJFrF SSKGJHrHJIrI SrJ"SS\K5rL"SS\?5rMSrNSrOSCSjrPSDS jrQSDS!jrRS"rSS#rTS$rUSES%jrVS&rWS'rXS(rYS)rZS*r[S+r\SDS,jr]S-r^S.r_S/r`SFS0jraS1rbS2rcS3rdS4reS5rfS6rgS7rhS84S9jriS:rjS;rkS<rlS=rmS>rnSGS?jroSHS@jrpSISAjrqSJSBjrrg)K)AddMulS)Tuple) factor_terms)I)EqEquality)default_sort_keyordered)DummySymbol) expand_mulexpand Derivative AppliedUndefFunctionSubs) expimcossinre Piecewisepiecewise_foldsqrtlog factorial)zerosMatrixNonSquareMatrixError MatrixBaseeye)Polytogether)collectradsimpsignsimp) powdenestpowsimp)ratsimp)simplify) FiniteSet ode_order)NonlinearErrorsolveset)connected_componentsiterablestrongly_connected_components) filldedent)Integral integratec^^UV^s0sHmT[U4SjU55_M sn$s snf)Nc3<># UHn[UT5v M g7fNr/).0eqfuncs Q/var/www/auris/envauris/lib/python3.13/site-packages/sympy/solvers/ode/systems.py "_get_func_order..s8CbiD))C)max)eqsfuncsr>s `r?_get_func_orderrFs+EJ KUTD#8C88 8U KK Ks *c\rSrSrSrSrg) ODEOrderError z@Raised by linear_ode_to_matrix if the system has the wrong orderN__name__ __module__ __qualname____firstlineno____doc____static_attributes__rJr?rHrH sJrRrHc\rSrSrSrSrg)ODENonlinearError%z9Raised by linear_ode_to_matrix if the system is nonlinearrJNrKrJrRr?rTrT%sCrRrTc^ URnURn[U5n[UR [ 55n[ U/UQ7SS06nUVs/sHn[U5PM nnU(d URn[S5[S5/m /n[UR5UR55Hupx[U5n[U[5(a[U 4SjUR 56nO[#U5R%T 5n['S[X8556nUR)Xx-5 M [+U[-U65$s snf)NrFC1C2c3`># UH#up[U5RT5U4v M% g7fr;)r,r')r<coefcondsymss r?r@_simpsol..8s)aV` !6!6t!_solsimp..Ds \!_)=rR)r+ras_independentr,replacer)etno_thas_ts r?_solsimpr@s?*Q-(77:KD 4=D MM#= >E <rRc ^^ ^ ^ U 4SjnSU U U 4Sjjm Sm Sm U(aH[5R"SU56nUVs0sHof[U5R5_M nnO0nUVs/sH+n[ UR U"UR XqU55PM- nnU$s snfs snf)z&Simplify solutions from dsolve_system.cv>U(aURU5n[U5nT"XU5n[U5nU$)z#Simplify the rhs of an ODE solution)subsrr))rcrepwrt1wrt2simp_coeff_deps r?simprhssimpsol..simprhsps7 ((3-C3S-sm rRc>^^^ ^ ^ U4Sjm U 4Sjm Sm U U 4Sjn[R"U"U55n0nUH}nUR"TSS06upxT"UT5nU[RLa3[ U5n U R "T6(dXy-n[RnX;aXuU'MqXX==U- ss'M UU4SjUR55n Tb UU4SjU 5n [S U 56$) zGSplit rhs into terms, split terms into dep and coeff and collect on depcH>UR=(a UR"T6$r;)is_Addhas)r{rs r?rw1simpsol..simp_coeff_dep..{s!((";quud|";rRch>UR=(a [[TUR55$r;)is_Mulanymaprk)r{ add_dep_termss r?rwr|s!qxxKCM1660J,KKrRc[USS9$)NF)deep)r)r{s r?rwr}s 15 9rRc(>URTT5$r;)rz)r{ expand_func expandables r?rwr~s199Z#ErRas_AddFc3>># UHupT"UT5U4v M g7fr;rJ)r<dc simpcoeffrs r?r@2simpsol..simp_coeff_dep..sDi4(!,c3>># UHupT"UT5U4v M g7fr;rJ)r<rrrrs r?r@rsL)$!.D115)rc3.# UH upX-v M g7fr;rJ)r<rrs r?r@rs1ytqQUyra)r make_argsryrOnerritems)exprrrexpand_mul_modrpdctermrqdepdep2 termpairsrrrrrsimpdeps `` @@@r?rsimpsol..simp_coeff_depys; K 9 E nT23 D,,dA5AJE#t$C!%%#C(xxME%%C}35 !&ED  L)LI1y122rRc ^U4Sjn[U5nUR[5Vs0sH!o3[U"URS55_M# nnUR U5nU$s snf)z[U5nUR5up[U5n[UT5nX- $r;)ras_numer_denomrr')rvnumdenrs r? canonicalise.simpsol..simpdep..canonicalises; QA'')HCS/C#t$C9 rRr)r+rerrkr)rrrr{rs ` r?rsimpsol..simpdeps\ t}8< 3H1#l166!9-..Hyy~ Is(A'c J[U5nUR5(a[[U55nUb7[ U5[ [ UR [U5- 55-nO[ [ UR 55n[X5n[U5nU$)z2Bring to a common fraction and cancel with ratsimp) r& is_polynomialr,r(rdr free_symbolssetr')rqrr\s r?rsimpsol..simpcoeffs    GEN+E  :WU-?-?#d)-K%L MMD 2 234D$ rRc3J# UHoR[5v M g7fr;)rer7)r<ss r?r@simpsol..s!AS''("3"3Ss!#r;)runionrdoitr rbrc) rnrrrr integralsr`rrrrrs @@@r?simpsolrIsN33@&* EKK!AS!AB 2;<)Q,q/&&(()<?B Cs!2aeeWQUUCt4 5sC C J = Ds #B%/2B*Nc 0n[X5(+nUSL=(d UR(+nSR[SR[U5[U55S5S-5nSnUR XgS.5 U(aE[ X5upxU(d[ [S55eXsS'UR [XUS 95 U$) a Helper function that determines the type of the system of ODEs for solving with :obj:`sympy.solvers.ode.systems.linodesolve()` Explanation =========== This function takes in the coefficient matrix and/or the non-homogeneous term and returns the type of the equation that can be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`. If the system is constant coefficient homogeneous, then "type1" is returned If the system is constant coefficient non-homogeneous, then "type2" is returned If the system is non-constant coefficient homogeneous, then "type3" is returned If the system is non-constant coefficient non-homogeneous, then "type4" is returned If the system has a non-constant coefficient matrix which can be factorized into constant coefficient matrix, then "type5" or "type6" is returned for when the system is homogeneous or non-homogeneous respectively. Note that, if the system of ODEs is of "type3" or "type4", then along with the type, the commutative antiderivative of the coefficient matrix is also returned. If the system cannot be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`, then NotImplementedError is raised. Parameters ========== A : Matrix Coefficient matrix of the system of ODEs b : Matrix or None Non-homogeneous term of the system. The default value is None. If this argument is None, then the system is assumed to be homogeneous. Examples ======== >>> from sympy import symbols, Matrix >>> from sympy.solvers.ode.systems import linodesolve_type >>> t = symbols("t") >>> A = Matrix([[1, 1], [2, 3]]) >>> b = Matrix([t, 1]) >>> linodesolve_type(A, t) {'antiderivative': None, 'type_of_equation': 'type1'} >>> linodesolve_type(A, t, b=b) {'antiderivative': None, 'type_of_equation': 'type2'} >>> A_t = Matrix([[1, t], [-t, 1]]) >>> linodesolve_type(A_t, t) {'antiderivative': Matrix([ [ t, t**2/2], [-t**2/2, t]]), 'type_of_equation': 'type3'} >>> linodesolve_type(A_t, t, b=b) {'antiderivative': Matrix([ [ t, t**2/2], [-t**2/2, t]]), 'type_of_equation': 'type4'} >>> A_non_commutative = Matrix([[1, t], [t, -1]]) >>> linodesolve_type(A_non_commutative, t) Traceback (most recent call last): ... NotImplementedError: The system does not have a commutative antiderivative, it cannot be solved by linodesolve. Returns ======= Dict Raises ====== NotImplementedError When the coefficient matrix does not have a commutative antiderivative See Also ======== linodesolve: Function for which linodesolve_type gets the information Ntype{}z{}{})type_of_equationantiderivativez The system does not have a commutative antiderivative, it cannot be solved by linodesolve. rb) _matrix_is_constantis_zero_matrixformatintupdate_is_commutative_anti_derivativeNotImplementedErrorr6_first_order_type5_6_subs) Ar|rmatchis_non_constantis_non_homogeneoustypeB is_commutings r?linodesolve_typerst E-a33O4i;1+;+;< ??3v}}S-A3GYCZ[]^_bcc dD A LLd@A9!?%j2'  #$ .qq9: LrRc 0n[X5nUSL=(d URnUb[SRU55n[ USU5n[ [ Xg5U5n[U[5(aUR[5(dn[U5S:Xa_USnU(d%X$S- nURU[U5S5nSRSU(+-5n URXXiUS.5 U$)N{}_rrr) func_coefftaut_rrc)_factor_matrixrrrr8r2r rjr.rrlenrrdr) rr|rrris_homogeneousrF_tinversers r?rr;s E!!'L$Y2!"2"2N ELLO $ Q+2b;* gy ) )'++i2H2HG !QA!Q'FF1d7mA./??1N(:#;>> from sympy import Function, Symbol, Matrix, Eq >>> from sympy.solvers.ode.systems import linear_ode_to_matrix >>> t = Symbol('t') >>> x = Function('x') >>> y = Function('y') We can create a system of linear ODEs like >>> eqs = [ ... Eq(x(t).diff(t), x(t) + y(t) + 1), ... Eq(y(t).diff(t), x(t) - y(t)), ... ] >>> funcs = [x(t), y(t)] >>> order = 1 # 1st order system Now ``linear_ode_to_matrix`` can represent this as a matrix differential equation. >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, order) >>> A1 Matrix([ [1, 0], [0, 1]]) >>> A0 Matrix([ [1, 1], [1, -1]]) >>> b Matrix([ [1], [0]]) The original equations can be recovered from these matrices: >>> eqs_mat = Matrix([eq.lhs - eq.rhs for eq in eqs]) >>> X = Matrix(funcs) >>> A1 * X.diff(t) - A0 * X - b == eqs_mat True If the system of equations has a maximum order greater than the order of the system specified, a ODEOrderError exception is raised. >>> eqs = [Eq(x(t).diff(t, 2), x(t).diff(t) + x(t)), Eq(y(t).diff(t), y(t) + x(t))] >>> linear_ode_to_matrix(eqs, funcs, t, 1) Traceback (most recent call last): ... ODEOrderError: Cannot represent system in 1-order form If the system of equations is nonlinear, then ODENonlinearError is raised. >>> eqs = [Eq(x(t).diff(t), x(t) + y(t)), Eq(y(t).diff(t), y(t)**2 + x(t))] >>> linear_ode_to_matrix(eqs, funcs, t, 1) Traceback (most recent call last): ... ODENonlinearError: The system of ODEs is nonlinear. Parameters ========== eqs : list of SymPy expressions or equalities The equations as expressions (assumed equal to zero). funcs : list of applied functions The dependent variables of the system of ODEs. t : symbol The independent variable. order : int The order of the system of ODEs. Returns ======= The tuple ``(As, b)`` where ``As`` is a tuple of matrices and ``b`` is the the matrix representing the rhs of the matrix equation. Raises ====== ODEOrderError When the system of ODEs have an order greater than what was specified ODENonlinearError When the system of ODEs is nonlinear See Also ======== linear_eq_to_matrix: for systems of linear algebraic equations. References ========== .. [1] https://en.wikipedia.org/wiki/Matrix_differential_equation r)linear_eq_to_matrixc3T># UHnTHn[X5T:v M M g7fr;r/)r<r=r>rEorders r?r@'linear_ode_to_matrix..s$ G29R  & &s%(z(Cannot represent system in {}-order formz The system of ODEs is nonlinear.) sympy.solvers.solvesetrrrHrrangediffr1rT applyfuncrrl)rDrEr|rrmsgAsor>r\Airr=rcs ` ` r?linear_ode_to_matrixrVsl; G GGG8CJJu-.. B 5"b !,12ED !E2 H'2EB\\* % U ", !"#23C#CC%"( s7N%3  H#$FG G H$sC3 C7 C/C,cF[X5up#X#-UR5-$)a@ Matrix exponential $\exp(A*t)$ for the matrix ``A`` and scalar ``t``. Explanation =========== This functions returns the $\exp(A*t)$ by doing a simple matrix multiplication: .. math:: \exp(A*t) = P * expJ * P^{-1} where $expJ$ is $\exp(J*t)$. $J$ is the Jordan normal form of $A$ and $P$ is matrix such that: .. math:: A = P * J * P^{-1} The matrix exponential $\exp(A*t)$ appears in the solution of linear differential equations. For example if $x$ is a vector and $A$ is a matrix then the initial value problem .. math:: \frac{dx(t)}{dt} = A \times x(t), x(0) = x0 has the unique solution .. math:: x(t) = \exp(A t) x0 Examples ======== >>> from sympy import Symbol, Matrix, pprint >>> from sympy.solvers.ode.systems import matrix_exp >>> t = Symbol('t') We will consider a 2x2 matrix for comupting the exponential >>> A = Matrix([[2, -5], [2, -4]]) >>> pprint(A) [2 -5] [ ] [2 -4] Now, exp(A*t) is given as follows: >>> pprint(matrix_exp(A, t)) [ -t -t -t ] [3*e *sin(t) + e *cos(t) -5*e *sin(t) ] [ ] [ -t -t -t ] [ 2*e *sin(t) - 3*e *sin(t) + e *cos(t)] Parameters ========== A : Matrix The matrix $A$ in the expression $\exp(A*t)$ t : Symbol The independent variable See Also ======== matrix_exp_jordan_form: For exponential of Jordan normal form References ========== .. [1] https://en.wikipedia.org/wiki/Jordan_normal_form .. [2] https://en.wikipedia.org/wiki/Matrix_exponential )matrix_exp_jordan_forminv)rr|PexpJs r? matrix_exprs$N%Q*GA 8aeeg rRc ^^^^URup#X#:wa[SU<SU<S35eURT5(a [S5eSnU"U5n[UR 5[ S9nUR[ 5(+n/n/m[5n UGHupU GHn [U 5n U(Ga5XR5:wGa!U R5U;Ga X;aMGU RU R55 [[U 5T-5n[U 5T-n[[U5[!U5/[!U5*[U5//5m[XUU4Sj5m[SU -SU -U4S j5nUR#UU-5 [%U 5H=nTR#[U U55 TR#[U U55 M? GMLTR'U 5 U4S jn[XU5nUR#[U T-5U-5 GM GM [R("U6n[X"U4S j5nUU4$) a Matrix exponential $\exp(A*t)$ for the matrix *A* and scalar *t*. Explanation =========== Returns the Jordan form of the $\exp(A*t)$ along with the matrix $P$ such that: .. math:: \exp(A*t) = P * expJ * P^{-1} Examples ======== >>> from sympy import Matrix, Symbol >>> from sympy.solvers.ode.systems import matrix_exp, matrix_exp_jordan_form >>> t = Symbol('t') We will consider a 2x2 defective matrix. This shows that our method works even for defective matrices. >>> A = Matrix([[1, 1], [0, 1]]) It can be observed that this function gives us the Jordan normal form and the required invertible matrix P. >>> P, expJ = matrix_exp_jordan_form(A, t) Here, it is shown that P and expJ returned by this function is correct as they satisfy the formula: P * expJ * P_inverse = exp(A*t). >>> P * expJ * P.inv() == matrix_exp(A, t) True Parameters ========== A : Matrix The matrix $A$ in the expression $\exp(A*t)$ t : Symbol The independent variable References ========== .. [1] https://en.wikipedia.org/wiki/Defective_matrix .. [2] https://en.wikipedia.org/wiki/Jordan_matrix .. [3] https://en.wikipedia.org/wiki/Jordan_normal_form z$Needed square matrix but got shape (z, )zMatrix A should not depend on tcUR5up[URS5Vs/sH o1SS2U4PM nnSn0nUH;nUSnURSn X;a/Xh'XhRXEXY-5 XY- nM= U$s snf)zChains from Jordan normal form analogous to M.eigenvects(). Returns a dict with eignevalues as keys like: {e1: [[v111,v112,...], [v121, v122,...]], e2:...} where vijk is the kth vector in the jth chain for eigenvalue i. rNrrr) jordan_cellsrshaperl) rrblocksr`basisnchainsreigvalsizes r? jordan_chains-matrix_exp_jordan_form..jordan_chainsps NN$ !&qwwqz!23!2A1Q3!23 AtWF771:D#!# N ! !%!&/ 2 IA  4sBkeycV>X:aTTX- --[X- 5- $[SS5$Nr)rr )r`jimblockr|s r?rw(matrix_exp_jordan_form..s3?@v!ac(*Yqs^;)"1a[)rRrc4>TUS-US-4US-US-4$r rJ)r`r  expJblock2s r?rwr s+AqDAI9NqQRsSTUVSVw9WrRc<>X:aTX- -[X- 5- $S$Nrr)r`r r|s r?rwr s"QV!ac(9QS>"9"J"JrRc>TUU$r;rJ)r`r vectorss r?rwr s ArR)r ValueErrorrsortedrr rrr conjugateaddrrrr!rrrlrextenddiag)rr|NMr eigenchainseigenchains_iterisrealrseen_conjugater{rchainrexprtimrt expJblockr`funrrrr rs ` @@@r?rr6sh 77DAv!QOPP q:;;& "Kk//17GHq\F FGUN% EE A!{{},+1M&""1;;=1BqEAI!uqy 3t9c$i"8$'I:s4y"9";<#A+)* #1Q3!-WX  ei/0qANN2eAh<0NN2eAh<0"u%J"1-  c!a%j945/&4 ;; Dq./A d7NrRc ^^[U[5(d[[S55eUR(d[ [S55eUbW[U[5(d[[S55eUR UR :wa[[S55eUb|[U[5(d[[S55eUR(d[ [S55eUR UR :wa[[S55e[U4S j[S S 555(dTS :Xd[[S 55eUR n[[U5Vs/sH n[5PM sn5n Uc&[U4SjS55(a [US 5nUSLn Tn TS :Xa[UTUS9n U SmU SnTS;aTSn U S :waLUcI[UTUS9n U (d#[[SRT555eU SnU SmU SnU SnU4Sjn TS;ah[UT5up[!U5nTS;aXU --nOUR#TT*5nX-UUR%5-U-R'U 5U --nObUc[)UT5up8TS:XaUR+5U -nO7UR+5U*R+5U-R'U 5U --nU (aUR#TU5nUR-[*5nTS:waUVs/sHn[/U5PM nnUVs/sHn[1U[3U5SS9PM nnU(a UVs/sHnUR55PM nnU$s snfs snfs snfs snf) a System of n equations linear first-order differential equations Explanation =========== This solver solves the system of ODEs of the following form: .. math:: X'(t) = A(t) X(t) + b(t) Here, $A(t)$ is the coefficient matrix, $X(t)$ is the vector of n independent variables, $b(t)$ is the non-homogeneous term and $X'(t)$ is the derivative of $X(t)$ Depending on the properties of $A(t)$ and $b(t)$, this solver evaluates the solution differently. When $A(t)$ is constant coefficient matrix and $b(t)$ is zero vector i.e. system is homogeneous, the system is "type1". The solution is: .. math:: X(t) = \exp(A t) C Here, $C$ is a vector of constants and $A$ is the constant coefficient matrix. When $A(t)$ is constant coefficient matrix and $b(t)$ is non-zero i.e. system is non-homogeneous, the system is "type2". The solution is: .. math:: X(t) = e^{A t} ( \int e^{- A t} b \,dt + C) When $A(t)$ is coefficient matrix such that its commutative with its antiderivative $B(t)$ and $b(t)$ is a zero vector i.e. system is homogeneous, the system is "type3". The solution is: .. math:: X(t) = \exp(B(t)) C When $A(t)$ is commutative with its antiderivative $B(t)$ and $b(t)$ is non-zero i.e. system is non-homogeneous, the system is "type4". The solution is: .. math:: X(t) = e^{B(t)} ( \int e^{-B(t)} b(t) \,dt + C) When $A(t)$ is a coefficient matrix such that it can be factorized into a scalar and a constant coefficient matrix: .. math:: A(t) = f(t) * A Where $f(t)$ is a scalar expression in the independent variable $t$ and $A$ is a constant matrix, then we can do the following substitutions: .. math:: tau = \int f(t) dt, X(t) = Y(tau), b(t) = b(f^{-1}(tau)) Here, the substitution for the non-homogeneous term is done only when its non-zero. Using these substitutions, our original system becomes: .. math:: Y'(tau) = A * Y(tau) + b(tau)/f(tau) The above system can be easily solved using the solution for "type1" or "type2" depending on the homogeneity of the system. After we get the solution for $Y(tau)$, we substitute the solution for $tau$ as $t$ to get back $X(t)$ .. math:: X(t) = Y(tau) Systems of "type5" and "type6" have a commutative antiderivative but we use this solution because its faster to compute. The final solution is the general solution for all the four equations since a constant coefficient matrix is always commutative with its antidervative. An additional feature of this function is, if someone wants to substitute for value of the independent variable, they can pass the substitution `tau` and the solution will have the independent variable substituted with the passed expression(`tau`). Parameters ========== A : Matrix Coefficient matrix of the system of linear first order ODEs. t : Symbol Independent variable in the system of ODEs. b : Matrix or None Non-homogeneous term in the system of ODEs. If None is passed, a homogeneous system of ODEs is assumed. B : Matrix or None Antiderivative of the coefficient matrix. If the antiderivative is not passed and the solution requires the term, then the solver would compute it internally. type : String Type of the system of ODEs passed. Depending on the type, the solution is evaluated. The type values allowed and the corresponding system it solves are: "type1" for constant coefficient homogeneous "type2" for constant coefficient non-homogeneous, "type3" for non-constant coefficient homogeneous, "type4" for non-constant coefficient non-homogeneous, "type5" and "type6" for non-constant coefficient homogeneous and non-homogeneous systems respectively where the coefficient matrix can be factorized to a constant coefficient matrix. The default value is "auto" which will let the solver decide the correct type of the system passed. doit : Boolean Evaluate the solution if True, default value is False tau: Expression Used to substitute for the value of `t` after we get the solution of the system. Examples ======== To solve the system of ODEs using this function directly, several things must be done in the right order. Wrong inputs to the function will lead to incorrect results. >>> from sympy import symbols, Function, Eq >>> from sympy.solvers.ode.systems import canonical_odes, linear_ode_to_matrix, linodesolve, linodesolve_type >>> from sympy.solvers.ode.subscheck import checkodesol >>> f, g = symbols("f, g", cls=Function) >>> x, a = symbols("x, a") >>> funcs = [f(x), g(x)] >>> eqs = [Eq(f(x).diff(x) - f(x), a*g(x) + 1), Eq(g(x).diff(x) + g(x), a*f(x))] Here, it is important to note that before we derive the coefficient matrix, it is important to get the system of ODEs into the desired form. For that we will use :obj:`sympy.solvers.ode.systems.canonical_odes()`. >>> eqs = canonical_odes(eqs, funcs, x) >>> eqs [[Eq(Derivative(f(x), x), a*g(x) + f(x) + 1), Eq(Derivative(g(x), x), a*f(x) - g(x))]] Now, we will use :obj:`sympy.solvers.ode.systems.linear_ode_to_matrix()` to get the coefficient matrix and the non-homogeneous term if it is there. >>> eqs = eqs[0] >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1) >>> A = A0 We have the coefficient matrices and the non-homogeneous term ready. Now, we can use :obj:`sympy.solvers.ode.systems.linodesolve_type()` to get the information for the system of ODEs to finally pass it to the solver. >>> system_info = linodesolve_type(A, x, b=b) >>> sol_vector = linodesolve(A, x, b=b, B=system_info['antiderivative'], type=system_info['type_of_equation']) Now, we can prove if the solution is correct or not by using :obj:`sympy.solvers.ode.checkodesol()` >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)] >>> checkodesol(eqs, sol) (True, [0, 0]) We can also use the doit method to evaluate the solutions passed by the function. >>> sol_vector_evaluated = linodesolve(A, x, b=b, type="type2", doit=True) Now, we will look at a system of ODEs which is non-constant. >>> eqs = [Eq(f(x).diff(x), f(x) + x*g(x)), Eq(g(x).diff(x), -x*f(x) + g(x))] The system defined above is already in the desired form, so we do not have to convert it. >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1) >>> A = A0 A user can also pass the commutative antiderivative required for type3 and type4 system of ODEs. Passing an incorrect one will lead to incorrect results. If the coefficient matrix is not commutative with its antiderivative, then :obj:`sympy.solvers.ode.systems.linodesolve_type()` raises a NotImplementedError. If it does have a commutative antiderivative, then the function just returns the information about the system. >>> system_info = linodesolve_type(A, x, b=b) Now, we can pass the antiderivative as an argument to get the solution. If the system information is not passed, then the solver will compute the required arguments internally. >>> sol_vector = linodesolve(A, x, b=b) Once again, we can verify the solution obtained. >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)] >>> checkodesol(eqs, sol) (True, [0, 0]) Returns ======= List Raises ====== ValueError This error is raised when the coefficient matrix, non-homogeneous term or the antiderivative, if passed, are not a matrix or do not have correct dimensions NonSquareMatrixError When the coefficient matrix or its antiderivative, if passed is not a square matrix NotImplementedError If the coefficient matrix does not have a commutative antiderivative See Also ======== linear_ode_to_matrix: Coefficient matrix computation function canonical_odes: System of ODEs representation change linodesolve_type: Getting information about systems of ODEs to pass in this solver zT The coefficients of the system of ODEs should be of type Matrix z< The coefficient matrix must be a square Nze The non-homogeneous terms of the system of ODEs should be of type Matrix z The system of ODEs should have the same number of non-homogeneous terms and the number of equations zn The antiderivative of coefficients of the system of ODEs should be of type Matrix zZ The antiderivative of the coefficient matrix must be a square zv The coefficient matrix and its antiderivative should have same dimensions c3L># UHnTSRU5:Hv M g7f)rN)r)r<r`rs r?r@linodesolve..s?;atxq));s!$rautozI The input type should be a valid one c3.># UH nTU:Hv M g7fr;rJ)r<typrs r?r@r'sL0K0K)type2type4type6rrr)type5r/TzI The system passed isn't {}. rrrrc.>U(a [UT5$S$r)r7)xr|s r?rwlinodesolve..sA(1a.414rR)type1r-r0r/)r4r0type3r4)exact)rjr#rr6 is_squarer"rowsrrr!r r rrrrr-rrrrrrerr'r r)rr|rrrrrr_Cvectis_transformed passed_type system_info intx_wrttrJ sol_vectorJinvrfrs ` ` r? linodesolverBsd a $ $%    ;;":/ $   }!Z((Z)  66QVV Z)   }!Z((Z) {{&z3(  66QVV Z)  ?5A;? ? ?PV%  A U1X.XEGX. /EySL0KLLL !QK_NK v~&q!q1 -. ( ) !! & {71B "$Z1t &&''"%(%$$4I 33%a+ QK % %%iJ66!aR=D4!%%'>A#5"@"@"Ke"STJ 921a8DA 7?5JqbXXZ!^$>$>y$IE$QRJ__Q,   C D w-78ZjmZ 8AKLA'!WT]$7JL (23 1affh 3 y/j9L4sN7N<.OOc.^[U4SjU55$)z2Checks if the matrix M is independent of t or not.c3N># UHoRTSS9SS:Hv M g7f)T)rrrN)ry)r<rZr|s r?r@&_matrix_is_constant..s)Iqt""1T"215:qs"%)all)rr|s `r?rrs IqI IIrRc TSSKJn [X5nU"U/UVs/sHoURX$U5PM snQ7SS06n/nUHVnUVs/sH5n[ URX$U5XRX$U55PM7 n nUR U 5 MX U$s snfs snf)az Function that solves for highest order derivatives in a system Explanation =========== This function inputs a system of ODEs and based on the system, the dependent variables and their highest order, returns the system in the following form: .. math:: X'(t) = A(t) X(t) + b(t) Here, $X(t)$ is the vector of dependent variables of lower order, $A(t)$ is the coefficient matrix, $b(t)$ is the non-homogeneous term and $X'(t)$ is the vector of dependent variables in their respective highest order. We use the term canonical form to imply the system of ODEs which is of the above form. If the system passed has a non-linear term with multiple solutions, then a list of systems is returned in its canonical form. Parameters ========== eqs : List List of the ODEs funcs : List List of dependent variables t : Symbol Independent variable Examples ======== >>> from sympy import symbols, Function, Eq, Derivative >>> from sympy.solvers.ode.systems import canonical_odes >>> f, g = symbols("f g", cls=Function) >>> x, y = symbols("x y") >>> funcs = [f(x), g(x)] >>> eqs = [Eq(f(x).diff(x) - 7*f(x), 12*g(x)), Eq(g(x).diff(x) + g(x), 20*f(x))] >>> canonical_eqs = canonical_odes(eqs, funcs, x) >>> canonical_eqs [[Eq(Derivative(f(x), x), 7*f(x) + 12*g(x)), Eq(Derivative(g(x), x), 20*f(x) - g(x))]] >>> system = [Eq(Derivative(f(x), x)**2 - 2*Derivative(f(x), x) + 1, 4), Eq(-y*f(x) + Derivative(g(x), x), 0)] >>> canonical_system = canonical_odes(system, funcs, x) >>> canonical_system [[Eq(Derivative(f(x), x), -1), Eq(Derivative(g(x), x), y*f(x))], [Eq(Derivative(f(x), x), 3), Eq(Derivative(g(x), x), y*f(x))]] Returns ======= List r)solvedictT)sympy.solvers.solversrHrFrr rl) rDrEr|rHrr> canon_eqssystemsr=systems r?canonical_odesrNst, C 'EcU5I54YYq+65IUPTUIG[`a[`SW"TYYq+.99Qd 3L0MN[`av NJbs B >> from sympy import symbols, Matrix >>> from sympy.solvers.ode.systems import _is_commutative_anti_derivative >>> t = symbols("t") >>> A = Matrix([[1, t], [-t, 1]]) >>> B, is_commuting = _is_commutative_anti_derivative(A, t) >>> is_commuting True Returns ======= Matrix, Boolean F)r8rrrr)rr|rrs r?rr9sKV !AC!#I((0::<HWWL(05lL ?rRcSnUH1nURU5SnURU5(dM/Un O Ub.X- R[5n[ XQ5nU(aX%4OSnU$)Nr)ryrrr,r)rr|relement temp_term A_factored can_factors r?rrlsr D**1-a0 ==  D    f''0 (7 %/!T KrRc[X5nSnUbSUS- nUR5nU(a[UR5U5nUR 5nUSSS;a[ US5nUupxpn [ [U5SS9n [ [U 5SS9n [ [U SU -U -- 5SS9nUSU -U-:H=(a U SU-U -:HnXS--X--U -nX24$SnX24$) NFrr)rrVT)forcer)rrr%rri_get_poly_coeffsr*r)rr|ris_type2polyricsrvrrrr{a1c1b1s r?_is_second_order_type2r_|s ! DH ay%%'DKKM1% !9Q<6 !!$*BMA!47$/B47$/B4AbDG ,D9BQrT"W 81"RB&D >H >rRc[US-5Vs/sHnSPM nn[UR5UR55HupEXCSUS- 'M U$s snf)Nrrr)rrgrhri)rZrr9r[rms r?rXrXsV57^ $^!^B $DKKM4;;=12ad7 2 I %s Ac SS0nURSn[X5(a[X5(aU$XU--R[5R(aUR SUS.5 U$UR(aUbUR(a[ X5upgU(a[[Xr5S5upn XS-R5-R[5US-S- X-- [XU5--n [SU- U5n [S RU55n UR S U [U5U S U S .5 U$) a Works only for second order system in its canonical form. Type 0: Constant coefficient matrix, can be simply solved by introducing dummy variables. Type 1: When the substitution: $U = t*X' - X$ works for reducing the second order system to first order system. Type 2: When the system is of the form: $poly * X'' = A*X$ where $poly$ is square of a quadratic polynomial with respect to *t* and $A$ is a constant coefficient matrix. rtype0rr4)rA1rrVrrr-T)rA0g(t)rr;r)rrrrrrr_rXr%rr,r$r8rrr) rdrer|rrrrYrrvrrrrs r?_match_second_order_typergs+  )E  A2!!&9"&@&@  T Z(77 '<= L   Q-=-=/6 &tD}a8GA!1W$$&&11':ad1fqslCPQI=UUAAdFA&C Q(B LLgQ"&t*SD "$ % LrRc [UVs/sHoCURU5-U- PM sn5n[XX1-5n[Xe5VVs/sHupx[ X5PM n nn[ XU5Sn U $s snfs snnf)a{ For a linear, second order system of ODEs, a particular substitution. A system of the below form can be reduced to a linear first order system of ODEs: .. math:: X'' = A(t) * (t*X' - X) + b(t) By substituting: .. math:: U = t*X' - X To get the system: .. math:: U' = t*(A(t)*U + b(t)) Where $U$ is the vector of dependent variables, $X$ is the vector of dependent variables in `funcs` and $X'$ is the first order derivative of $X$ with respect to $t$. It may or may not reduce the system into linear first order system of ODEs. Then a check is made to determine if the system passed can be reduced or not, if this substitution works, then the system is reduced and its solved for the new substitution. After we get the solution for $U$: .. math:: U = a(t) We substitute and return the reduced system: .. math:: a(t) = t*X' - X Parameters ========== A: Matrix Coefficient matrix($A(t)*t$) of the second order system of this form. b: Matrix Non-homogeneous term($b(t)$) of the system of ODEs. funcs: List List of dependent variables t: Symbol Independent variable of the system of ODEs. Returns ======= List r)r!rrBrgr rN) rrrEr|r>Urnru reduced_eqss r?_second_order_subs_type1rlszb %8%$$))A,%%89A aAC C(+C 4 2a8 K4 Q7:K  95s A8 A=c rUVs/sHo3RRPM nnUVs/sH,n[[SR U555"U5PM. nnU[ U5-n[ Xg5VVs/sH!up8[URUS5U5PM# n nnX4$s snfs snfs snnf)a Returns a second order system based on the coefficient matrix passed. Explanation =========== This function returns a system of second order ODE of the following form: .. math:: X'' = A * X Here, $X$ is the vector of dependent variables, but a bit modified, $A$ is the coefficient matrix passed. Along with returning the second order system, this function also returns the new dependent variables with the new independent variable `t_` passed. Parameters ========== A: Matrix Coefficient matrix of the system funcs: List List of old dependent variables t_: Symbol New independent variable Returns ======= List, List rr) r>rLrr rr!rgr r) rrErr> func_namesname new_funcsrhssrcnew_eqss r?_second_order_subs_type2rssD277))$$J7EOPZT% T 234R8ZIP vi D:=i:NO:NYTr$))B"C(:NGO   8POsB)3B.;(B3c@^[U4Sj[U555$)Nc3r># UH,up[UTU--R[5T5v M. g7fr;)rrr,)r<r`rr|s r?r@#_is_euler_system..)s1]}tq"AadF#5#5g#>BB}s47)rF enumerate)rr|s `r?_is_euler_systemrx(s ]yY[}] ]]rRc^^[U5[U5:wa[SU-5eUH*n[UR5S:wdM[SU-5e [X5m[ U4SjU55nUS:nUS:H=(a [ U4SjU55nU(d [ XT5OU/n[U5S:Xa[USUTU5upOSUS .n U $Sn U R(aSOS n [U5UUTU U SS .n U (dXS '[ U4SjU 55nU(dUU SnXS'[UT5nXS'[UTU S9nU RU5 U RS5nU(dUU S'U $SU S'U(a+U SS unn[UUT5nU RU5 SU S'U SS:XaU(d[!U T5nU(a0[#SR%T55nU RSSUS.5 OoSn['U ST5n[ SU SS55(aCUb@U"US5(d0USR)5unnU RSUUSUSS.5 U SS:waU(aU RSS 5 XkS'U $![a g f=f![a g f=f) a Returns a dictionary with details of the eqs if the system passed is linear and can be classified by this function else returns None Explanation =========== This function takes the eqs, converts it into a form Ax = b where x is a vector of terms containing dependent variables and their derivatives till their maximum order. If it is possible to convert eqs into Ax = b, then all the equations in eqs are linear otherwise they are non-linear. To check if the equations are constant coefficient, we need to check if all the terms in A obtained above are constant or not. To check if the equations are homogeneous or not, we need to check if b is a zero matrix or not. Parameters ========== eqs: List List of ODEs funcs: List List of dependent variables t: Symbol Independent variable of the equations in eqs is_canon: Boolean If True, then this function will not try to get the system in canonical form. Default value is False Returns ======= match = { 'no_of_equation': len(eqs), 'eq': eqs, 'func': funcs, 'order': order, 'is_linear': is_linear, 'is_constant': is_constant, 'is_homogeneous': is_homogeneous, } Dict or list of Dicts or None Dict with values for keys: 1. no_of_equation: Number of equations 2. eq: The set of equations 3. func: List of dependent variables 4. order: A dictionary that gives the order of the dependent variable in eqs 5. is_linear: Boolean value indicating if the set of equations are linear or not. 6. is_constant: Boolean value indicating if the set of equations have constant coefficients or not. 7. is_homogeneous: Boolean value indicating if the set of equations are homogeneous or not. 8. commutative_antiderivative: Antiderivative of the coefficient matrix if the coefficient matrix is non-constant and commutative with its antiderivative. This key may or may not exist. 9. is_general: Boolean value indicating if the system of ODEs is solvable using one of the general case solvers or not. 10. rhs: rhs of the non-homogeneous system of ODEs in Matrix form. This key may or may not exist. 11. is_higher_order: True if the system passed has an order greater than 1. This key may or may not exist. 12. is_second_order: True if the system passed is a second order ODE. This key may or may not exist. This Dict is the answer returned if the eqs are linear and constant coefficient. Otherwise, None is returned. zDNumber of functions given is not equal to the number of equations %srzOdsolve() and classify_sysode() work with functions of one variable only, not %sc3.># UH nTUv M g7fr;rJr<r>rs r?r@*_classify_linear_system..s5utuT{ur,rc34># UH nTUS:Hv M g7f)rNrJr{s r?r@r|s/SUTd q0@UsrT) is_implicitrKNF)no_of_equationr=r>r is_linearr is_generalrcc3<># UHn[UT5v M g7fr;)r)r<A_r|s r?r@r|s>2R)"a002rBr is_constantrrcommutative_antiderivativercris_second_orderrr4)r;rrcVU[R"URSUS5:H$)Nrr)r! jordan_blockr)rs r?rw)_classify_linear_system..s"a6+>+>qwwqz1T7+S&SrRrc38# UHoRv M g7fr;)r)r<rs r?r@r|s:A''sr-)rr?f(t)rr;is_higher_order)rrrkrFrCrFrNrrTrrrrrpoprgrxrrr jordan_form)rDrEr|is_canonr> system_orderrrrKrrrrrrrr=rrdrematch_second_orderis_eulerr is_jordanrprr?rs ` @r?_classify_linear_systemr,s\ 5zSX_bgghh tyy>Q 57;<= = C 'E5u55L"Q&O"a'SC/SU/S,SO 9AN3q1u y>Q (1uaNEB $&E LI--T5N c(( E e >2>>K  qEl*!Q/ *m *1a15K  [!#342@E. / $+ ! VFB!9"b!!D  LL+ ,'+E# $ # $ / 'A.HELLO, '$&()T &r"vq1:Ab:::u?PYbchijckYlYl 8//1DAqLLgA*/(d"TU'(G3 +T2#2  c L#  s* 8J'J' J7' J43J47 KKc/nUH5nUR[U[5(aUO [US55 M7 U$r)rlrjr r )rD processed_eqsr=s r?_preprocess_eqsrs;M:b(#;#;RBK rRc0n0n[U5nUHRnURR[5unURR[5U1- U-nXsU'XRU'MT X24$r;)rrbrerrc)rDrEeqsorigeqsmapfuncsetr=f1f2ss r? _eqs2dictrsiG F%jGffll<(vv||L)RD0G;r   ?rRc[U5nUR5VVVs/sHup#UHoBU4PM M nnnnX4nU$s snnnfr;)rdr)rnodesrrf2edgesGs r? _dict2graphrsB GE%&WWY =Y'"2"XXYE = A H >sAcUup#[X#US5uupEn[XQ5(aUR(agg![[4a gf=f)NrFT)rrTrHrr)sccr|rDrErdrers r? _is_type1r sVJC*3q!< !2!!a&6&6  } -s;A Ac^^[[UT55VVs/sHup4[XB5(dMUPM nnn[5n[U5HPunmXWS-SH?n[ UU4SjX55(dM"UTX-X'UR T5 MA MR [U5VVs/sHup4X6;dM UPM nnnU$s snnfs snnf)Nrc3J># UHoRTT5v M g7fr;)r)r<eq2rEr`s r?r@,_combine_type1_subsystems..s= 7758$$ s #)rwrgrrrr) subsystemrEr|r`sysindicesremoveipr s ` ` r?_combine_type1_subsystemsrs(Y)>?U?VQ9SCTq?GU UF7#AAA= ===(|il:  1  $ $-Y#7K#71?#7IK VLsCC5 CCc P[X5up4/n[[U55HnnUVs0sHowX7_M nn[[U55n U V Vs/sHoVs/sHotUPM snPM n n n[ XU5n UR U 5 Mp U$s snfs snfs snn fr;)rr3rr5rrl) rDrEr|rr subsystemsccfeqsmap_csccsrrs r?_component_divisionr&s  +OFJ";v#67*,-"QvyL"-,[-BC:>?$3#.#Qaj#.$ ?-iqA )$ 8  ..?sB B"B+B"B"c &USnUSnURSS5nURSS5nSU;aUSOUnUSnURSS5nUSn[XQX6XtS 9n[X(5V V s/sHup[X5PM n n n U $s sn n f) Nr|r>rcrrrrr)rrrr)getrBrgr ) rr|rErcrrrrr@rrrns r?_linear_ode_solverr9s c A &ME ))E4 C ))E4 Cu}d !A lA  .5A # $DQS"&1J!$E 6 7 62a8 6C 7 J 8s1B cU$r;rJ)r2s r?rwrwOsrRc UVs0sHo3RUR_M nnUVs/sHn[XTU"U55PM sn$s snfs snfr;)rbrcr )rDrErr{eq_dictrs r?_select_equationsrOsJ%()Suuaee|SG),1 2EqBq#a&/ "E 22* 2s A Ac^^USnUSnUSmUSnURSS5nURSS5nURS S5nU=(a US :HnU=(a US :H=(a S U;nU(aR[XTURS S5URSS5URSS5UURSS5S9upOQ[XTUX@RSS5URSS5URS S5URSS5S9 upU(aURST5mU(d*[XV s/sHoR T5PM sn 5n Sn U(d [ XT5n U c [XT5n U cU $U=(a US :Hn U(aSOSm[XUU4SjS9n URS S5(aU (aOUSnUSnU Vs/sH6n[URURRTU5U-5PM8 n nU $U(a7USmUSnU Vs/sHnURU[T55PM n nU $U(aYUS nU[U Vs/sHnURPM sn5-n[UU5V Vs/sHun n[U U5PM n n nU $s sn f![ a Sn GN^f=f![ a Sn GNaf=fs snfs snfs snfs snn f)Nr=r>r|rrrcrFr;r4r-rrdrercr)rdrerrrr?r)rErr?f_trr__r9c>[[SRURRT555"T5$)Nz{}{}0)rr rr>rL)r2r| underscoress r?rw*_higher_order_ode_solver..s)(5Yd9e3f*ghi*jrRrrfr)r_second_order_to_first_order_higher_order_to_first_orderrr_strong_component_solverr_component_solverr rbrcrrr!rg)rrDrEsysorderrrr;ris_higher_order_type2rrrprrnis_second_order_type2g_trrrr@r|rs @@r?_higher_order_ode_solverrTs +C &ME c AW~H 99' 1Dii 159OYY/7N1$'/H*OtwO3%<9#a=BYYtT=RW\W`W`aegkWlCiiPT>U?(>12a8(>C? JW.L # C "E5%9?sBK ,K K!(=K4>%K9=K> +L KK! K10K1cSSKJnJn [XUSS9nSnU(aX%S'UR SS5(a [ U5nO"UR SS5(a [ U5nUcq[U5S :XabU"USUSS 9n[US5Rn[[USUS55Vs/sH n[5PM n nU"XgU S 9nU/nU$s snf) Nr)dsolveconstant_renumberT)rr|rFrr)r>) variables newconstants) sympy.solvers.ode.oderrrrrrrrrrr0r ) rDrEr|rrrrnrr9 new_constantss r?rrs? #CD AE C  c 99& . .*51C YY{E * *$U+C ;3s8q=QeAh/Cc!f 22I.3Ic!feAh4O.PQ.PUW.PMQ#C=YC%C J Rs:Cc^UVs/sHoRRSPM sn$s snfr)rbrk)rDr=s r?_get_funcs_from_canonrs$%( )SrFFKKNS )) )s"*c /nUHnX#- nM [U5n[X$U5nU(aU$/nUH~nUn[U5nUVVs/sH8ofRUVs0sHowRUR_M sn5PM: nnn[XU5n U c[ [ S55eXY- nM U$s snfs snnf)NzZ The system of ODEs passed cannot be solved by dsolve_system. )rrrrbrcrr6) wccr|rDrrErnr=rcomp_eqsscc_sols r?_weak_component_solverrs C  !# &E "3q 1C  C%c*DGG3RGG373aUUAEE\3783G*8A> ?%j2'  !$ J8Gs B= B8= B=8B=cP[XU5n/nUHnU[XR5- nM U$r;)rr)rDrEr| componentsrnrs r?rrs6$S3J C %c-- JrRcUSLnUSLn US:XaU(d!US:XaU (dUS:XaEU(dU (a7[XUS5uuppVU R(d[[S55eUS:Xa5[ XEU5n U SnU R SS5nU R S S5n[ RUS5n US:Xa9Uc[[U55n[XFX5n[ RUS 5n US:XaCUc[S RU55nUn[XQU5up[ RUS5n [X X!S 9$) a/ Expects the system to be in second order and in canonical form Explanation =========== Reduces a second order system into a first order one depending on the type of second order system. 1. "type0": If this is passed, then the system will be reduced to first order by introducing dummy variables. 2. "type1": If this is passed, then a particular substitution will be used to reduce the the system into first order. 3. "type2": If this is passed, then the system will be transformed with new dependent variables and independent variables. This transformation is a part of solving the corresponding system of ODEs. `A1` and `A0` are the coefficient matrices from the system and it is assumed that the second order system has the form given below: .. math:: A2 * X'' = A1 * X' + A0 * X + b Here, $A2$ is the coefficient matrix for the vector $X''$ and $b$ is the non-homogeneous term. Default value for `b` is None but if `A1` and `A0` are passed and `b` is not passed, then the system will be assumed homogeneous. Nr4r-r)rzG The system must be in its canonical form. rrdrerrrE)r is_Identityrr6rgrrIfromkeysr rrlrrrsr) rDrEr|rrdrerris_a1is_a0A2r sys_orders r?rrs9> $JE $JE Etw5 FN.s1a@ ~~Z)  v~(3'( YYtT " YYtT " eQ'I w 9c#hA&re7MM%+  w : Q(B -b< MM%+ ' GGrRc  UbUb[X5(d[[S55eUc(Ub%UR(d[[S55e[ UVs/sH@n[ [ SRURR555"U5PMB sn5nURX45X-U-- n Ub&UR(dXR5U--n [XU5Sn X4$s snf)Nzi Correctly input for args 'A' and 'f_t' for Linear, Higher Order, Type 2 zN Provide the keyword 'P' for matrix P in A = P * J * P-1. z{}__0r) rrr6rr!rr rr>rLrrrN) r?rrEr| max_orderrrrrprrs r?"_higher_order_type2_to_sub_systemsr;s yCK':1'@'@%     yQ]1+;+;%   UZ[UZPQw~~affoo'F!GHKUZ[\InnQ*SWy-@@G}Q--557Q;W3A6G  \sADc ^^^ ^!UcTR5nUS:XGa[SRU55m!UVs/sH@n[[ SRUR R 555"T!5PMB nn[U4SjU55n[[X755n [T!5X'[[ 55m U4Sjm[SUS-5Hn T "[T!55RT!U 5T!U --n T"U 5n [U S-5V s/sHoU ;aXOSPM nn [U U!4Sj[U555X*-- nU R![X75VVs0sH.unnURX*5UR#T "T!5U5_M0 snn5 M UVs/sHnUR#U 5PM nn[X75VVs0sH unnUTU_M nnn[%UUT!5Sn['UUT!US9$US :XakUR)S S5nUR)S S5nUR)S S5nUR)S S5n[U4SjU55n[+UUX2UUUS9$/nUGH)nUR R n[[ SRU555"U5nUR-U5 UU0n /n[STU5Hn[[ SRUU555"U5nUU URUU5'UR-U5 U URUUS- 5n[/URU5U5nUR-U5 M UVs/sHnUR#U 5PM snU-nGM, X4$s snfs sn fs snnfs snfs snnfs snf)Nr4rc3.># UH nTUv M g7fr;rJr<r>rs r?r@/_higher_order_to_first_order..\:ED $Er,c8>[U[5(a.URSSnURSn[X!5S0$[U[5(aAURSn[ T"URS5R 55SnXC0$[U[5(ak0nURHWn[U[5(aURT"U55 M1[ T"U5R 55SnSXT'MY U$g)Nrr) rjrrkr0rrdkeysrr)r free_symbolrrqrrharg _get_coeffs_from_subs_expressions r?rF_higher_order_to_first_order.._get_coeffs_from_subs_expressionbs$%%"iil1o yy|!$4a88$$$ ! =diilKPPRSTUV~%$$$99C!#s++ &Fs&KL!%%Ec%J%O%O%Q RST U() % %rRrrc3^># UH"upT"T5RTU5U-v M$ g7fr;)r)r<r`r free_functionrs r?r@r~s3+)FJQ}R055b!# UH nTUv M g7fr;rJrs r?r@rrr,)rrz{}_0z{}_{})rrrrr r>rLrCrIrgrrrrsumrwrrrNrrrrlr )"rDrr|rErkwargsrrpr subs_dictrr coeff_dictrrh expr_to_subsnfr=rr new_sys_orderr?rrr prev_func func_namer>r`new_funcprev_fnew_eqrrrs" ` @@@r?rrTs }  w ELLO $QVWQVAXeELL$ABCBGQV W:E:: U./ 2w  )  0q)a-(A R)..r15b!e;D9$?JSXYZ]^Y^S_`S_%J+>j'AES_F`+!&)++-.T2L   +.u+@B+@%!R ffQlL,=,=mB>OQS,TT+@B C )144"2779%47:57LM7LeaYq\)7L M )R8;+G]BiXX  w JJsD !jj% JJsD ! JJsD !:E:: 1!S%IQRVWXXI NN++ fmmI678;% q)I./AgnnY&B CDQGH.6IinnQ* +   X &y~~a156F A1F NN6 "0-00Cbrwwy!C07:!$ >iXDaB5MR1s$AO&O:5O ?O*OOcSSKJnJnJn [ U5(d[ [ S55e[U5nUb)[U[5(d[ [ S55eUcU"U5n[SU55(a[ [ S55e[U5[U5:wa[ [ S55eUb)[U[5(d[ [ S 55eUcC[[USR[55SR[55Sn/n [XU5n U H0n [!XU5n U c [%XU5n U R'U 5 M2 U (a/n [)U6R*nU Hn [-X5n U"XS 9n U(a?[)U 6R*U- nU"XX5nU Vs/sHnUR/U5PM n nU(a [)U 6R*U- n[1X/XS 9n U R'U 5 M U n U $!["a Sn Nf=fs snf) a? Solves any(supported) system of Ordinary Differential Equations Explanation =========== This function takes a system of ODEs as an input, determines if the it is solvable by this function, and returns the solution if found any. This function can handle: 1. Linear, First Order, Constant coefficient homogeneous system of ODEs 2. Linear, First Order, Constant coefficient non-homogeneous system of ODEs 3. Linear, First Order, non-constant coefficient homogeneous system of ODEs 4. Linear, First Order, non-constant coefficient non-homogeneous system of ODEs 5. Any implicit system which can be divided into system of ODEs which is of the above 4 forms 6. Any higher order linear system of ODEs that can be reduced to one of the 5 forms of systems described above. The types of systems described above are not limited by the number of equations, i.e. this function can solve the above types irrespective of the number of equations in the system passed. But, the bigger the system, the more time it will take to solve the system. This function returns a list of solutions. Each solution is a list of equations where LHS is the dependent variable and RHS is an expression in terms of the independent variable. Among the non constant coefficient types, not all the systems are solvable by this function. Only those which have either a coefficient matrix with a commutative antiderivative or those systems which may be divided further so that the divided systems may have coefficient matrix with commutative antiderivative. Parameters ========== eqs : List system of ODEs to be solved funcs : List or None List of dependent variables that make up the system of ODEs t : Symbol or None Independent variable in the system of ODEs ics : Dict or None Set of initial boundary/conditions for the system of ODEs doit : Boolean Evaluate the solutions if True. Default value is True. Can be set to false if the integral evaluation takes too much time and/or is not required. simplify: Boolean Simplify the solutions for the systems. Default value is True. Can be set to false if simplification takes too much time and/or is not required. Examples ======== >>> from sympy import symbols, Eq, Function >>> from sympy.solvers.ode.systems import dsolve_system >>> f, g = symbols("f g", cls=Function) >>> x = symbols("x") >>> eqs = [Eq(f(x).diff(x), g(x)), Eq(g(x).diff(x), f(x))] >>> dsolve_system(eqs) [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]] You can also pass the initial conditions for the system of ODEs: >>> dsolve_system(eqs, ics={f(0): 1, g(0): 0}) [[Eq(f(x), exp(x)/2 + exp(-x)/2), Eq(g(x), exp(x)/2 - exp(-x)/2)]] Optionally, you can pass the dependent variables and the independent variable for which the system is to be solved: >>> funcs = [f(x), g(x)] >>> dsolve_system(eqs, funcs=funcs, t=x) [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]] Lets look at an implicit system of ODEs: >>> eqs = [Eq(f(x).diff(x)**2, g(x)**2), Eq(g(x).diff(x), g(x))] >>> dsolve_system(eqs) [[Eq(f(x), C1 - C2*exp(x)), Eq(g(x), C2*exp(x))], [Eq(f(x), C1 + C2*exp(x)), Eq(g(x), C2*exp(x))]] Returns ======= List of List of Equations Raises ====== NotImplementedError When the system of ODEs is not solvable by this function. ValueError When the parameters passed are not in the required form. r) solve_ics_extract_funcsrzQ List of equations should be passed. The input is not valid. NzG Input to the funcs should be a list of functions. c3R# UHn[UR5S:gv M g7f)rN)rrk)r<r>s r?r@ dsolve_system.. s 1543tyy>Q 5s%'zn dsolve_system can solve a system of ODEs with only one independent variable. zN Number of equations and number of functions do not match zE The independent variable must be of type Symbol )r)r)rrrrr4rr6rrjrdrrrrerrNrrrrlrrrrr)rDrEr|icsrr-rrrsolsrKcanon_eqrn final_solsr constantssolved_constantsrs r? dsolve_systemrsLzSR C==%    # C E4!8!8%    }s# 15 111%     3x3u:%    }Z622%    y c!fll:./288@ A! D Ds1-I *8A>C ;#HQ7C C  3K,, C#C/C#C=C!3K44y@ #,S#H 9<=Aqvv./=!3K44y@ c3 =   c "  K=# C (>s H5I5 II)Tr;)NNr)FN)F)r)NNNN)NN)Nrc)NNNFT)s sympy.corerrrsympy.core.containersrsympy.core.exprtoolsrsympy.core.numbersrsympy.core.relationalr r sympy.core.sortingr r sympy.core.symbolr rsympy.core.functionrrrrrrsympy.functionsrrrrrrrrr(sympy.functions.combinatorial.factorialsrsympy.matricesr r!r"r#r$ sympy.polysr%r&sympy.simplifyr'r(r)sympy.simplify.powsimpr*r+sympy.simplify.ratsimpr,sympy.simplify.simplifyr-sympy.sets.setsr.sympy.solvers.deutilsr0rr1r2sympy.utilities.iterablesr3r4r5sympy.utilities.miscr6sympy.integrals.integralsr7r8rFrrHrTrsrrrrrrrrBrrNrrr_rXrgrlrsrxrrrrrrrrrrrrrrrrrrrJrRr?r%sz""'- .8+??888>OO&555*,%+;FF+9L J    ,Dm`6RjHVsn9>|~ J EP0f  :!H7t'T^CJ    &,'23 FX@* "L AE59@HF2[|erR