Maple dsolve in Education - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Differential Equations : dsolve : dsolve/education

Maple dsolve in Education

 

Description

ODEs can be classified

Solutions using "this" or "that" method

Integrating factors and ODEs

The Lie symmetry approach for solving ODEs

Singular solutions for nonlinear ODEs

Description

• 

Most of the intermediate solving steps used by Maple dsolve are now available as user level commands, including all the steps of the integrating factor and symmetry approaches.

• 

New optional arguments in dsolve also permit you to tackle a given ODE using methods you specify, and with or without performing the integration step, facilitating the understanding of the different possible solving methods, and the use of dsolve and related Maple commands in classroom.

ODEs can be classified

• 

The relevant command is odeadvisor. The capability of classifying ODEs was introduced in Maple 5. In subsequent versions, the list of classifications known by the system was enlarged, focusing in classifications traditionally found in textbooks, and also in new ones related to solving algorithms recently presented in the literature.

Example

  

If infolevel is set to a greater integer (possible settings are 1 through 5), more detailed information about the computation method is displayed.

with(DEtools):

with(PDEtools, declare):

declare(y(x), prime=x); # Turn ON the enhanced DEdisplay feature

yxwill now be displayed asy

derivatives with respect toxof functions of one variable will now be displayed with '

(1)

infolevel[dsolve] := 3;

infoleveldsolve:=3

(2)

ode1 := diff(y(x), x)-y(x)^2+y(x)*sin(x)-cos(x);

ode1:=y'y2+ysinxcosx

(3)
  

This ODE is recognized by the system as of Riccati type

odeadvisor(ode1);

_Riccati

(4)
  

and solved accordingly:

dsolve(ode1);

Methods for first order ODEs:
--- Trying classification methods ---
trying a quadrature
trying 1st order linear
trying Bernoulli
trying separable
trying inverse linear
trying homogeneous types:
trying Chini
differential order: 1; looking for linear symmetries
trying exact
Looking for potential symmetries
trying Riccati
trying Riccati sub-methods:
   <- Riccati with symmetry of the form [0, exp(-Int(f,x))/P*(y*P-f)^2] successful

y&equals;&ExponentialE;cosx_C1&plus;&int;&ExponentialE;cosx&DifferentialD;x&plus;sinx

(5)
  

To know more about this type of ODE and related solving methods one can give the extra argument help:

odeadvisor(ode1, help);

  

A table with all the classifications recognized in Maple is found at odeadvisor, classifications.

Solutions using "this" or "that" method

  

dsolve accepts extra arguments related to the solving method to be used (a single ODE can usually be solved using different methods); it is also possible to avoid the integration step, or avoid making the answer explicit; (these last two steps may easily obscure the whole solving process).

Example

  

A linear ODE

ode_L := sin(x)*diff(y(x), x)-cos(x)*y(x)=0;

ode_L:=y'sinxycosx&equals;0

(6)
  

Although dsolve has its own strategy and defaults, one can also indicate to dsolve the use of any specific sequence of 'methods' to tackle the ODE. In this example the method for 'linear' ODEs is specified; in addition the optional argument 'useInt' makes dsolve not evaluating the integral appearing in the answer

dsolve(ode_L, [linear], useInt);

Classification methods on request
Methods to be used are: [linear]
----------------------------
* Tackling ODE using method: linear
--- Trying classification methods ---
trying 1st order linear
<- 1st order linear successful

y&equals;_C1&ExponentialE;&int;cosxsinx&DifferentialD;x

(7)
  

Solutions like this one - before evaluating integrals - are useful to understand how the solution was obtained; integrals can be evaluated afterwards using value

value((7));

y&equals;_C1sinx

(8)
  

This particular linear ODE is also separable, hence it can also be solved via

dsolve(ode_L, [separable], useInt);

Classification methods on request
Methods to be used are: [separable]
----------------------------
* Tackling ODE using method: separable
--- Trying classification methods ---
trying separable
<- separable successful

