\haNSrSSKJr SSKJr SSKJr SSKJrJ r SSK J r J r J r Jr SSKJrJr SSKJrJrJr SS KJr SS KJrJr SS KJrJr SS KJr SS K J!r!J"r"J#r# SSK$J%r% SSK&J'r' SSK(r(Sr)S!Sjr*Sr+Sr,S"SS.Sjjr-S#Sjr.Sr/Sr0Sr1Sr2S$Sjr3Sr4Sr5S r6g)%a This module contains pdsolve() and different helper functions that it uses. It is heavily inspired by the ode module and hence the basic infrastructure remains the same. **Functions in this module** These are the user functions in this module: - pdsolve() - Solves PDE's - classify_pde() - Classifies PDEs into possible hints for dsolve(). - pde_separate() - Separate variables in partial differential equation either by additive or multiplicative separation approach. These are the helper functions in this module: - pde_separate_add() - Helper function for searching additive separable solutions. - pde_separate_mul() - Helper function for searching multiplicative separable solutions. **Currently implemented solver methods** The following methods are implemented for solving partial differential equations. See the docstrings of the various pde_hint() functions for more information on each (run help(pde)): - 1st order linear homogeneous partial differential equations with constant coefficients. - 1st order linear general partial differential equations with constant coefficients. - 1st order linear partial differential equations with variable coefficients. )reduce)combinations_with_replacement)simplify)AddS)Functionexpand AppliedUndefSubs)EqualityEq)SymbolWildsymbols)exp)Integral integrate)has_dups is_sequence) filldedent) _preprocess ode_order_desolve)solve)collectN)%1st_linear_constant_coeff_homogeneous1st_linear_constant_coeff"1st_linear_constant_coeff_Integral1st_linear_variable_coeffc U(d [S5n[U4XSSS.UD6nURSS5nURSS5nU(ag0n0n [USS9n UR U S U S S .5 UH&n[ XXbS XbS XbUU5n XU'M( UR U 5 U$[ XSUS US XfSU5$![ an XU'S n A MnS n A ff=f)aK Solves any (supported) kind of partial differential equation. **Usage** pdsolve(eq, f(x,y), hint) -> Solve partial differential equation eq for function f(x,y), using method hint. **Details** ``eq`` can be any supported partial differential equation (see the pde docstring for supported methods). This can either be an Equality, or an expression, which is assumed to be equal to 0. ``f(x,y)`` is a function of two variables whose derivatives in that variable make up the partial differential equation. In many cases it is not necessary to provide this; it will be autodetected (and an error raised if it could not be detected). ``hint`` is the solving method that you want pdsolve to use. Use classify_pde(eq, f(x,y)) to get all of the possible hints for a PDE. The default hint, 'default', will use whatever hint is returned first by classify_pde(). See Hints below for more options that you can use for hint. ``solvefun`` is the convention used for arbitrary functions returned by the PDE solver. If not set by the user, it is set by default to be F. **Hints** Aside from the various solving methods, there are also some meta-hints that you can pass to pdsolve(): "default": This uses whatever hint is returned first by classify_pde(). This is the default argument to pdsolve(). "all": To make pdsolve apply all relevant classification hints, use pdsolve(PDE, func, hint="all"). This will return a dictionary of hint:solution terms. If a hint causes pdsolve to raise the NotImplementedError, value of that hint's key will be the exception object raised. The dictionary will also include some special keys: - order: The order of the PDE. See also ode_order() in deutils.py - default: The solution that would be returned by default. This is the one produced by the hint that appears first in the tuple returned by classify_pde(). "all_Integral": This is the same as "all", except if a hint also has a corresponding "_Integral" hint, it only returns the "_Integral" hint. This is useful if "all" causes pdsolve() to hang because of a difficult or impossible integral. This meta-hint will also be much faster than "all", because integrate() is an expensive routine. See also the classify_pde() docstring for more info on hints, and the pde docstring for a list of all supported hints. **Tips** - You can declare the derivative of an unknown function this way: >>> from sympy import Function, Derivative >>> from sympy.abc import x, y # x and y are the independent variables >>> f = Function("f")(x, y) # f is a function of x and y >>> # fx will be the partial derivative of f with respect to x >>> fx = Derivative(f, x) >>> # fy will be the partial derivative of f with respect to y >>> fy = Derivative(f, y) - See test_pde.py for many tests, which serves also as a set of examples for how to use pdsolve(). - pdsolve always returns an Equality class (except for the case when the hint is "all" or "all_Integral"). Note that it is not possible to get an explicit solution for f(x, y) as in the case of ODE's - Do help(pde.pde_hintname) to get help more information on a specific hint Examples ======== >>> from sympy.solvers.pde import pdsolve >>> from sympy import Function, Eq >>> from sympy.abc import x, y >>> f = Function('f') >>> u = f(x, y) >>> ux = u.diff(x) >>> uy = u.diff(y) >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0) >>> pdsolve(eq) Eq(f(x, y), F(3*x - 2*y)*exp(-2*x/13 - 3*y/13)) FTpde)funchintrtypeeqFall)dictorderdefault)r)r*r#Nr$)rrpop classify_pdeupdate_helper_simplifyNotImplementedError) r&r#r$r(solvefunkwargshintsall_pdedict failed_hintsgethintsrvdetails I/var/www/auris/envauris/lib/python3.13/site-packages/sympy/solvers/pde.pypdsolver:?s-L C= R +d +#) +E 4 B 99UE "D  .'!2#+I#68 9D #%b F0CK(%+d*;XG !#  |$ &M5= %gFm0DhP P' ,%+T" ,s<C C+C&&C+c j[5SURS5-n[U"XUXE5X#U5$)zHelper function of pdsolve that calls the respective pde functions to solve for the partial differential equations. This minimizes the computation in calling _desolve multiple times. pde_ _Integral)globals removesuffix_handle_Integral)r&r$r#r)matchr0 solvefuncs r9r.r.s@  &4#4#4[#AABI Ib t --ctURS5(aU$US:Xa[UR55$U$)zp Converts a solution with integrals in it into an actual solution. Simplifies the integral mainly using doit() r=r)endswithrdoit)exprr#r)r$s r9r@r@s9  }}[!! , , $$ rCT)prepc ^U(a$[UR5S:wa [S5eU(dUc[X5up5UcUn[ U[ 5(a?UR S:wa#[URUR - U5$URnURnURSnURSnU"Xx5RU5n U"Xx5RU5n [X"Xx55n SU 0mU (dU(aSTS'T$g[U5n[S U"Xx5/S 9n [S U"Xx5XXx/S 9n [S U"Xx5XXx/S 9n[S U"Xx5XXx/S 9n[SU"Xx5X/S 9n[SXx/S 9nUnUR(aSn[[!Xx4U 55HsnUR#U"Xx5R"U65nUS:XaM/UR%X"Xx5U--5nU(dMTUU (dM`Ub UUU:dMnUUnMu U(a1U"Xx5U-n['URVs/sHnUU- PM sn6nU S:XGa[)UU"Xx55nUR%X-X--X"Xx5--U-5nU(aYUU(dUR+XUS.5 UTS'OUU S-UUS--S:waUR+XUUS.5 UTS'UTS'O}[S U"Xx5X/S 9n [S U"Xx5X/S 9n[S U"Xx5X/S 9nUR%X-X--X"Xx5--U-5nU(aUR+XUUS.5 UTS'[-U4Sj[.55nU(a'STS'UTS'[.HnUT;dM UTS' T$ T$U$s snf)a9 Returns a tuple of possible pdsolve() classifications for a PDE. The tuple is ordered so that first item is the classification that pdsolve() uses to solve the PDE by default. In general, classifications near the beginning of the list will produce better solutions faster than those near the end, though there are always exceptions. To make pdsolve use a different classification, use pdsolve(PDE, func, hint=). See also the pdsolve() docstring for different meta-hints you can use. If ``dict`` is true, classify_pde() will return a dictionary of hint:match expression terms. This is intended for internal use by pdsolve(). Note that because dictionaries are ordered arbitrarily, this will most likely not be in the same order as the tuple. You can get help on different hints by doing help(pde.pde_hintname), where hintname is the name of the hint without "_Integral". See sympy.pde.allhints or the sympy.pde docstring for a list of all supported hints that can be returned from classify_pde. Examples ======== >>> from sympy.solvers.pde import classify_pde >>> from sympy import Function, Eq >>> from sympy.abc import x, y >>> f = Function('f') >>> u = f(x, y) >>> ux = u.diff(x) >>> uy = u.diff(y) >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0) >>> classify_pde(eq) ('1st_linear_constant_coeff_homogeneous',) zLRight now only partial differential equations of two variables are supportedNrr)r*a)excludebcden)rOrPrQr)rOrPrQrRrrrc36># UHoT;dM Uv M g7f)NrL).0imatching_hintss r9 classify_pde.._s@1,?QQs   ordered_hints)lenargsr/r isinstancer rhsr,lhsr#diffrr ris_AddsetrcoeffrArrr-tupleallhints)r&r#r(rHr1func_fxyfxfyr)rMrOrPrQrRrS reduced_eqpowerrVrcrAdenargrrettuplerWs @r9r,r,sN DII!#!#DE E t|!"+  <D"h 66Q;6 6 VV A ! A ! A 1QB 1QB b!A& !Eu%N  (,N9 %! ! B SQqVH%A SQqVRQ23A SQqVRQ23A SQqVRQ23A SQqVR,-A SQF#AJ yy2A5%@AAHHQqV[[!_-EzKK!A&!) ,Euq=E!Hu$4!!HEB A&%-C"'':'3s3w':;J zZ11   QTAD[1QqV83a7 8 Q4qq12JKFG1q1Q47"a'qqq9:>?:;GHCDS1Q7B"34AS1Q7B"34AS1Q7B"34A  q1x!7!!;?:;@@@H %)y!*2'AN",-y)  OQ;sOc [U[5(d [US5nUc[UR5upB[ U[5(a+[U5"UVs/sHn[XUUS9PM sn5$[U[5(d [X!5nOURU:Xa UR nURU:H=(a URR#U5(+nU(aeU(d^[%X5nU(aL[U5S:Xa[U[X(S5USS9$[XV s/sHn [X)5PM sn USS9$URU:Xa_URUR- n['UR)X!R5R+55nU[,R.LU4$[1[3SU<SU<S355e![ a [ U[5(aUOU/Vs/sHoUR[5PM Os snfnn[5RU5n[U5S:wa [ S5eUR5nGN=f=fs snfs sn f) a% Checks if the given solution satisfies the partial differential equation. pde is the partial differential equation which can be given in the form of an equation or an expression. sol is the solution for which the pde is to be checked. This can also be given in an equation or an expression form. If the function is not provided, the helper function _preprocess from deutils is used to identify the function. If a sequence of solutions is passed, the same sort of container will be used to return the result for each solution. The following methods are currently being implemented to check if the solution satisfies the PDE: 1. Directly substitute the solution in the PDE and check. If the solution has not been solved for f, then it will solve for f provided solve_for_func has not been set to False. If the solution satisfies the PDE, then a tuple (True, 0) is returned. Otherwise a tuple (False, expr) where expr is the value obtained after substituting the solution in the PDE. However if a known solution returns False, it may be due to the inability of doit() to simplify it to zero. Examples ======== >>> from sympy import Function, symbols >>> from sympy.solvers.pde import checkpdesol, pdsolve >>> x, y = symbols('x y') >>> f = Function('f') >>> eq = 2*f(x,y) + 3*f(x,y).diff(x) + 4*f(x,y).diff(y) >>> sol = pdsolve(eq) >>> assert checkpdesol(eq, sol)[0] >>> eq = x*f(x,y) + f(x,y).diff(x) >>> checkpdesol(eq, sol) (False, (x*F(4*x - 3*y) - 6*F(4*x - 3*y)/25 + 4*Subs(Derivative(F(_xi_1), _xi_1), _xi_1, 4*x - 3*y))*exp(-6*x/25 - 8*y/25)) rrKz0must pass func arg to checkpdesol for this case.)r#solve_for_funcFz Unable to test if z is a solution to .)r]r r rr_ ValueErrorrrbatomsr unionr[r+r% checkpdesolr^reversedhasrrsubsrFrZeror/r) r"solr#rs_sfuncsrVsolvedts r9rxrxns<T c8 $ $aj | !#''*GA3Cy47947q& )+479: : c8 $ $m DllWW_ 6SWW[[%6!6Ffs! 6{a"34(;e55#3f(EfDf(Ee55 ww$gg SXXdGG,113 4AFF{A~ j8;S*BC DDQ "3,,3%7:701WW\*7:E:EKK&E5zQ FHH99;D 9&)Fs*G(!I>J (&I;H-,A I;:I;c URnURSnURSnX3SnX3Sn X3Sn [U"Xg5[[ U 5*US-U S--- X-X---5U"X-X-- 5-5$)a6 Solves a first order linear homogeneous partial differential equation with constant coefficients. The general form of this partial differential equation is .. math:: a \frac{\partial f(x,y)}{\partial x} + b \frac{\partial f(x,y)}{\partial y} + c f(x,y) = 0 where `a`, `b` and `c` are constants. The general solution is of the form: .. math:: f(x, y) = F(- a y + b x ) e^{- \frac{c (a x + b y)}{a^2 + b^2}} and can be found in SymPy with ``pdsolve``:: >>> from sympy.solvers import pdsolve >>> from sympy.abc import x, y, a, b, c >>> from sympy import Function, pprint >>> f = Function('f') >>> u = f(x,y) >>> ux = u.diff(x) >>> uy = u.diff(y) >>> genform = a*ux + b*uy + c*u >>> pprint(genform) d d a*--(f(x, y)) + b*--(f(x, y)) + c*f(x, y) dx dy >>> pprint(pdsolve(genform)) -c*(a*x + b*y) --------------- 2 2 a + b f(x, y) = F(-a*y + b*x)*e Examples ======== >>> from sympy import pdsolve >>> from sympy import Function, pprint >>> from sympy.abc import x,y >>> f = Function('f') >>> pdsolve(f(x,y) + f(x,y).diff(x) + f(x,y).diff(y)) Eq(f(x, y), F(x - y)*exp(-x/2 - y/2)) >>> pprint(pdsolve(f(x,y) + f(x,y).diff(x) + f(x,y).diff(y))) x y - - - - 2 2 f(x, y) = F(x - y)*e References ========== - Viktor Grigoryan, "Partial Differential Equations" Math 124A - Fall 2010, pp.7 rrKrOrPrQrJ)r#r\r rr) r&r#r)rAr0rgrhrirOrPrQs r9)pde_1st_linear_constant_coeff_homogeneousrsB A ! A ! A CjA CjA CjA afc1Q4%A1-qsQSy9:8AC!#I;NN OOrCc 0[S5upVURnURSnURSn X3Sn X3Sn X3Sn X3S*n [[ U 5*U S-U S--- U-5nU"U5n[ X-X--U- X-X-- U- 4X5nS[ U S-U S--5- [ SU- U -RU5XZU-X--45-n[U"X5[XU--Xe4X-X-- X-X--455$) a Solves a first order linear partial differential equation with constant coefficients. The general form of this partial differential equation is .. math:: a \frac{\partial f(x,y)}{\partial x} + b \frac{\partial f(x,y)}{\partial y} + c f(x,y) = G(x,y) where `a`, `b` and `c` are constants and `G(x, y)` can be an arbitrary function in `x` and `y`. The general solution of the PDE is: .. math:: f(x, y) = \left. \left[F(\eta) + \frac{1}{a^2 + b^2} \int\limits^{a x + b y} G\left(\frac{a \xi + b \eta}{a^2 + b^2}, \frac{- a \eta + b \xi}{a^2 + b^2} \right) e^{\frac{c \xi}{a^2 + b^2}}\, d\xi\right] e^{- \frac{c \xi}{a^2 + b^2}} \right|_{\substack{\eta=- a y + b x\\ \xi=a x + b y }}\, , where `F(\eta)` is an arbitrary single-valued function. The solution can be found in SymPy with ``pdsolve``:: >>> from sympy.solvers import pdsolve >>> from sympy.abc import x, y, a, b, c >>> from sympy import Function, pprint >>> f = Function('f') >>> G = Function('G') >>> u = f(x, y) >>> ux = u.diff(x) >>> uy = u.diff(y) >>> genform = a*ux + b*uy + c*u - G(x,y) >>> pprint(genform) d d a*--(f(x, y)) + b*--(f(x, y)) + c*f(x, y) - G(x, y) dx dy >>> pprint(pdsolve(genform, hint='1st_linear_constant_coeff_Integral')) // a*x + b*y \ \| || / | || || | | || || | c*xi | || || | ------- | || || | 2 2 | || || | /a*xi + b*eta -a*eta + b*xi\ a + b | || || | G|------------, -------------|*e d(xi)| || || | | 2 2 2 2 | | || || | \ a + b a + b / | -c*xi || || | | -------|| || / | 2 2|| || | a + b || f(x, y) = ||F(eta) + -------------------------------------------------------|*e || || 2 2 | || \\ a + b / /|eta=-a*y + b*x, xi=a*x + b*y Examples ======== >>> from sympy.solvers.pde import pdsolve >>> from sympy import Function, pprint, exp >>> from sympy.abc import x,y >>> f = Function('f') >>> eq = -2*f(x,y).diff(x) + 4*f(x,y).diff(y) + 5*f(x,y) - exp(x + 3*y) >>> pdsolve(eq) Eq(f(x, y), (F(4*x + 2*y)*exp(x/2) + exp(x + 4*y)/15)*exp(-y)) References ========== - Viktor Grigoryan, "Partial Differential Equations" Math 124A - Fall 2010, pp.7 zxi etarrKrOrPrQrRrJ) rr#r\rrrrr{r r )r&r#r)rAr0xietargrhrirOrPrQrRexptermfuncterm solvedictgenterms r9pde_1st_linear_constant_coeffrsK`hGB A ! A ! A CjA CjA CjA Sz A1Q4%A1%b()G}HqsQSy2~qsQSy37>I1a4!Q$; 719%aC!#I"88G afd7w$67 AC!#IqsQSy)+ ,,rCc$SSKJn [S5nURnURSnURSn X3Sn X3Sn X3Sn X3S*n U (dpU (aU (dbU (a*[ X- U 5n[ U"X5U"U5U-5$U (a*[ X- U5n[ U"X5U"U 5U-5$U (d|U"U5RU5U -X"U5--U - nU"X"U55nURUR- X1- n[URUXI5n[ U"X5U5$U (d|U"U 5RU 5U -X"U 5--U - nU"X"U 55nURUR- X1- n[URUXH5n[ U"X5U5$[S5nX- RU U"U55nU"U"U5RU5U- U"U55n[U[5(aUSnURUR- X1- n[!U5S:XaUR#5n[%UU5SRU"U5U 5n[%UU- U 5SnX"U5RU5-X"U5--U - RU U5nU"UU"U5S S 9Rn[U[5(aUSnURUR- X1- n[UUUU5n[ U"X5U5$[S 5e![a [S 5ef=f![a [S 5ef=f) a@ Solves a first order linear partial differential equation with variable coefficients. The general form of this partial differential equation is .. math:: a(x, y) \frac{\partial f(x, y)}{\partial x} + b(x, y) \frac{\partial f(x, y)}{\partial y} + c(x, y) f(x, y) = G(x, y) where `a(x, y)`, `b(x, y)`, `c(x, y)` and `G(x, y)` are arbitrary functions in `x` and `y`. This PDE is converted into an ODE by making the following transformation: 1. `\xi` as `x` 2. `\eta` as the constant in the solution to the differential equation `\frac{dy}{dx} = -\frac{b}{a}` Making the previous substitutions reduces it to the linear ODE .. math:: a(\xi, \eta)\frac{du}{d\xi} + c(\xi, \eta)u - G(\xi, \eta) = 0 which can be solved using ``dsolve``. >>> from sympy.abc import x, y >>> from sympy import Function, pprint >>> a, b, c, G, f= [Function(i) for i in ['a', 'b', 'c', 'G', 'f']] >>> u = f(x,y) >>> ux = u.diff(x) >>> uy = u.diff(y) >>> genform = a(x, y)*u + b(x, y)*ux + c(x, y)*uy - G(x,y) >>> pprint(genform) d d -G(x, y) + a(x, y)*f(x, y) + b(x, y)*--(f(x, y)) + c(x, y)*--(f(x, y)) dx dy Examples ======== >>> from sympy.solvers.pde import pdsolve >>> from sympy import Function, pprint >>> from sympy.abc import x,y >>> f = Function('f') >>> eq = x*(u.diff(x)) - y*(u.diff(y)) + y**2*u - y**2 >>> pdsolve(eq) Eq(f(x, y), F(x*y)*exp(y**2/2) + 1) References ========== - Viktor Grigoryan, "Partial Differential Equations" Math 124A - Fall 2010, pp.7 r)dsolverrKrOrPrQrRz7Unable to find a solution due to inability of integrate 1st_linear)r$zOCannot solve the partial differential equation due to inability of constantsimp)sympy.solvers.oderrr#r\rr r/r` free_symbols_simplify_variable_coeffr^rr{r]listr[r+r)r&r#r)rAr0rrrgrhrirOrPrQrRtsolploder}symsr^dummyhsolsymetatysubdeqfinalfinsymss r9pde_1st_linear_variable_coeffrysp) %.C A ! A ! A CjA CjA CjA Sz A a:$QS!,D afhqkD&899:$QS!,D afhqkD&899 ! ! Q1Q4'!+UAaD!%"4"44v=&swwhB!A'3 ! ! Q1Q4'!+UAaD!%"4"44v=&swwhB!A'3 SME  1eAhA qq!A%uQx 0C#t!f    .! 7F 6{ac6"1%++E!Ha8S4Z#A&!A$))A,!AaD&(1,221d;QqT 5:: eT " "!HE$$s'7'771&@&ugxF!A'3"#,- -g+:-/9:::+:-/9:::s6M 'M9 M69Nc[S5n[U5S:Xa(UR5nURXR"U55nO UHnURXR"U55nM [ WRXC55$)zP Helper function to replace constants by functions in 1st_linear_variable_coeff rrK)rr[r+r{r)r}rr#funcargrsymrs r9rrsm -C 4yA~hhjd7m,CHHS$w-0E EJJs, --rCcSnUS:XaSnOUS:XaSnO[SU-5e[U[5(a?URS:wa.[ [ UR UR- S5XU5$O[ [ US5XU5$URS:wa [S5e[UR5nUVVs/sHofRHowPM M nnnU(a[[RU5n O[[RU5n [U5[U5:wa [S5e[U5(a [S 5e[U5[U5:wa [S 5eUR R!X5R#5n U(dSnU RH n X U - - nM Un USn US S n [%XU 5$s snnf) aISeparate variables in partial differential equation either by additive or multiplicative separation approach. It tries to rewrite an equation so that one of the specified variables occurs on a different side of the equation than the others. :param eq: Partial differential equation :param fun: Original function F(x, y, z) :param sep: List of separated functions [X(x), u(y, z)] :param strategy: Separation strategy. You can choose between additive separation ('add') and multiplicative separation ('mul') which is default. Examples ======== >>> from sympy import E, Eq, Function, pde_separate, Derivative as D >>> from sympy.abc import x, t >>> u, X, T = map(Function, 'uXT') >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t)) >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='add') [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)] >>> eq = Eq(D(u(x, t), x, 2), D(u(x, t), t, 2)) >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='mul') [Derivative(X(x), (x, 2))/X(x), Derivative(T(t), (t, 2))/T(t)] See Also ======== pde_separate_add, pde_separate_mul FaddTmulzUnknown strategy: %srzValue should be 0zVariable counts do not matchz)Duplicate substitution arguments detectedzArguments do not matchrKN)rur]r r^ pde_separater r_rr\roperatorrrr[rrbr{rF _separate)r&funsepstrategydo_add orig_argsrro subs_args functionsresultrVsvardvars r9rr sHF5 U /(:;;"h 66Q;266BFF?A 6(K K Br1Is:: vv{,--SXXI!4cVVcVcI4 8<<- 8<<-  9~Y'788 DEE 9~Y'122VV[[ ( - - /F  A I+ B Q>> from sympy import E, Eq, Function, pde_separate_add, Derivative as D >>> from sympy.abc import x, t >>> u, X, T = map(Function, 'uXT') >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t)) >>> pde_separate_add(eq, u(x, t), [X(x), T(t)]) [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)] rrrr&rrs r9pde_separate_addra, u 55rCc[XUSS9$)a< Helper function for searching multiplicative separable solutions. Consider an equation of two independent variables x, y and a dependent variable w, we look for the product of two functions depending on different arguments: `w(x, y, z) = X(x)*u(y, z)` Examples ======== >>> from sympy import Function, Eq, pde_separate_mul, Derivative as D >>> from sympy.abc import x, y >>> u, X, Y = map(Function, 'uXY') >>> eq = Eq(D(u(x, y), x, 2), D(u(x, y), y, 2)) >>> pde_separate_mul(eq, u(x, y), [X(x), Y(y)]) [Derivative(X(x), (x, 2))/X(x), Derivative(Y(y), (y, 2))/Y(y)] rrrrs r9pde_separate_mulrzrrCc [5nURHnUR(aOURH=nUR(dMUR"U6(aM,UR U5 M? McUR(dMvUR"U6(aMUR U5 M [5nUHKnUR 5RU5upxUR"U6(a gUR U5 MM [U5S:aG[URVVs/sH'n[[UVs/sHoTU- PM sn65PM) snn6n[5nS=pURHwnUR"U6(dX- n MUR 5RU5upUR"U6(a gUR U5 XR 5-n My [[R U5n [X- 5R 5n [X- 5R 5n U R"U6(dU R U5(agX/$s snfs snnf)zFSeparate expression into two parts based on dependencies of variables.Nr) rbr\is_Mul is_Derivativerzrr as_independentr[rrrr) r&depotherstermstermrVdivextrr_r^tempfulldivs r9rrs EE ;;YY???155&>>IIdO   &(9(9 IIdO %C;;=//4 77F    3x!| RWWMWT8C#!6#Qq&#!678WM N %CMCxx KC KKM005  77F    {{}X\\3'G 3;  & & (C 3;  & & (C ww3773<< :1"7Ms6J I; J ;J )Nr*FN)NF)NT)r)7__doc__ functoolsr itertoolsrsympy.simplifyr sympy.corerrsympy.core.functionrr r r sympy.core.relationalr r sympy.core.symbolrrrsympy.functionsrsympy.integrals.integralsrrsympy.utilities.iterablesrrsympy.utilities.miscrsympy.solvers.deutilsrrrsympy.solvers.solversrsympy.simplify.radsimprrrer:r.r@r,rxrrrrrrrrrLrCr9rs!D3#DD.339;+BB'* DPN-  JDJZZD|GPT`,F~-B . T)n62623rC