ó 9­\c%@ sdZddlmZmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZddlmZmZmZmZmZddlmZdd lmZdd lmZmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=ddl>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZIddlJmKZKddlLmMZMmNZNddlOmPZPmQZQmRZRmSZSddlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]ddl^m_Z_m`Z`maZaddlbmcZcddldmeZeddlfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnddlompZpddlqmrZrddlsmtZtddlumvZvdd lwmxZxmyZymzZzdd!l{m|Z|m}Z}m~Z~d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFf%ZdGdHdIdJdKdLdMdNdOf Z€dP„ZdQdQdRdS„Z‚dQdRdT„Zƒe„dUe…e„e„e„dVdWdX„Z†e…e„dY„Z‡dZ„Zˆe„e‰e„d[„ZŠe„d\„Z‹d]„ZŒd^„Zd_„ZŽd`„Zda„Zdb„Z‘dc„Z’dd„Z“e„de„Z”e'dVƒdf„ƒZ•e„dge…dh„Z–e…di„Z—dj„Z˜dk„Z™e'dVƒdl„ƒZše„e„dm„Z›dn„Zœdo„Zdp„Zždq„ZŸdr„Z ds„Z¡dt„Z¢du„Z£dv„Z¤dw„Z¥dx„Z¦dy„Z§e„dz„Z¨d{„Z©d|„Zªd}„Z«d~„Z¬d„Z­d€„Z®d„Z¯d‚dƒ„Z°d‚d„„Z±d‚d…„Z²d†„Z³d‡„Z´dˆ„Zµd‰„Z¶dŠ„Z·d‚d‹„Z¸dŒ„Z¹d„ZºdŽ„Z»d„Z¼d„Z½d‘„Z¾e„e„d’„Z¿d“„ZÀd”„ZÁe„e„dUe„d•„ZÂe‰d–„ZÃe‰d—„ZÄe‰d˜„ZÅe‰d™„ZÆe‰dš„ZÇe‰d›„ZÈe‰dœ„ZÉe‰d„ZÊe‰dž„ZËdŸ„ZÌd „ZÍd¡„ZÎd¢„ZÏd£„ZÐd¤„ZÑd¥„ZÒd¦„ZÓd§„ZÔd¨„ZÕd©„ZÖdª„Z×d«„ZØd¬„ZÙd­„ZÚd®„ZÛd¯„ZÜd°„ZÝd±„ZÞd²„Zßd³„Zàd´„Zádµ„Zâd¶„Zãd·„Zäd¸„Zåd¹„Zædº„Zçd»„Zèd¼„Zéd½„Zêd¾„Zëd¿„ZìdÀ„ZídÁ„Zîd„ZïdÄZðdÄ„ZñdÅ„ZòdÆS(Çs]5 This module contains :py:meth:`~sympy.solvers.ode.dsolve` and different helper functions that it uses. :py:meth:`~sympy.solvers.ode.dsolve` solves ordinary differential equations. See the docstring on the various functions for their uses. Note that partial differential equations support is in ``pde.py``. Note that hint functions have docstrings describing their various methods, but they are intended for internal use. Use ``dsolve(ode, func, hint=hint)`` to solve an ODE using a specific hint. See also the docstring on :py:meth:`~sympy.solvers.ode.dsolve`. **Functions in this module** These are the user functions in this module: - :py:meth:`~sympy.solvers.ode.dsolve` - Solves ODEs. - :py:meth:`~sympy.solvers.ode.classify_ode` - Classifies ODEs into possible hints for :py:meth:`~sympy.solvers.ode.dsolve`. - :py:meth:`~sympy.solvers.ode.checkodesol` - Checks if an equation is the solution to an ODE. - :py:meth:`~sympy.solvers.ode.homogeneous_order` - Returns the homogeneous order of an expression. - :py:meth:`~sympy.solvers.ode.infinitesimals` - Returns the infinitesimals of the Lie group of point transformations of an ODE, such that it is invariant. - :py:meth:`~sympy.solvers.ode_checkinfsol` - Checks if the given infinitesimals are the actual infinitesimals of a first order ODE. These are the non-solver helper functions that are for internal use. The user should use the various options to :py:meth:`~sympy.solvers.ode.dsolve` to obtain the functionality provided by these functions: - :py:meth:`~sympy.solvers.ode.odesimp` - Does all forms of ODE simplification. - :py:meth:`~sympy.solvers.ode.ode_sol_simplicity` - A key function for comparing solutions by simplicity. - :py:meth:`~sympy.solvers.ode.constantsimp` - Simplifies arbitrary constants. - :py:meth:`~sympy.solvers.ode.constant_renumber` - Renumber arbitrary constants. - :py:meth:`~sympy.solvers.ode._handle_Integral` - Evaluate unevaluated Integrals. See also the docstrings of these functions. **Currently implemented solver methods** The following methods are implemented for solving ordinary differential equations. See the docstrings of the various hint functions for more information on each (run ``help(ode)``): - 1st order separable differential equations. - 1st order differential equations whose coefficients or `dx` and `dy` are functions homogeneous of the same order. - 1st order exact differential equations. - 1st order linear differential equations. - 1st order Bernoulli differential equations. - Power series solutions for first order differential equations. - Lie Group method of solving first order differential equations. - 2nd order Liouville differential equations. - Power series solutions for second order differential equations at ordinary and regular singular points. - `n`\th order differential equation that can be solved with algebraic rearrangement and integration. - `n`\th order linear homogeneous differential equation with constant coefficients. - `n`\th order linear inhomogeneous differential equation with constant coefficients using the method of undetermined coefficients. - `n`\th order linear inhomogeneous differential equation with constant coefficients using the method of variation of parameters. **Philosophy behind this module** This module is designed to make it easy to add new ODE solving methods without having to mess with the solving code for other methods. The idea is that there is a :py:meth:`~sympy.solvers.ode.classify_ode` function, which takes in an ODE and tells you what hints, if any, will solve the ODE. It does this without attempting to solve the ODE, so it is fast. Each solving method is a hint, and it has its own function, named ``ode_``. That function takes in the ODE and any match expression gathered by :py:meth:`~sympy.solvers.ode.classify_ode` and returns a solved result. If this result has any integrals in it, the hint function will return an unevaluated :py:class:`~sympy.integrals.Integral` class. :py:meth:`~sympy.solvers.ode.dsolve`, which is the user wrapper function around all of this, will then call :py:meth:`~sympy.solvers.ode.odesimp` on the result, which, among other things, will attempt to solve the equation for the dependent variable (the function we are solving for), simplify the arbitrary constants in the expression, and evaluate any integrals, if the hint allows it. **How to add new solution methods** If you have an ODE that you want :py:meth:`~sympy.solvers.ode.dsolve` to be able to solve, try to avoid adding special case code here. Instead, try finding a general method that will solve your ODE, as well as others. This way, the :py:mod:`~sympy.solvers.ode` module will become more robust, and unhindered by special case hacks. WolphramAlpha and Maple's DETools[odeadvisor] function are two resources you can use to classify a specific ODE. It is also better for a method to work with an `n`\th order ODE instead of only with specific orders, if possible. To add a new method, there are a few things that you need to do. First, you need a hint name for your method. Try to name your hint so that it is unambiguous with all other methods, including ones that may not be implemented yet. If your method uses integrals, also include a ``hint_Integral`` hint. If there is more than one way to solve ODEs with your method, include a hint for each one, as well as a ``_best`` hint. Your ``ode__best()`` function should choose the best using min with ``ode_sol_simplicity`` as the key argument. See :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best`, for example. The function that uses your method will be called ``ode_()``, so the hint must only use characters that are allowed in a Python function name (alphanumeric characters and the underscore '``_``' character). Include a function for every hint, except for ``_Integral`` hints (:py:meth:`~sympy.solvers.ode.dsolve` takes care of those automatically). Hint names should be all lowercase, unless a word is commonly capitalized (such as Integral or Bernoulli). If you have a hint that you do not want to run with ``all_Integral`` that doesn't have an ``_Integral`` counterpart (such as a best hint that would defeat the purpose of ``all_Integral``), you will need to remove it manually in the :py:meth:`~sympy.solvers.ode.dsolve` code. See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for guidelines on writing a hint name. Determine *in general* how the solutions returned by your method compare with other methods that can potentially solve the same ODEs. Then, put your hints in the :py:data:`~sympy.solvers.ode.allhints` tuple in the order that they should be called. The ordering of this tuple determines which hints are default. Note that exceptions are ok, because it is easy for the user to choose individual hints with :py:meth:`~sympy.solvers.ode.dsolve`. In general, ``_Integral`` variants should go at the end of the list, and ``_best`` variants should go before the various hints they apply to. For example, the ``undetermined_coefficients`` hint comes before the ``variation_of_parameters`` hint because, even though variation of parameters is more general than undetermined coefficients, undetermined coefficients generally returns cleaner results for the ODEs that it can solve than variation of parameters does, and it does not require integration, so it is much faster. Next, you need to have a match expression or a function that matches the type of the ODE, which you should put in :py:meth:`~sympy.solvers.ode.classify_ode` (if the match function is more than just a few lines, like :py:meth:`~sympy.solvers.ode._undetermined_coefficients_match`, it should go outside of :py:meth:`~sympy.solvers.ode.classify_ode`). It should match the ODE without solving for it as much as possible, so that :py:meth:`~sympy.solvers.ode.classify_ode` remains fast and is not hindered by bugs in solving code. Be sure to consider corner cases. For example, if your solution method involves dividing by something, make sure you exclude the case where that division will be 0. In most cases, the matching of the ODE will also give you the various parts that you need to solve it. You should put that in a dictionary (``.match()`` will do this for you), and add that as ``matching_hints['hint'] = matchdict`` in the relevant part of :py:meth:`~sympy.solvers.ode.classify_ode`. :py:meth:`~sympy.solvers.ode.classify_ode` will then send this to :py:meth:`~sympy.solvers.ode.dsolve`, which will send it to your function as the ``match`` argument. Your function should be named ``ode_(eq, func, order, match)`. If you need to send more information, put it in the ``match`` dictionary. For example, if you had to substitute in a dummy variable in :py:meth:`~sympy.solvers.ode.classify_ode` to match the ODE, you will need to pass it to your function using the `match` dict to access it. You can access the independent variable using ``func.args[0]``, and the dependent variable (the function you are trying to solve for) as ``func.func``. If, while trying to solve the ODE, you find that you cannot, raise ``NotImplementedError``. :py:meth:`~sympy.solvers.ode.dsolve` will catch this error with the ``all`` meta-hint, rather than causing the whole routine to fail. Add a docstring to your function that describes the method employed. Like with anything else in SymPy, you will need to add a doctest to the docstring, in addition to real tests in ``test_ode.py``. Try to maintain consistency with the other hint functions' docstrings. Add your method to the list at the top of this docstring. Also, add your method to ``ode.rst`` in the ``docs/src`` directory, so that the Sphinx docs will pull its docstring into the main SymPy documentation. Be sure to make the Sphinx documentation by running ``make html`` from within the doc directory to verify that the docstring formats correctly. If your solution method involves integrating, use :py:meth:`Integral() ` instead of :py:meth:`~sympy.core.expr.Expr.integrate`. This allows the user to bypass hard/slow integration by using the ``_Integral`` variant of your hint. In most cases, calling :py:meth:`sympy.core.basic.Basic.doit` will integrate your solution. If this is not the case, you will need to write special code in :py:meth:`~sympy.solvers.ode._handle_Integral`. Arbitrary constants should be symbols named ``C1``, ``C2``, and so on. All solution methods should return an equality instance. If you need an arbitrary number of arbitrary constants, you can use ``constants = numbered_symbols(prefix='C', cls=Symbol, start=1)``. If it is possible to solve for the dependent function in a general way, do so. Otherwise, do as best as you can, but do not call solve in your ``ode_()`` function. :py:meth:`~sympy.solvers.ode.odesimp` will attempt to solve the solution for you, so you do not need to do that. Lastly, if your ODE has a common simplification that can be applied to your solutions, you can add a special case in :py:meth:`~sympy.solvers.ode.odesimp` for it. For example, solutions returned from the ``1st_homogeneous_coeff`` hints often have many :py:meth:`~sympy.functions.log` terms, so :py:meth:`~sympy.solvers.ode.odesimp` calls :py:meth:`~sympy.simplify.simplify.logcombine` on them (it also helps to write the arbitrary constant as ``log(C1)`` instead of ``C1`` in this case). Also consider common ways that you can rearrange your solution to have :py:meth:`~sympy.solvers.ode.constantsimp` take better advantage of it. It is better to put simplification in :py:meth:`~sympy.solvers.ode.odesimp` than in your method, because it can then be turned off with the simplify flag in :py:meth:`~sympy.solvers.ode.dsolve`. If you have any extraneous simplification in your function, be sure to only run it using ``if match.get('simplify', True):``, especially if it can be slow or if it can reduce the domain of the solution. Finally, as with every contribution to SymPy, your method will need to be tested. Add a test for each method in ``test_ode.py``. Follow the conventions there, i.e., test the solver using ``dsolve(eq, f(x), hint=your_hint)``, and also test the solution using :py:meth:`~sympy.solvers.ode.checkodesol` (you can put these in a separate tests and skip/XFAIL if it runs too slow/doesn't work). Be sure to call your hint specifically in :py:meth:`~sympy.solvers.ode.dsolve`, that way the test won't be broken simply by the introduction of another matching hint. If your method works for higher order (>1) ODEs, you will need to run ``sol = constant_renumber(sol, 'C', 1, order)`` for each solution, where ``order`` is the order of the ODE. This is because ``constant_renumber`` renumbers the arbitrary constants by printing order, which is platform dependent. Try to test every corner case of your solver, including a range of orders if it is a `n`\th order solver, but if your solver is slow, such as if it involves hard integration, try to keep the test run time down. Feel free to refactor existing hints to avoid duplicating code or creating inconsistencies. If you can show that your method exactly duplicates an existing method, including in the simplicity and speed of obtaining the solutions, then you can remove the old, less general method. The existing code is tested extensively in ``test_ode.py``, so if anything is broken, one of those tests will surely fail. iÿÿÿÿ(tprint_functiontdivision(t defaultdict(tislice(t cmp_to_key(tAddtStMultPowtoo(torderedtiterablet is_sequencetranget string_types(tTuple(t factor_terms(t AtomicExprtExpr(tFunctiont Derivativet AppliedUndeftdifftexpandt expand_multSubst_mexpand(t vectorize(tNaNtzootItNumber(tEqualitytEq(tSymboltWildtDummytsymbols(tsympify(t BooleanAtomtAndtOrtNott BooleanTruet BooleanFalse( tcostexptimtlogtretsinttantsqrttatan2t conjugatet Piecewise(t factorial(tIntegralt integrate(t wronskiantMatrixteyetzeros(tPolytRootOftrootoft terms_gcdtPolynomialErrortlcmtroots(t roots_quartic(tcanceltdegreetdiv(tOrder(tseries(tcollectt logcombinetpowsimpt separatevarstsimplifyttrigsimptposifytcse(t powdenest(t collect_const(tsolve(tpdsolve(tnumbered_symbolstdefault_sort_keytsift(t _preprocesst ode_ordert_desolvet nth_algebraict separablet 1st_exactt 1st_lineart BernoullitRiccati_special_minus2t1st_homogeneous_coeff_bestt(1st_homogeneous_coeff_subs_indep_div_dept(1st_homogeneous_coeff_subs_dep_div_indept almost_lineartlinear_coefficientstseparable_reducedt1st_power_seriest lie_groupt%nth_linear_constant_coeff_homogeneoustnth_linear_euler_eq_homogeneoust3nth_linear_constant_coeff_undetermined_coefficientst<nth_linear_euler_eq_nonhomogeneous_undetermined_coefficientst1nth_linear_constant_coeff_variation_of_parameterst:nth_linear_euler_eq_nonhomogeneous_variation_of_parameterst Liouvilletnth_order_reduciblet2nd_power_series_ordinaryt2nd_power_series_regulartnth_algebraic_Integraltseparable_Integralt1st_exact_Integralt1st_linear_IntegraltBernoulli_Integralt11st_homogeneous_coeff_subs_indep_div_dep_Integralt11st_homogeneous_coeff_subs_dep_div_indep_Integraltalmost_linear_Integraltlinear_coefficients_Integraltseparable_reduced_Integralt:nth_linear_constant_coeff_variation_of_parameters_IntegraltCnth_linear_euler_eq_nonhomogeneous_variation_of_parameters_IntegraltLiouville_Integralt abaco1_simpletabaco1_producttabaco2_similartabaco2_unique_unknowntabaco2_unique_generaltlineart function_sumt bivariatetchicC s‚i||6}xe|jtƒD]T}|j|krK|j|jŒ||>> from sympy import Derivative, symbols, Function >>> from sympy.solvers.ode 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) tdeep(tatomsRtexprRtvariable_counttxreplacetdoittFalse(teqtfunctnewtrepstd((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt sub_func_doitVs  *itCcC sUt|||ƒ}gt|ƒD]}t|ƒ^q}|dkrK|dSt|ƒS(sJ Returns a list of constants that do not occur in eq already. ii(titer_numbered_constantsR tnextttuple(R“tnumtstarttprefixtncstitCs((s0lib/python2.7/site-packages/sympy/solvers/ode.pytget_numbered_constantsts%cC sÆt|tƒr|g}nt|ƒs:td|ƒ‚ntƒjg|D]}|j^qJŒ}tƒjg|D]}|jtƒ^qrŒ}|r­|d„|DƒO}nt d|d|d|ƒS(sO Returns an iterator of constants that do not occur in eq already. s$Expected Expr or iterable but got %scS s%h|]}tt|jƒƒ’qS((R"tstrR”(t.0tf((s0lib/python2.7/site-packages/sympy/solvers/ode.pys s RžRŸtexclude( t isinstanceRR t ValueErrortsettuniont free_symbolsRRRX(R“RžRŸR¡tatom_settfunc_set((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRšs  (.tdefaultiic  s)t|ƒrUt|ˆƒ} | d}| d} | d‰tt|djtƒƒdjtƒƒd} x†tt|ƒƒD]r} xiˆD]a}t|tƒr¡q‰|| j t ˆ| | t || ˆ| ƒƒƒj r‰||  || Solve ordinary differential equation ``eq`` for function ``f(x)``, using method ``hint``. **Details** ``eq`` can be any supported ordinary differential equation (see the :py:mod:`~sympy.solvers.ode` docstring for supported methods). This can either be an :py:class:`~sympy.core.relational.Equality`, or an expression, which is assumed to be equal to ``0``. ``f(x)`` is a function of one variable whose derivatives in that variable make up the ordinary differential equation ``eq``. In many cases it is not necessary to provide this; it will be autodetected (and an error raised if it couldn't be detected). ``hint`` is the solving method that you want dsolve to use. Use ``classify_ode(eq, f(x))`` to get all of the possible hints for an ODE. The default hint, ``default``, will use whatever hint is returned first by :py:meth:`~sympy.solvers.ode.classify_ode`. See Hints below for more options that you can use for hint. ``simplify`` enables simplification by :py:meth:`~sympy.solvers.ode.odesimp`. See its docstring for more information. Turn this off, for example, to disable solving of solutions for ``func`` or simplification of arbitrary constants. It will still integrate with this hint. Note that the solution may contain more arbitrary constants than the order of the ODE with this option enabled. ``xi`` and ``eta`` are the infinitesimal functions of an ordinary differential equation. They are the infinitesimals of the Lie group of point transformations for which the differential equation is invariant. The user can specify values for the infinitesimals. If nothing is specified, ``xi`` and ``eta`` are calculated using :py:meth:`~sympy.solvers.ode.infinitesimals` with the help of various heuristics. ``ics`` is the set of initial/boundary conditions for the differential equation. It should be given in the form of ``{f(x0): x1, f(x).diff(x).subs(x, x2): x3}`` and so on. For power series solutions, if no initial conditions are specified ``f(0)`` is assumed to be ``C0`` and the power series solution is calculated about 0. ``x0`` is the point about which the power series solution of a differential equation is to be evaluated. ``n`` gives the exponent of the dependent variable up to which the power series solution of a differential equation is to be evaluated. **Hints** Aside from the various solving methods, there are also some meta-hints that you can pass to :py:meth:`~sympy.solvers.ode.dsolve`: ``default``: This uses whatever hint is returned first by :py:meth:`~sympy.solvers.ode.classify_ode`. This is the default argument to :py:meth:`~sympy.solvers.ode.dsolve`. ``all``: To make :py:meth:`~sympy.solvers.ode.dsolve` apply all relevant classification hints, use ``dsolve(ODE, func, hint="all")``. This will return a dictionary of ``hint:solution`` terms. If a hint causes dsolve 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 ODE. See also :py:meth:`~sympy.solvers.deutils.ode_order` in ``deutils.py``. - ``best``: The simplest hint; what would be returned by ``best`` below. - ``best_hint``: The hint that would produce the solution given by ``best``. If more than one hint produces the best solution, the first one in the tuple returned by :py:meth:`~sympy.solvers.ode.classify_ode` is chosen. - ``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 :py:meth:`~sympy.solvers.ode.classify_ode`. ``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 :py:meth:`~sympy.solvers.ode.dsolve` to hang because of a difficult or impossible integral. This meta-hint will also be much faster than ``all``, because :py:meth:`~sympy.core.expr.Expr.integrate` is an expensive routine. ``best``: To have :py:meth:`~sympy.solvers.ode.dsolve` try all methods and return the simplest one. This takes into account whether the solution is solvable in the function, whether it contains any Integral classes (i.e. unevaluatable integrals), and which one is the shortest in size. See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for more info on hints, and the :py:mod:`~sympy.solvers.ode` 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 # x is the independent variable >>> f = Function("f")(x) # f is a function of x >>> # f_ will be the derivative of f with respect to x >>> f_ = Derivative(f, x) - See ``test_ode.py`` for many tests, which serves also as a set of examples for how to use :py:meth:`~sympy.solvers.ode.dsolve`. - :py:meth:`~sympy.solvers.ode.dsolve` always returns an :py:class:`~sympy.core.relational.Equality` class (except for the case when the hint is ``all`` or ``all_Integral``). If possible, it solves the solution explicitly for the function being solved for. Otherwise, it returns an implicit solution. - Arbitrary constants are symbols named ``C1``, ``C2``, and so on. - Because all solutions should be mathematically equivalent, some hints may return the exact same result for an ODE. Often, though, two different hints will return the same solution formatted differently. The two should be equivalent. Also note that sometimes the values of the arbitrary constants in two different solutions may not be the same, because one constant may have "absorbed" other constants into it. - Do ``help(ode.ode_)`` to get help more information on a specific hint, where ```` is the name of a hint without ``_Integral``. For system of ordinary differential equations ============================================= **Usage** ``dsolve(eq, func)`` -> Solve a system of ordinary differential equations ``eq`` for ``func`` being list of functions including `x(t)`, `y(t)`, `z(t)` where number of functions in the list depends upon the number of equations provided in ``eq``. **Details** ``eq`` can be any supported system of ordinary differential equations This can either be an :py:class:`~sympy.core.relational.Equality`, or an expression, which is assumed to be equal to ``0``. ``func`` holds ``x(t)`` and ``y(t)`` being functions of one variable which together with some of their derivatives make up the system of ordinary differential equation ``eq``. It is not necessary to provide this; it will be autodetected (and an error raised if it couldn't be detected). **Hints** The hints are formed by parameters returned by classify_sysode, combining them give hints name used later for forming method name. Examples ======== >>> from sympy import Function, dsolve, Eq, Derivative, sin, cos, symbols >>> from sympy.abc import x >>> f = Function('f') >>> dsolve(Derivative(f(x), x, x) + 9*f(x), f(x)) Eq(f(x), C1*sin(3*x) + C2*cos(3*x)) >>> eq = sin(x)*cos(f(x)) + cos(x)*sin(f(x))*f(x).diff(x) >>> dsolve(eq, hint='1st_exact') [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))] >>> dsolve(eq, hint='almost_linear') [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))] >>> t = symbols('t') >>> x, y = symbols('x, y', cls=Function) >>> eq = (Eq(Derivative(x(t),t), 12*t*x(t) + 8*y(t)), Eq(Derivative(y(t),t), 21*x(t) + 7*t*y(t))) >>> dsolve(eq) [Eq(x(t), C1*x0(t) + C2*x0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t)), Eq(y(t), C1*y0(t) + C2*(y0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t) + exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)))] >>> eq = (Eq(Derivative(x(t),t),x(t)*y(t)*sin(t)), Eq(Derivative(y(t),t),y(t)**2*sin(t))) >>> dsolve(eq) {Eq(x(t), -exp(C1)/(C2*exp(C1) - cos(t))), Eq(y(t), -1/(C1 - cos(t)))} R“torderR”iis@It solves only those systems of equations whose orders are equalc st‡fd†|DƒƒS(Nc3 s0|]&}t|tƒr$ˆ|ƒndVqdS(iN(R¨tlist(R¥titem(t recur_len(s0lib/python2.7/site-packages/sympy/solvers/ode.pys gs(tsum(tl(R³(s0lib/python2.7/site-packages/sympy/solvers/ode.pyR³fss_dsolve() and classify_sysode() work with number of functions being equal to number of equationsttype_of_equationt is_lineartno_of_equationis sysode_linear_neq_order%(order)ss1sysode_linear_%(no_of_equation)seq_order%(order)ss4sysode_nonlinear_%(no_of_equation)seq_order%(order)sthintRPtxitetattypetodeticstx0tntalltdictt ordered_hintstkeyc st|ˆdˆ ƒS(Nt trysolving(tode_sol_simplicity(tx(R”RP(s0lib/python2.7/site-packages/sympy/solvers/ode.pyt“stbestt best_hintR¯N( R tclassify_sysodeR±RRR"R tlenR¨tcoeffRR\t is_negativeRªtvaluesR©tNonetNotImplementedErrortTruetglobalsRR¬t solve_icstsubsR]tpopR’t classify_odet_helper_simplifytmintgettupdate(R“R”R¹RPR¾RºR»R¿RÀtkwargstmatchR°ttR¡tfunc_t solvefunctsolst constantstsolved_constantstsolt given_hintthintstall_tretdictt failed_hintstgethintst orderedhintstrvtdetail((R”R³RPs0lib/python2.7/site-packages/sympy/solvers/ode.pytdsolve‘s~    0 7    $  .     c sÿ|}|jdƒr4tƒd|tdƒ }ntƒd|}|d}|d} ||}|j‰‡fd†} |rè|||| |ƒ} t| tƒr½t|| ||ƒ} qg| D]} t|| ||ƒ^qÄ} n+t|d    + !% )  cC s|djd}g}g}tƒ}xL|jƒD]>\}} t|tƒr“|jd} g|D]} | j|jkrb| ^qbd} |} nBt|ttfƒrÉt|tƒrÆ|jƒ}nt|tƒr|j }|j d} |j j }|} nMt|tƒrM|}|j d} |ft |j ƒ}|j | |ƒ} n||kr³xW|D]L}|j|j jƒr`|jt|jj|Œ|jj|Œƒƒq`q`Wn|j|ƒ|} n tdƒ‚x™| D]‘}|j| ƒrÜ|}|j || ƒ}|j || ƒ}t|tƒ s2| rmg|D]}t|tƒs9|^q9}|j|ƒqmqÜqÜWq3Wyt||dtƒ}Wntk r§g}nX|s½tdƒ‚n|tkrØtdƒ‚nt |ƒdkrùtdƒ‚n|dS(sì Solve for the constants given initial conditions ``sols`` is a list of solutions. ``funcs`` is a list of functions. ``constants`` is a list of constants. ``ics`` is the set of initial/boundary conditions for the differential equation. It should be given in the form of ``{f(x0): x1, f(x).diff(x).subs(x, x2): x3}`` and so on. Returns a dictionary mapping constants to values. ``solution.subs(constants)`` will replace the constants in ``solution``. Example ======= >>> # From dsolve(f(x).diff(x) - f(x), f(x)) >>> from sympy import symbols, Eq, exp, Function >>> from sympy.solvers.ode import solve_ics >>> f = Function('f') >>> x, C1 = symbols('x C1') >>> sols = [Eq(f(x), C1*exp(x))] >>> funcs = [f(x)] >>> constants = [C1] >>> ics = {f(0): 2} >>> solved_constants = solve_ics(sols, funcs, constants, ics) >>> solved_constants {C1: 2} >>> sols[0].subs(solved_constants) Eq(f(x), 2*exp(x)) isUnrecognized initial conditionRÂs%Couldn't solve for initial conditionss\Initial conditions did not produce any solutions for constants. Perhaps they are degenerate.is<Initial conditions produced too many solutions for constants(targsRªtitemsR¨RR”RRR‘RŽtpointt variablesRÌRÕthasRùR!tlhsRtrhstaddRÑR'RVRÒR©(RátfuncsRâR¾RÇt diff_solst subs_solstdiff_variablestfuncargtvalueR¿R¦t matching_funcRtderivRRätsol2RòRã((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÔ×s`'  /        8    (   c^ st|ƒ}|jdtƒ}|rLt|jƒdkrLtd|ƒ‚n|s^|dfkr‹t||ƒ\}}|dfkr‹|}q‹n|jd‰|j‰t dƒ}|j dƒ}|j dƒ} |j dƒ} t |t ƒr?|j dkr3t|j|j |d |d |d|d| d| dtƒS|j}nt|ˆˆƒƒ} i| d 6} | s‚|r{df| d <| SdgSnˆˆƒjˆƒ} td dˆˆƒgƒ}tddˆˆƒgƒ}tddˆˆƒgƒ}tdd| ˆˆƒjˆdƒgƒ}tdd| gƒ}tdd| gƒ}tddˆˆˆƒ| gƒ}tddˆgƒ}tddˆˆˆƒ| gƒ}tddˆˆˆƒ| gƒ}tddˆˆˆƒ| gƒ}tddˆˆˆƒ| gƒ}tddˆˆƒ| ˆˆƒjˆdƒgƒ}tddˆˆƒ| ˆˆƒjˆdƒgƒ}tddˆˆƒ| ˆˆƒjˆdƒgƒ}i|d6| d6}i}tdƒ}t|ƒ}|dfk ròx"|D]} t | ttfƒrIt | tƒr$| j‰| jd}!| jd}"n+t | tƒrO| ‰ˆ}!| jd}"nt ˆtƒr:t ˆjdtƒr:ˆjdjˆkr:tˆjdjƒdkr:|!ˆkr:|"jˆƒ r:t‡fd†ˆjDƒƒr:|| jˆƒ r:tˆˆƒ}#dt|#ƒ}$|ji|"|$6|| |$d 6ƒqëtd!ƒ‚qÔt | tƒrß| jˆkrÐt| jƒdkrÐ| jdjˆƒ rÐ|| jˆƒ rÐ|ji| jdd"6|| d#6ƒqëtd$ƒ‚qÔtd%ƒ‚qÔWndf}%|j rž|j!ˆˆƒjˆ| ƒƒ}&|&dhkrž|&j"|ˆˆƒ|ƒ‰ˆr›ˆ|r›ˆˆƒˆ|}'t#g|jD]}(|(|'^q|Œ}%q›qžn|%s­|}%n| dkr„|j rÚ|%j$ˆƒ\})}*nVt d&ƒ}+|%|+j$ˆƒ\})}*g|)|*gD]},|,j%|+dƒ^q \})}*i|*j!| ƒ|6|*j!ˆˆƒƒ|6|)|6‰ˆ|jˆƒ røˆ|jˆƒ røˆ|| ˆ|ˆˆƒˆ|jƒ|%dkrø|ˆd <|ˆd<|ˆd<ˆ| d'<ˆ| d(|=d;}?t,ˆ||;ˆ|j%idˆ6|;|6ƒƒdkréˆ| |><ˆ| |>d<| kre|?| kreˆ| d=ƒ}D|%j%| |Dfˆˆƒ|+ffƒ}Eˆˆ|Bf|+|+|Cf|D| f|+ˆˆƒff}Ft,|Ej%|Fƒƒ}Et&t|Eƒ| ˆˆƒgƒj"|| |ƒ}G|Gr7t3|G|ˆˆˆƒƒ}H|Hdfk r4t3|G|ˆˆˆƒƒ}I|H|Ikr1|G|j%ˆˆƒ|ƒ|G|<|G|j%ˆˆƒ|ƒ|G|<|Gji|Bd?6|Cd@6|d6|d6|d6ƒ|G| dA<|G| dBƒ}Di|Dd>6}G|+j$ˆˆƒƒ\}N}Oˆj%|+|Dfd|+d|Dffƒ}P|Pj-}Qt|Qƒdkr|Qjƒ|Dkr|Gji|Nj:ƒddE6|Pd&6ƒ|G| dF<|G| dGƒ^q8ƒr˜t'ˆ|ˆ|ƒ}Mt'ˆ|ˆ|ƒ}W|j dOdƒ}-|Mj%ˆ|-ƒ}/|/jt(ƒ r…|/jt*ƒ r…|/jt)ƒ r…|/jt( ƒ r…|Wj%ˆ|-ƒ}/|/jt(ƒ r…|/jt*ƒ r…|/jt)ƒ r…|/jt( ƒ r…t}Uˆji|d6|d6|d6|-dO6| d-6ƒˆ| dP)``. See also the :py:meth:`~sympy.solvers.ode.dsolve` docstring for different meta-hints you can use. If ``dict`` is true, :py:meth:`~sympy.solvers.ode.classify_ode` will return a dictionary of ``hint:match`` expression terms. This is intended for internal use by :py:meth:`~sympy.solvers.ode.dsolve`. 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 executing ``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint without ``_Integral``. See :py:data:`~sympy.solvers.ode.allhints` or the :py:mod:`~sympy.solvers.ode` docstring for a list of all supported hints that can be returned from :py:meth:`~sympy.solvers.ode.classify_ode`. Notes ===== These are remarks on hint names. ``_Integral`` If a classification has ``_Integral`` at the end, it will return the expression with an unevaluated :py:class:`~sympy.integrals.Integral` class in it. Note that a hint may do this anyway if :py:meth:`~sympy.core.expr.Expr.integrate` cannot do the integral, though just using an ``_Integral`` will do so much faster. Indeed, an ``_Integral`` hint will always be faster than its corresponding hint without ``_Integral`` because :py:meth:`~sympy.core.expr.Expr.integrate` is an expensive routine. If :py:meth:`~sympy.solvers.ode.dsolve` hangs, it is probably because :py:meth:`~sympy.core.expr.Expr.integrate` is hanging on a tough or impossible integral. Try using an ``_Integral`` hint or ``all_Integral`` to get it return something. Note that some hints do not have ``_Integral`` counterparts. This is because :py:meth:`~sympy.solvers.ode.integrate` is not used in solving the ODE for those method. For example, `n`\th order linear homogeneous ODEs with constant coefficients do not require integration to solve, so there is no ``nth_linear_homogeneous_constant_coeff_Integrate`` hint. You can easily evaluate any unevaluated :py:class:`~sympy.integrals.Integral`\s in an expression by doing ``expr.doit()``. Ordinals Some hints contain an ordinal such as ``1st_linear``. This is to help differentiate them from other hints, as well as from other methods that may not be implemented yet. If a hint has ``nth`` in it, such as the ``nth_linear`` hints, this means that the method used to applies to ODEs of any order. ``indep`` and ``dep`` Some hints contain the words ``indep`` or ``dep``. These reference the independent variable and the dependent function, respectively. For example, if an ODE is in terms of `f(x)`, then ``indep`` will refer to `x` and ``dep`` will refer to `f`. ``subs`` If a hints has the word ``subs`` in it, it means the the ODE is solved by substituting the expression given after the word ``subs`` for a single dummy variable. This is usually in terms of ``indep`` and ``dep`` as above. The substituted expression will be written only in characters allowed for names of Python objects, meaning operators will be spelled out. For example, ``indep``/``dep`` will be written as ``indep_div_dep``. ``coeff`` The word ``coeff`` in a hint refers to the coefficients of something in the ODE, usually of the derivative terms. See the docstring for the individual methods for more info (``help(ode)``). This is contrast to ``coefficients``, as in ``undetermined_coefficients``, which refers to the common name of a method. ``_best`` Methods that have more than one fundamental way to solve will have a hint for each sub-method and a ``_best`` meta-classification. This will evaluate all hints and return the best, using the same considerations as the normal ``best`` meta-hint. Examples ======== >>> from sympy import Function, classify_ode, Eq >>> from sympy.abc import x >>> f = Function('f') >>> classify_ode(Eq(f(x).diff(x), 0), f(x)) ('nth_algebraic', 'separable', '1st_linear', '1st_homogeneous_coeff_best', '1st_homogeneous_coeff_subs_indep_div_dep', '1st_homogeneous_coeff_subs_dep_div_indep', '1st_power_series', 'lie_group', 'nth_linear_constant_coeff_homogeneous', 'nth_linear_euler_eq_homogeneous', 'nth_algebraic_Integral', 'separable_Integral', '1st_linear_Integral', '1st_homogeneous_coeff_subs_indep_div_dep_Integral', '1st_homogeneous_coeff_subs_dep_div_indep_Integral') >>> classify_ode(f(x).diff(x, 2) + 3*f(x).diff(x) + 2*f(x) - 4) ('nth_linear_constant_coeff_undetermined_coefficients', 'nth_linear_constant_coeff_variation_of_parameters', 'nth_linear_constant_coeff_variation_of_parameters_Integral') tprepisLdsolve() and classify_ode() only work with functions of one variable, not %sityRºR»RÀRÂR¾R°R¯taR§tbtcR—itetktc1ta2tb2tc2td2ta3tb3tc3tC1c3 s"|]}|ˆjdkVqdS(iN(R(R¥R¡(R (s0lib/python2.7/site-packages/sympy/solvers/ode.pys sR¦tvals/Enter valid boundary conditions for Derivativestf0tf0vals,Enter valid boundary conditions for FunctionsfEnter boundary conditions of the form ics={f(point}: value, f(x).diff(x, order).subs(x, point): value}tuRaRytexactRbRzRcttermsRjR`RxRkR%tm1tm2R_Rwtu1tu2t1st_homogeneous_coeff_subst_dep_div_indept_indep_div_depRïRdRÞtxargtyargRhR~tgentptpowerRiRtas_AddRgR}tgthRrR‚R¿RttqRuRst solutionsR^Rvc3 s.|]$}|dkrˆ|jˆƒVqdS(iN(R(R¥R¡(RúRÇ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys dsiÿÿÿÿRpttestttrialsetRnRlc sº|dkrtdƒ‚n|dkr+tS|dkrNˆ|jkrJtStS|jr|jˆˆƒƒrptSˆ||jkS|jr |jƒˆ|fkS|dkr¶ˆ|kStS(sN Linear Euler ODEs have the form K*x**order*diff(y(x),x,order) = F(x), where K is independent of x and y(x), order>= 0. So we need to check that for each term, coeff == K*x**order from some K. We have a few cases, since coeff may have several different types. isorder should be greater than 0i( R©RÒR¬R’tis_MulRRýtis_Powt as_base_exp(RÍR°(R¦RÇ(s0lib/python2.7/site-packages/sympy/solvers/ode.pyt _test_termws"       c s!i|]}ˆˆ||“qS(((R¥R¡(tfactorRú(s0lib/python2.7/site-packages/sympy/solvers/ode.pys —s c3 s;|]1}|dkr|dkrˆˆ||ƒ VqdS(R6iN((R¥R¡(R:t r_rescaled(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ™sRmRqRRoRÃN((ii(GR&RÖRÒRÌRýR©RÐR[R”R$RÚR¨R RR×RR’R\RR#R"RRRRŽRRÿRRRÁR¤RÛtis_AddRÍRÝRtas_independentRÕRLRGR RRtcopyRPR¬R.R9R‘RÑROthomogeneous_ordert_linear_coeff_matchR RRRHR?R9RtZeroRt is_polynomialt_nth_order_reducible_matcht_nth_algebraic_matcht_nth_linear_matchtanyt _undetermined_coefficients_matchRRtallhintsRœ(^R“R”RÂR¾RÜRRßRRºR»R#R°tmatching_hintstdfRRRR—RRRÀRRRRRRRRtr3tboundaryRR toldR•tdorderttempt reduced_eqt deriv_coeftdentargtindtdepR!ttmpRÿR tchecktcheck1tcheck2trseriest numeratorRRR$R%tr1torderatorderbR&R'Ròts1ts2tFtparamsR+R,RÞtdummy_eqR–tr2torderdtorderetmult_R2R.txparttypartR5Rótno_fR1tdeqtordinaryRÄR3t coeff_dictt undetcoeffRÍR1R¡tretlist((R:R R¦R;RúR<RÇs0lib/python2.7/site-packages/sympy/solvers/ode.pyR×>sšy       (   *!!!!!333      ($&$+) ! /    1 (8     E&      R6     &      !& ! " * $   $    &   ""         9 9     '82     8 -  ) $% ,   #'#)  0 **  2B) ! !0 ! !"     &          ( %c sžd„‰‡fd†|ˆgDƒ\}‰x@t|ƒD]2\}}t|tƒr8|j|j||t|ˆˆƒ}q‡d}q|ddkr|dkrxt|ˆˆƒ}q‡d}qd}nd}||d<|S(sy Returns a dictionary of parameter names and values that define the system of ordinary differential equations in ``eq``. The parameters are further used in :py:meth:`~sympy.solvers.ode.dsolve` for solving that system. The parameter names and values are: 'is_linear' (boolean), which tells whether the given system is linear. Note that "linear" here refers to the operator: terms such as ``x*diff(x,t)`` are nonlinear, whereas terms like ``sin(t)*diff(x,t)`` are still linear operators. 'func' (list) contains the :py:class:`~sympy.core.function.Function`s that appear with a derivative in the ODE, i.e. those that we are trying to solve the ODE for. 'order' (dict) with the maximum derivative for each element of the 'func' parameter. 'func_coeff' (dict) with the coefficient for each triple ``(equation number, function, order)```. The coefficients are those subexpressions that do not appear in 'func', and hence can be considered constant for purposes of ODE solving. 'eq' (list) with the equations from ``eq``, sympified and transformed into expressions (we are solving for these expressions to be zero). 'no_of_equations' (int) is the number of equations (same as ``len(eq)``). 'type_of_equation' (string) is an internal classification of the type of ODE. References ========== -http://eqworld.ipmnet.ru/en/solutions/sysode/sode-toc1.htm -A. D. Polyanin and A. V. Manzhirov, Handbook of Mathematics for Engineers and Scientists Examples ======== >>> from sympy import Function, Eq, symbols, diff >>> from sympy.solvers.ode import classify_sysode >>> from sympy.abc import t >>> f, x, y = symbols('f, x, y', cls=Function) >>> k, l, m, n = symbols('k, l, m, n', Integer=True) >>> x1 = diff(x(t), t) ; y1 = diff(y(t), t) >>> x2 = diff(x(t), t, t) ; y2 = diff(y(t), t, t) >>> eq = (Eq(5*x1, 12*x(t) - 6*y(t)), Eq(2*y1, 11*x(t) + 3*y(t))) >>> classify_sysode(eq) {'eq': [-12*x(t) + 6*y(t) + 5*Derivative(x(t), t), -11*x(t) - 3*y(t) + 2*Derivative(y(t), t)], 'func': [x(t), y(t)], 'func_coeff': {(0, x(t), 0): -12, (0, x(t), 1): 5, (0, y(t), 0): 6, (0, y(t), 1): 0, (1, x(t), 0): -11, (1, x(t), 1): 0, (1, y(t), 0): -3, (1, y(t), 1): 2}, 'is_linear': True, 'no_of_equation': 2, 'order': {x(t): 1, y(t): 1}, 'type_of_equation': 'type1'} >>> eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t))) >>> classify_sysode(eq) {'eq': [-t**2*y(t) - 5*t*x(t) + Derivative(x(t), t), t**2*x(t) - 5*t*y(t) + Derivative(y(t), t)], 'func': [x(t), y(t)], 'func_coeff': {(0, x(t), 0): -5*t, (0, x(t), 1): 1, (0, y(t), 0): -t**2, (0, y(t), 1): 0, (1, x(t), 0): t**2, (1, x(t), 1): 0, (1, y(t), 0): -5*t, (1, y(t), 1): 1}, 'is_linear': True, 'no_of_equation': 2, 'order': {x(t): 1, y(t): 1}, 'type_of_equation': 'type4'} cS s(tttt|ƒr|n|gƒƒS(N(R±tmapR&R (R“((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt_sympifyôsc3 s|]}ˆ|ƒVqdS(N((R¥tw(Rs(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ÷siR¸R“isYclassify_sysode() works for systems of ODEs. For scalar ODEs, classify_ode should be usedsDNumber of functions given is not equal to the number of equations %sR”sOdsolve() and classify_sysode() work with functions of one variable only, not %sR°c  sùxòtˆ|dƒD]Ü}t|jƒt|ˆ|ƒgƒjt|ˆ|ƒƒˆ|||f<|tkrˆ|||fdkrD|dkr|j|dtƒd}xMtdt||ƒdƒD]/}||jt|ˆ|ƒdtƒd8}qÈW|dkrAt}qAqî|jt|ˆ|ƒdtƒdrît}qîqñxªˆD]Ÿ}t |t ƒr¯x‡|D]A}ˆ|||fj|dtƒd} | dkrgt}qgqgWqKˆ|||fj|dtƒd} | dkrKt}qKqKWqqW|S(NiiR0( R RLRRRÍRÒR>R\R’R¨R±( teqstjR”t is_linear_RtcoeftxrRßt elem_func_RV(t func_coefRR°RÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pytlinearity_check4s,F  #-  %   & & t func_coeffR·iiR¶N(t enumerateR¨R RRR©R±RRR"RÂRÐRªR«RRùRÌRÚR’R\R RýRÒRÏtcheck_linear_2eq_order1tcheck_linear_2eq_order2tcheck_linear_3eq_order1tcheck_linear_neq_order1tcheck_nonlinear_2eq_order1tcheck_nonlinear_3eq_order1(R“RRÜR¡tfiRJRutderivsR—R”Rßt func_dictt max_orderteqs_torder_teq_not list_funct func_elemR|R·Rvtorder_eqR¶((RsR{RR°RÞs0lib/python2.7/site-packages/sympy/solvers/ode.pyR˳s´A "  0  .         )                      c s½|dj}|dj}|}tt|djtƒƒdjtƒƒd‰tƒ‰|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdf |d|ˆƒdfˆd<|d|ˆƒdf |d|ˆƒdfˆd<|d|ˆƒdf |d|ˆƒdfˆd<|d|ˆƒdf |d|ˆƒdfˆd³ssa1 a2 b1 b2 c1 c2ttype2c3 s#|]}ˆ|jˆƒ VqdS(N(R(R¥R(RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ¹sttype1ttype3ttype4ttype5ttype6ttype7(R”R±RRR"RÂRR Rt make_argsRRÐRGtas_numer_denomR~RRURÁtsplit(R“R”R{RÇRtfctforcingR¡RvR.R3tp1tp2RÀ((RúRÞs0lib/python2.7/site-packages/sympy/solvers/ode.pyR‡sn  0 5555&00 0 0 (%%(RLLc sB |dj}|dj}|}tt|djtƒƒdjtƒƒd‰tƒ‰tdddˆgƒ}tdddˆdgƒ}tddˆˆdgƒ}tddˆˆdgƒ} td dˆˆdgƒ} td dˆˆdgƒ} |d|ˆƒdfˆd <|d|ˆƒdfˆd <|d|ˆƒdfˆd <|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd dSnUˆd ˆdko&ˆdko&ˆdko&dknrTt ‡‡fd†dj ƒDƒƒrTdSˆd ˆdko‘ˆdko‘ˆdko‘dknrèt ‡‡fd †d!j ƒDƒƒrèˆdˆd krèˆdˆdkrèd"Stˆd ˆdƒˆkr¤tˆd ˆdƒˆkr¤ˆdˆd j ˆƒ r¤ˆdˆd j ˆƒ r¤ˆd ˆdko›ˆdko›ˆdko›dknr¤d#Sˆd ˆdjƒj| |ˆd| ˆ| djƒƒr—tˆd ˆdˆd ˆdƒj ˆƒ r—ˆdˆdj ˆƒ r—ˆdˆdj ˆƒ r—ˆd ˆdkoŽˆdkoŽˆdkoŽdknr—d$Stˆdˆdƒj ˆƒ rStˆdˆdƒj ˆƒ rStˆdˆd ˆdˆd ƒj ˆƒ rSˆd ˆdkoJˆdkoJˆdkoJdknrSd%Stˆd ˆdƒj ˆƒ r tˆdˆdƒj ˆƒ r tˆd ˆd ˆdˆd ƒj ˆƒ r ˆdˆdko ˆdko ˆdko dknr d&Stˆd ˆdƒˆkrØ tˆd ˆdƒˆkrØ tˆdˆd ˆdˆd ƒj ˆƒ rØ ˆdj ˆƒrØ ˆd ˆdkoÏ ˆdkoÏ ˆdkoÏ dknrØ d'Sˆd ˆd j|ˆƒrÐ ˆdˆd j|ˆƒrÐ ˆd ˆdj ˆƒ rÐ ˆdˆdj ˆƒ rÐ ˆdˆd j|ˆdƒrÐ ˆdˆd j|ˆdƒrÐ ˆdˆdj ˆƒ rÐ ˆdˆdj ˆƒ rÐ d(Sˆd  ˆdˆd ˆdko1 ˆd ˆdko1 ˆd ˆdko1 ˆknr: d)SdSdS(*NiiRR§RiR!tvRtR.RRRRRRR‘Rte1te2tf1tf2c3 s#|]}ˆ|jˆƒ VqdS(N(R(R¥R(RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys èssa1 a2 d1 d2 e1 e2 f1 f2R’c3 s#|]}ˆ|jˆƒ VqdS(N(R(R¥R(RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ìssa1 a2 b1 b2 c1 c2 d1 d2 e1 e1R•c3 s#|]}ˆ|jˆƒ VqdS(N(R(R¥R(RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ssa1 a2 d1 d2 e1 e2R“c3 s#|]}ˆ|jˆƒ VqdS(N(R(R¥R(RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ssa1 a2 b2 c1 d1 e2R”R–ttype10R—R˜ttype8ttype9ttype11(R”R±RRR"RÂR#RR RR™RRÁR›R~R>RR.R9RÍRRÐRGRRÝ(R“R”R{RÇRRœRRR!R RtR.tconstR¡RvR3RÀRttparttco((RúRÞs0lib/python2.7/site-packages/sympy/solvers/ode.pyR€Ïs¨  0 * %B%'%  @TT(>8BCN^DtDt>EB>8F8fc  s”|dj}|dj}|dj}|}tt|djtƒƒdjtƒƒd‰tƒ‰|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd<|d|ˆƒdfˆd <|d|ˆƒdfˆd <|d|ˆƒdfˆd <|d|ˆƒdfˆd <|d|ˆƒdfˆd <|d|ˆƒdfˆd<|d|ˆƒdfˆdFss#a1 a2 a3 b1 b2 b3 c1 c2 c3 d1 d2 d3R“R’R”sc1 d1 b2 d2 b3 c3c3 sA|]7}ˆ|dkrtˆˆˆ|ƒjˆƒ VqdS(iN(RGR(R¥R(tk1RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys Vssd1 b2 d2 b3 c3c3 sM|]C}ˆdˆ|krtˆˆˆdˆ|ƒjˆƒ VqdS(RN(RGR(R¥R(R­RúRÞ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys Wssb1 c2 d3R•(R”R±RRR"RÂRR RR™RRÐRÁR›( R“R”R{RÇRtzRœRR¡Rv((R­RúRÞs0lib/python2.7/site-packages/sympy/solvers/ode.pyR1sV   0 !'9%3?3XJ((c C só|dj}|dj}|dj}|}tt|djtƒƒdjtƒƒd}tƒ}t|ƒ} xdt| ƒD]V} xMt| ƒD]?} || || df|| || dfj|ƒr’dSq’WqWt|ƒdkrïdSdS(NiiiiR—R“( R”R±RRR"RÂRÌR RRÐ( R“R”R{RÇRR®RœRÞRúRÀR¡Rv((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR‚]s   0  5 c s¢ttˆdjtƒƒdjtƒƒd‰tdƒ‰tdƒ‰tddtƒ\‰‰‡‡‡‡‡‡fd†}xj|D]b}t|tƒr…|ddj}|ddj}|||ƒ}|sã|||ƒ}n|Sq…W|dj}|dj}|}tdd |ˆƒ|ˆƒgƒ} td d ˆˆgƒ} td d ˆˆgƒ} td d ˆˆgƒ} td d ˆˆgƒ} xat dƒD]S}d}x:t j ˆ|ƒD]%}||||||df7}q¼W|ˆ|$/"QV4$/"GLcC sdS(N(RÐ(R“R”R{((s0lib/python2.7/site-packages/sympy/solvers/ode.pytcheck_nonlinear_3eq_order2scC s.d„}||ƒ}xLtt|ƒƒD]8}t||tƒr(||j||j||>> from sympy import Eq, diff, symbols, sin, cos, exp, sqrt, S, Function >>> from sympy.solvers.ode 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]) cS s(tttt|ƒr|n|gƒƒS(N(R±RrR&R (R“((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRs@scs s3|])}t|tƒo*t|jƒdkVqdS(iN(R¨RRÌRý(R¥R”((s0lib/python2.7/site-packages/sympy/solvers/ode.pys NscS sh|]}|j’qS((Rý(R¥R”((s0lib/python2.7/site-packages/sympy/solvers/ode.pys Os is/func must be a function of one variable, not %ss'solutions should have one function onlycS sh|]}|j’qS((R(R¥Rä((s0lib/python2.7/site-packages/sympy/solvers/ode.pys Ts sCnumber of solutions provided does not match the number of equationsitforceN(R RÌR¨R RRRÐRRRªR«RRùR±RÁR©RýRÂtreversedRRVRÑR˜RPRRÒR’(RuRáR”RsR¡RR“R†R—RßRäRÞtdictsoltsolvedRtcheckeqtss((s0lib/python2.7/site-packages/sympy/solvers/ode.pytchecksysodesol s\4  #  .  "   "      4 cC s|jd}|j}t|ddƒ}|j|j}t|||ƒ}|jdƒrht|ƒ}nt|tƒs†t dƒ‚nt ||ƒ}|j |krÒ|j j |ƒ rÒt|j |j ƒg}n|j |kro|j j |ƒ ro|g}|jdƒr®ytjdtƒtjƒWntk r=nXt|ƒdkri|dj ||ƒksot‚|dj }t|ƒ}x{tD]s\} } } t||| t| |ƒtt| ƒ|ƒƒ}t||| t| |ƒt| |ƒƒ}qWx8tD]0\} } } t||| t| |ƒƒ}q Wbt|ƒ}t||ƒ|ƒ|dWnxGt&|ƒD]9\} }t ||ƒ|| >> from sympy import sin, symbols, dsolve, pprint, Function >>> from sympy.solvers.ode import odesimp >>> x , u2, C1= symbols('x,u2,C1') >>> f = Function('f') >>> eq = dsolve(x*f(x).diff(x) - f(x) - x*sin(f(x)/x), f(x), ... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral', ... simplify=False) >>> pprint(eq, wrap_line=False) x ---- f(x) / | | / 1 \ | -|u2 + -------| | | /1 \| | | sin|--|| | \ \u2// log(f(x)) = log(C1) + | ---------------- d(u2) | 2 | u2 | / >>> pprint(odesimp(eq, f(x), 1, {C1}, ... hint='1st_homogeneous_coeff_subs_indep_div_dep' ... )) #doctest: +SKIP x --------- = C1 /f(x)\ tan|----| \2*x / iRit"nth_linear_euler_eq_nonhomogeneouss$eq should be an instance of Equalitytnth_linear_constant_coeffRÄcs s|]}|jVqdS(N(tis_Float(R¥R¡((s0lib/python2.7/site-packages/sympy/solvers/ode.pys ösRÂtrationalcS s?|jƒ\}}|jr|St|jƒdddtƒSdS(NtcombineR.RŒ(RšR=RNRRÒ(RŽtnumertdenom((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt_expandýs t1st_homogeneous_coeffN(*RýR”R£R¬Røt startswithRPR¨R t TypeErrort constantsimpRRRR!t collecttermstsortRYtreverset ExceptionRÌtAssertionErrorRRLR.R2tabsR-RNRGRRRVRÒR’RÐRÑRCR~RMR0tconstant_renumber(R½R“R”R¹RÇR¦RRâRäR¡treroottimroottfloatsteqsolRÐRÞRvteqitnewi((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR÷tsh:  ""  1  53% '   .!  tautoc C stt|tƒs!t|dƒ}n|dkrÖyt|jƒ\}}WqÖtk rÒgt|tƒrn|n|gD]}|j t ƒ^qu}tƒj |Œ}t |ƒdkrÃtdƒ‚n|j ƒ}qÖXnt|t ƒ sût |jƒdkrtd|ƒ‚nt|tƒrUt|ƒg|D]!}t||d|d|ƒ^q-ƒSt|tƒsvt||ƒ}n|j|kr‘|j}n|dkr¯t||ƒ}n|j|koÎ|jj|ƒ } |rP| rPt||ƒ} | rPg| D]} t|| ƒ^qú} t | ƒdkr4| d} nt|| d|dtƒSnt}d} |jd}x³|r| dkrü|j|j}|j|krµt|||jƒ}n | d7} qlt|ƒ}|ré|jdtƒ}nd}| d7} ql| dkrcttt|j||ƒt|j||ƒƒt|jƒt|jƒƒ}| d7} ql| d kr|j|kr¤|jj|ƒ r¤i|jd6}n;|j|krÙ|jj|ƒ rÙi|jd6}ni}|j|j}x¯td|dƒD]š}|dkr‚|j|ƒ}y.t||j||ƒƒ}|sQt‚nWntk rp| d7} PqX|d||>> from sympy import Eq, Function, checkodesol, symbols >>> x, C1 = symbols('x,C1') >>> f = Function('f') >>> 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) iis0must pass func arg to checkodesol for this case.s/func must be a function of one variable, not %sR°tsolve_for_funcRâRÂiiÿÿÿÿR”sUnable to test if s is a solution to t.N()R¨R R!RÐR[RR©R RªRRR«RÌRÖRýR¼t checkodesolRRÃR\RRVR’RÒR˜RPRRQRR RÑtboolR'RRBRšR$RÕRRRR¤(R½RäR”R°RãRiRòRR¡RÅRRÞRuttestnumRÇtode_diffRÇtdiffsolstdstsdfRt ode_or_boolRt_funcR–((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRå sÆ:  7 %8  " "         K  ""     ""    %   (cC sút|ƒrLx-|D]%}t||d|ƒtkrtSqWtt|ƒƒS|jtƒr_tS|j|kr|jj|ƒ s£|j|kr§|jj|ƒ r§dS|rêy"t ||ƒ}|sÎt ‚nWnt k râqêXdSntt|ƒƒS(s= Returns an extended integer representing how simple a solution to an ODE is. The following things are considered, in order from most simple to least: - ``sol`` is solved for ``func``. - ``sol`` is not solved for ``func``, but can be if passed to solve (e.g., a solution returned by ``dsolve(ode, func, simplify=False``). - If ``sol`` is not solved for ``func``, then base the result on the length of ``sol``, as computed by ``len(str(sol))``. - If ``sol`` has any unevaluated :py:class:`~sympy.integrals.Integral`\s, this will automatically be considered less simple than any of the above. This function returns an integer such that if solution A is simpler than solution B by above metric, then ``ode_sol_simplicity(sola, func) < ode_sol_simplicity(solb, func)``. Currently, the following are the numbers returned, but if the heuristic is ever improved, this may change. Only the ordering is guaranteed. +----------------------------------------------+-------------------+ | Simplicity | Return | +==============================================+===================+ | ``sol`` solved for ``func`` | ``-2`` | +----------------------------------------------+-------------------+ | ``sol`` not solved for ``func`` but can be | ``-1`` | +----------------------------------------------+-------------------+ | ``sol`` is not solved nor solvable for | ``len(str(sol))`` | | ``func`` | | +----------------------------------------------+-------------------+ | ``sol`` contains an | ``oo`` | | :py:class:`~sympy.integrals.Integral` | | +----------------------------------------------+-------------------+ ``oo`` here means the SymPy infinity, which should compare greater than any integer. If you already know :py:meth:`~sympy.solvers.solvers.solve` cannot solve ``sol``, you can use ``trysolving=False`` to skip that step, which is the only potentially slow step. For example, :py:meth:`~sympy.solvers.ode.dsolve` with the ``simplify=False`` flag should do this. If ``sol`` is a list of solutions, if the worst solution in the list returns ``oo`` it returns that, otherwise it returns ``len(str(sol))``, that is, the length of the string representation of the whole list. Examples ======== This function is designed to be passed to ``min`` as the key argument, such as ``min(listofsolutions, key=lambda i: ode_sol_simplicity(i, f(x)))``. >>> from sympy import symbols, Function, Eq, tan, cos, sqrt, Integral >>> from sympy.solvers.ode import ode_sol_simplicity >>> x, C1, C2 = symbols('x, C1, C2') >>> f = Function('f') >>> ode_sol_simplicity(Eq(f(x), C1*x**2), f(x)) -2 >>> ode_sol_simplicity(Eq(x**2 + f(x), C1), f(x)) -1 >>> ode_sol_simplicity(Eq(f(x), C1*Integral(2*x, x)), f(x)) oo >>> eq1 = Eq(f(x)/tan(f(x)/(2*x)), C1) >>> eq2 = Eq(f(x)/tan(f(x)/(2*x) + f(x)), C2) >>> [ode_sol_simplicity(eq, f(x)) for eq in [eq1, eq2]] [28, 35] >>> min([eq1, eq2], key=lambda i: ode_sol_simplicity(i, f(x))) Eq(f(x)/tan(f(x)/(2*x)), C1) RÅiþÿÿÿiÿÿÿÿ( R RÆR RÌR¤RR9RRRVRÑ(RäR”RÅR¡Rá((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÆó s&Q  ""   c s5tˆƒ‰g‰‡‡‡fd†‰ˆ|ƒˆS(Nc s9|j}|r.|jˆƒr.ˆj|ƒn|jtkrR|jdtƒ}n|jttfkrÊt |j ‡fd†ƒ}t |tƒdkr|j|tŒ}|j sLjj|ƒqÇqnMt |tƒr|jjˆƒrtd„|jDƒƒrˆj|ƒqnx|j D]}ˆ|ƒq!WdS(NRhc s|jjˆƒS(N(R¬tissubset(R¡(R¢(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈz Rôics s!|]}t|ƒdkVqdS(iN(RÌ(R¥RÇ((s0lib/python2.7/site-packages/sympy/solvers/ode.pys s(R¬RîRùR”R.RRÒRRRZRýRÌt is_numberR¨R9RÁtlimits(RŽt expr_symsR—RÇR¡(tCesR¢t_recursive_walk(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRór s$  (Rª(RŽR¢((RòR¢Rós0lib/python2.7/site-packages/sympy/solvers/ode.pyt_get_constant_subexpressionso s   c  sœ‡fd†ˆDƒ‰gˆD]}ˆ|dkr|^q‰‡‡fd†‰‡‡fd†‰tˆtƒrŽgˆjD]}ˆ|ƒ^q|\}}‡fd†}t|tƒrÔ|ˆkrÔ||}}n|jttfkrÛ|jttfkrÛtt|tƒr|gn|j|ƒ}tt|tƒrC|gn|j|ƒ}xGtt gD]9}x0||gD]"}||krrdg||Š s ic st|tƒrgˆD]=}|j|ƒˆ|krd|j|dƒkr|^q}i}xG|D]?}|j|ƒ}||kr”g||>> from sympy import symbols >>> from sympy.solvers.ode import constantsimp >>> C1, C2, C3, x, y = symbols('C1, C2, C3, x, y') >>> constantsimp(2*C1*x, {C1, C2, C3}) C1*x >>> constantsimp(C1 + 2 + x, {C1, C2, C3}) C1 + x >>> constantsimp(C1*C2 + 2 + C2 + C3*x, {C1, C2, C3}) C1 + C3*x RÄiic3 s+|]!}|ˆkrˆd|kVqdS(iN((R¥tex(tcsRò(s0lib/python2.7/site-packages/sympy/solvers/ode.pys  scS s¡t|dtdtdtƒ}|jrt}t}xg|jD]Y}t|tƒr[t}n%|jr€td„|jDƒƒ}n|r=|r=|}Pq=q=Wn|S(NtclearRŒRcs s4|]*}tj|ƒD]}t|tƒVqqdS(N(RR™R¨R.(R¥RÞR…((s0lib/python2.7/site-packages/sympy/solvers/ode.pys / s( RBR’RÒR7RýR¨R.R=RG(RŽtnew_exprtinfactasfactm((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt_conditional_term_factoring$ s     (RôR±R¬RÁRõRÖR¤RÕRSR×RR"RÌRGRØRüRÔ( RŽRâR¢t orig_exprtconstant_subexprstxetxesRtcommonstrexprR((RþRòs0lib/python2.7/site-packages/sympy/solvers/ode.pyRÔ¾ s<G 7   "       c  s¾t|ƒtttfkrPg|D]}t|ˆ|ƒ^q"}t|ƒ|ƒSˆd k r~tˆƒ‰t|jˆƒ‰n=tƒ‰d„}g|jD]}||jƒrš|^qš‰|d kråtdddddˆƒ}n‡fd†|Dƒ}da t ˆƒ}d g|d‰gˆD]} | t j f^q%‰‡fd †‰‡‡‡‡fd †‰ˆ|ƒ}gˆD]} | ˆkrz| ^qz‰|j tˆd|ƒd tƒ}|S( sÚ Renumber arbitrary constants in ``expr`` to use the symbol names as given in ``newconstants``. In the process, this reorders expression terms in a standard way. If ``newconstants`` is not provided then the new constant names will be ``C1``, ``C2`` etc. Otherwise ``newconstants`` should be an iterable giving the new symbols to use for the constants in order. The ``variables`` argument is a list of non-constant symbols. All other free symbols found in ``expr`` are assumed to be constants and will be renumbered. If ``variables`` is not given then any numbered symbol beginning with ``C`` (e.g. ``C1``) is assumed to be a constant. Symbols are renumbered based on ``.sort_key()``, so they should be numbered roughly in the order that they appear in the final, printed expression. Note that this ordering is based in part on hashes, so it can produce different results on different machines. The structure of this function is very similar to that of :py:meth:`~sympy.solvers.ode.constantsimp`. Examples ======== >>> from sympy import symbols, Eq, pprint >>> from sympy.solvers.ode import constant_renumber >>> x, C1, C2, C3 = symbols('x,C1:4') >>> expr = C3 + C2*x + C1*x**2 >>> expr C1*x**2 + C2*x + C3 >>> constant_renumber(expr) C1 + C2*x + C3*x**2 The ``variables`` argument specifies which are constants so that the other symbols will not be renumbered: >>> constant_renumber(expr, [C1, x]) C1*x**2 + C2 + C3*x The ``newconstants`` argument is used to specify what symbols to use when replacing the constants: >>> constant_renumber(expr, [x], newconstants=symbols('E1:4')) E1 + E2*x + E3*x**2 cS s|jdƒo|djƒS(NR™i(RÒtisdigit(Rò((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈy RôRžiRŸR™R§c3 s!|]}|ˆkr|VqdS(N((R¥tsym(R(s0lib/python2.7/site-packages/sympy/solvers/ode.pys € sic st|jˆƒƒS(N(RYRÕ(RT(tC_1(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈ‹ Rôc s:t|tƒr.tˆ|jƒˆ|jƒƒSt|ƒtttfkrg|j rg|j ˆŒ rg|S|j rt|S|ˆkr§|ˆkr£|ˆt s,0%    +  "! %"cC s¼|jd}|j}|dkrF|jƒjt||ƒƒ}bnr|dkrtt|jt||ƒƒ|jƒ}bn9|dkr”|}n$|j dƒs²|jƒ}n|}|S(sƒ Converts a solution with Integrals in it into an actual solution. For most hints, this simply runs ``expr.doit()``. iR`RxRlRï( RýR”R‘RÕRR!RRRRö(RŽR”R¹RÇR¦Rä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRø¸ s    '  c C s“|jd}|j}|}||d}||d}|dat|ddƒ} t||ƒt|t||ƒjtƒtƒ} t| | ƒS(sõ Solves 1st order exact ordinary differential equations. A 1st order differential equation is called exact if it is the total differential of a function. That is, the differential equation .. math:: P(x, y) \,\partial{}x + Q(x, y) \,\partial{}y = 0 is exact if there is some function `F(x, y)` such that `P(x, y) = \partial{}F/\partial{}x` and `Q(x, y) = \partial{}F/\partial{}y`. It can be shown that a necessary and sufficient condition for a first order ODE to be exact is that `\partial{}P/\partial{}y = \partial{}Q/\partial{}x`. Then, the solution will be as given below:: >>> from sympy import Function, Eq, Integral, symbols, pprint >>> x, y, t, x0, y0, C1= symbols('x,y,t,x0,y0,C1') >>> P, Q, F= map(Function, ['P', 'Q', 'F']) >>> pprint(Eq(Eq(F(x, y), Integral(P(t, y), (t, x0, x)) + ... Integral(Q(x0, t), (t, y0, y))), C1)) x y / / | | F(x, y) = | P(t, y) dt + | Q(x0, t) dt = C1 | | / / x0 y0 Where the first partials of `P` and `Q` exist and are continuous in a simply connected region. A note: SymPy currently has no way to represent inert substitution on an expression, so the hint ``1st_exact_Integral`` will return an integral with `dy`. This is supposed to represent the function that you are solving for. Examples ======== >>> from sympy import Function, dsolve, cos, sin >>> from sympy.abc import x >>> f = Function('f') >>> dsolve(cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x), ... f(x), hint='1st_exact') Eq(x*cos(f(x)) + f(x)**3/3, C1) References ========== - https://en.wikipedia.org/wiki/Exact_differential_equation - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 73 # indirect doctest iRR—RRi(RýR”RR£R9RR!( R“R”R°RÝRÇR¦RúRR—RRä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt ode_1st_exactÔ s8   2c s‘t|ˆ||ƒ}t|ˆ||ƒ}|jdtƒ‰ˆrot||ˆdƒ}t||ˆdƒ}nt||gd‡‡fd†ƒS(s* Returns the best solution to an ODE from the two hints ``1st_homogeneous_coeff_subs_dep_div_indep`` and ``1st_homogeneous_coeff_subs_indep_div_dep``. This is as determined by :py:meth:`~sympy.solvers.ode.ode_sol_simplicity`. See the :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep` and :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep` docstrings for more information on these hints. Note that there is no ``ode_1st_homogeneous_coeff_best_Integral`` hint. Examples ======== >>> from sympy import Function, dsolve, pprint >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x), ... hint='1st_homogeneous_coeff_best', simplify=False)) / 2 \ | 3*x | log|----- + 1| | 2 | \f (x) / log(f(x)) = log(C1) - -------------- 3 References ========== - https://en.wikipedia.org/wiki/Homogeneous_differential_equation - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 59 # indirect doctest RPReRfRÄc st|ˆdˆ ƒS(NRÅ(RÆ(RÇ(R”RP(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈP s (t,ode_1st_homogeneous_coeff_subs_indep_div_dept,ode_1st_homogeneous_coeff_subs_dep_div_indepRÚRÒR÷RÙ(R“R”R°RÝtsol1R ((R”RPs0lib/python2.7/site-packages/sympy/solvers/ode.pytode_1st_homogeneous_coeff_best s,cC sE|jd}|j}tdƒ}tdƒ}|}t|ddƒ} |jddƒ} |jddƒ} t||d ||d |||djid|6||d 6ƒ|d ||ƒ|fƒ} tt t |ƒ| t | ƒƒd t ƒ} | j||ƒ|ƒj||| f||| f|||ƒffƒ} | S( st Solves a 1st order differential equation with homogeneous coefficients using the substitution `u_1 = \frac{\text{}}{\text{}}`. This is a differential equation .. math:: P(x, y) + Q(x, y) dy/dx = 0 such that `P` and `Q` are homogeneous and of the same order. A function `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`. Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`. See also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`. If the coefficients `P` and `Q` in the differential equation above are homogeneous functions of the same order, then it can be shown that the substitution `y = u_1 x` (i.e. `u_1 = y/x`) will turn the differential equation into an equation separable in the variables `x` and `u`. If `h(u_1)` is the function that results from making the substitution `u_1 = f(x)/x` on `P(x, f(x))` and `g(u_2)` is the function that results from the substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) + Q(x, f(x)) f'(x) = 0`, then the general solution is:: >>> from sympy import Function, dsolve, pprint >>> from sympy.abc import x >>> f, g, h = map(Function, ['f', 'g', 'h']) >>> genform = g(f(x)/x) + h(f(x)/x)*f(x).diff(x) >>> pprint(genform) /f(x)\ /f(x)\ d g|----| + h|----|*--(f(x)) \ x / \ x / dx >>> pprint(dsolve(genform, f(x), ... hint='1st_homogeneous_coeff_subs_dep_div_indep_Integral')) f(x) ---- x / | | -h(u1) log(x) = C1 + | ---------------- d(u1) | u1*h(u1) + g(u1) | / Where `u_1 h(u_1) + g(u_1) \ne 0` and `x \ne 0`. See also the docstrings of :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best` and :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`. Examples ======== >>> from sympy import Function, dsolve >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x), ... hint='1st_homogeneous_coeff_subs_dep_div_indep', simplify=False)) / 3 \ |3*f(x) f (x)| log|------ + -----| | x 3 | \ x / log(x) = log(C1) - ------------------- 3 References ========== - https://en.wikipedia.org/wiki/Homogeneous_differential_equation - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 59 # indirect doctest iR!R&RiR+R,RR—RRÂN( RýR”R$R£RÚR9RÕRÐRMR!R0RÒ(R“R”R°RÝRÇR¦R!R&RúRR+R,tintRä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR"T sM    C+JcC sQ|jd}|j}tdƒ}tdƒ}|}t|ddƒ} |jddƒ} |jddƒ} tt||d ||d |||dji||6d|d 6ƒƒ|d |||ƒfƒ} t t t ||ƒƒ| t | ƒƒd t ƒ} | j||ƒ|ƒj||| f||| f|||ƒffƒ} | S( s. Solves a 1st order differential equation with homogeneous coefficients using the substitution `u_2 = \frac{\text{}}{\text{}}`. This is a differential equation .. math:: P(x, y) + Q(x, y) dy/dx = 0 such that `P` and `Q` are homogeneous and of the same order. A function `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`. Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`. See also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`. If the coefficients `P` and `Q` in the differential equation above are homogeneous functions of the same order, then it can be shown that the substitution `x = u_2 y` (i.e. `u_2 = x/y`) will turn the differential equation into an equation separable in the variables `y` and `u_2`. If `h(u_2)` is the function that results from making the substitution `u_2 = x/f(x)` on `P(x, f(x))` and `g(u_2)` is the function that results from the substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) + Q(x, f(x)) f'(x) = 0`, then the general solution is: >>> from sympy import Function, dsolve, pprint >>> from sympy.abc import x >>> f, g, h = map(Function, ['f', 'g', 'h']) >>> genform = g(x/f(x)) + h(x/f(x))*f(x).diff(x) >>> pprint(genform) / x \ / x \ d g|----| + h|----|*--(f(x)) \f(x)/ \f(x)/ dx >>> pprint(dsolve(genform, f(x), ... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral')) x ---- f(x) / | | -g(u2) | ---------------- d(u2) | u2*g(u2) + h(u2) | / f(x) = C1*e Where `u_2 g(u_2) + h(u_2) \ne 0` and `f(x) \ne 0`. See also the docstrings of :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best` and :py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep`. Examples ======== >>> from sympy import Function, pprint, dsolve >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x), ... hint='1st_homogeneous_coeff_subs_indep_div_dep', ... simplify=False)) / 2 \ | 3*x | log|----- + 1| | 2 | \f (x) / log(f(x)) = log(C1) - -------------- 3 References ========== - https://en.wikipedia.org/wiki/Homogeneous_differential_equation - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 59 # indirect doctest iR!R'RiR+R,R—RRRÂN( RýR”R$R£RÚR9RPRÕRÐRMR!R0RÒ(R“R”R°RÝRÇR¦R!R'RúRR+R,R%Rä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR!± sP    F1JcG s|stdƒ‚nt|ƒ}t|ƒ}|jttƒrCd S|js^|js^|j ret j St dddt ƒ}tƒ}xŠg|D]}t|dƒr|^qD]`}t|jƒ}|j|ƒrÔd St|ƒ}|j||ƒ}|j|ƒ|j|ƒq¬W|j|ƒ|j|@s.d St|tƒrjt|jdt|ƒŒdkrcd St j St ddtƒ} t|jg|D]}|| |f^qŒƒ| gd tƒ| } | t jkrÔt j S| j| d tƒ\}} | j ƒ\} } | | kr| Sd S( s Returns the order `n` if `g` is homogeneous and ``None`` if it is not homogeneous. Determines if a function is homogeneous and if so of what order. A function `f(x, y, \cdots)` is homogeneous of order `n` if `f(t x, t y, \cdots) = t^n f(x, y, \cdots)`. If the function is of two variables, `F(x, y)`, then `f` being homogeneous of any order is equivalent to being able to rewrite `F(x, y)` as `G(x/y)` or `H(y/x)`. This fact is used to solve 1st order ordinary differential equations whose coefficients are homogeneous of the same order (see the docstrings of :py:meth:`~solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep` and :py:meth:`~solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`). Symbols can be functions, but every argument of the function must be a symbol, and the arguments of the function that appear in the expression must match those given in the list of symbols. If a declared function appears with different arguments than given in the list of symbols, ``None`` is returned. Examples ======== >>> from sympy import Function, homogeneous_order, sqrt >>> from sympy.abc import x, y >>> f = Function('f') >>> homogeneous_order(f(x), f(x)) is None True >>> homogeneous_order(f(x,y), f(y, x), x, y) is None True >>> homogeneous_order(f(x), f(x), x) 1 >>> homogeneous_order(x**2*f(x)/sqrt(x**2+f(x)**2), x, f(x)) 2 >>> homogeneous_order(x**2+f(x), x, f(x)) is None True s)homogeneous_order: no symbols were given.RŸR—R¯RiRÞtpositiveRÂR0N(!R©RªR&RRJRRÐt is_Numbertis_NumberSymbolRïRRBRXR$tgetattrRýRñR›RÕtremoveRRÛR¬R¨RR@RœRÒRORR>R’R9(R“R%tsymsettdumtnewsymsRvR¡tiargstdummyvarRÞRuR—RR((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR@ sD*      /    *B c C s¬|jd}|j}|}t|ddƒ}tt||d||d|ƒƒ}t|||d ||d|ƒ} |jd||ƒƒ}t|| ||ƒS(sp Solves 1st order linear differential equations. These are differential equations of the form .. math:: dy/dx + P(x) y = Q(x)\text{.} These kinds of differential equations can be solved in a general way. The integrating factor `e^{\int P(x) \,dx}` will turn the equation into a separable equation. The general solution is:: >>> from sympy import Function, dsolve, Eq, pprint, diff, sin >>> from sympy.abc import x >>> f, P, Q = map(Function, ['f', 'P', 'Q']) >>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x)) >>> pprint(genform) d P(x)*f(x) + --(f(x)) = Q(x) dx >>> pprint(dsolve(genform, f(x), hint='1st_linear_Integral')) / / \ | | | | | / | / | | | | | | | | P(x) dx | - | P(x) dx | | | | | | | / | / f(x) = |C1 + | Q(x)*e dx|*e | | | \ / / Examples ======== >>> f = Function('f') >>> pprint(dsolve(Eq(x*diff(f(x), x) - f(x), x**2*sin(x)), ... f(x), '1st_linear')) f(x) = x*(C1 - cos(x)) References ========== - https://en.wikipedia.org/wiki/Linear_differential_equation#First_order_equation - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 92 # indirect doctest iRiRRRR!(RýR”R£R.R9RÚR!( R“R”R°RÝRÇR¦RúRRÞttt((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_1st_linearo s3  )(c C sÍ|jd}|j}|}t|ddƒ}td||dt||d||d|ƒƒ}||ddt|||d||d|ƒ} t||ƒ| ||dd||dƒS(sr Solves Bernoulli differential equations. These are equations of the form .. math:: dy/dx + P(x) y = Q(x) y^n\text{, }n \ne 1`\text{.} The substitution `w = 1/y^{1-n}` will transform an equation of this form into one that is linear (see the docstring of :py:meth:`~sympy.solvers.ode.ode_1st_linear`). The general solution is:: >>> from sympy import Function, dsolve, Eq, pprint >>> from sympy.abc import x, n >>> f, P, Q = map(Function, ['f', 'P', 'Q']) >>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)**n) >>> pprint(genform) d n P(x)*f(x) + --(f(x)) = Q(x)*f (x) dx >>> pprint(dsolve(genform, f(x), hint='Bernoulli_Integral')) #doctest: +SKIP 1 ---- 1 - n // / \ \ || | | | || | / | / | || | | | | | || | (1 - n)* | P(x) dx | (-1 + n)* | P(x) dx| || | | | | | || | / | / | f(x) = ||C1 + (-1 + n)* | -Q(x)*e dx|*e | || | | | \\ / / / Note that the equation is separable when `n = 1` (see the docstring of :py:meth:`~sympy.solvers.ode.ode_separable`). >>> pprint(dsolve(Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)), f(x), ... hint='separable_Integral')) f(x) / | / | 1 | | - dy = C1 + | (-P(x) + Q(x)) dx | y | | / / Examples ======== >>> from sympy import Function, dsolve, Eq, pprint, log >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(Eq(x*f(x).diff(x) + f(x), log(x)*f(x)**2), ... f(x), hint='Bernoulli')) 1 f(x) = ------------------- / log(x) 1\ x*|C1 + ------ + -| \ x x/ References ========== - https://en.wikipedia.org/wiki/Bernoulli_differential_equation - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 95 # indirect doctest iRiRÀRRR(RýR”R£R.R9R!( R“R”R°RÝRÇR¦RúRRÞR0((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt ode_Bernoulli¬ sL  97cC sÈ|jd}|j}|}gdjƒD]}|||^q)\}} } } t|ddƒ} td| | || dƒ} t||ƒ|| | t| d|t|ƒ| ƒd| |ƒS(s… The general Riccati equation has the form .. math:: dy/dx = f(x) y^2 + g(x) y + h(x)\text{.} While it does not have a general solution [1], the "special" form, `dy/dx = a y^2 - b x^c`, does have solutions in many cases [2]. This routine returns a solution for `a(dy/dx) = b y^2 + c y/x + d/x^2` that is obtained by using a suitable change of variables to reduce it to the special form and is valid when neither `a` nor `b` are zero and either `c` or `d` is zero. >>> from sympy.abc import x, y, a, b, c, d >>> from sympy.solvers.ode import dsolve, checkodesol >>> from sympy import pprint, Function >>> f = Function('f') >>> y = f(x) >>> genform = a*y.diff(x) - (b*y**2 + c*y/x + d/x**2) >>> sol = dsolve(genform, y) >>> pprint(sol, wrap_line=False) / / __________________ \\ | __________________ | / 2 || | / 2 | \/ 4*b*d - (a + c) *log(x)|| -|a + c - \/ 4*b*d - (a + c) *tan|C1 + ----------------------------|| \ \ 2*a // f(x) = ------------------------------------------------------------------------ 2*b*x >>> checkodesol(genform, sol, order=1)[0] True References ========== 1. http://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Riccati 2. http://eqworld.ipmnet.ru/en/solutions/ode/ode0106.pdf - http://eqworld.ipmnet.ru/en/solutions/ode/ode0123.pdf is a2 b2 c2 d2Riii(RýR”R›R£R4R!R3R0(R“R”R°RÝRÇR¦RúRòRRRRRtmu((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_Riccati_special_minus2s(  3 c C s«|jd}|j}|}|d}t|ddƒ\}} ttt|d|ƒƒ|d||ƒfƒ} t| |ttt|d|ƒ ƒ|ƒ| dƒ} | S(sÛ Solves 2nd order Liouville differential equations. The general form of a Liouville ODE is .. math:: \frac{d^2 y}{dx^2} + g(y) \left(\! \frac{dy}{dx}\!\right)^2 + h(x) \frac{dy}{dx}\text{.} The general solution is: >>> from sympy import Function, dsolve, Eq, pprint, diff >>> from sympy.abc import x >>> f, g, h = map(Function, ['f', 'g', 'h']) >>> genform = Eq(diff(f(x),x,x) + g(f(x))*diff(f(x),x)**2 + ... h(x)*diff(f(x),x), 0) >>> pprint(genform) 2 2 /d \ d d g(f(x))*|--(f(x))| + h(x)*--(f(x)) + ---(f(x)) = 0 \dx / dx 2 dx >>> pprint(dsolve(genform, f(x), hint='Liouville_Integral')) f(x) / / | | | / | / | | | | | - | h(x) dx | | g(y) dy | | | | | / | / C1 + C2* | e dx + | e dy = 0 | | / / Examples ======== >>> from sympy import Function, dsolve, Eq, pprint >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(diff(f(x), x, x) + diff(f(x), x)**2/f(x) + ... diff(f(x), x)/x, f(x), hint='Liouville')) ________________ ________________ [f(x) = -\/ C1 + C2*log(x) , f(x) = \/ C1 + C2*log(x) ] References ========== - Goldstein and Braun, "Advanced Methods for the Solution of Differential Equations", pp. 98 - http://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Liouville # indirect doctest iRRiR1R2N(RýR”R£R9R.RÐR!( R“R”R°RÝRÇR¦RúRRtC2R%Rä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt ode_Liouville2s>   18c2C s„|jd}|j}t|ddƒ\}}tddtƒ}tdƒ} tdd|gƒ} |jd ƒ} |jd d ƒ} ||d } ||d }||d}i}tdƒ}||ƒ|f|||ƒ|f||d||ƒ| fg}xft|ƒD]X\}}|drt t |d|| ||j ||| ƒƒƒ}|j ro|j}n |g}xë|D]à}|j | || ƒ}|d|| }|| jså|j |||| j|ƒdƒ}n|| j ||ƒ}|rOx[tt|ƒƒD]4}|j ||ƒs9|||>> from sympy import dsolve, Function, pprint >>> from sympy.abc import x, y >>> f = Function("f") >>> eq = f(x).diff(x, 2) + f(x) >>> pprint(dsolve(eq, hint='2nd_power_series_ordinary')) / 4 2 \ / 2\ |x x | | x | / 6\ f(x) = C2*|-- - -- + 1| + C1*x*|1 - --| + O\x / \24 2 / \ 6 / References ========== - http://tutorial.math.lamar.edu/Classes/DE/SeriesSolutions.aspx - George E. Simmons, "Differential Equations with Applications and Historical Notes", p.p 176 - 184 iRiRÀtintegerRòRR§R¿R#iRRRRúiRÄcS s |jdS(Ni(Rý(RÇ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈãRôcS s |jdS(Ni(Rý(RÇ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈëRôcS s |jdS(Ni(Rý(RÇ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈìRôi($RýR”R£R$RÒR#RÚRR~RNRRÕR=RÝt is_SymbolR>RÃR RRÏtkeysRRGtmaxRRRÌRÖRVR¨R±RÙRLRRJR!(2R“R”R°RÝRÇR¦tC0RRÀRòRR¿R#R.R3Rút seriesdicttrecurrt coefflisttindexRÍR¤taddargsRTtpowmttermtstartindR¡tteqtsuminittrkeystreqtmaxvalRt finaldicttfargstmaxfRätminft startiterRRRÞttcounterRiRXtnlhstnrhsRKtfact((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_2nd_power_series_ordinaryzsž$    C 6     *          $    +    1)c C s |jd}|j}t|ddƒ\}}tdƒ}tdƒ} tdƒ} tdd|gƒ} |jd ƒ} |jd d ƒ} |d }|d }g}x¤||gD]–}|j|ƒsÔ|j|ƒq¯t|ddd | ƒ}t |t ƒr|jt dƒƒq¯x1|jD]&}|j|ƒs|j|ƒPqqWq¯W|\}}t | | d| ||| ƒ}|rt |t ƒrtg|D]}|j^q—ƒri}i}t|ƒdkr9|jƒ}}| |ddkr t||ƒt | ƒƒSt| |d|||||| ||ƒ }nÊ|d}|d}||kri||}}nt| |d|||||| ||ƒ }||jsÑt| |d|||||| ||ƒ }n2t| |d|||||| ||d|ƒ }|r|}x;|D]3}t|jdƒ}||||| |7}qW|| ||}t dƒ}|rÎx;|D]3}t|jdƒ}||||| |7}qxW||7}|| ||}nt||ƒt||||gƒt || ƒƒSndS(sK Gives a power series solution to a second order homogeneous differential equation with polynomial coefficients at a regular point. A second order homogenous differential equation is of the form .. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) = 0 A point is said to regular singular at `x0` if `x - x0\frac{Q(x)}{P(x)}` and `(x - x0)^{2}\frac{R(x)}{P(x)}` are analytic at `x0`. For simplicity `P(x)`, `Q(x)` and `R(x)` are assumed to be polynomials. The algorithm for finding the power series solutions is: 1. Try expressing `(x - x0)P(x)` and `((x - x0)^{2})Q(x)` as power series solutions about x0. Find `p0` and `q0` which are the constants of the power series expansions. 2. Solve the indicial equation `f(m) = m(m - 1) + m*p0 + q0`, to obtain the roots `m1` and `m2` of the indicial equation. 3. If `m1 - m2` is a non integer there exists two series solutions. If `m1 = m2`, there exists only one solution. If `m1 - m2` is an integer, then the existence of one solution is confirmed. The other solution may or may not exist. The power series solution is of the form `x^{m}\sum_{n=0}^\infty a_{n}x^{n}`. The coefficients are determined by the following recurrence relation. `a_{n} = -\frac{\sum_{k=0}^{n-1} q_{n-k} + (m + k)p_{n-k}}{f(m + n)}`. For the case in which `m1 - m2` is an integer, it can be seen from the recurrence relation that for the lower root `m`, when `n` equals the difference of both the roots, the denominator becomes zero. So if the numerator is not equal to zero, a second series solution exists. Examples ======== >>> from sympy import dsolve, Function, pprint >>> from sympy.abc import x, y >>> f = Function("f") >>> eq = x*(f(x).diff(x, 2)) + 2*(f(x).diff(x)) + x*f(x) >>> pprint(dsolve(eq)) / 6 4 2 \ | x x x | / 4 2 \ C1*|- --- + -- - -- + 1| | x x | \ 720 24 2 / / 6\ f(x) = C2*|--- - -- + 1| + ------------------------ + O\x / \120 6 / x References ========== - George E. Simmons, "Differential Equations with Applications and Historical Notes", p.p 176 - 184 iRiRÀRRòRR§R¿R#iR.R3iRXN(RýR”R£R$R#RÚRRùRKR¨RJRRVR±RÁtis_realRÌRÖR!t _frobeniust is_integerR%RRL(R“R”R°RÝRÇR¦R;RRÀRRòRR¿R#R.R3tindicialRBRTtp0tq0tsollistRätserdict1tserdict2R$R%t finalseries1RÄR/t finalseries2((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_2nd_power_series_regular sp6          #/   , /2    c C s®t|ƒ}| } tdƒ} tdddƒ} gt|dƒD]} t| ƒ^qA} tdƒ}g}x||gD]ø}|j|ƒrßt||ƒjƒ|krß|rÇ|j |||ƒ}nt||ƒj ƒ}nDt |d|d|dƒ}tt t |jƒƒd |ƒj ƒ}x=t|dƒD]+} | f|kr4tdƒ|| f>> from sympy import Function, dsolve, Eq >>> from sympy.abc import x >>> f = Function('f') >>> eq = Eq(x*f(x).diff(x)**2 + f(x).diff(x, 2)) >>> dsolve(eq, f(x), hint='nth_order_reducible') ... # doctest: +NORMALIZE_WHITESPACE Eq(f(x), C1 - sqrt(-1/C2)*log(-C2*sqrt(-1/C2) + x) + sqrt(-1/C2)*log(C2*sqrt(-1/C2) + x)) iRÀi(RýR”RRRRÒR$RRRÕRîR¨R±RùRÌ(R“R”R°RÝRÇR¦RÀRtnamesRR1Rttgeqtgsoltfsoltgsolitfsoli((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_nth_order_reducibleÓs*   %      ' c s÷t|ƒ‰‡fd†‰dtf‡‡fd†ƒY‰‡fd†}‡fd†}|jd‰||ˆƒ}yt||ƒ}Wntk r g}nXg|D]}||ˆƒ^q¨}g|D]}t||ƒ^qÊ}iˆd6|d6S( s Matches any differential equation that nth_algebraic can solve. Uses `sympy.solve` but teaches it how to integrate derivatives. This involves calling `sympy.solve` and does most of the work of finding a solution (apart from evaluating the integrals). c s tˆdƒS(N(R›RÐ((Râ(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈRôtdiffxc seZ‡‡fd†ZRS(c s‡‡fd†S(Nc st|ˆƒˆƒS(N(R9(RŽ(tconstanttvar(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈRô((tself(RtRu(s0lib/python2.7/site-packages/sympy/solvers/ode.pytinverses(t__name__t __module__Rw((RtRu(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRssc s"‡‡fd†}|jt|ƒS(Nc sw|d|d}}|}xU|D]M\}}x>t|ƒD]0}|ˆkr\ˆ|ƒ}q;t||ƒ}q;Wq"W|S(Nii(R R(Rýt differandtdiffst toreplaceR RÀRi(RsRu(s0lib/python2.7/site-packages/sympy/solvers/ode.pyt expand_diffxs (treplaceR(R“RuR}(Rs(Rus0lib/python2.7/site-packages/sympy/solvers/ode.pyR~s c s|jˆ‡fd†ƒS(Nc s t|ˆƒS(N(R(R(Ru(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÈ,Rô(R~(R“Ru(Rs(Rus0lib/python2.7/site-packages/sympy/solvers/ode.pyt unreplace+siRuR4(RšRRýRVRÑR (R“R”R~Rtsubs_eqntsolnstsoln((RtRâRsRus0lib/python2.7/site-packages/sympy/solvers/ode.pyREs    ""cC sK|d}|d}t||||ƒ}t|ƒdkrC|dS|SdS(s Solves an `n`\th order ordinary differential equation using algebra and integrals. There is no general form for the kind of equation that this can solve. The the equation is solved algebraically treating differentiation as an invertible algebraic function. Examples ======== >>> from sympy import Function, dsolve, Eq >>> from sympy.abc import x >>> f = Function('f') >>> eq = Eq(f(x) * (f(x).diff(x)**2 - 1), 0) >>> dsolve(eq, f(x), hint='nth_algebraic') ... # doctest: +NORMALIZE_WHITESPACE [Eq(f(x), 0), Eq(f(x), C1 - x), Eq(f(x), C1 + x)] Note that this solver can return algebraic solutions that do not have any integration constants (f(x) = 0 in the above example). # indirect doctest R4RuiiN(t)_nth_algebraic_remove_redundant_solutionsRÌ(R“R”R°RÝRRu((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_nth_algebraic:s   c s‡‡‡fd†}g}x_|D]W}xN|D]8}|||ƒrIPq0|||ƒr0|j|ƒq0q0W|j|ƒq"W|S(sÜ Remove redundant solutions from the set of solutions returned by nth_algebraic. This function is needed because otherwise nth_algebraic can return redundant solutions where both algebraic solutions and integral solutions are found to the ODE. As an example consider: eq = Eq(f(x) * f(x).diff(x), 0) There are two ways to find solutions to eq. The first is the algebraic solution f(x)=0. The second is to solve the equation f(x).diff(x) = 0 leading to the solution f(x) = C1. In this particular case we then see that the first solution is a special case of the second and we don't want to return it. This does not always happen for algebraic solutions though since if we have eq = Eq(f(x)*(1 + f(x).diff(x)), 0) then we get the algebraic solution f(x) = 0 and the integral solution f(x) = -x + C1 and in this case the two solutions are not equivalent wrt initial conditions so both should be returned. c st||ˆˆˆƒS(N(t!_nth_algebraic_is_special_case_of(tsoln1tsoln2(R“R°Ru(s0lib/python2.7/site-packages/sympy/solvers/ode.pytis_special_case_ofys(R*Rù(R“RR°RuRˆt unique_solnsR†R‡((R“R°Rus0lib/python2.7/site-packages/sympy/solvers/ode.pyRƒ_s c sÈ|jj|jƒ}|jj|jƒ}t|j|jt|ƒƒ}t|ƒdkrg|h}nx/t||ƒD]\}} |j|| ƒ}qwW|jjƒ} |jjƒ} t| | ƒg} xQt d|ƒD]@} | j ˆƒ} | j ˆƒ} t| | ƒ}| j |ƒqÙWt d„| Dƒƒr7t Sg| D]}t|tƒs>|^q>} t| |ƒ}t|tƒr‰|g}nx8|D],}t ‡fd†|jƒDƒƒstSqWt SdS(s‰ True if soln1 is found to be a special case of soln2 wrt some value of the constants that appear in soln2. False otherwise. ics s|]}t|tƒVqdS(N(R¨R,(R¥R“((s0lib/python2.7/site-packages/sympy/solvers/ode.pys ®sc3 s|]}|jˆƒVqdS(N(R(R¥R(Ru(s0lib/python2.7/site-packages/sympy/solvers/ode.pys »sN(R¬RñR£RRÌRRÕR‘R!R RRùRGR’R¨R+RVRÂRÏRÒ(R†R‡R“R°Rut constants1t constants2tconstants1_newtc_oldtc_newRRteqnsRÀtconstant_solnst constant_soln((Rus0lib/python2.7/site-packages/sympy/solvers/ode.pyR…ˆs2 (  "c C s|jd}|h}d„td|dƒDƒ}xËtj|ƒD]º}|j|ƒsk|dc|7>> from sympy import Function, cos, sin >>> from sympy.abc import x >>> from sympy.solvers.ode import _nth_linear_match >>> f = Function('f') >>> _nth_linear_match(f(x).diff(x, 3) + 2*f(x).diff(x) + ... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) - ... sin(x), f(x), 3) {-1: x - sin(x), 0: -1, 1: cos(x) + 2, 2: x, 3: 1} >>> _nth_linear_match(f(x).diff(x, 3) + 2*f(x).diff(x) + ... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) - ... sin(f(x)), f(x), 3) == None True icS si|]}tj|“qS((RRB(R¥R¡((s0lib/python2.7/site-packages/sympy/solvers/ode.pys às iÿÿÿÿiN( RýR RR™RR>R¨RRªRtderivative_countRÌRÐ( R“R”R°RÇtone_xR#R¡RR¦((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRFÁs    Räc C sîga|jd}|j}|}tjtdƒ}} xd|jƒD]V} t| tƒ rE| dkrE||| t || || ƒ|| j ƒ7}qEqEWt || ƒ}gt |j ƒƒD]} t|| ƒ^qÁ} tt|d|j ƒdƒƒ} | jƒttƒ}x| D]}||cd7>> from sympy import Function, dsolve, Eq >>> from sympy.abc import x >>> f = Function('f') >>> dsolve(4*x**2*f(x).diff(x, 2) + f(x), f(x), ... hint='nth_linear_euler_eq_homogeneous') ... # doctest: +NORMALIZE_WHITESPACE Eq(f(x), sqrt(x)*(C1 + C2*log(x))) Note that because this method does not involve integration, there is no ``nth_linear_euler_eq_homogeneous_Integral`` hint. The following is for internal use: - ``returns = 'sol'`` returns the solution to the ODE. - ``returns = 'list'`` returns a list of linearly independent solutions, corresponding to the fundamental solution set, for use with non homogeneous solution methods like variation of parameters and undetermined coefficients. Note that, though the solutions should be linearly independent, this function does not explicitly check that. You can do ``assert simplify(wronskian(sollist)) != 0`` to check for linear independence. Also, ``assert len(sollist) == order`` will need to pass. - ``returns = 'both'``, return a dictionary ``{'sol': , 'list': }``. Examples ======== >>> from sympy import Function, dsolve, pprint >>> from sympy.abc import x >>> f = Function('f') >>> eq = f(x).diff(x, 2)*x**2 - 4*f(x).diff(x)*x + 6*f(x) >>> pprint(dsolve(eq, f(x), ... hint='nth_linear_euler_eq_homogeneous')) 2 f(x) = x *(C1 + C2*x) References ========== - https://en.wikipedia.org/wiki/Cauchy%E2%80%93Euler_equation - C. Bender & S. Orszag, "Advanced Mathematical Methods for Scientists and Engineers", Springer 1999, pp. 12 # indirect doctest iRÇRiisValue should be 1RätlistbothR±s Unknown value for key "returns".N(!RÕRýR”RRBR$R9R¨RRRR?R RHRAR±R£R×RR%R0RþR@RÖR©RSR1R/R2RÚR-R!Rù(R“R”R°RÝtreturnsRÇR¦RútchareqtsymbolR¡Rt chareqrootsRât charrootstrootRntlnt multiplicityRÜRÝtgensolstsin_formtcos_form((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt#ode_nth_linear_euler_eq_homogeneousñsbD  8."      &  ##   "2 , $c C sí|jd}|j}|}tjtjtdƒ}}} xd|jƒD]V} t| tƒ rI| dkrI||| t|| || ƒ|| j ƒ7}qIqIWxWt dt t || ƒƒdƒD]3} ||j | | ƒt||ƒ|| ƒ7}qÆW|j| ƒdr4||j| ƒd||ƒ7}nt|dj|t|ƒƒƒ\} } || j| ƒ7}t|||ƒt|||ƒƒƒ}|d|d>> from sympy import dsolve, Function, Derivative, log >>> from sympy.abc import x >>> f = Function('f') >>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - log(x) >>> dsolve(eq, f(x), ... hint='nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients').expand() Eq(f(x), C1*x + C2*x**2 + log(x)/2 + 3/4) iRÇiiÿÿÿÿR6(RýR”RRBR$R9R¨RRRR RHR?RÍt as_coeff_addRRRÕR.RFR\t7ode_nth_linear_constant_coeff_undetermined_coefficientsR0( R“R”R°RÝR•RÇR¦RúR–R—R¡RR1((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt@ode_nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients~s .   8)1$('c C sÁ|jd}|j}|}t||||ddƒ}|j|ƒ|d|t|||ƒƒ|d>> from sympy import Function, dsolve, Derivative >>> from sympy.abc import x >>> f = Function('f') >>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - x**4 >>> dsolve(eq, f(x), ... hint='nth_linear_euler_eq_nonhomogeneous_variation_of_parameters').expand() Eq(f(x), C1*x + C2*x**2 + x**4/6) iR•tbothiÿÿÿÿRä(RýR”R RÛR\t_solve_variation_of_parametersR!R( R“R”R°RÝR•RÇR¦RútgensolRä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt>ode_nth_linear_euler_eq_nonhomogeneous_variation_of_parametersÃs6   %cC st||||ƒS(s_ Solves an almost-linear differential equation. The general form of an almost linear differential equation is .. math:: f(x) g(y) y + k(x) l(y) + m(x) = 0 \text{where} l'(y) = g(y)\text{.} This can be solved by substituting `l(y) = u(y)`. Making the given substitution reduces it to a linear differential equation of the form `u' + P(x) u + Q(x) = 0`. The general solution is >>> from sympy import Function, dsolve, Eq, pprint >>> from sympy.abc import x, y, n >>> f, g, k, l = map(Function, ['f', 'g', 'k', 'l']) >>> genform = Eq(f(x)*(l(y).diff(y)) + k(x)*l(y) + g(x)) >>> pprint(genform) d f(x)*--(l(y)) + g(x) + k(x)*l(y) = 0 dy >>> pprint(dsolve(genform, hint = 'almost_linear')) / // y*k(x) \\ | || ------ || | || f(x) || -y*k(x) | ||-g(x)*e || -------- | ||-------------- for k(x) != 0|| f(x) l(y) = |C1 + |< k(x) ||*e | || || | || -y*g(x) || | || -------- otherwise || | || f(x) || \ \\ // See Also ======== :meth:`sympy.solvers.ode.ode_1st_linear` Examples ======== >>> from sympy import Function, Derivative, pprint >>> from sympy.solvers.ode import dsolve, classify_ode >>> from sympy.abc import x >>> f = Function('f') >>> d = f(x).diff(x) >>> eq = x*d + x*f(x) + 1 >>> dsolve(eq, f(x), hint='almost_linear') Eq(f(x), (C1 - Ei(x))*exp(-x)) >>> pprint(dsolve(eq, f(x), hint='almost_linear')) -x f(x) = (C1 - Ei(x))*e References ========== - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications of the ACM, Volume 14, Number 8, August 1971, pp. 558 (R1(R“R”R°RÝ((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_almost_linearsCc  s|j‰|jd‰‡‡fd†‰‡fd†‰g|jtƒD]H}|jˆkrGt|jƒdkrG|jdj rG|jd^qGp›|h}ˆ|jƒƒ‰ˆrt‡‡fd†|Dƒƒrˆ\}}}}}} } |||| | || ||| fSdS(s÷ Helper function to match hint ``linear_coefficients``. Matches the expression to the form `(a_1 x + b_1 f(x) + c_1)/(a_2 x + b_2 f(x) + c_2)` where the following conditions hold: 1. `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are Rationals; 2. `c_1` or `c_2` are not equal to zero; 3. `a_2 b_1 - a_1 b_2` is not equal to zero. Return ``xarg``, ``yarg`` where 1. ``xarg`` = `(b_2 c_1 - b_1 c_2)/(a_2 b_1 - a_1 b_2)` 2. ``yarg`` = `(a_1 c_2 - a_2 c_1)/(a_2 b_1 - a_1 b_2)` Examples ======== >>> from sympy import Function >>> from sympy.abc import x >>> from sympy.solvers.ode import _linear_coeff_match >>> from sympy.functions.elementary.trigonometric import sin >>> f = Function('f') >>> _linear_coeff_match(( ... (-25*f(x) - 8*x + 62)/(4*f(x) + 11*x - 11)), f(x)) (1/9, 22/9) >>> _linear_coeff_match( ... sin((-5*f(x) - 8*x + 6)/(4*f(x) + x - 1)), f(x)) (19/27, 2/27) >>> _linear_coeff_match(sin(f(x)/x), f(x)) ic s¬t|ƒ}|jˆˆˆƒdtƒd}|js;dS|jˆƒ}|jsWdS|jˆˆƒƒ}|jsydS||ˆ|ˆˆƒ|kr¨|||fSdS(s Internal function of _linear_coeff_match that returns Rationals a, b, c if eq is a*x + b*f(x) + c, else None. R0iN(RR>RÒt is_RationalRÍ(R“RRR(R¦RÇ(s0lib/python2.7/site-packages/sympy/solvers/ode.pytabcms "   "c  s­|jƒjƒ\}}ˆ|ƒ}|dk r©|\}}}ˆ|ƒ}|dk r©|\}}} ||||}|s„| r¦|r¦|||||| |fSq©ndS(s  Internal function of _linear_coeff_match that returns Rationals a1, b1, c1, a2, b2, c2 and a2*b1 - a1*b2 of the expression (a1*x + b1*f(x) + c1)/(a2*x + b2*f(x) + c2) if one of c1 or c2 and a2*b1 - a1*b2 is non-zero, else None. N(ttogetherRšRÐ( RTRÀR—RRRRRRR(Rª(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÝ€s    ic3 s!|]}ˆ|ƒˆkVqdS(N((R¥tmi(R$RÝ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys •sN(R”RýRRRÌRRÖRÁ( RŽR”R…RRRRRRRRÏ((RªR¦R$RÝRÇs0lib/python2.7/site-packages/sympy/solvers/ode.pyRAIs"  %B%cC st||||ƒS(s² Solves a differential equation with linear coefficients. The general form of a differential equation with linear coefficients is .. math:: y' + F\left(\!\frac{a_1 x + b_1 y + c_1}{a_2 x + b_2 y + c_2}\!\right) = 0\text{,} where `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are constants and `a_1 b_2 - a_2 b_1 \ne 0`. This can be solved by substituting: .. math:: x = x' + \frac{b_2 c_1 - b_1 c_2}{a_2 b_1 - a_1 b_2} y = y' + \frac{a_1 c_2 - a_2 c_1}{a_2 b_1 - a_1 b_2}\text{.} This substitution reduces the equation to a homogeneous differential equation. See Also ======== :meth:`sympy.solvers.ode.ode_1st_homogeneous_coeff_best` :meth:`sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep` :meth:`sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep` Examples ======== >>> from sympy import Function, Derivative, pprint >>> from sympy.solvers.ode import dsolve, classify_ode >>> from sympy.abc import x >>> f = Function('f') >>> df = f(x).diff(x) >>> eq = (x + f(x) + 1)*df + (f(x) - 6*x + 1) >>> dsolve(eq, hint='linear_coefficients') [Eq(f(x), -x - sqrt(C1 + 7*x**2) - 1), Eq(f(x), -x + sqrt(C1 + 7*x**2) - 1)] >>> pprint(dsolve(eq, hint='linear_coefficients')) ___________ ___________ / 2 / 2 [f(x) = -x - \/ C1 + 7*x - 1, f(x) = -x + \/ C1 + 7*x - 1] References ========== - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications of the ACM, Volume 14, Number 8, August 1971, pp. 558 (R$(R“R”R°RÝ((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_linear_coefficients™s4c C sÓ|jd}|j}tdƒ}|dj|d|ƒ}d||d|}id|6d||6dd6} i||6d|6dd6} i| d 6| d 6|d6||d||ƒd 6} t|||| ƒS( sx Solves a differential equation that can be reduced to the separable form. The general form of this equation is .. math:: y' + (y/x) H(x^n y) = 0\text{}. This can be solved by substituting `u(y) = x^n y`. The equation then reduces to the separable form `\frac{u'}{u (\mathrm{power} - H(u))} - \frac{1}{x} = 0`. The general solution is: >>> from sympy import Function, dsolve, Eq, pprint >>> from sympy.abc import x, n >>> f, g = map(Function, ['f', 'g']) >>> genform = f(x).diff(x) + (f(x)/x)*g(x**n*f(x)) >>> pprint(genform) / n \ d f(x)*g\x *f(x)/ --(f(x)) + --------------- dx x >>> pprint(dsolve(genform, hint='separable_reduced')) n x *f(x) / | | 1 | ------------ dy = C1 + log(x) | y*(n - g(y)) | / See Also ======== :meth:`sympy.solvers.ode.ode_separable` Examples ======== >>> from sympy import Function, Derivative, pprint >>> from sympy.solvers.ode import dsolve, classify_ode >>> from sympy.abc import x >>> f = Function('f') >>> d = f(x).diff(x) >>> eq = (x - x**2*f(x))*d - f(x) >>> dsolve(eq, hint='separable_reduced') [Eq(f(x), (1 - sqrt(C1*x**2 + 1))/x), Eq(f(x), (sqrt(C1*x**2 + 1) + 1)/x)] >>> pprint(dsolve(eq, hint='separable_reduced')) ___________ ___________ / 2 / 2 1 - \/ C1*x + 1 \/ C1*x + 1 + 1 [f(x) = ------------------, f(x) = ------------------] x x References ========== - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications of the ACM, Volume 14, Number 8, August 1971, pp. 558 iRR!RÞiR/iÿÿÿÿRÍR$R%R¹(RýR”R$RÕt ode_separable( R“R”R°RÝRÇR¦RR!tycoeffR$R%Rú((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_separable_reducedÐsA   4cC s|jd}|d}|j}||d ||d}|jdƒ}|jdƒ} |jdƒ} |} |s‡t||ƒ| ƒS| } | dkr|ji||6| |6ƒ} | jtƒsã| jtƒsã| jtƒröt||ƒtƒS| r| | ||7} qnxÊt d | ƒD]¹}| j |ƒ| j |ƒ|}|ji||6| |6ƒ}|jtƒs¤|jtƒs¤|jt ƒs¤|jtƒr·t||ƒtƒS| ||||t |ƒ7} |} q$W| t || ƒ7} t||ƒ| ƒS( sy The power series solution is a method which gives the Taylor series expansion to the solution of a differential equation. For a first order differential equation `\frac{dy}{dx} = h(x, y)`, a power series solution exists at a point `x = x_{0}` if `h(x, y)` is analytic at `x_{0}`. The solution is given by .. math:: y(x) = y(x_{0}) + \sum_{n = 1}^{\infty} \frac{F_{n}(x_{0},b)(x - x_{0})^n}{n!}, where `y(x_{0}) = b` is the value of y at the initial value of `x_{0}`. To compute the values of the `F_{n}(x_{0},b)` the following algorithm is followed, until the required number of terms are generated. 1. `F_1 = h(x_{0}, b)` 2. `F_{n+1} = \frac{\partial F_{n}}{\partial x} + \frac{\partial F_{n}}{\partial y}F_{1}` Examples ======== >>> from sympy import Function, Derivative, pprint, exp >>> from sympy.solvers.ode import dsolve >>> from sympy.abc import x >>> f = Function('f') >>> eq = exp(x)*(f(x).diff(x)) - f(x) >>> pprint(dsolve(eq, hint='1st_power_series')) 3 4 5 C1*x C1*x C1*x / 6\ f(x) = C1 + C1*x - ----- + ----- + ----- + O\x / 6 24 60 References ========== - Travis W. Walker, Analytic power series technique for solving first-order differential equations, p.p 17, 18 iRR—RRR R#ii( RýR”RÚR!RÕRR RRR RR8RJ(R“R”R°RÝRÇRR¦R2RÿR R#RbRKthct factcounttFnewtFnewc((s0lib/python2.7/site-packages/sympy/solvers/ode.pytode_1st_power_seriess4(    - =  cC s |jd}|j}|}tjtdƒ}} xK|jƒD]=} t| ƒtks|| dkrfq?||| | | 7}q?Wt|| ƒ}t |dt ƒ} t | ƒ|krägt |j ƒƒD]} t|| ƒ^qÆ} ntg|jƒD]} | j^qôƒ } tt|d|j ƒdƒƒ}ttƒ}x| D]}||cd7>> from sympy import Function, dsolve, Eq >>> from sympy.abc import x >>> f = Function('f') >>> dsolve(f(x).diff(x, 5) + 10*f(x).diff(x) - 2*f(x), f(x), ... hint='nth_linear_constant_coeff_homogeneous') ... # doctest: +NORMALIZE_WHITESPACE Eq(f(x), C5*exp(x*CRootOf(_x**5 + 10*_x - 2, 0)) + (C1*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 1))) + C2*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 1))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 1))) + (C3*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 3))) + C4*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 3))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 3)))) Note that because this method does not involve integration, there is no ``nth_linear_constant_coeff_homogeneous_Integral`` hint. The following is for internal use: - ``returns = 'sol'`` returns the solution to the ODE. - ``returns = 'list'`` returns a list of linearly independent solutions, for use with non homogeneous solution methods like variation of parameters and undetermined coefficients. Note that, though the solutions should be linearly independent, this function does not explicitly check that. You can do ``assert simplify(wronskian(sollist)) != 0`` to check for linear independence. Also, ``assert len(sollist) == order`` will need to pass. - ``returns = 'both'``, return a dictionary ``{'sol': , 'list': }``. Examples ======== >>> from sympy import Function, dsolve, pprint >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(f(x).diff(x, 4) + 2*f(x).diff(x, 3) - ... 2*f(x).diff(x, 2) - 6*f(x).diff(x) + 5*f(x), f(x), ... hint='nth_linear_constant_coeff_homogeneous')) x -2*x f(x) = (C1 + C2*x)*e + (C3*sin(x) + C4*cos(x))*e References ========== - https://en.wikipedia.org/wiki/Linear_differential_equation section: Nonhomogeneous_equation_with_constant_coefficients - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 211 # indirect doctest iRÇtmultipleRiiR±tsolbothRäs Unknown value for key "returns".N(&RýR”RRBR$R9R¼R¤R?RERÒRÌR RHRARÁt all_coeffsRSR±R£RR%RÕRÖRùR.R1R/RR5R6R2RÚR-RRR!R©(R“R”R°RÝR•RÇR¦RúR–R—R¡R˜Rtchareq_is_complexRâR™RšRnRtconjugate_rootsRœRÜRÝRv((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt)ode_nth_linear_constant_coeff_homogeneousgslN  1)"         3-  2 $cC s;t||||ddƒ}|j|ƒt||||ƒS(sž Solves an `n`\th order linear differential equation with constant coefficients using the method of undetermined coefficients. This method works on differential equations of the form .. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x) + a_0 f(x) = P(x)\text{,} where `P(x)` is a function that has a finite number of linearly independent derivatives. Functions that fit this requirement are finite sums functions of the form `a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i` is a non-negative integer and `a`, `b`, `c`, and `d` are constants. For example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`, and `e^x \cos(x)` can all be used. Products of `\sin`'s and `\cos`'s have a finite number of derivatives, because they can be expanded into `\sin(a x)` and `\cos(b x)` terms. However, SymPy currently cannot do that expansion, so you will need to manually rewrite the expression in terms of the above to use this method. So, for example, you will need to manually convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method of undetermined coefficients on it. This method works by creating a trial function from the expression and all of its linear independent derivatives and substituting them into the original ODE. The coefficients for each term will be a system of linear equations, which are be solved for and substituted, giving the solution. If any of the trial functions are linearly dependent on the solution to the homogeneous equation, they are multiplied by sufficient `x` to make them linearly independent. Examples ======== >>> from sympy import Function, dsolve, pprint, exp, cos >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(f(x).diff(x, 2) + 2*f(x).diff(x) + f(x) - ... 4*exp(-x)*x**2 + cos(2*x), f(x), ... hint='nth_linear_constant_coeff_undetermined_coefficients')) / 4\ | x | -x 4*sin(2*x) 3*cos(2*x) f(x) = |C1 + C2*x + --|*e - ---------- + ---------- \ 3 / 25 25 References ========== - https://en.wikipedia.org/wiki/Method_of_undetermined_coefficients - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 221 # indirect doctest R•R¤(R»RÛt _solve_undetermined_coefficients(R“R”R°RÝR¦((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR¢s9  cC sH|jd}|j}|}tddtƒ}g}|d} |d} |d} tgƒ} tgƒ} t| ƒ|kr«tdt|ƒdd t|ƒd ƒ‚ntgƒ}d}t}x@t D]8\}}}|rò|d }t }n|dkrt}n|rŠ||f|krH||t ||ƒt ||ƒ}q¢||t ||ƒt t|ƒ|ƒ}|j||fƒn||t ||ƒ}|| krÊx,trÜ|||| krØ|d 7}q±Pq±W| j|||ƒ| j|ƒqÊqÊW| | } d}x5| D]-}t|ƒ}|j|ƒ|||7}qWt|||ƒ|ƒ}ttt| dgt| ƒd ƒƒƒ}t|ƒ}xJtj|ƒD]9}t|d td |gƒ}|||c|d7RRnR6t notneedsett newtrialsettusedsintmulttgetmultR¡RÜRÝRXt trialfuncRRut coeffsdictRòt coeffvalstpsol((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR¼Dsn             ),       ,  c s¦tdd|gƒ‰tdd|gƒ‰t|ddƒ}i}‡‡‡fd†‰tgƒ‡fd†‰ˆ||ƒ|d<|dr¢ˆ||ƒ|d >> from sympy import log, exp >>> from sympy.solvers.ode import _undetermined_coefficients_match >>> from sympy.abc import x >>> _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x) {'test': True, 'trialset': {x*exp(x), exp(-x), exp(x)}} >>> _undetermined_coefficients_match(log(x), x) {'test': False} RR§RRÍR.c s–|jˆƒstS|jr<t‡‡fd†|jDƒƒS|jr¹|jttƒr™t}x9|jD]+}|jttƒrg|r‰tSt}qgqgWnt‡‡fd†|jDƒƒS|j r |j ttt fkr|jdj ˆˆˆƒrütStSq’tSnˆ|j r>|jjr>|j jr>|j dkr>tS|j rx|jjrx|j j ˆˆˆƒrqtStSn|jsŠ|jrŽtStSdS(sV Test if ``expr`` fits the proper form for undetermined coefficients. c3 s|]}ˆ|ˆƒVqdS(N((R¥R¡(R:RÇ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys Ýsc3 s|]}ˆ|ˆƒVqdS(N((R¥R¡(R:RÇ(s0lib/python2.7/site-packages/sympy/solvers/ode.pys ésiN(RRÒR=RÁRýR7R2R-R’RR”R.RÝR8tbaseR8t is_IntegerRï(RŽRÇt foundtrigR¡(R:RR(RÇs0lib/python2.7/site-packages/sympy/solvers/ode.pyR:Ös:     !c s&d„}t|ƒ}|jr~x|jD]O}|||ƒ|krFq(|j|||ƒƒ|jˆ|||ƒƒ}q(Wn¤|||ƒ}|j|hƒ}tgƒ}xn||kr|jƒ}|j|ƒ}|||ƒ}|jr |jˆ|||ƒƒ}q®|j|ƒq®W|}|S(sq Returns a set of trial terms for undetermined coefficients. The idea behind undetermined coefficients is that the terms expression repeat themselves after a finite number of derivatives, except for the coefficients (they are linearly dependent). So if we collect these, we should have the terms of our trial function. cS satj}|jrExH|jD]"}|j|ƒr||9}qqWn|j|ƒr]|}n|S(s­ Returns the expression without a coefficient. Similar to expr.as_independent(x)[1], except it only works multiplicatively. (RRR7RýR(RŽRÇRBR¡((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt_remove_coefficients   (RR=RýRR«RªR?R(RŽRÇtexprsRÊRBttmpsettoldset(t_get_trial_set(s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÎÿs(   "   R5R6(R#RNRª(RŽRÇRè((RÎR:RRs0lib/python2.7/site-packages/sympy/solvers/ode.pyRH­s$)2 cC s;t||||ddƒ}|j|ƒt||||ƒS(s Solves an `n`\th order linear differential equation with constant coefficients using the method of variation of parameters. This method works on any differential equations of the form .. math:: f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x) + a_0 f(x) = P(x)\text{.} This method works by assuming that the particular solution takes the form .. math:: \sum_{x=1}^{n} c_i(x) y_i(x)\text{,} where `y_i` is the `i`\th solution to the homogeneous equation. The solution is then solved using Wronskian's and Cramer's Rule. The particular solution is given by .. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \,dx \right) y_i(x) \text{,} where `W(x)` is the Wronskian of the fundamental system (the system of `n` linearly independent solutions to the homogeneous equation), and `W_i(x)` is the Wronskian of the fundamental system with the `i`\th column replaced with `[0, 0, \cdots, 0, P(x)]`. This method is general enough to solve any `n`\th order inhomogeneous linear differential equation with constant coefficients, but sometimes SymPy cannot simplify the Wronskian well enough to integrate it. If this method hangs, try using the ``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and simplifying the integrals manually. Also, prefer using ``nth_linear_constant_coeff_undetermined_coefficients`` when it applies, because it doesn't use integration, making it faster and more reliable. Warning, using simplify=False with 'nth_linear_constant_coeff_variation_of_parameters' in :py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will not attempt to simplify the Wronskian before integrating. It is recommended that you only use simplify=False with 'nth_linear_constant_coeff_variation_of_parameters_Integral' for this method, especially if the solution to the homogeneous equation has trigonometric functions in it. Examples ======== >>> from sympy import Function, dsolve, pprint, exp, log >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(f(x).diff(x, 3) - 3*f(x).diff(x, 2) + ... 3*f(x).diff(x) - f(x) - exp(x)*log(x), f(x), ... hint='nth_linear_constant_coeff_variation_of_parameters')) / 3 \ | 2 x *(6*log(x) - 11)| x f(x) = |C1 + C2*x + C3*x + ------------------|*e \ 36 / References ========== - https://en.wikipedia.org/wiki/Variation_of_parameters - http://planetmath.org/VariationOfParameters - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 233 # indirect doctest R•R¤(R»RÛR¥(R“R”R°RÝR¦((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt5ode_nth_linear_constant_coeff_variation_of_parameters>sG  c C s½|jd}|j}|}d}|d}|d} t||ƒ} |jdtƒr~t| ƒ} t| dtdtƒ} n| s³tdt|ƒdd t|ƒd ƒ‚nt |ƒ|krôtdt|ƒdd t|ƒd ƒ‚nd |} xo|D]g} || t tg|D]} | | kr| ^q|ƒ|d | |ƒ| ||7}| d 9} qW|jdtƒr£t|ƒ}t|dtƒ}nt ||ƒ| j |ƒS( s‰ Helper function for the method of variation of parameters and nonhomogeneous euler eq. See the :py:meth:`~sympy.solvers.ode.ode_nth_linear_constant_coeff_variation_of_parameters` docstring for more information on this method. The parameter ``match`` should be a dictionary that has the following keys: ``list`` A list of solutions to the homogeneous equation, such as the list returned by ``ode_nth_linear_constant_coeff_homogeneous(returns='list')``. ``sol`` The general solution, such as the solution returned by ``ode_nth_linear_constant_coeff_homogeneous(returns='sol')``. iR±RäRPRŒt recursives Cannot find s: solutions to the homogeneous equation necessary to apply svariation of parameters to s (Wronskian == 0)s (number of terms != order)iÿÿÿÿ( RýR”R;RÚRÒRPRQRÑR¤RÌR9R!R(R“R”R°RÝRÇR¦RúRÆRRntwrt negonetermR¡Rä((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR¥‹s0     ,,  W c C s¿|jd}|j}t|ddƒ}|}|jd||ƒƒ}tt|dd|d|d|d|d|dd |fƒt|dd |d||d||ƒ|ƒS( sa Solves separable 1st order differential equations. This is any differential equation that can be written as `P(y) \tfrac{dy}{dx} = Q(x)`. The solution can then just be found by rearranging terms and integrating: `\int P(y) \,dy = \int Q(x) \,dx`. This hint uses :py:meth:`sympy.simplify.simplify.separatevars` as its back end, so if a separable equation is not caught by this solver, it is most likely the fault of that function. :py:meth:`~sympy.simplify.simplify.separatevars` is smart enough to do most expansion and factoring necessary to convert a separable equation `F(x, y)` into the proper form `P(x)\cdot{}Q(y)`. The general solution is:: >>> from sympy import Function, dsolve, Eq, pprint >>> from sympy.abc import x >>> a, b, c, d, f = map(Function, ['a', 'b', 'c', 'd', 'f']) >>> genform = Eq(a(x)*b(f(x))*f(x).diff(x), c(x)*d(f(x))) >>> pprint(genform) d a(x)*b(f(x))*--(f(x)) = c(x)*d(f(x)) dx >>> pprint(dsolve(genform, f(x), hint='separable_Integral')) f(x) / / | | | b(y) | c(x) | ---- dy = C1 + | ---- dx | d(y) | a(x) | | / / Examples ======== >>> from sympy import Function, dsolve, Eq >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(Eq(f(x)*f(x).diff(x) + x, 3*x*f(x)**2), f(x), ... hint='separable', simplify=False)) / 2 \ 2 log\3*f (x) - 1/ x ---------------- = C1 + -- 6 2 References ========== - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations", Dover 1963, pp. 52 # indirect doctest iRiR¹R%RÍRR$N(RýR”R£RÚR!R9RÐ( R“R”R°RÝRÇR¦RRúR!((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR®Ås7  1.cC sít|tƒr"|j|j}n|s=t|ƒ\}}n|j}t|ƒdkrgtdƒ‚n‚|d}|s‰t||ƒ}n|dkr¤t dƒ‚nE|j |ƒ}t dd|gƒ}t dd|gƒ}t t |ƒ|ƒj|||ƒ} | r%t| || |ƒ } n=yt||ƒ} Wnt k rWt dƒ‚n X| d} td ƒ} | j|| ƒ} td ƒ|| ƒ} td ƒ|| ƒ}td ƒ||ƒ}td ƒ||ƒ}|j |ƒ|j | ƒ| j |ƒ| | j | ƒ| d | | j |ƒ|| j | ƒ}g}x¤|D]œ} it| |ƒj|| ƒ| 6t| |ƒj|| ƒ|6}t|j|ƒjƒƒ} | rÎ|jt| j| |ƒfƒqE|jtdfƒqEW|Sd S(s= This function is used to check if the given infinitesimals are the actual infinitesimals of the given first order differential equation. This method is specific to the Lie Group Solver of ODEs. As of now, it simply checks, by substituting the infinitesimals in the partial differential equation. .. math:: \frac{\partial \eta}{\partial x} + \left(\frac{\partial \eta}{\partial y} - \frac{\partial \xi}{\partial x}\right)*h - \frac{\partial \xi}{\partial y}*h^{2} - \xi\frac{\partial h}{\partial x} - \eta\frac{\partial h}{\partial y} = 0 where `\eta`, and `\xi` are the infinitesimals and `h(x,y) = \frac{dy}{dx}` The infinitesimals should be given in the form of a list of dicts ``[{xi(x, y): inf, eta(x, y): inf}]``, corresponding to the output of the function infinitesimals. It returns a list of values of the form ``[(True/False, sol)]`` where ``sol`` is the value obtained after substituting the infinitesimals in the PDE. If it is ``True``, then ``sol`` would be 0. is(ODE's have only one independent variableisRLie groups solver has been implemented only for first order differential equationsRR§Rs9Infinitesimals for the first order ODE could not be foundRRºR»iN(R¨R RRR[RýRÌR©R\RÑRR#RLRRÝRPRVR$RÕRRR‘RùR’RÒ(R“tinfinitesimalsR”R°RRÇRKRRRÝR2RäRRºR»tdxitdetatpdetsoltupttsol((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt checkinfsolsN   &   d   "c' C sYt}i}|j}|jd}|j|ƒ}tdƒ} tdƒ} tdd|gƒ} tdd|gƒ} |jdƒ} |jdƒ}|rÅt||d||dƒ }|d }nxy(t||ƒ}|gkrìt ‚nWn+t k rt d t |ƒd ƒ‚n#Xt d ƒ}|dj ||ƒ}| dk rÚ|dk rÚit| ƒ| |||ƒƒ6t|ƒ| |||ƒƒ6g}t||d ||ƒd dƒddsÎtdƒ‚qÚdg}ni|d6|d 6}g}xÎ|D]Æ}y1|s1t|d|d |d dd|ƒ}nWntk rHqûqûXxu|D]m}|| ||ƒj ||ƒ}|| ||ƒj ||ƒ}t||ƒ|kr°qPn|||ƒj|ƒ||||ƒj|ƒ|}t|d |||ƒƒj}t|dd |||ƒƒj}g||gD]}t|ƒ^q3}t dƒ}t dƒ}tdƒ}|d}|d}y*t||||g||dtƒ}Wnt k rÃqPqPX|d}||}||} t|j|ƒ|j|ƒ|ƒ}!t|j|ƒ|j|ƒ|ƒ}"|!ri|"rit|!|"j ||f|| fgƒƒ}#t|#d||gdtƒ}$|$r½td|$||ƒ|t|$d|$||ƒ}%|%j ||f||fgƒ}%yt|%|ƒ}&Wnt k r|j|%ƒqfXt|&ƒdkr=t||ƒ|&jƒƒSg|&D]}t||ƒ|ƒ^qDSq½qP|"r“t||ƒt|||ƒdƒS|!rPt||ƒt|||ƒdƒSqPWqûW|r7t|ƒdkrt|jƒj |||ƒƒdƒSg|D]'}t|j |||ƒƒdƒ^q Snt dt |ƒddƒ‚dS(sÝ This hint implements the Lie group method of solving first order differential equations. The aim is to convert the given differential equation from the given coordinate given system into another coordinate system where it becomes invariant under the one-parameter Lie group of translations. The converted ODE is quadrature and can be solved easily. It makes use of the :py:meth:`sympy.solvers.ode.infinitesimals` function which returns the infinitesimals of the transformation. The coordinates `r` and `s` can be found by solving the following Partial Differential Equations. .. math :: \xi\frac{\partial r}{\partial x} + \eta\frac{\partial r}{\partial y} = 0 .. math :: \xi\frac{\partial s}{\partial x} + \eta\frac{\partial s}{\partial y} = 1 The differential equation becomes separable in the new coordinate system .. math :: \frac{ds}{dr} = \frac{\frac{\partial s}{\partial x} + h(x, y)\frac{\partial s}{\partial y}}{ \frac{\partial r}{\partial x} + h(x, y)\frac{\partial r}{\partial y}} After finding the solution by integration, it is then converted back to the original coordinate system by substituting `r` and `s` in terms of `x` and `y` again. Examples ======== >>> from sympy import Function, dsolve, Eq, exp, pprint >>> from sympy.abc import x >>> f = Function('f') >>> pprint(dsolve(f(x).diff(x) + 2*x*f(x) - x*exp(-x**2), f(x), ... hint='lie_group')) / 2\ 2 | x | -x f(x) = |C1 + --|*e \ 2 / References ========== - Solving differential equations by Symmetry Groups, John Starrett, pp. 1 - pp. 14 iRºR»RR§RR—RRs*Unable to solve the differential equation s by the lie group methodR”R°isTThe given infinitesimals xi and eta are not the infinitesimals to the given equationt user_definedR2R¹RÝRúRòRiÿÿÿÿRÂR%RÍsThe given ODE s cannot be solved bys the lie group methodN(tlie_heuristicsR”RýRRR#RÖRPRVRÑR¤R$RÕRÐRRÙR©RÓRWRt_lie_group_removeR"RÒROR:RùRÌR!('R“R”R°RÝt heuristicstinfR¦RÇRKRºR»RRtxistetasR2RRättempsolt heuristictinfsimtxiinftetainftrpdeRúRòtcoordtnewcoordRtrcoordtscoordtxsubtysubRRÏtdiffeqtsepRmtsdeq((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt ode_lie_groupRs¤2    !     A)  +  6"%     *    && +4! ,$,%5cC sùt|tƒr|jdS|jrb|jtƒ}|r^x#|D]}|j|dƒ}q?Wn|S|jr|jƒ\}}t|ƒ}t|ƒ}||S|j rõg}|j}x3|D]+}t|tƒs¼|j t|ƒƒq¼q¼Wt |ŒS|S(sø This function is strictly meant for internal use by the Lie group ODE solving method. It replaces arbitrary functions returned by pdsolve with either 0 or 1 or the args of the arbitrary function. The algorithm used is: 1] If coords is an instance of an Undefined Function, then the args are returned 2] If the arbitrary function is present in an Add object, it is replaced by zero. 3] If the arbitrary function is present in an Mul object, it is replaced by one. 4] If coords has no Undefined Function, it is returned as it is. Examples ======== >>> from sympy.solvers.ode import _lie_group_remove >>> from sympy import Function >>> from sympy.abc import x, y >>> F = Function("F") >>> eq = x**2*y >>> _lie_group_remove(eq) x**2*y >>> eq = F(x**2*y) >>> _lie_group_remove(eq) x**2*y >>> eq = y**2*x + F(x**3) >>> _lie_group_remove(eq) x*y**2 >>> eq = (F(x**3) + y)*x**4 >>> _lie_group_remove(eq) x**4*y i( R¨RRýR=RRÕR8R9RÜR7RùR(tcoordstsubfuncR”RÇRŽtmulargst coordargsRT((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÜös*!          cC sqt|tƒr"|j|j}n|s=t|ƒ\}}n|j}t|ƒdkrgtdƒ‚n|d}|s‰t||ƒ}n|dkr¤t dƒ‚nÉ|j |ƒ}t dd|gƒ}t dd|gƒ} |rú|d} |d } n£t t |ƒ|ƒj||| ƒ}|rBt|| ||ƒ } n=yt||ƒ} Wnt k rtt d ƒ‚n X| d} td ƒ} | j|| ƒ} td ƒ} | j |ƒ}| j | ƒ}d| j|| f| |fgƒj| | ƒ}i| d6|d 6|d 6|d6| d 6|d6}|dkr¼g}xftD]^}tƒd|}||dtƒ}|rA|jg|D]}||kr}|^q}ƒqAqAW|r­|St dƒ‚n±|dkrx;tD]3}tƒd|}||dtƒ}|rÏ|SqÏWt dƒ‚nX|tkr4td|ƒ‚n9tƒd|}||dtƒ}|ra|Stdƒ‚dS(s© The infinitesimal functions of an ordinary differential equation, `\xi(x,y)` and `\eta(x,y)`, are the infinitesimals of the Lie group of point transformations for which the differential equation is invariant. So, the ODE `y'=f(x,y)` would admit a Lie group `x^*=X(x,y;\varepsilon)=x+\varepsilon\xi(x,y)`, `y^*=Y(x,y;\varepsilon)=y+\varepsilon\eta(x,y)` such that `(y^*)'=f(x^*, y^*)`. A change of coordinates, to `r(x,y)` and `s(x,y)`, can be performed so this Lie group becomes the translation group, `r^*=r` and `s^*=s+\varepsilon`. They are tangents to the coordinate curves of the new system. Consider the transformation `(x, y) \to (X, Y)` such that the differential equation remains invariant. `\xi` and `\eta` are the tangents to the transformed coordinates `X` and `Y`, at `\varepsilon=0`. .. math:: \left(\frac{\partial X(x,y;\varepsilon)}{\partial\varepsilon }\right)|_{\varepsilon=0} = \xi, \left(\frac{\partial Y(x,y;\varepsilon)}{\partial\varepsilon }\right)|_{\varepsilon=0} = \eta, The infinitesimals can be found by solving the following PDE: >>> from sympy import Function, diff, Eq, pprint >>> from sympy.abc import x, y >>> xi, eta, h = map(Function, ['xi', 'eta', 'h']) >>> h = h(x, y) # dy/dx = h >>> eta = eta(x, y) >>> xi = xi(x, y) >>> genform = Eq(eta.diff(x) + (eta.diff(y) - xi.diff(x))*h ... - (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)), 0) >>> pprint(genform) /d d \ d 2 d |--(eta(x, y)) - --(xi(x, y))|*h(x, y) - eta(x, y)*--(h(x, y)) - h (x, y)*--(x \dy dx / dy dy d d i(x, y)) - xi(x, y)*--(h(x, y)) + --(eta(x, y)) = 0 dx dx Solving the above mentioned PDE is not trivial, and can be solved only by making intelligent assumptions for `\xi` and `\eta` (heuristics). Once an infinitesimal is found, the attempt to find more heuristics stops. This is done to optimise the speed of solving the differential equation. If a list of all the infinitesimals is needed, ``hint`` should be flagged as ``all``, which gives the complete list of infinitesimals. If the infinitesimals for a particular heuristic needs to be found, it can be passed as a flag to ``hint``. Examples ======== >>> from sympy import Function, diff >>> from sympy.solvers.ode import infinitesimals >>> from sympy.abc import x >>> f = Function('f') >>> eq = f(x).diff(x) - x**2*f(x) >>> infinitesimals(eq) [{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0}] References ========== - Solving differential equations by Symmetry Groups, John Starrett, pp. 1 - pp. 14 is(ODE's have only one independent variableis?Infinitesimals for only first order ODE's have been implementedRR§RR2Rs9Infinitesimals for the first order ODE could not be foundR!R”thxthythinvRÁtlie_heuristic_tcomps3Infinitesimals could not be found for the given ODER¯sHeuristic not recognized: s;Infinitesimals could not be found using the given heuristicN(R¨R RRR[RýRÌR©R\RÑRR#RLRRÝRPRVR$RÕRÛRÓRÒtextendR’(R“R”R°R¹RÝRRÇRKRRR2RRäR!RõRöR÷txietaRâtfunctiontinflistRÞ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÓ-srB     &    10  3   cC sñg}|d}|d}|d}|jd}|d}|d}tdƒ||ƒ} tdƒ||ƒ} |j} || krýytt||ƒƒ} Wntk r°qýXitdƒ| 6| | 6} |sØ| gS|rý| |krý|j| ƒqýn||}|j}||kr¡ytt||ƒƒ}Wntk rHq¡Xitdƒ| 6|j||ƒ| 6} |s|| gS|r¡| |kr¡|j| ƒq¡n| |}|j}||kr:ytt||ƒƒ} Wntk ríq:Xi| | 6tdƒ| 6} |s| gS|r:| |kr:|j| ƒq:n| |d }|j}||krãytt||ƒƒ}Wntk rŠqãXi|j||ƒ| 6tdƒ| 6} |s¾| gS|rã| |krã|j| ƒqãn|rí|Sd S( sD The first heuristic uses the following four sets of assumptions on `\xi` and `\eta` .. math:: \xi = 0, \eta = f(x) .. math:: \xi = 0, \eta = f(y) .. math:: \xi = f(x), \eta = 0 .. math:: \xi = f(y), \eta = 0 The success of this heuristic is determined by algebraic factorisation. For the first assumption `\xi = 0` and `\eta` to be a function of `x`, the PDE .. math:: \frac{\partial \eta}{\partial x} + (\frac{\partial \eta}{\partial y} - \frac{\partial \xi}{\partial x})*h - \frac{\partial \xi}{\partial y}*h^{2} - \xi*\frac{\partial h}{\partial x} - \eta*\frac{\partial h}{\partial y} = 0 reduces to `f'(x) - f\frac{\partial h}{\partial y} = 0` If `\frac{\partial h}{\partial y}` is a function of `x`, then this can usually be integrated easily. A similar idea is applied to the other 3 assumptions as well. References ========== - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra Solving of First Order ODEs Using Symmetry Methods, pp. 8 RR2R”iRõRöRºR»iN( RýRR¬R.R:RÑRRùRÕ(RÝRùRûRR2R”RÇRõRöRºR»thysymtfxRÞR;tfacsymtfy((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_abaco1_simple½st#             &       &cC s¶g}|d}|d}|d}|d}|jd}tdƒ||ƒ}tdƒ||ƒ} tt|ƒj|ƒj|ƒ|dd td ||gƒ} | rg| d rg| |} t| d | |j|ƒƒ} | j} || krgtt | |ƒƒ} it dƒ| 6| | j ||ƒ|6} |s?| gS|rd| |krd|j | ƒqdqgnt d ƒ}tt|ƒj|ƒj|ƒ|dd td ||gƒ} | r¨| d r¨| |} t| d | |j|ƒƒ} | j} || kr¨tt | |ƒƒ} | | }|j ||f||fgƒj ||ƒ}i|j ||ƒ| 6t dƒ|6} |s€| gS|r¥| |kr¥|j | ƒq¥q¨n|r²|SdS(sû The second heuristic uses the following two assumptions on `\xi` and `\eta` .. math:: \eta = 0, \xi = f(x)*g(y) .. math:: \eta = f(x)*g(y), \xi = 0 The first assumption of this heuristic holds good if `\frac{1}{h^{2}}\frac{\partial^2}{\partial x \partial y}\log(h)` is separable in `x` and `y`, then the separated factors containing `x` is `f(x)`, and `g(y)` is obtained by .. math:: e^{\int f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)\,dy} provided `f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)` is a function of `y` only. The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption satisfies. After obtaining `f(x)` and `g(y)`, the coordinates are again interchanged, to get `\eta` as `f(x)*g(y)` References ========== - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order ODE Patterns, pp. 7 - pp. 8 RR2R÷R”iRºR»iRÂR%RÍiR&N(RýRROR0RRÒRPR¬R.R:RRÕRùR$(RÝRùRûRR2R÷R”RÇRºR»RÞRÿtgytgysymsR&tetaval((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_abaco1_product$sJ     > !  * > !   -&c" C sÕ|d}|d}|d}|d}|jd}|d}tdƒ||ƒ}tdƒ||ƒ} |jƒrÑtd ƒ\} } } } }}| | | |||d ||| |}t|ƒjƒ\}}t|||ƒjƒ}td ƒ||ƒ}td ƒ||ƒ}|j|ƒ|j|ƒ|j|ƒ||j|ƒ|d ||||}t d ƒ}t dƒ}xIt |dƒD]4}|rk|t gt |dƒD]B}t dt |ƒdt ||ƒƒ|||||^q¹Œ7}|t gt |dƒD]B}t dt |ƒdt ||ƒƒ|||||^qŒ7}n|j i||6||6ƒjƒjƒ\}}t|ƒ}|j||ƒrÜ|jrÜt|||ƒjƒ}n|r–|jj|jƒ||h}t|jƒ|Œ}t|tƒr2|d}ntd„|jƒDƒƒrÊ|j |ƒ}|j |ƒ}td„|Dƒƒ} i|j | ƒj ||ƒ| 6|j | ƒj ||ƒ|6}!|!gSq–q–WndS(sÔ The third heuristic assumes the infinitesimals `\xi` and `\eta` to be bi-variate polynomials in `x` and `y`. The assumption made here for the logic below is that `h` is a rational function in `x` and `y` though that may not be necessary for the infinitesimals to be bivariate polynomials. The coefficients of the infinitesimals are found out by substituting them in the PDE and grouping similar terms that are polynomials and since they form a linear system, solve and check for non trivial solutions. The degree of the assumed bivariates are increased till a certain maximum value. References ========== - Lie Groups and Differential Equations pp. 327 - pp. 329 R2RõRöR”iRRºR»setax etay etad xix xiy xidiRÕRÔtxi0teta0itxi_Riteta_cs s|] }|VqdS(N((R¥RÇ((s0lib/python2.7/site-packages/sympy/solvers/ode.pys «scs s|]}|dfVqdS(iN((R¥R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pys °sN(RýRtis_rational_functionR%RGRšR?t total_degreeRR"R RR¤RÕR‘RRCR=R_R¬R«RVRÏR¨R±RGRÂ("RÝRùR2RõRöR”RÇRRºR»tetaxtetaytetadtxixtxiytxidtipdeRRÏtdegRÕRÔtxieqtetaeqR¡R/tpdentpolyyR+tsoldicttxiredtetaredRcRÞ((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_bivariatemsT       .R  Z]/  c C s|d}|d}|d}|d}|jd}|d}tdƒ||ƒ}tdƒ||ƒ} |jƒrÿtd ƒ\} } } | || || } t| ƒjƒ\}}t|||ƒjƒ}td ƒ||ƒ}|j|ƒ}|j|ƒ}|||||} t d ƒ}x×t d |d ƒD]¿}|t gt |d ƒD]B}t d t |ƒd t ||ƒƒ|||||^qVŒ7}t| j i||6ƒjƒƒjƒ\}}t|ƒ}|j||ƒr9|jr9t|||ƒjƒ}|rø|j||h}t|jƒ|Œ}t|tƒrY|d}ntd„|jƒDƒƒrõ|j |ƒ}td„|Dƒƒ}|j |ƒ}t||ƒ\}}i|j ||ƒ| 6|j ||ƒ |6}|gSqøq9q9WndS(s» The aim of the fourth heuristic is to find the function `\chi(x, y)` that satisfies the PDE `\frac{d\chi}{dx} + h\frac{d\chi}{dx} - \frac{\partial h}{\partial y}\chi = 0`. This assumes `\chi` to be a bivariate polynomial in `x` and `y`. By intuition, `h` should be a rational function in `x` and `y`. The method used here is to substitute a general binomial for `\chi` up to a certain maximum degree is reached. The coefficients of the polynomials, are calculated by by collecting terms of the same order in `x` and `y`. After finding `\chi`, the next step is to use `\eta = \xi*h + \chi`, to determine `\xi` and `\eta`. This can be done by dividing `\chi` by `h` which would give `-\xi` as the quotient and `\eta` as the remainder. References ========== - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra Solving of First Order ODEs Using Symmetry Methods, pp. 8 R2RõRöR”iRRºR»sschi, schix, schiyR‹itchi_Rics s|] }|VqdS(N((R¥RÇ((s0lib/python2.7/site-packages/sympy/solvers/ode.pys îscs s|]}|dfVqdS(iN((R¥R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pys ðsN(RýRR R%RGRšR?R RR"R RR¤RÕR‘RRCR=R_R¬RVRÏR¨R±RGRÂRI( RÝRùR2RõRöR”RÇRRºR»tschitschixtschiytcpdeRRÏRR‹tchixtchiytchieqR¡R/tcnumtcdentcpolytsolsymsRRctxictetacRÞ((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_chiµsL        Z.  -cC s g}|d}|d}|d}|d}|d}|jd}|d} tdƒ||ƒ} td ƒ||ƒ} xŒ||gD]~} | d | j|d ƒ} td | j| ƒd td || gƒ}|rú|drú||j|ƒrú|| j| ƒrútdƒ}y|t|| | ƒ}Wntk rAqúXd ||||d}t || |ƒ}t |j|d ƒ|ƒ}|rú|s·|j |d ƒ}||}nEt ||ƒ}|r†|d}|j ||ƒ}|||}nq†| |kr/|j || ƒ}|j | |ƒ}nt ||ƒ}|j rtg|jD]}|j|| ƒrU|^qUŒ}n| |kr´i|j | |ƒ| 6tdƒ| 6}n&i|j | |ƒ| 6tdƒ| 6}|sç|gS|j|ƒqún|r†|Sq†WdS(s/ This heuristic uses the following two assumptions on `\xi` and `\eta` .. math:: \eta = 0, \xi = f(x) + g(y) .. math:: \eta = f(x) + g(y), \xi = 0 The first assumption of this heuristic holds good if .. math:: \frac{\partial}{\partial y}[(h\frac{\partial^{2}}{ \partial x^{2}}(h^{-1}))^{-1}] is separable in `x` and `y`, 1. The separated factors containing `y` is `\frac{\partial g}{\partial y}`. From this `g(y)` can be determined. 2. The separated factors containing `x` is `f''(x)`. 3. `h\frac{\partial^{2}}{\partial x^{2}}(h^{-1})` equals `\frac{f''(x)}{f(x) + g(y)}`. From this `f(x)` can be determined. The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption satisfies. After obtaining `f(x)` and `g(y)`, the coordinates are again interchanged, to get `\eta` as `f(x) + g(y)`. For both assumptions, the constant factors are separated among `g(y)` and `f''(x)`, such that `f''(x)` obtained from 3] is the same as that obtained from 2]. If not possible, then this heuristic fails. References ========== - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order ODE Patterns, pp. 7 - pp. 8 R2RõRöR”R÷iRRºR»iiRÂR%RÍRN(RýRRRORÒRR$R:RÑRPRÕRVRR7RRRù(RÝRùRûR2RõRöR”R÷RÇRRºR»todefacR;RîRRtfddRÿRXRäRRTRÞ((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_function_sumýs\&       +6      7 )&cC sog}|d}|d}|d}|d}|d}|jd}|d} tdƒ||ƒ} td ƒ||ƒ} t|j| ƒ|j| d ƒƒ} | j|ƒ} | j| ƒ}| j|ƒ r§| j| ƒ r§td d | gƒ}td d | gƒ}tdd || gƒ}|j||t| |ƒƒ}y.tt||||ƒ |ƒ||}Wnt k r€qQX|||}i|| 6|| 6gSnªt| |ƒ}|j| ƒsQt|||j|ƒ|||ƒ}|j| ƒsQytt||ƒƒ}Wnt k r*qNX| |}i|| 6|| 6gSqQnt|j| ƒ|j| d ƒƒ} | j|ƒ} | j| ƒ}| j|ƒ r—| j| ƒ r—td d | gƒ}td d | gƒ}tdd || gƒ}|j||t| |ƒƒ}y.tt||||ƒ |ƒ||}Wnt k rXqkX|||}i|j ||ƒ| 6|j ||ƒ| 6gSnÔt| |ƒ}|j| ƒskt||j| ƒ|j|ƒ|j|ƒ||ƒ}|j| ƒskytt||ƒƒ}Wnt k r,qhX| |}i|j ||ƒ| 6|j ||ƒ| 6gSqkndS(sW This heuristic uses the following two assumptions on `\xi` and `\eta` .. math:: \eta = g(x), \xi = f(x) .. math:: \eta = f(y), \xi = g(y) For the first assumption, 1. First `\frac{\frac{\partial h}{\partial y}}{\frac{\partial^{2} h}{ \partial yy}}` is calculated. Let us say this value is A 2. If this is constant, then `h` is matched to the form `A(x) + B(x)e^{ \frac{y}{C}}` then, `\frac{e^{\int \frac{A(x)}{C} \,dx}}{B(x)}` gives `f(x)` and `A(x)*f(x)` gives `g(x)` 3. Otherwise `\frac{\frac{\partial A}{\partial X}}{\frac{\partial A}{ \partial Y}} = \gamma` is calculated. If a] `\gamma` is a function of `x` alone b] `\frac{\gamma\frac{\partial h}{\partial y} - \gamma'(x) - \frac{ \partial h}{\partial x}}{h + \gamma} = G` is a function of `x` alone. then, `e^{\int G \,dx}` gives `f(x)` and `-\gamma*f(x)` gives `g(x)` The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption satisfies. After obtaining `f(x)` and `g(x)`, the coordinates are again interchanged, to get `\xi` as `f(x^*)` and `\eta` as `g(y^*)` References ========== - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order ODE Patterns, pp. 10 - pp. 12 R2RõRöR”R÷iRRºR»itAR§tBR™N( RýRRGRRR#RÝR.R:RÑRÕ(RÝRùRûR2RõRöR”R÷RÇRRºR»R;tfactorxtfactoryR/R0R™ttautgxtgammattauint((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_abaco2_similarYsv&       % !. )  % !. 0-  cC srg}|d}|d}|d}|d}|d}|jd}|d} tdƒ||ƒ} td ƒ||ƒ} g} xc|jtƒD]R} | jƒ\}}|j|ƒr|j| ƒr|jsá| j| ƒqáqqWxH|jtƒD]7}|j }||krõ| |krõ| j|ƒqõqõWx;| D]3}t |j | ƒ|j |ƒƒ}t |d t d || gƒ}|rŒ|d rŒ||}d || |d }|j | ƒ||j |ƒ|||||}t|ƒsi|| 6|j| |ƒ| 6gSd|}d|}|j |ƒ|j | ƒ|d||||}tt|ƒƒsji|j| |ƒ| 6|| 6gSq7d |}|j |ƒ|j | ƒ||||}t|ƒsõitdƒ| 6|j| |ƒ| 6gS| }|j |ƒ ||j | ƒ|d|||}tt|ƒƒs7i|j| |ƒ| 6tdƒ| 6gSq7WdS(s¡ This heuristic assumes the presence of unknown functions or known functions with non-integer powers. 1. A list of all functions and non-integer powers containing x and y 2. Loop over each element `f` in the list, find `\frac{\frac{\partial f}{\partial x}}{ \frac{\partial f}{\partial x}} = R` If it is separable in `x` and `y`, let `X` be the factors containing `x`. Then a] Check if `\xi = X` and `\eta = -\frac{X}{R}` satisfy the PDE. If yes, then return `\xi` and `\eta` b] Check if `\xi = \frac{-R}{X}` and `\eta = -\frac{1}{X}` satisfy the PDE. If yes, then return `\xi` and `\eta` If not, then check if a] :math:`\xi = -R,\eta = 1` b] :math:`\xi = 1, \eta = -\frac{1}{R}` are solutions. References ========== - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order ODE Patterns, pp. 10 - pp. 12 R2RõRöR”R÷iRRºR»RÂR%RÍiÿÿÿÿiiN(RýRRRR9RRÈRùRR¬RGRRORÒRPRÕRR(RÝRùRûR2RõRöR”R÷RÇRRºR»tfunclisttatomRÇR.RütsymsR¦tfracRîtxitry1tetatry1tpde1txitry2tetatry2tpde2tetatryRÖtxitry((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt#lie_heuristic_abaco2_unique_unknownÆsT          " 4 !  4$ , '5cC sµg}|d}|d}|d}|d}|d}|jd}|d} tdƒ||ƒ} td ƒ||ƒ} tdƒ} |j| ƒ} |j| ƒ|d }|j|ƒ|d } | oÑ|oÑ| sØd S| j|ƒ}| j| ƒ}|j| ƒ}|j|ƒ}|j| ƒ}td |||||||d | | ƒ| d ||}|std |d |d d | | d || ƒ}|r±td |d ||d | | d |d ƒ}|st|d |d|| | d ||| ||j|ƒd| dƒ}|sÿtd| d ||| ||| |td ƒ| |ƒ}||krüytt|| ƒƒ}Wntk r²qùXd| d ||}| |krùi|| 6|j | |ƒ| 6gSqüqÿqq±n¬td |d ||d | | d |d ƒ}|r±td| d ||d |d ||d d | | | d |d ƒ}|s±t| | |j| ƒ|j|ƒ||| d ||| |d |||ƒ}|s®t| ||||| ||td ƒ| |ƒ}||kr«ytt|| ƒƒ}Wntk rhq¨X| ||}| |kr¨i|| 6|j | |ƒ| 6gSq«q®q±nd S(sQ This heuristic finds if infinitesimals of the form `\eta = f(x)`, `\xi = g(y)` without making any assumptions on `h`. The complete sequence of steps is given in the paper mentioned below. References ========== - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order ODE Patterns, pp. 10 - pp. 12 R2RõRöR”R÷iRRºR»iNiiiiiüÿÿÿ( RýRRRRPRGR.R:RÑRÕ(RÝRùRûR2RõRöR”R÷RÇRRºR»R™R/R0tAxtAytAxytAxxtAyyRktE1tE2tE3Rtxival((s0lib/python2.7/site-packages/sympy/solvers/ode.pyt#lie_heuristic_abaco2_unique_generalsr         D44NB   04M9:   c#C sg}|d}|d}|d}|d}|d}|jd}|d} tdƒ||ƒ} td ƒ||ƒ} i} td d tƒ} gt| d ƒD]}t| ƒ^q¡}|\}}}}}}|||||||| |||||| ||||d }|jƒ\}}tt|ƒƒ}|j r|j}x¹|D]®}|j rÕt g|jD]}|j || ƒsx|^qxŒ}||}|| krÂ|| |¥sN(RýRRXR$RR›RšRNRR=R7RRRRÏRVR¨R±RGRÂRRÕ(#RÝRùRûR2RõRöR”R÷RÇRRºR»t coeffdictR%RitsymlistR;RR5tC3tC4tC5RÖRÏR#RBRtremtxypartRYRtsubvaltonedictRMR((s0lib/python2.7/site-packages/sympy/solvers/ode.pytlie_heuristic_linearesX       (N    4       cC s3|ddj}|ddj}|d}|d}|d}t|ddƒ\}}}} tƒ} tt|djtƒƒdjtƒƒd} xatdƒD]S} d} x:tj || ƒD]%}| ||| || df7} qÄW| || 0` and `ad - bc > 0` - a saddle if `D > 0` and `ad - bc < 0` - a focus if `D < 0` and `a + d \neq 0` - a centre if `D < 0` and `a + d \neq 0`. 1.1. If `D > 0`. The characteristic equation has two distinct real roots `\lambda_1` and `\lambda_ 2` . The general solution of the system in question is expressed as .. math:: x = C_1 b e^{\lambda_1 t} + C_2 b e^{\lambda_2 t} .. math:: y = C_1 (\lambda_1 - a) e^{\lambda_1 t} + C_2 (\lambda_2 - a) e^{\lambda_2 t} where `C_1` and `C_2` being arbitrary constants 1.2. If `D < 0`. The characteristics equation has two conjugate roots, `\lambda_1 = \sigma + i \beta` and `\lambda_2 = \sigma - i \beta`. The general solution of the system is given by .. math:: x = b e^{\sigma t} (C_1 \sin(\beta t) + C_2 \cos(\beta t)) .. math:: y = e^{\sigma t} ([(\sigma - a) C_1 - \beta C_2] \sin(\beta t) + [\beta C_1 + (\sigma - a) C_2 \cos(\beta t)]) 1.3. If `D = 0` and `a \neq d`. The characteristic equation has two equal roots, `\lambda_1 = \lambda_2`. The general solution of the system is written as .. math:: x = 2b (C_1 + \frac{C_2}{a-d} + C_2 t) e^{\frac{a+d}{2} t} .. math:: y = [(d - a) C_1 + C_2 + (d - a) C_2 t] e^{\frac{a+d}{2} t} 1.4. If `D = 0` and `a = d \neq 0` and `b = 0` .. math:: x = C_1 e^{a t} , y = (c C_1 t + C_2) e^{a t} 1.5. If `D = 0` and `a = d \neq 0` and `c = 0` .. math:: x = (b C_1 t + C_2) e^{a t} , y = C_1 e^{a t} 2. Case when `ad - bc = 0` and `a^{2} + b^{2} > 0`. The whole straight line `ax + by = 0` consists of singular points. The original system of differential equations can be rewritten as .. math:: x' = ax + by , y' = k (ax + by) 2.1 If `a + bk \neq 0`, solution will be .. math:: x = b C_1 + C_2 e^{(a + bk) t} , y = -a C_1 + k C_2 e^{(a + bk) t} 2.2 If `a + bk = 0`, solution will be .. math:: x = C_1 (bk t - 1) + b C_2 t , y = k^{2} b C_1 t + (b k^{2} t + 1) C_2 RµRiRRRR—cs s|]}|jVqdS(N(RS(R¥R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pys /siii(R$R£RÁR4R!RR*R(R<R7RÒR.RùR’R1R/t is_positiveR-R2RRRB(RÇRRÞRúR“RµRR5RRRR—t real_coeffRktl1tl2t equal_rootstgsol1tgsol2texponential_formtbad_ab_vector1tbad_ab_vector2tvector1tvector2t sol_vectorttrigonometric_formtsigmatbetat scalar_matrix((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRZãs\I ." !!%%.  4,- %'$(c C s|d |d<|d |d<|d|d|d|ddkrÅtdd tƒ\}}t|d||d||d|d||d||df||ƒ}||||g}nV|d|d|d|ddkr|dd |dd dkr|d|d} |d|d| } | dkr¸|d| d |d| |d|| d |d|d|d|d} | | |d|d| |} nT|d|d|d| |d |d|} | | |d|d| |} | | g}n|S( sõ The equations of this type are .. math:: x' = ax + by + k1 , y' = cx + dy + k2 The general solution of this system is given by sum of its particular solution and the general solution of the corresponding homogeneous system is obtained from type1. 1. When `ad - bc \neq 0`. The particular solution will be `x = x_0` and `y = y_0` where `x_0` and `y_0` are determined by solving linear system of equations .. math:: a x_0 + b y_0 + k1 = 0 , c x_0 + d y_0 + k2 = 0 2. When `ad - bc = 0` and `a^{2} + b^{2} > 0`. In this case, the system of equation becomes .. math:: x' = ax + by + k_1 , y' = k (ax + by) + k_2 2.1 If `\sigma = a + bk \neq 0`, particular solution is given by .. math:: x = b \sigma^{-1} (c_1 k - c_2) t - \sigma^{-2} (a c_1 + b c_2) .. math:: y = kx + (c_2 - c_1 k) t 2.2 If `\sigma = a + bk = 0`, particular solution is given by .. math:: x = \frac{1}{2} b (c_2 - c_1 k) t^{2} + c_1 t .. math:: y = kx + (c_2 - c_1 k) t R­RYRR—RRisx0, y0R¯iiÿÿÿÿiþÿÿÿ(R%R$RV( RÇRRÞRúR“R¿ty0RäRÆRRqR#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR[ms (PH R%2"c C s¾t|ddƒ\}}}}t|d|ƒ} t|d|ƒ} t| ƒ|t| ƒ|t| ƒ} t| ƒ|t| ƒ|t| ƒ} t||ƒ| ƒt||ƒ| ƒgS(sn The equations of this type of ode are .. math:: x' = f(t) x + g(t) y .. math:: y' = g(t) x + f(t) y The solution of such equations is given by .. math:: x = e^{F} (C_1 e^{G} + C_2 e^{-G}) , y = e^{F} (C_1 e^{G} - C_2 e^{-G}) where `C_1` and `C_2` are arbitrary constants, and .. math:: F = \int f(t) \,dt , G = \int g(t) \,dt RiRR(R£R9R.R!( RÇRRÞRúR“RR5RQRRRbtGR#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR\žs ))c C sXt|ddƒ\}}}}|d|d kr§tt|d|ƒƒ} t|d|ƒ} | |t| ƒ|t| ƒ} | | t| ƒ|t| ƒ} n‰|d|d kr0tt|d|ƒƒ} t|d|ƒ} | | t| ƒ|t| ƒ} | |t| ƒ|t| ƒ} nt||ƒ| ƒt||ƒ| ƒgS(s] The equations of this type of ode are . .. math:: x' = f(t) x + g(t) y .. math:: y' = -g(t) x + f(t) y The solution is given by .. math:: x = F (C_1 \cos(G) + C_2 \sin(G)), y = F (-C_1 \sin(G) + C_2 \cos(G)) where `C_1` and `C_2` are arbitrary constants, and .. math:: F = \int f(t) \,dt , G = \int g(t) \,dt RiRRRR—(R£R.R9R-R2R!( RÇRRÞRúR“RR5RQRRRbRuR#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR]¶s"&#%cC sÙt|ddƒ\}}}}tddtƒ\} } tdƒ} t|d|dƒj|ƒs~t|d|dƒ} t|d|d |dƒ} tt| | ƒ| ƒ| | ƒƒtt| | ƒ| ƒ| | | ƒ| | | ƒƒf}t|ƒ}t t |d |ƒƒ|d j j | t |d|ƒƒ}t t |d |ƒƒ|d j j | t |d|ƒƒ}nt|d |dƒj|ƒs±t|d |dƒ} t|d|d|dƒ} ttt| | ƒ| ƒ| | ƒƒtt| | ƒ| ƒ| | | ƒ| | | ƒƒƒ}t t |d|ƒƒ|d j j | t |d|ƒƒ}t t |d|ƒƒ|d j j | t |d|ƒƒ}nt||ƒ|ƒt||ƒ|ƒgS( sr The equations of this type of ode are . .. math:: x' = f(t) x + g(t) y .. math:: y' = a g(t) x + [f(t) + b g(t)] y The transformation of .. math:: x = e^{\int f(t) \,dt} u , y = e^{\int f(t) \,dt} v , T = \int g(t) \,dt leads to a system of constant coefficient linear differential equations .. math:: u'(T) = v , v'(T) = au + bv Risu, vR¯tTRRR—Rii( R£R%RR"RGRR!RRîR.R9RRÕ(RÇRRÞRúR“RR5RQRRR!R RvR.R3RäR#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR^Ôs" ! Z =@! ]=@c C sqt|ddƒ\}}}}d} d} t|dt|d|dƒjƒdƒ} t|dt|d|dƒjƒdƒ} xt| | gƒD]ú\} }xëtjt|ƒƒD]Ô}|j|ƒsÝ|} n| dkr8| dkr8|d||d|d|d||kr8d} |}Pq8n| dkr¿| dkr¿|d||d|d|d||kr“d } |}Pq“q¿q¿WqW| dkrrt||ƒ|ƒ|d||ƒ|d|||ƒ|t | t |d|d||ƒƒ}t |ƒd}t |d |d ƒj }|||t | t |d|d||ƒƒ}n×| d krIt||ƒ|ƒ|d||ƒ|d|||ƒ|t | t |d|d||ƒƒ}t |ƒd}t |d |d ƒj }|||t | t |d|d||ƒƒ}nt||ƒ|ƒt||ƒ|ƒgS( sg The equations of this type of ode are . .. math:: x' = f(t) x + g(t) y .. math:: y' = a [f(t) + a h(t)] x + a [g(t) - h(t)] y This is solved by first multiplying the first equation by `-a` and adding it to the second equation to obtain .. math:: y' - a x' = -a h(t) (y - a x) Setting `U = y - ax` and integrating the equation we arrive at .. math:: y - ax = C_1 e^{-a \int h(t) \,dt} and on substituting the value of y in first equation give rise to first order ODEs. After solving for `x`, we can obtain `y` by substituting the value of `x` in second equation. RiiRR—RRiiR¹Rï(R£RGRšR~RR™RURRR.R9R×RîRR!(RÇRRÞRúR“RR5RQRRR.R3RžRŸRÀR¡RvRòtequthint1R#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR_÷s<00 00 i9 i9cC sÔt|ddƒ\}}}}|d|d|d|dd|d|dt|d|ƒt|d|ƒ|d} |d|d|d|d|ddt|d|ƒ|d|dt|d|ƒ} |d|d|d|dt|d|ƒ} |d|d|d|dt|d|ƒ} | dkrÏt|dt||ƒ||ƒ| t||ƒ|ƒƒj} tt||ƒ|ƒ|d| |d||ƒƒj}nÝ| dkrZt|dt||ƒ||ƒ| t||ƒ|ƒƒj}tt||ƒ|ƒ|d||ƒ|d|ƒj} nR| |dj|ƒ r| |dj|ƒ rtt||ƒ||ƒ| |dt||ƒ|ƒ| |d||ƒƒj} tt||ƒ|ƒ|d| |d||ƒƒj}n| |dj|ƒ rä| |dj|ƒ rätt||ƒ||ƒ| |dt||ƒ|ƒ| |d||ƒƒj}tt||ƒ|ƒ|d||ƒ|d|ƒj} nÈtd ƒ|ƒ}td ƒ|ƒ}tt|d|ƒƒ}tt|d|ƒƒ}||||t|d|||d|ƒ} |||||||t|d|||d|ƒ}t||ƒ| ƒt||ƒ|ƒgS( sÄ The equations of this type of ode are . .. math:: x' = f(t) x + g(t) y .. math:: y' = h(t) x + p(t) y Differentiating the first equation and substituting the value of `y` from second equation will give a second-order linear equation .. math:: g x'' - (fg + gp + g') x' + (fgp - g^{2} h + f g' - f' g) x = 0 This above equation can be easily integrated if following conditions are satisfied. 1. `fgp - g^{2} h + f g' - f' g = 0` 2. `fgp - g^{2} h + f g' - f' g = ag, fg + gp + g' = bg` If first condition is satisfied then it is solved by current dsolve solver and in second case it becomes a constant coefficient differential equation which is also solved by current solver. Otherwise if the above condition fails then, a particular solution is assumed as `x = x_0(t)` and `y = y_0(t)` Then the general solution is expressed as .. math:: x = C_1 x_0(t) + C_2 x_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt .. math:: y = C_1 y_0(t) + C_2 [\frac{F(t) P(t)}{x_0(t)} + y_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt] where C1 and C2 are arbitrary constants and .. math:: F(t) = e^{\int f(t) \,dt} , P(t) = e^{\int p(t) \,dt} RiRRRiR—iR¿Rt( R£RRîRRRR.R9R!(RÇRRÞRúR“RR5RQRRR¡R¢R$R%R#R R¿RtRbtP((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR`+s0#``33 @? @?0V?0V?3?cC s‘|ddj}|ddj}|d}|d}|d}t|ddƒ\}}}} tƒ} tt|djtƒƒdjtƒƒd} xjtdƒD]\} g} x=tj || ƒD](}| j ||| || dfƒqÄWt| Œ|| 0`. Then the original system becomes .. math:: x'' = ax + by .. math:: y'' = k (ax + by) 2.1. If `a + bk \neq 0`: .. math:: x = C_1 e^{t \sqrt{a + bk}} + C_2 e^{-t \sqrt{a + bk}} + C_3 bt + C_4 b .. math:: y = C_1 k e^{t \sqrt{a + bk}} + C_2 k e^{-t \sqrt{a + bk}} - C_3 at - C_4 a 2.2. If `a + bk = 0`: .. math:: x = C_1 b t^3 + C_2 b t^2 + C_3 t + C_4 .. math:: y = kx + 6 C_1 t + 2 C_2 RRR‘RRRRR—RµRiiiiii(R"R£RAR.R4R!(RÇRRÞRúR“RµRR5RQRRtchara_eqReRftl3tl4RkRhRiRtmidtsa((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRzžsL@ B*( j.Œ¿47g4d=HCN6!c C s+tdƒ\}}|d|d|d|ddkr¡t|d||d||d|d||d||df||ƒ}||||g}n†|d|d|d|ddkr'|dd |dd dkr'|d|d} |d|d| } | dkr°|d| d |d| |d|d d | d |d|d|d|d} | | |d|d| |d d } | | g}q'|d|d|d| |d d |d|d d } | | |d|d| |d d } | | g}n|S(s¬ The equations in this type are .. math:: x'' = a_1 x + b_1 y + c_1 .. math:: y'' = a_2 x + b_2 y + c_2 The general solution of this system is given by the sum of its particular solution and the general solution of the homogeneous system. The general solution is given by the linear system of 2 equation of order 2 and type 1 1. If `a_1 b_2 - a_2 b_1 \neq 0`. A particular solution will be `x = x_0` and `y = y_0` where the constants `x_0` and `y_0` are determined by solving the linear algebraic system .. math:: a_1 x_0 + b_1 y_0 + c_1 = 0, a_2 x_0 + b_2 y_0 + c_2 = 0 2. If `a_1 b_2 - a_2 b_1 = 0` and `a_1^2 + b_1^2 > 0`. In this case, the system in question becomes .. math:: x'' = ax + by + c_1, y'' = k (ax + by) + c_2 2.1. If `\sigma = a + bk \neq 0`, the particular solution will be .. math:: x = \frac{1}{2} b \sigma^{-1} (c_1 k - c_2) t^2 - \sigma^{-2} (a c_1 + b c_2) .. math:: y = kx + \frac{1}{2} (c_2 - c_1 k) t^2 2.2. If `\sigma = a + bk = 0`, the particular solution will be .. math:: x = \frac{1}{24} b (c_2 - c_1 k) t^4 + \frac{1}{2} c_1 t^2 .. math:: y = kx + \frac{1}{2} (c_2 - c_1 k) t^2 sx0, y0RRRR‘iR¡R¢iiÿÿÿÿiþÿÿÿii(R%RV( RÇRRÞRúR“R¿RtRäRÆRtsigtpsol1tpsol2((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR{ s "(PH /+*>*c C s{t|ddƒ\}}}}|ddd|ddkrS|d|d<|d |d<|ddt|ddd|dƒd} |ddt|ddd|dƒd} |t| |ƒ|t| |ƒ|t| |ƒ|t| |ƒ} | t| |ƒ|t| |ƒ|t| |ƒ|t| |ƒ} nt||ƒ| ƒt||ƒ| ƒgS( s These type of equation is used for describing the horizontal motion of a pendulum taking into account the Earth rotation. The solution is given with `a^2 + 4b > 0`: .. math:: x = C_1 \cos(\alpha t) + C_2 \sin(\alpha t) + C_3 \cos(\beta t) + C_4 \sin(\beta t) .. math:: y = -C_1 \sin(\alpha t) + C_2 \cos(\alpha t) - C_3 \sin(\beta t) + C_4 \cos(\beta t) where `C_1,...,C_4` and .. math:: \alpha = \frac{1}{2} a + \frac{1}{2} \sqrt{a^2 + 4b}, \beta = \frac{1}{2} a - \frac{1}{2} \sqrt{a^2 + 4b} RiRiRiRR(R£R4R-R2R!( RÇRRÞRúR“RR5RQRRtalphaRrR#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR|?s 00JNc'C söt|ddƒ\}}}}tdƒ} tdƒ\} } } } |d}|d}|d}|d}|d }|d }|d }|d }|d jƒj|ƒd}|djƒj|ƒd}|d jƒj|ƒd}t|ƒjƒd}t||ƒj|ƒ}t |t ƒ}|d || ||| || ||| |}||| |d || ||| || }|| ||| |d || ||| |}||| || ||| |d || }t ||||gƒ} | d|| || d|| ||| ||| |}!t t |!ƒƒ\}}}"}#| |||t||ƒ||||t||ƒ|||"|t|"|ƒ|||#|t|#|ƒ| t | tt ||ƒ}$|d}%||d|%||t||ƒ||d|%||t||ƒ||"d|%|"|t|"|ƒ||#d|%|#|t|#|ƒ| t | tt ||ƒ}&t||ƒ|$ƒt||ƒ|&ƒgS(s These equations are found in the theory of oscillations .. math:: x'' + a_1 x' + b_1 y' + c_1 x + d_1 y = k_1 e^{i \omega t} .. math:: y'' + a_2 x' + b_2 y' + c_2 x + d_2 y = k_2 e^{i \omega t} The general solution of this linear nonhomogeneous system of constant-coefficient differential equations is given by the sum of its particular solution and the general solution of the corresponding homogeneous system (with `k_1 = k_2 = 0`) 1. A particular solution is obtained by the method of undetermined coefficients: .. math:: x = A_* e^{i \omega t}, y = B_* e^{i \omega t} On substituting these expressions into the original system of differential equations, one arrive at a linear nonhomogeneous system of algebraic equations for the coefficients `A` and `B`. 2. The general solution of the homogeneous system of differential equations is determined by a linear combination of linearly independent particular solutions determined by the method of undetermined coefficients in the form of exponentials: .. math:: x = A e^{\lambda t}, y = B e^{\lambda t} On substituting these expressions into the original system and collecting the coefficients of the unknown `A` and `B`, one obtains .. math:: (\lambda^{2} + a_1 \lambda + c_1) A + (b_1 \lambda + d_1) B = 0 .. math:: (a_2 \lambda + c_2) A + (\lambda^{2} + b_2 \lambda + d_2) B = 0 The determinant of this system must vanish for nontrivial solutions A, B to exist. This requirement results in the following characteristic equation for `\lambda` .. math:: (\lambda^2 + a_1 \lambda + c_1) (\lambda^2 + b_2 \lambda + d_2) - (b_1 \lambda + d_1) (a_2 \lambda + c_2) = 0 If all roots `k_1,...,k_4` of this equation are distinct, the general solution of the original system of the differential equations has the form .. math:: x = C_1 (b_1 \lambda_1 + d_1) e^{\lambda_1 t} - C_2 (b_1 \lambda_2 + d_1) e^{\lambda_2 t} - C_3 (b_1 \lambda_3 + d_1) e^{\lambda_3 t} - C_4 (b_1 \lambda_4 + d_1) e^{\lambda_4 t} .. math:: y = C_1 (\lambda_1^{2} + a_1 \lambda_1 + c_1) e^{\lambda_1 t} + C_2 (\lambda_2^{2} + a_1 \lambda_2 + c_1) e^{\lambda_2 t} + C_3 (\lambda_3^{2} + a_1 \lambda_3 + c_1) e^{\lambda_3 t} + C_4 (\lambda_4^{2} + a_1 \lambda_4 + c_1) e^{\lambda_4 t} RiRsRa, Ca, Rb, CbRRRRRRR‘RR¡iR¢ii(R£R"R%RR>RTR9RLRÍRGRRVRFR?R.R!('RÇRRÞRúR“RR5RQRRRtRatCatRbtCbRRRRRRR‘RR­RYtew1tew2tew3Rttpeq1tpeq2tpeq3tpeq4RÆR–tk3tk4R#ta1_R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR}Ws8.     7373B™ ¸cC sît|ddƒ\}}}}|d |d<|d |d 0`: .. math:: u = C_1 a e^{\frac{1}{2} \sqrt{ab} t^2} + C_2 a e^{-\frac{1}{2} \sqrt{ab} t^2} .. math:: v = C_1 \sqrt{ab} e^{\frac{1}{2} \sqrt{ab} t^2} - C_2 \sqrt{ab} e^{-\frac{1}{2} \sqrt{ab} t^2} If `ab < 0`: .. math:: u = C_1 a \cos(\frac{1}{2} \sqrt{\left|ab\right|} t^2) + C_2 a \sin(-\frac{1}{2} \sqrt{\left|ab\right|} t^2) .. math:: v = C_1 \sqrt{\left|ab\right|} \sin(\frac{1}{2} \sqrt{\left|ab\right|} t^2) + C_2 \sqrt{\left|ab\right|} \cos(-\frac{1}{2} \sqrt{\left|ab\right|} t^2) where `C_1` and `C_2` are arbitrary constants. On substituting the value of `u` and `v` in above equations and integrating the resulting expressions, the general solution will become .. math:: x = C_3 t + t \int \frac{u}{t^2} \,dt, y = C_4 t + t \int \frac{u}{t^2} \,dt where `C_3` and `C_4` are arbitrary constants. RiR‘RRRii(R£R4RÚR.R-R2R9R!(RÇRRÞRúR“RR5RQRRRhR!R R#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR~¦s&GBF?##cC s-t|ddƒ\}}}}tdƒ} tdƒ} t|d||ƒ|d||ƒ|d||ƒ|d||ƒƒjƒ\} } |d| j||ƒƒ} | j||ƒƒ}| j||ƒƒ}| j||ƒƒ}| j||ƒƒ}| d ||| ||||}gtt|ƒjƒƒD]} t || ƒ^qB\}}t t | |ƒ||ƒ|| | |ƒƒj }t t | |ƒ||ƒ|| | |ƒƒj }||||||||||}||||}t ||ƒ|ƒt ||ƒ|ƒgS( sš The equations are .. math:: x'' = f(t) (a_1 x + b_1 y) .. math:: y'' = f(t) (a_2 x + b_2 y) If `k_1` and `k_2` are roots of the quadratic equation .. math:: k^2 - (a_1 + b_2) k + a_1 b_2 - a_2 b_1 = 0 Then by multiplying appropriate constants and adding together original equations we obtain two independent equations: .. math:: z_1'' = k_1 f(t) z_1, z_1 = a_2 x + (k_1 - a_1) y .. math:: z_2'' = k_2 f(t) z_2, z_2 = a_2 x + (k_2 - a_1) y Solving the equations will give the values of `x` and `y` after obtaining the value of `z_1` and `z_2` by solving the differential equation and substituting the result. RiRR®RR‘RRi(R£R"RRGRšRÍR R?RHRARîRRR!(RÇRRÞRúR“RR5RQRRRR®RRSR¦RRRRR–R­RYtz1tz2R#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRÙs$  #6&:33*cC s t|ddƒ\}}}}tdƒ} t|d||ƒ|d||ƒ|d||ƒ|d||ƒƒjƒ\} } |d| j||ƒƒ} | j||ƒƒ} | j||ƒƒ}| j||ƒƒ}| j||ƒƒ}| d| || | |||}gtt|ƒjƒƒD]} t|| ƒ^q6\}}t | |ƒ}|t t ||ƒ|ƒ|}|t t ||ƒ|ƒ|}||||| |||||}||||}t ||ƒ|ƒt ||ƒ|ƒgS( s{ The equations are given as .. math:: x'' = f(t) (a_1 x' + b_1 y') .. math:: y'' = f(t) (a_2 x' + b_2 y') If `k_1` and 'k_2` are roots of the quadratic equation .. math:: k^2 - (a_1 + b_2) k + a_1 b_2 - a_2 b_1 = 0 Then the system can be reduced by adding together the two equations multiplied by appropriate constants give following two independent equations: .. math:: z_1'' = k_1 f(t) z_1', z_1 = a_2 x + (k_1 - a_1) y .. math:: z_2'' = k_2 f(t) z_2', z_2 = a_2 x + (k_2 - a_1) y Integrating these and returning to the original variables, one arrives at a linear algebraic system for the unknowns `x` and `y`: .. math:: a_2 x + (k_1 - a_1) y = C_1 \int e^{k_1 F(t)} \,dt + C_2 .. math:: a_2 x + (k_2 - a_1) y = C_3 \int e^{k_2 F(t)} \,dt + C_4 where `C_1,...,C_4` are arbitrary constants and `F(t) = \int f(t) \,dt` RiRRRRRi( R£R"RGRšRÍR R?RHRAR9R.R!(RÇRRÞRúR“RR5RQRRRRRSR¦RRRRR–R­RYRbRRžR#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR€s$ #6&:!!*cC sÂt|ddƒ\}}}}t|d|dƒjƒ\} } |d | } | } | } tt| | ƒƒ}t|| |ƒ}| | dkr÷|| t||ƒ|| t| |ƒ}||t||ƒ||t| |ƒ}n]|| t||ƒ|| t||ƒ}| |t||ƒ||t||ƒ}|||t||d|ƒ}|||t||d|ƒ}t ||ƒ|ƒt ||ƒ|ƒgS(s¾ The equation of this category are .. math:: x'' = a f(t) (t y' - y) .. math:: y'' = b f(t) (t x' - x) The transformation .. math:: u = t x' - x, v = t y' - y leads to the system of first-order equations .. math:: u' = a t f(t) v, v' = b t f(t) u The general solution of this system has the form If `ab > 0`: .. math:: u = C_1 a e^{\sqrt{ab} \int t f(t) \,dt} + C_2 a e^{-\sqrt{ab} \int t f(t) \,dt} .. math:: v = C_1 \sqrt{ab} e^{\sqrt{ab} \int t f(t) \,dt} - C_2 \sqrt{ab} e^{-\sqrt{ab} \int t f(t) \,dt} If `ab < 0`: .. math:: u = C_1 a \cos(\sqrt{\left|ab\right|} \int t f(t) \,dt) + C_2 a \sin(-\sqrt{\left|ab\right|} \int t f(t) \,dt) .. math:: v = C_1 \sqrt{\left|ab\right|} \sin(\sqrt{\left|ab\right|} \int t f(t) \,dt) + C_2 \sqrt{\left|ab\right|} \cos(-\sqrt{\left|ab\right|} \int t f(t) \,dt) where `C_1` and `C_2` are arbitrary constants. On substituting the value of `u` and `v` in above equations and integrating the resulting expressions, the general solution will become .. math:: x = C_3 t + t \int \frac{u}{t^2} \,dt, y = C_4 t + t \int \frac{u}{t^2} \,dt where `C_3` and `C_4` are arbitrary constants. RiR‘Rii( R£RGRšR4RÚR9R.R-R2R!(RÇRRÞRúR“RR5RQRRRRSR¦RRRhtIgralR!R R#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR3s&$/2./##cC s‘t|ddƒ\}}}}tdƒ} |d |} |d |} |d |} |d |} |d |d }|d  |d }|d  |d }|d  |d }| d | d | || d | d | || | || | |}tt|ƒƒ\}}}}| | ||t|t|ƒƒ|| ||t|t|ƒƒ|| ||t|t|ƒƒ|| ||t|t|ƒƒ}| d }||d |||t|t|ƒƒ||d |||t|t|ƒƒ||d |||t|t|ƒƒ||d |||t|t|ƒƒ}t||ƒ|ƒt||ƒ|ƒgS(sÓ .. math:: t^2 x'' + a_1 t x' + b_1 t y' + c_1 x + d_1 y = 0 .. math:: t^2 y'' + a_2 t x' + b_2 t y' + c_2 x + d_2 y = 0 These system of equations are euler type. The substitution of `t = \sigma e^{\tau} (\sigma \neq 0)` leads to the system of constant coefficient linear differential equations .. math:: x'' + (a_1 - 1) x' + b_1 y' + c_1 x + d_1 y = 0 .. math:: y'' + a_2 x' + (b_2 - 1) y' + c_2 x + d_2 y = 0 The general solution of the homogeneous system of differential equations is determined by a linear combination of linearly independent particular solutions determined by the method of undetermined coefficients in the form of exponentials .. math:: x = A e^{\lambda t}, y = B e^{\lambda t} On substituting these expressions into the original system and collecting the coefficients of the unknown `A` and `B`, one obtains .. math:: (\lambda^{2} + (a_1 - 1) \lambda + c_1) A + (b_1 \lambda + d_1) B = 0 .. math:: (a_2 \lambda + c_2) A + (\lambda^{2} + (b_2 - 1) \lambda + d_2) B = 0 The determinant of this system must vanish for nontrivial solutions A, B to exist. This requirement results in the following characteristic equation for `\lambda` .. math:: (\lambda^2 + (a_1 - 1) \lambda + c_1) (\lambda^2 + (b_2 - 1) \lambda + d_2) - (b_1 \lambda + d_1) (a_2 \lambda + c_2) = 0 If all roots `k_1,...,k_4` of this equation are distinct, the general solution of the original system of the differential equations has the form .. math:: x = C_1 (b_1 \lambda_1 + d_1) e^{\lambda_1 t} - C_2 (b_1 \lambda_2 + d_1) e^{\lambda_2 t} - C_3 (b_1 \lambda_3 + d_1) e^{\lambda_3 t} - C_4 (b_1 \lambda_4 + d_1) e^{\lambda_4 t} .. math:: y = C_1 (\lambda_1^{2} + (a_1 - 1) \lambda_1 + c_1) e^{\lambda_1 t} + C_2 (\lambda_2^{2} + (a_1 - 1) \lambda_2 + c_1) e^{\lambda_2 t} + C_3 (\lambda_3^{2} + (a_1 - 1) \lambda_3 + c_1) e^{\lambda_3 t} + C_4 (\lambda_4^{2} + (a_1 - 1) \lambda_4 + c_1) e^{\lambda_4 t} RiRRRRRRiRR‘Ri(R£R"RFR?R.R0R!(RÇRRÞRúR“RR5RQRRRRRRRRRR‘RR­RYRšR›R#RœR ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR‚js ) J“ ²c C sËt|ddƒ\}}}}tddtƒ\} } tsBt‚tdƒ} tdd||dgƒ} td d||dgƒ} td d||dgƒ}td d||dgƒ}|d jƒ\}}|j|| |d| ||dj ƒƒ}|| |d|| |||}|||}t |d |dƒ}t |d|dƒ}t |d|dƒ}t t t | |ƒ||ƒ||| |||| dd| |ƒ|| |ƒƒt t | |ƒ||ƒ|| |ƒ||| |||| dd| |ƒƒgƒ\}}|jtt|ƒƒj|td||ƒƒ}|jtt|ƒƒj|td||ƒƒ}t ||ƒ|ƒt ||ƒ|ƒgS(s The equation of this category are .. math:: (\alpha t^2 + \beta t + \gamma)^{2} x'' = ax + by .. math:: (\alpha t^2 + \beta t + \gamma)^{2} y'' = cx + dy The transformation .. math:: \tau = \int \frac{1}{\alpha t^2 + \beta t + \gamma} \,dt , u = \frac{x}{\sqrt{\left|\alpha t^2 + \beta t + \gamma\right|}} , v = \frac{y}{\sqrt{\left|\alpha t^2 + \beta t + \gamma\right|}} leads to a constant coefficient linear system of equations .. math:: u'' = (a - \alpha \gamma + \frac{1}{4} \beta^{2}) u + b v .. math:: v'' = c u + (d - \alpha \gamma + \frac{1}{4} \beta^{2}) v These system of equations obtained can be solved by type1 of System of two constant-coefficient second-order linear homogeneous differential equations. Risu, vR¯RvR.R§iR3RòRÀRR‘RRi(R£R%RR’RÙR"R#RšRÝRRGRîR!RRR4RÚRÕR9(RÇRRÞRúR“RR5RQRRR!R RvR.R3RòRÀRRStdicteqzRRRR—tmsol1tmsol2R#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyRƒ¤s(  1&Hv22cC s^t|ddƒ\}}}}tddtƒ\} } |d } |d } |d } |d }ttt| |ƒ|ƒ|| | |ƒ|| | |ƒƒtt| |ƒ|ƒ|| | |ƒ||| |ƒƒgƒ\}}|||t|j|d |ƒ}|||t|j|d |ƒ}t||ƒ|ƒt||ƒ|ƒgS( sY The equations which comes under this type are .. math:: x'' = f(t) (t x' - x) + g(t) (t y' - y) .. math:: y'' = h(t) (t x' - x) + p(t) (t y' - y) The transformation .. math:: u = t x' - x, v = t y' - y leads to the linear system of first-order equations .. math:: u' = t f(t) u + t g(t) v, v' = t h(t) u + t p(t) v On substituting the value of `u` and `v` in transformed equation gives value of `x` and `y` as .. math:: x = C_3 t + t \int \frac{u}{t^2} \,dt , y = C_4 t + t \int \frac{v}{t^2} \,dt. where `C_3` and `C_4` are arbitrary constants. Risu, vR¯RR‘RRi(R£R%RRîR!RR9R(RÇRRÞRúR“RR5RQRRR!R R¦R1R2R.R¢R£R#R ((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR„Ïs  ˆ&&cC s&|ddj}|ddj}|ddj}|d}|d}|d}t|ddƒ\}}} } tƒ} tt|djtƒƒdjtƒƒd} xatd ƒD]S} d}x:tj || ƒD]%}|||| || df7}qÕW||| >>cC s¯t|ddddƒ\}}}} t|d|dƒ} t|d|dƒ} t|d|dƒ} | d || d|| d} t| d| d| dƒ} || |t| |ƒ| d | | || t| |ƒ}|| |t| |ƒ| | d | | |t| |ƒ}|| | t| |ƒ| | | d ||t| |ƒ}t||ƒ|ƒt||ƒ|ƒt||ƒ|ƒgS( sÎ Equations of this system of ODEs .. math:: a x' = bc (y - z) .. math:: b y' = ac (z - x) .. math:: c z' = ab (x - y) 1. First integral: .. math:: a^2 x + b^2 y + c^2 z = A where A is an arbitrary constant. It follows that the integral lines are plane curves. 2. Solution: .. math:: x = C_0 + k C_1 \cos(kt) + a^{-1} bc (C_2 - C_3) \sin(kt) .. math:: y = C_0 + k C_2 \cos(kt) + a b^{-1} c (C_3 - C_1) \sin(kt) .. math:: z = C_0 + k C_3 \cos(kt) + ab c^{-1} (C_1 - C_2) \sin(kt) where `k = \sqrt{a^2 + b^2 + c^2}` and the four constants of integration, `C_1,...,C_4` are constrained by a single relation .. math:: a^2 C_1 + b^2 C_2 + c^2 C_3 = 0 RiRžiRRRiiÿÿÿÿ(R£R4R-R2R!(RÇRR®RÞRúR“R;RR5RQRRRRR#R Rª((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR¦as$# BBBcC s‰tddtƒ\}}}t|d|dƒjƒ\} } t|d| ƒ} t|d| ƒ} t|d| ƒ} t|d| ƒ}t|d| ƒ}t|d | ƒ\}}t|d | ƒd }t|d | ƒd }t||ƒ|ƒ|||ƒ| ||ƒ| ||ƒt||ƒ|ƒ| ||ƒ|||ƒ| ||ƒt||ƒ|ƒ|||ƒ|||ƒ|||ƒf}t|ƒ}tt||ƒƒ|d j j |t| |ƒƒ}tt||ƒƒ|d j j |t| |ƒƒ}tt||ƒƒ|dj j |t| |ƒƒ}t ||ƒ|ƒt ||ƒ|ƒt ||ƒ|ƒgS(s! Equations: .. math:: x' = (a_1 f(t) + g(t)) x + a_2 f(t) y + a_3 f(t) z .. math:: y' = b_1 f(t) x + (b_2 f(t) + g(t)) y + b_3 f(t) z .. math:: z' = c_1 f(t) x + c_2 f(t) y + (c_3 f(t) + g(t)) z The transformation .. math:: x = e^{\int g(t) \,dt} u, y = e^{\int g(t) \,dt} v, z = e^{\int g(t) \,dt} w, \tau = \int f(t) \,dt leads to the system of constant coefficient linear differential equations .. math:: u' = a_1 u + a_2 v + a_3 w .. math:: v' = b_1 u + b_2 v + b_3 w .. math:: w' = c_1 u + c_2 v + c_3 w These system of equations are solved by homogeneous linear system of constant coefficients of `n` equations of first order. Then substituting the value of `u, v` and `w` in transformed equation gives value of `x, y` and `z`. su, v, wR¯RRRRRRRRiRii( R%RRGRšRIRRîR.R9RRÕR!(RÇRR®RÞRúR“R!R RtRRR¦RRRRRR1RRttrans_eqRäR#R Rª((s0lib/python2.7/site-packages/sympy/solvers/ode.pyR§Šs"$<~ 555cC st|ƒ}|S(N(R¨(RaRä((s0lib/python2.7/site-packages/sympy/solvers/ode.pytsysode_linear_neq_order1µs c  s7|d}|d‰|d‰t|ƒ‰tt|djtƒƒdjtƒƒd‰tdddtdd ƒ}tˆˆ‡‡fd †ƒ}|jd tƒ}‡‡fd †}‡‡fd †}g}t ˆd ƒ}x|D] } | d|kråt| dƒ| d krRtˆd d„ƒ‰|| dt | ddj ƒˆ} gt | d ƒD] } d^qb} | dd| dR=trowsR RVRþRÕRùR›RRRPR.R1R8R6R!(RaR“RâtMtevectorR®R¯tconjugate_rootte_vectortevectstMnewR¡RtRútw_RÄR R™RvRä((RœR”RÀR°RÞR±s0lib/python2.7/site-packages/sympy/solvers/ode.pyR¨¹sTD    0 '#" U XJ!"c C s–|d}|d}|d}tt|djtƒƒdjtƒƒd}|ddkrtt|||ƒ}|S|dj}|dj}xatdƒD]S}d} x:tj||ƒD]%} | | ||||df7} q»W| ||$/"U @@@(((llllll```cC s®t|ddƒ}tdƒ\}}}tdd||ƒ||ƒt|ƒ|gƒ}tdd||ƒ||ƒt|ƒ|gƒ} tdd||ƒ||ƒt|ƒ|gƒ} tdd tƒ\} } } |d jt||ƒ|ƒ||ƒ| | ƒ}t|| ƒj| | ƒ}|jt|| ƒj| | ƒƒ|dj|| ƒrµ|dj|| ƒ rµ|| || || <|| <||  ||  || <|| t sympy.polysR?R@RARBRCRDREtsympy.polys.polyrootsRFtsympy.polys.polytoolsRGRHRIt sympy.seriesRJtsympy.series.seriesRKtsympy.simplifyRLRMRNRORPRQRRRStsympy.simplify.powsimpRTtsympy.simplify.radsimpRUt sympy.solversRVtsympy.solvers.pdeRWtsympy.utilitiesRXRYRZtsympy.solvers.deutilsR[R\R]RIRÛR˜R£RšRÐRÒRîRØRÔR’R×RËRR€RR‚RƒR·R„RÁRÈR÷RåRÆRôRüRÔRÛRøR R$R"R!R@R1R2R4R6RRR^RTRDRrRER„RƒR…RFR R£R§R¨RAR­R°RµR»R¢R¼RHRÏR¥R®RÙRðRÜRÓRRRR+R.R7RDRNRXRbRZR[R\R]R^R_R`R…RzR{R|R}R~RR€RR‚RƒR„R©R¤R¥R¦R§R¬R¨RÀR¼R½R¾R¿R»RÏRÊRËRÌRÍRÎ(((s0lib/python2.7/site-packages/sympy/solvers/ode.pytès‚((:"".L"4:     ÿ2 gÿÿw Ô H b ,  H  P  h¬Ó |  5€z  G 9 ] c [ = U 1 H ’ } 5  4 3 % ) 9 0 E A E P 7 L L ? i ‘ M : AL ¤ 7 g I H H \ m P O K 3 Š 1   # 4 > 5 m 4  O 3 * 0 7 : + )  + ) +  t  - - $ / 1  2 7 ; ;