&int;cosxsinx&DifferentialD;x&int;y1_a&DifferentialD;_a&plus;_C1&equals;0

(9)

value((9));

lnsinxlny&plus;_C1&equals;0

(10)

Integrating factors and ODEs

• 

As a general alternative, ODEs can be tackled by looking for an integrating factor. The relevant commands in this approach are: intfactor, firint, firtest, muchange, mutest, adjoint.

Example

  

The linear first order ODE of the previous section can be solved by first determining an integrating factor for it

mu := intfactor(ode_L);

&mu;:=1sinx2

(11)
  

Integrating factors turn ODEs exact, that is: the product μ times the ODE is a total derivative. One can combine the determination of an integrating factor with indicating to dsolve the use of the method for exact ODEs:

dsolve(mu * ode_L, [exact]);

Classification methods on request
Methods to be used are: [exact]
----------------------------
* Tackling ODE using method: exact
--- Trying classification methods ---
trying exact
<- exact successful

y&equals;_C1sinx

(12)

simplify(convert((12), sincos));

y&equals;_C1sinx

(13)

Integrating factors for second and higher order linear ODEs

• 

For linear ODEs (LODEs) of order 2 or greater, it is possible to calculate integrating factors by solving the adjoint of the LODE. This could be as difficult as the original problem, or much easier, depending on the example. The set of DEtools available permits a discussion of such a strategy in details.

Example

ode := diff(y(x), x, x) =
(y(x)*x+y(x)*ln(x)*x^2+diff(y(x), x)*ln(x)*x^2)/ln(x)/x^2*exp(x)-
y(x)/ln(x)/x^2;

ode:=y''&equals;yx&plus;ylnxx2&plus;y'lnxx2&ExponentialE;xlnxx2ylnxx2

(14)
  

This ODE has the following adjoint

DEtools[adjoint](ode, y(x));

&ExponentialE;xx1ylnxx2&plus;&ExponentialE;xy'&plus;y''

(15)
  

This adjoint equation is in turn solvable by dsolve

dsolve((15));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
   <- BRANCH 2 successful. Symmetry is:, [0, exp(Int(1/x/ln(x),x))]
<- linear_1 successful

y&equals;&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;x_C1&plus;_C2lnx

(16)
  

Now the solutions to the adjoint equation are integrating factors of the original LODE, so the two independent solutions implied in the general solution above

eval(rhs((16)), {_C1=0, _C2=1});

lnx

(17)

eval(rhs((16)), {_C1=1, _C2=2});

&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;x&plus;2lnx

(18)
  

are integrating factors of ode. These integrating factors could also be found using the intfactor directly

Mu := intfactor(ode);

trying a symmetry of the form [xi=0, eta=F(x)]<- linear_1 successful
Trying an integrating factor as the solution to the adjoint linear ODE
trying a symmetry of the form [xi=0, eta=F(x)]
<- linear_1 successful

The integrating factors are: &comma;lnx&comma;&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;xlnx

&Mu;:=lnx&comma;&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;xlnx

(19)

Constructing solutions using integrating factors

  

How are these integrating factors transformed into a solution to the original problem? By using them to construct two first integrals; that is: two ODEs of lower order (in this case two first order ODEs). For that purpose it is provided the firint command which receives an exact ODE and returns a first integral. The idea is simple: an exact ODE is a total derivative - say dR/dx; firint returns the R + _C1:

firint(Mu[1]*ode);

lnxx2&ExponentialE;x&plus;xyx2&plus;lnxy'&plus;_C1&equals;0

(20)

firint(Mu[2]*ode);

&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;xlnx2&ExponentialE;xx2&plus;&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;xlnxx&plus;&ExponentialE;&ExponentialE;xx2ylnxx2&plus;&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;xlnxy'&plus;_C1&equals;0

(21)
  

Eliminating y' from these two first integrals (and replacing _C1 by _C2 in one of them) leads to the solution fx&comma;yx&comma;_C1&comma;_C2&equals;0 to this ode. So all this process could be ran interactively, as shown, or in one step

dsolve(ode);

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
   -> Tackling the "Normal Form" of the given linear ODE:
      trying a symmetry of the form [xi=0, eta=F(x)]
   -> Tackling the linear ODE using alternative approaches:
      trying 2nd order exact linear
      trying symmetries linear in x and y(x)
      trying to convert to a linear ODE with constant coefficients
         testing BRANCH 1 ->
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
   -> Tackling the "Normal Form" of the given linear ODE:
      trying a symmetry of the form [xi=0, eta=F(x)]
   -> Tackling the linear ODE using alternative approaches:
      trying 2nd order exact linear
      trying symmetries linear in x and y(x)
      trying to convert to a linear ODE with constant coefficients
         testing BRANCH 1 ->
<- unable to find a useful change of variables
-> Tackling the "Normal Form" of the given linear ODE:
   trying a symmetry of the form [xi=0, eta=F(x)]
-> Tackling the linear ODE using alternative approaches:
   trying 2nd order exact linear
   trying symmetries linear in x and y(x)
   trying to convert to a linear ODE with constant coefficients
      testing BRANCH 1 ->
   trying 2nd order, integrating factor of the form mu(x,y)
   <- 2nd order, integrating factors of the form mu(x,y) successful

y&equals;_C1&ExponentialE;&ExponentialE;xlnx&plus;_C2&ExponentialE;&ExponentialE;x&int;&ExponentialE;&ExponentialE;xlnx2&DifferentialD;xlnx

(22)

Integrating factors for second and higher order nonlinear ODEs

  

There are algorithms in dsolve for determining integrating factors for nonlinear ODEs too:

• 

for second order ODEs, integrating factors depending on two variables (x, y) or (x, y') or (y, y') - when they exist - can be systematically determined;

• 

for third order ODEs, integrating factors depending only on (y'') can also be systematically determined.

Examples

infoleveldsolve0

infoleveldsolve:=0

(23)

ode&DifferentialD;3&DifferentialD;x3yx&equals;&DifferentialD;2&DifferentialD;x2yx2&DifferentialD;&DifferentialD;xyx

ode:=y'''&equals;y''2y'

(24)
  

For this ODE, three integrating factors are

intfactor

y'&comma;y'x&comma;1y''

(25)
  

The product of any of them times the ode is a total derivative, from where a first integral can be obtained; for instance taking the third one

firint3ode

lny'&plus;lny''&plus;_C1&equals;0

(26)
  

Solving for y'' this reduced ODE,

isolate&comma;&DifferentialD;2&DifferentialD;x2yx

y''&equals;1y'&ExponentialE;_C1

(27)
  

we are able to calculate more integrating factors (in this case intfactor succeeds again):

intfactor

y'

(28)
  

and obtain a lower order first integral as in the previous step

firint

y'22x&ExponentialE;_C1&plus;_C2&equals;0

(29)
  

Finally, this is a simple first order ODE which can be solved directly, leading to the general solution for the original ode problem:

dsolve

y&equals;13_C2&ExponentialE;_C12x&ExponentialE;_C1_C2&ExponentialE;_C12x&ExponentialE;_C1&plus;_C3&comma;y&equals;13_C2&ExponentialE;_C12x&ExponentialE;_C1_C2&ExponentialE;_C12x&ExponentialE;_C1&plus;_C3

(30)

mapodetest&comma;&comma;ode

0&comma;0

(31)
  

where in above we map the odetest command over each of the solutions. As a general comment, the integration constants entering the general solution of an ODE are arbitrary, we can always rename &ExponentialE;_C1_C1, simplifying a bit the solution. This ode here solved using the integrating factor approach can also be solved using the symmetry approach (following the steps shown in the next section).

  

Also interesting in the integrating factor approach is the inverse problem; that is: to determine the most general ODE family having a given integrating factor (related worked examples are found in redode).

The Lie symmetry approach for solving ODEs

• 

dsolve includes symmetry methods for all differential order. The possibility of using separate tool-commands related to each of the symmetry steps makes approaching the method relatively easy. In addition, the possibility of also classifying the ODE according to standard methods, or looking for related integrating factors permits observing the natural relation existing among all these approaches. The most relevant related commands are symgen, canoni, transinv, reduce_order and buildsol; see also DEtools, Lie and dsolve, Lie.

Example

  

The following worked example aims at illustrating how the solving process can be performed step-by-step, using the symmetry approach, and with instructions easy to re-use. The commands to be used are: symgen (for calculating the symmetries), reduce_order (for reducing the order using these symmetries), and buildsol (to build the solution to the original problem from the solutions to the reduced ODE problems)

  

This is a fifth order ODE (from Kamke's book, high order ODE example 17):

ode5 := 9*diff(y(x), x, x)^2*diff(y(x), x, x, x, x, x)
- 45*diff(y(x), x, x)*diff(y(x), x, x, x)*diff(y(x), x, x, x, x) +
40*diff(y(x), x, x, x)=0;

ode5:=9y''2y'''''45y''y'''y''''&plus;40y'''&equals;0

(32)
  

Classifying using odeadvisor (classifying ODEs is now a menu option available when "right clicking" on the ODE above)

odeadvisor(ode5);

_high_order&comma;_missing_x&comma;_high_order&comma;_missing_y&comma;_high_order&comma;_with_linear_symmetries

(33)
  

it is apparent that there are various possible departure points to start reducing the ODE order: the ODE is missing the dependent and independent variables, it also has linear symmetries. In connection with all these starting points there are the symmetries:

X5 := symgen(ode5);

X5:=_&xi;&equals;0&comma;_&eta;&equals;1&comma;_&xi;&equals;1&comma;_&eta;&equals;0&comma;_&xi;&equals;0&comma;_&eta;&equals;x&comma;_&xi;&equals;1&comma;_&eta;&equals;x&comma;_&xi;&equals;13x&comma;_&eta;&equals;y

(34)
  

The result above means, basically, that dsolve is able to solve the ODE by itself. With the purpose of illustrating the method, these symmetries are used below interactively to solve the ODE. The simplest manner of doing that is: reduce the order of the ODE by one and restart the discussion around this reduced ODE. When this approach is successful, build the solution to the original problem from the solution to the last reduced ODE. The steps below can be re-used with others ODE examples, as for instance the one solved interactively in the previous section by using integrating factors.

  

So we start reducing the order using just one of the symmetries above

OFF;    # Turn OFF the enhanced DEdisplay feature

R_5_to_4 := reduce_order(ode5, X5[1], u(t));

R_5_to_4:=yx&equals;&int;ut&DifferentialD;t&plus;_C1 &where &DifferentialD;4&DifferentialD;t4ut&equals;5&DifferentialD;2&DifferentialD;t2ut&DifferentialD;3&DifferentialD;t3ut&DifferentialD;&DifferentialD;tut409&DifferentialD;2&DifferentialD;t2ut&DifferentialD;&DifferentialD;tut2&comma;t&equals;x&comma;ut&equals;&DifferentialD;&DifferentialD;xyx&comma;x&equals;t&comma;yx&equals;&int;ut&DifferentialD;t&plus;_C1

(35)
  

The structure of the solution above contains the answer in terms of a new function, u(t), which satisfy the fourth order differential equation being shown.

  

Now select this fourth order ODE and consider the same cycle again (finding symmetries plus reducing its order again):

ode4 := op([2, 2, 1, 1], R_5_to_4);

ode4:=&DifferentialD;4&DifferentialD;t4ut&equals;5&DifferentialD;2&DifferentialD;t2ut&DifferentialD;3&DifferentialD;t3ut&DifferentialD;&DifferentialD;tut409&DifferentialD;2&DifferentialD;t2ut&DifferentialD;&DifferentialD;tut2

(36)

X4 := symgen(ode4);

X4:=_&xi;&equals;0&comma;_&eta;&equals;1&comma;_&xi;&equals;1&comma;_&eta;&equals;0&comma;_&xi;&equals;1&comma;_&eta;&equals;1&comma;_&xi;&equals;12t&comma;_&eta;&equals;u

(37)
  

With the symmetries of ode4 in hands we can proceed in the same way to obtain a reduction of order from 4 to 3, now expressing the third order differential equation in terms of a new function s(r)

R_4_to_3 := reduce_order(ode4, X4[1], s(r));

R_4_to_3:=ut&equals;&int;sr&DifferentialD;r&plus;_C1 &where &DifferentialD;3&DifferentialD;r3sr&equals;5&DifferentialD;&DifferentialD;rsr&DifferentialD;2&DifferentialD;r2srsr409&DifferentialD;&DifferentialD;rsrsr2&comma;r&equals;t&comma;sr&equals;&DifferentialD;&DifferentialD;tut&comma;t&equals;r&comma;ut&equals;&int;sr&DifferentialD;r&plus;_C1

(38)
  

Selecting the third order ODE and calculating its symmetries leads to

ode3 := op([2, 2, 1, 1], R_4_to_3);

ode3:=&DifferentialD;3&DifferentialD;r3sr&equals;5&DifferentialD;&DifferentialD;rsr&DifferentialD;2&DifferentialD;r2srsr409&DifferentialD;&DifferentialD;rsrsr2

(39)

X3 := symgen(ode3);

X3:=_&xi;&equals;1&comma;_&eta;&equals;0&comma;_&xi;&equals;r&comma;_&eta;&equals;s

(40)
  

These symmetries can be used to reduced the order further, obtaining a second order ODE - we choose z(v) as new unknown function:

R_3_to_2 := reduce_order(ode3, X3[1], z(v));

R_3_to_2:=sr&equals;v &where &DifferentialD;2&DifferentialD;v2zv&equals;3&DifferentialD;&DifferentialD;vzv2zv&plus;409zv3v2&plus;5&DifferentialD;&DifferentialD;vzvv&comma;v&equals;sr&comma;zv&equals;1&DifferentialD;&DifferentialD;rsr&comma;r&equals;&int;zv&DifferentialD;v&plus;_C1&comma;sr&equals;v

(41)

ode2 := op([2, 2, 1, 1], R_3_to_2);

ode2:=&DifferentialD;2&DifferentialD;v2zv&equals;3&DifferentialD;&DifferentialD;vzv2zv&plus;409zv3v2&plus;5&DifferentialD;&DifferentialD;vzvv

(42)
  

One more cycle reduce the problem to a first order linear ODE which is a problem having solution in the general case in terms of integrals

X2 := symgen(ode2);

X2:=_&xi;&equals;0&comma;_&eta;&equals;z3&comma;_&xi;&equals;v&comma;_&eta;&equals;0

(43)

R_2_to_1 := reduce_order(ode2, X2[1], a(b));

R_2_to_1:=zv&equals;12&int;ab&DifferentialD;b&plus;_C1 &where &DifferentialD;&DifferentialD;bab&equals;5abb&plus;409b2&comma;b&equals;v&comma;ab&equals;&DifferentialD;&DifferentialD;vzvzv3&comma;v&equals;b&comma;zv&equals;12&int;ab&DifferentialD;b&plus;_C1

(44)

ode1 := op([2, 2, 1, 1], R_2_to_1);

ode1:=&DifferentialD;&DifferentialD;bab&equals;5abb&plus;409b2

(45)
  

The answer to this easy ODE found at the end of the reduction process is

sol1 := dsolve(ode1);

sol1:=ab&equals;2027b6&plus;_C1b5

(46)
  

Now, how could we build the solution to the original fifth order ode5? As follows: first use this solution above to build the solution to ode2 (the second order ODE one step above and rename integration constants which appeared as _C1 in all reductions):

buildsol(subs(_C1=_C2, R_2_to_1), sol1);

zv&equals;12&int;v5_C12027v&DifferentialD;v&plus;_C2

(47)
  

The integral can be evaluated via

sol2 := value((47));

sol2:=zv&equals;1216_C1v62027lnv&plus;_C2

(48)
  

And now repeat the process until arriving at the solution to the original fifth order ode

sol3 := buildsol(subs(_C1=_C3, R_3_to_2), sol2);

sol3:=sr&equals;RootOfr&plus;33&int;_Z19_C1_a6&plus;40ln_a54_C2&DifferentialD;_a&plus;_C3

(49)

sol4 := buildsol(subs(_C1=_C4, R_4_to_3), sol3);

sol4:=ut&equals;&int;RootOft&plus;33&int;_Z19_C1_a6&plus;40ln_a54_C2&DifferentialD;_a&plus;_C3&DifferentialD;t&plus;_C4

(50)

sol5 := buildsol(subs(_C1=_C5, R_5_to_4), sol4);

sol5:=yx&equals;&int;&int;RootOfx&plus;33&int;_Z19_C1_a6&plus;40ln_a54_C2&DifferentialD;_a&plus;_C3&DifferentialD;x&plus;_C4&DifferentialD;x&plus;_C5

(51)
  

This result can be tested using odetest

odetest(sol5, ode5);

0

(52)
  

For more examples see dsolve, Lie, , reduce_order and the help pages linked from DEtools, Lie.

• 

Also interesting in the symmetry approach is the inverse problem; that is: to determine the most general ODE family having given symmetries (see equinv), or the symmetries of an 'unknown' ODE when its solution is given (see buildsym). Combining these two tools it is possible to depart from the form of the solution and arrive at the most general ODE problem having the symmetries of that type of solution (examples are found in the mentioned help-pages).

Singular solutions for nonlinear ODEs

• 

In addition to the general solution, Nonlinear ODEs may also have singular solutions (see references). When the ODE is polynomial in the unknown function y(x) and its derivatives, these singular solutions can be obtained separately by first splitting the ODE problem into cases. For example, consider

ON;     # Turn ON the enhanced DEdisplay

ode := (y(x)*diff(y(x), x, x)-diff(y(x), x)^2)*diff(y(x), x, x, x, x)-diff(y(x), x, x)^3
-y(x)*diff(y(x), x, x, x)^2+2*diff(y(x), x)*diff(y(x), x, x)*diff(y(x), x, x, x);

ode:=yy''y'2y''''y''3yy'''2&plus;2y'y''y'''

(53)
  

The set of general and singular solutions to this ODE is given by the union of the non-singular solutions to each of the following ODEs:

casesplit(ode);

y''''&equals;yy'''22y'y''y'''&plus;y''3yy''y'2 &where yy''y'20&comma;y''&equals;y'2y &where y0&comma;y&equals;0 &where

(54)
  

In above we see three cases. The first one, which has the same differential order of the original problem ode leads to the general solution. The two second cases are of lower differential order and lead to singular solutions. So for this example dsolve returns

dsolve(ode);

y&equals;12&ExponentialE;x_C1_C3_C12&plus;4_C2x_C12&plus;4_C2&plus;2_C4&ExponentialE;12_C3_C12&plus;4_C2&plus;12x_C12&plus;4_C22&plus;1&comma;y&equals;12&ExponentialE;x_C1_C3_C12&plus;4_C2x_C12&plus;4_C2&plus;2_C4&ExponentialE;12_C3_C12&plus;4_C2&plus;12x_C12&plus;4_C22&plus;1

(55)
  

In some cases (e.g.: the one above) some of the singular solutions can be obtained by adjusting the integration constants in the other solutions (general or singular).

See Also

odeadvisor

dsolve, formal_series

dsolve, ICs

dsolve, inttrans

dsolve, Lie

dsolve, linear

dsolve, numeric

dsolve, piecewise

dsolve, series

dsolve, system

infolevel

DEtools

PDEtools

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam