Differential Equations - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : System : Information : Updates : Maple 9.5 : Differential Equations

Updates to Differential Equation (DE) Solvers in Maple 9.5

  

In Maple 9.5, the power of the differential equation solvers has been increased for computing both exact and numeric DEs solutions regarding various aspects.

 

Summary

Exact Solutions

Numeric Solutions

The Differential Equation Packages: DEtools, PDEtools and diffalg

Summary

The dsolve and pdsolve Commands: Exact Solutions

• 

Important efficiency improvements for difficult first order Abel type ODE problems.

• 

New solving algorithms for Riccati type ODEs.

• 

New solving algorithms for second order linear ODEs of Mathieu type.

• 

Hypergeometric solutions free of integrals for linear ODEs, exploring the automorphisms of the 2F1 equation.

• 

New methods for initial value ODE problems.

• 

New methods for piecewise ODEs.

• 

New solving algorithms for computing polynomial solutions for nonlinear ODEs and systems of them.

• 

New solving algorithms for linear and nonlinear PDEs and systems of them.

The dsolve and pdsolve Commands: Numeric Solutions

• 

Three new numerical solution methods for Differential-Algebraic ODE initial value (stiff and non-stiff) problems.

• 

New optimization option, useful for large or complex systems, results in a speed improvement by a factor of up to 30 times.

• 

New implicit option for the stiff IVP solver (rosenbrock), useful for large, dense ODE systems.

• 

The dsolve[interactive] assistant (Maplet interface) now permits interactive numerical solution of DAE problems.

The Differential Equation Packages: DEtools, PDEtools, and diffalg

• 

Seven new commands were added to DEtools, including the rewritten polysols command, which can now compute polynomial solutions to linear and nonlinear ODE systems, and the new diff_table command that greatly simplifies the notation used to input differential equations.

• 

New command for computing Traveling Wave Solutions in the PDEtools package.

• 

New capabilities in the diffalg package to compute using algebraic triangular techniques instead of Groebner basis.

Exact Solutions

Ordinary Differential Equations (ODEs)

Abel Equations: 40% Faster

  

Important efficiency improvement in the methods for first order ODEs of Abel type: The dsolve command's computational time for all parameterized Abel ODE classes is reduced almost 40 % compared with previous releases. This is achieved using new specialized subroutines for computing resultants using modular arithmetics. In addition, some families of Abel equations in second kind format, which can be transformed into Riccati equations, are handled in 1/10 or less of the previous computational time.

  

Example

diff(y(x),x) = -y(x)/(y(x)+x*(-x+a-1));

ⅆⅆxyx=yxyx+xx+a1

(1)

dsolve((1), y(x));

c__1+xBesselJa1,2yxBesselJa,2yxyxxBesselYa1,2yxBesselYa,2yxyx=0

(2)

New Methods for Riccati Equations

  

A new solving method for a Riccati family depending on two arbitrary functions, which explores different forms of the symmetries of first order Riccati equations, is available.

  

Example

  

The Riccati first order ODE family:

PDEtools[declare]((y,F,G)(x), prime=x);

yxwill now be displayed asy

Fxwill now be displayed asF

Gxwill now be displayed asG

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

(3)

diff(y(x),x) = G(x)*y(x)^2 - (diff(F(x),x)+2*G(x)*F(x)^2)/F(x)*y(x) + (2*F(x)*diff(F(x),x)+G(x)*F(x)^3)/F(x);

diffyx,x=Gxyx2diffFx,x+2GxFx2yxFx+2FxdiffFx,x+GxFx3Fx

(4)
  

Independent of the values of the functions F,G, a solution is now always computable as:

dsolve((4), y(x));

yx=IntGxFx,xFx2+c__1Fx21FxIntGxFx,x+c__1

(5)
  

The new method extends the solving capabilities for second order linear ODEs with non-rational coefficients. Independent of the value of G, a solution for the following ODE is now always computable.

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

diffdiffyx,x,x=2expxGx2Gx+diffGx,xdiffyx,xGxGx2expx+Gxexp2xyx

(6)

sol := dsolve((6), y(x));

yx=expIntIntGxexpx,xexp6x+c__1exp6xexp4xGxexp5xIntGxexpx,x+c__1,xc__2

(7)
  

The computation of the integrals depends on the particular value of G. ODE solutions can be tested by entering odetest(sol, ode). For more information, see odetest.

New Methods for Mathieu Equations

  

A new algorithm was implemented for computing Mathieu function solutions for second order linear ODEs by resolving an equivalence similar to the one formulated in previous Maple releases to compute hypergeometric 2F1, 1F1, 0F1 solutions.

  

Example

  

The equation number 2.268 from Kamke's book:

ode := 2*x*(x-1)*diff(y(x),x,x)+(2*x-1)*diff(y(x),x)+(mu*x+nu)*y(x) = 0;

2x1+xdiffdiffyx,x,x+2x1diffyx,x+μx+νyx=0

(8)

dsolve(ode);

yx=c__1MathieuCμ2ν,12μ,arccosx+c__2MathieuSμ2ν,12μ,arccosx

(9)

New Methods for Second Order Linear ODEs Admitting Hypergeometric Solutions

  

For ODEs that admit 2F1 hypergeometric solutions, when possible, the solutions are now systematically expressed using special functions instead of uncomputed integrals. This is achieved exploring the automorphisms of the 2F1 equation. For more information, see dsolve,references.

  

Example

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

diffdiffyx,x,x=x2+1diffyx,xx1+xx+1+yx1+xx+1

(10)

dsolve(ode);             # New output free of uncomputed integrals

yx=c__1xLegendreP12,1,x2+1x21x21+c__2xLegendreQ12,1,x2+1x21x21

(11)

New Methods for Initial Value ODE Problems

  

Computing solutions for initial value ODE problems in more difficult cases:

  

Example

ode := diff(y(x),x) = 1/(x-y(x)); # Abel type ODE

diffyx,x=1xyx

(12)

sol := dsolve({ode, y(0) = 1});   # correct branch for LambertW

yx=LambertW1,2exp2+x1+x

(13)

simplify( eval(sol, x = 0) );     # verifying initial condition

y0=1

(14)
  

Note also that, new in Maple 9.5, odetest can test that dsolve's output also satisfies the initial conditions of the problem.

odetest( sol, [ode, y(0) = 1]);   # verifies 'sol' solves the ode and satisfies y(0) = 1

0,0

(15)

New Methods for Piecewise ODEs

  

Example

ode := diff(diff(y(x),x),x) + piecewise(x < 1/2, 1, 1/2 <= x, 0) * y(x) = 0;

diffdiffyx&comma;x&comma;x&plus;piecewisex<12&comma;1&comma;12x&comma;0yx&equals;0

(16)

initial_values := y(0)=1, D(y)(0)=1;

initial_valuesy0=1,Dy0=1

(17)

dsolve( {ode, initial_values} );

yx&equals;piecewisex<12&comma;sinx&plus;cosx&comma;12x&comma;cos12x&plus;32sin12&plus;12cos12sin12x

(18)
  

For linear problems, like the previous one, when possible, the new routines return a solution that is continuous at the point where the piecewise function changes branches (in this example, at x = 1/2).

New Methods for Polynomial Solutions for Nonlinear ODEs

  

The DEtools[polysols] command was rewritten to compute polynomial solutions for nonlinear ODEs and systems of them.

  

Example

  

This is equation 14 from the section on nonlinear higher order ODEs in Kamke's book.

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

diffyx&comma;xdiffdiffdiffdiffyx&comma;x&comma;x&comma;x&comma;xdiffdiffyx&comma;x&comma;xdiffdiffdiffyx&comma;x&comma;x&comma;x&plus;diffyx&comma;x3diffdiffdiffyx&comma;x&comma;x&comma;x&equals;0

(19)
  

The general solution to this equation is not known. Attempting its computation using dsolveode, we obtain a partial solution, a reduction of order from 4 to 1. It is in difficult problems like this one that the new routines for computing polynomial solutions can play a crucial role. This equation, in fact, admits polynomial solutions.

ans := DEtools[polysols]( ode );

yx&equals;_C5x2&plus;_C4x&plus;_C3

(20)
  

Although this solution, depending only on three arbitrary constants, is not the most general for the given fourth order equation, it still has an important level of generality and is the most general solution presently known.

New Routines for Testing ODE Initial Conditions and Piecewise Implicit ODE Solutions

  

Example

  

An ODE problem with initial conditions

ode := [diff(y(x),x)=sin(x-y(x)), y(0) = 8];

diffyx&comma;x&equals;sinxyx&comma;y0&equals;8

(21)

sol := dsolve(ode);     # new solution in Maple 9.5

yx&equals;x2arctantan4x2tan4&plus;xtan4x&plus;x&plus;2&plus;2&pi;

(22)

odetest( sol, ode );    # verifies 'sol' solves the ode and satisfies y(0) = 8

0&comma;0

(23)

Partial Differential Equations (PDEs)

  

There are important improvements and new options for solving both linear and nonlinear PDE systems.

  

Examples

  

A linear PDE system for one unknown fx&comma;y&comma;z. You can use the new diff_table to avoid redundant typing when inputting the equations.

restart;

F := DEtools[diff_table]( f(x,y,z) ):

sys := [x*F[x,x] + (y+1)*F[x,y] + z*F[x,z] = 0,
    x*F[x,y] + (y+1)*F[y,y] + z*F[y,z] = 0,
    x*F[x,z] + (y+1)*F[y,z] + z*F[z,z] = 0 ];

sysx2x2fx&comma;y&comma;z+y+12xyfx&comma;y&comma;z+z2xzfx&comma;y&comma;z=0&comma;x2xyfx&comma;y&comma;z+y+12y2fx&comma;y&comma;z+z2yzfx&comma;y&comma;z=0&comma;x2xzfx&comma;y&comma;z+y+12yzfx&comma;y&comma;z+z2z2fx&comma;y&comma;z=0

(24)
  

The general solution involving two arbitrary functions of one and two arguments respectively is:

pdsolve(sys);

fx&comma;y&comma;z=f__5zxx+c__1+f__4zx&comma;y+1xx

(25)
  

The new technique is equivalent to computing differential invariants for the problem.

  

A nonlinear PDE depending on two parameters p&comma;q: the Korteweg - de Vries (KdV) Burgers' equation that occurs in various physical systems:

U := DEtools[diff_table]( u(x,t) ):

pde := U[t] + U[]*U[x] - p * U[x,x] + q * U[x,x,x] = 0;

pdep2x2ux&comma;t+q3x3ux&comma;t+ux&comma;txux&comma;t+tux&comma;t=0

(26)

pdsolve(pde);

ux&comma;t=3p2tanhc__3tpx10q+c__1225q+6p2tanhc__3tpx10q+c__125q+250c__3q2+3p325qp

(27)
  

For examples of TWS for PDE systems, see PDEtools[TWSolutions].

  

To move to the corresponding section of this page, click Summary, Exact Solutions, Numeric Solutions, DEtools, PDEtools, or diffalg.

Numeric Solutions

Numeric Solution of DAE Problems

  

Maple now has three numerical solution methods for Differential-Algebraic ODE initial value problems. The first of these is the Modified Extended Backward Difference Implicit mebdfi method, which is a direct solution method for DAE problems. The other two are extensions of Maple's default stiff and non-stiff ODE solvers, that is, rkf45_dae and rosenbrock_dae.

  

The latter methods are a combination of modifications to the default solvers, and an extension of the system to more closely resemble a standard ODE system (called index reduction and addition of a projection step to the solvers).

  

For many problems, DAE systems can be automatically recognized, and sent to the correct solver, but in some cases the method must be specified.

  

Example

  

Basic pendulum:

restart;

psys := {diff(x(t),t,t) = -2*lambda(t)*x(t),
         diff(y(t),t,t) = -2*lambda(t)*y(t)-9.8,
         x(t)^2+y(t)^2 = 1,
         x(0)=0, D(x)(0)=0.1, y(0)=-1, D(y)(0)=0};

psysxt2+yt2=1&comma;&DifferentialD;2&DifferentialD;t2xt=2λtxt&comma;&DifferentialD;2&DifferentialD;t2yt=2λtyt9.8&comma;x0=0&comma;y0=−1&comma;Dx0=0.1&comma;Dy0=0

(28)

psol := dsolve(psys, numeric);

psolprocx_rkf45_dae...end proc

(29)

psol(1);

t=1.&comma;λt=4.90499905723651&comma;xt=0.000360891517794992&comma;&DifferentialD;&DifferentialD;txt=−0.0999937504894365&comma;yt=−0.999999934755133&comma;&DifferentialD;&DifferentialD;tyt=−0.0000360794101890703

(30)
  

In addition, the extension methods have the implicit option, which is quite useful for problems that are complicated and dense.

Optimization

  

Maple's numerical DE solvers now accept the optimization argument, which controls whether the procedures used in computing the numerical solution are optimized for efficient solutions.

  

By default, this option is true for the DAE numerical solvers, and false for all other solvers (IVP and BVP) because generally the DAE case requires this option to compute solutions in a reasonable amount of time.

  

The option is most useful for large or complex systems. For example:

dsys := {
  3/10*cos(beta(t))*diff(beta(t),t)^2+3/10*sin(beta(t))*diff(beta(t),t,t)+
    diff(s(t),t,t),
  2/25*sin(theta(t))*diff(theta(t),t)^2-2/25*cos(theta(t))*diff(theta(t),t,t)
    +3/10*sin(eta(t))*diff(eta(t),t)^2*sin(beta(t))-3/10*cos(eta(t))
    *diff(eta(t),t,t)*sin(beta(t))-3/5*cos(eta(t))*diff(eta(t),t)*cos(beta(t))
    *diff(beta(t),t)+3/10*sin(eta(t))*sin(beta(t))*diff(beta(t),t)^2
    -3/10*sin(eta(t))*cos(beta(t))*diff(beta(t),t,t),
  -2/25*cos(theta(t))*diff(theta(t),t)^2-2/25*sin(theta(t))*diff(theta(t),t,t)
    -3/10*cos(eta(t))*diff(eta(t),t)^2*sin(beta(t))-3/10*sin(eta(t))
    *diff(eta(t),t,t)*sin(beta(t))-3/5*sin(eta(t))*diff(eta(t),t)*cos(beta(t))
    *diff(beta(t),t)-3/10*cos(eta(t))*sin(beta(t))*diff(beta(t),t)^2
    +3/10*cos(eta(t))*cos(beta(t))*diff(beta(t),t,t),
  4/15*(-61/4000*sin(eta(t))*sin(theta(t))+9/800*sin(eta(t))*sin(theta(t))
    *cos(beta(t))^2-61/4000*cos(theta(t))*cos(eta(t))+9/800*cos(theta(t))
    *cos(eta(t))*cos(beta(t))^2)/sin(beta(t))*diff(eta(t),t,t)-4/15
    *(217/20000*sin(theta(t))*cos(eta(t))-9/400*sin(theta(t))*cos(eta(t))
    *cos(beta(t))^2-217/20000*sin(eta(t))*cos(theta(t))+9/400*sin(eta(t))
    *cos(theta(t))*cos(beta(t))^2)/cos(beta(t))*diff(beta(t),t,t)
    -9/50*(sin(theta(t))*cos(eta(t))-sin(eta(t))*cos(theta(t)))*sin(beta(t))
    /cos(beta(t))*diff(s(t),t,t)+73/250000*diff(theta(t),t,t)
    -3/500*sin(beta(t))*diff(beta(t),t)^2*sin(theta(t))*cos(eta(t))-3/1000
    *sin(beta(t))*diff(eta(t),t)^2*sin(theta(t))*cos(eta(t))+3/1000
    *sin(eta(t))*sin(beta(t))*diff(eta(t),t)^2*cos(theta(t))+3/500
    *sin(beta(t))*diff(beta(t),t)^2*sin(eta(t))*cos(theta(t))-30411/125000
    *sin(theta(t))-3/500*sin(eta(t))*cos(beta(t))*diff(beta(t),t)
    *diff(eta(t),t)*sin(theta(t))-3/500*cos(beta(t))*diff(beta(t),t)
    *diff(eta(t),t)*cos(theta(t))*cos(eta(t))};

dsys3cosβt&DifferentialD;&DifferentialD;tβt210+3sinβt&DifferentialD;2&DifferentialD;t2βt10+&DifferentialD;2&DifferentialD;t2st&comma;2cosθt&DifferentialD;&DifferentialD;tθt2252sinθt&DifferentialD;2&DifferentialD;t2θt253cosηt&DifferentialD;&DifferentialD;tηt2sinβt103sinηt&DifferentialD;2&DifferentialD;t2ηtsinβt103sinηt&DifferentialD;&DifferentialD;tηtcosβt&DifferentialD;&DifferentialD;tβt53cosηtsinβt&DifferentialD;&DifferentialD;tβt210+3cosηtcosβt&DifferentialD;2&DifferentialD;t2βt10&comma;2sinθt&DifferentialD;&DifferentialD;tθt2252cosθt&DifferentialD;2&DifferentialD;t2θt25+3sinηt&DifferentialD;&DifferentialD;tηt2sinβt103cosηt&DifferentialD;2&DifferentialD;t2ηtsinβt103cosηt&DifferentialD;&DifferentialD;tηtcosβt&DifferentialD;&DifferentialD;tβt5+3sinηtsinβt&DifferentialD;&DifferentialD;tβt2103sinηtcosβt&DifferentialD;2&DifferentialD;t2βt10&comma;461sinηtsinθt4000+9sinηtsinθtcosβt280061cosθtcosηt4000+9cosθtcosηtcosβt2800&DifferentialD;2&DifferentialD;t2ηt15sinβt4217sinθtcosηt200009sinθtcosηtcosβt2400217sinηtcosθt20000+9sinηtcosθtcosβt2400&DifferentialD;2&DifferentialD;t2βt15cosβt9sinθtcosηtsinηtcosθtsinβt&DifferentialD;2&DifferentialD;t2st50cosβt+73&DifferentialD;2&DifferentialD;t2θt2500003sinβt&DifferentialD;&DifferentialD;tβt2sinθtcosηt5003sinβt&DifferentialD;&DifferentialD;tηt2sinθtcosηt1000+3sinηtsinβt&DifferentialD;&DifferentialD;tηt2cosθt1000+3sinβt&DifferentialD;&DifferentialD;tβt2sinηtcosθt50030411sinθt1250003sinηtcosβt&DifferentialD;&DifferentialD;tβt&DifferentialD;&DifferentialD;tηtsinθt5003cosβt&DifferentialD;&DifferentialD;tβt&DifferentialD;&DifferentialD;tηtcosθtcosηt500

(31)

ics := {eta(0) = arcsin(1/sqrt(5)), D(eta)(0)=-48/25,
        s(0)=1/5, D(s)(0)=6/25,
        theta(0)=0, D(theta)(0)=-6,
        beta(0) = -arccos(2/3), D(beta)(0) = 12*sqrt(5)/25};

icsβ0=arccos23&comma;η0=arcsin55&comma;s0=15&comma;θ0=0&comma;Dβ0=12525&comma;Dη0=4825&comma;Ds0=625&comma;Dθ0=−6

(32)

dsn1 := dsolve(dsys union ics,numeric);

dsn1procx_rkf45...end proc

(33)

tt := time(): dsn1(5); time1 := time()-tt;

t=5.&comma;βt=−0.440221710805809&comma;&DifferentialD;&DifferentialD;tβt=3.61399010461755&comma;ηt=0.159001441306591&comma;&DifferentialD;&DifferentialD;tηt=0.623236063947850&comma;st=0.271397346852253&comma;&DifferentialD;&DifferentialD;tst=0.462019863043112&comma;θt=−51.7583332393869&comma;&DifferentialD;&DifferentialD;tθt=−12.3007185226169

time11.014

(34)

dsn2 := dsolve(dsys union ics,numeric,optimize=true);

dsn2procx_rkf45...end proc

(35)

tt := time(): dsn2(5); time2 := time()-tt;

t=5.&comma;βt=−0.440221710801970&comma;&DifferentialD;&DifferentialD;tβt=3.61399010465201&comma;ηt=0.159001441307698&comma;&DifferentialD;&DifferentialD;tηt=0.623236064057435&comma;st=0.271397346852741&comma;&DifferentialD;&DifferentialD;tst=0.462019863043752&comma;θt=−51.7583332393983&comma;&DifferentialD;&DifferentialD;tθt=−12.3007185227680

time20.120

(36)

`Speed increase factor`=time1/time2;

Speed increase factor=8.450000000

(37)

Other Items

  

The default Maple stiff IVP solver (rosenbrock) now accepts the implicit argument, making it possible to obtain efficient numerical solutions for large, dense systems of ODEs. For more information, see dsolve[rosenbrock].

  

The dsolve[interactive] assistant (Maplet interface) has been updated to allow interactive numerical solution of DAE problems via the new DAE solvers previously mentioned.

  

To move to the corresponding section of this page, click Summary, Exact Solutions, Numeric Solutions, DEtools, PDEtools, or diffalg.

The Differential Equation Packages: DEtools, PDEtools and diffalg

DEtools

  

In connection with important enhancements in the differential equation solvers dsolve and pdsolve, seven new commands, some based on original algorithms, are available in DEtools in this release.

Avoiding Redundant Typing: The New diff_table Command

  

The diff_table command is basically the inverse facility of PDEtools[declare]: it permits entering (input) expressions and their derivatives using compact mathematical notation, without using macros or aliases. The notation implemented by diff_table is the jet notation also used by the diffalg package and greatly reduces redundant typing.

  

Example

  

Let U and V be the "differentiation tables" of ux&comma;y&comma;t and vx&comma;y&comma;t - that is, a handy representations for these objects and their derivatives.

U := DEtools[diff_table]( u(x,y,t) ):

V := DEtools[diff_table]( v(x,y,t) ):

  

You can now input the functions ux&comma;y&comma;t or vx&comma;y&comma;t or any of its partial derivatives using mathematical notation directly, resulting in the expected expression on output.

e1 := U[y,t] + V[x,x] + U[x]*U[y] + U[]*U[x,y];

e1ux&comma;y&comma;t2xyux&comma;y&comma;t+xux&comma;y&comma;tyux&comma;y&comma;t+2tyux&comma;y&comma;t+2x2vx&comma;y&comma;t

(38)
  

diff_table can be used simultaneously with PDEtools[declare] so that both input and display are simplified while the contents of the expressions generated are as expected.

Polynomial Solutions for Nonlinear ODEs and Systems of Them

  

The DEtools[polysols] command was rewritten to compute polynomial solutions for nonlinear ODEs and systems of them and also for linear ODE systems. The new functionality uses the LinearFunctionalSystems package, in the case of linear ODEs, and the subroutines of the new PDEtools[TWSolutions] in the case of nonlinear ODEs. For advanced users, this new DEtools[polysols] includes programmer entry points for the different types of problems it can handle.

  

Examples

  

A linear ODE system:

sys := [diff(y1(x), x) - y2(x), diff(y2(x), x) - y3(x) - y4(x), diff(y3(x), x) - y5(x) = 0,
        diff(y4(x), x) - 2*y1(x) - 2*x*y2(x) - y5(x) = 0,
        diff(y5(x), x) - x^2*y1(x) - 2*x*y3(x) - y6(x) = 0,
        diff(y6(x), x) - x^2*y2(x) + 2*y3(x) = 0];

sys&DifferentialD;&DifferentialD;xy1xy2x&comma;&DifferentialD;&DifferentialD;xy2xy3xy4x&comma;&DifferentialD;&DifferentialD;xy3xy5x=0&comma;&DifferentialD;&DifferentialD;xy4x2y1x2xy2xy5x=0&comma;&DifferentialD;&DifferentialD;xy5xx2y1x2xy3xy6x=0&comma;&DifferentialD;&DifferentialD;xy6xx2y2x+2y3x=0

(39)
  

In addition to the new functionality for computing solutions for ODE systems, a new option, output = solution, causes the polysols command to return output in the same closed form format used by the dsolve command, instead of a list of the solution basis for the linear system. Also, similar to the Maple dsolve command, the dependent variables of the system do not need to be specified unless really necessary.

DEtools[polysols](sys, output = solution);

Warning, received no explicit list of solving variables. The output corresponds to the ordered list [y1(x), y2(x), y3(x), y4(x), y5(x), y6(x)]

y1x=_C3x+_C2&comma;y2x=_C3&comma;y3x=_C3x2_C2x+_C1&comma;y4x=_C3x2+_C2x_C1&comma;y5x=2_C3x_C2&comma;y6x=_C3x3+_C2x22_C1x2_C3

(40)
  

A nonlinear ODE of seventh order depending on three parameters a&comma;b&comma;c:

U := DEtools[diff_table]( u(t) ):

ODE := ((-a*t^2+a)*U[]-1/2159 * (13185*a^3*c*t^2-4335*a^3*c + 315*a^3*c*t^6-525*a^3*c*t^4+259080*a^5*t^4 - 259080*a^5*t^2+34544*a^5+2159*b) * (t+1)*(t-1))*U[t]-5/4318*a^3*(t+1)^4 * (t-1)^4*(105*t^2*c+17272*a^2-35*c)*t*U[t$4] - 1/17272*a^3*(t+1)^5*(t-1)^5*(315*t^2*c+17272*a^2-35*c)*U[t$5] - 15/2159*a^3*(63*t^4*c-70*t^2*c+34544*a^2*t^2+879*c - 17272*a^2)*t*(t+1)^2*(t-1)^2*U[t,t] - 5/4318*a^3*(315*t^4*c+103632*a^2*t^2-210*t^2*c+879*c-17272*a^2)*(t+1)^3*(t-1)^3*U[t$3] - 21/17272*c*a^3*(-1+t^2)^6*t*U[t$6]-1/34544*c*a^3*(-1+t^2)^7*U[t$7] = 0;

ODEat2+aut315a3ct6+259080a5t4525a3ct4259080a5t2+13185a3ct2+34544a54335a3c+2159bt+1t12159&DifferentialD;&DifferentialD;tut5a3t+14t14105t2c+17272a235ct&DifferentialD;4&DifferentialD;t4ut4318a3t+15t15315t2c+17272a235c&DifferentialD;5&DifferentialD;t5ut1727215a363t4c+34544a2t270t2c17272a2+879ctt+12t12&DifferentialD;2&DifferentialD;t2ut21595a3315t4c+103632a2t2210t2c17272a2+879ct+13t13&DifferentialD;3&DifferentialD;t3ut431821ca3t216t&DifferentialD;6&DifferentialD;t6ut17272ca3t217&DifferentialD;7&DifferentialD;t7ut34544=0

(41)
  

In addition to the new functionality for solving nonlinear ODEs and systems of them, a new option, parameters = {...}, causes the polynomial solutions to be computed taking into account all possible values of the parameters (in this example a&comma;b&comma;c) which could lead to more solutions. In other words, the parameters become solving variables too. The approach uses differential algebra techniques.

DEtools[polysols](ODE, parameters={a,b,c});

a=a&comma;b=b&comma;c=c&comma;ut=_C3&comma;a=a&comma;b=109525a5_C3a&comma;c=2159a225&comma;ut=83165a4t6332645a4t4+8316a4t2+_C3&comma;a=0&comma;b=0&comma;c=c&comma;ut=_C9t6+_C8t5+_C7t4+_C6t3+_C5t2+_C4t+_C3

(42)
  

For definitions and more information, see DEtools[polysols].

FunctionDecomposition

  

A new command, DEtools[FunctionDecomposition], is available to perform rational function decomposition on overdetermined systems with parameters. The new command efficiently solves this problem, which appears frequently when solving differential equations using an equivalence approach.

  

Example

with(DEtools, FunctionDecomposition):

  

Consider the following rational system with three equations.

sys :=
[1/4*(9*C-15*F(x)*C+15*C^2*F(x)^3+2-4*C*F(x)^2+2*C^2*F(x)^4)^3/C^3/(1-
F(x)+C*F(x)^3)^5 =
9/4*x^3*(4+30*x-12*x^2-45*x^3+36*x^4)^3/(-3*x^2+2+3*x^3)^5,
C*(4*C^3*F(x)^7-4*F(x)+135*C+60*C^3*F(x)^6+315*C^2*F(x)^3-315*F(x)*C-
60*C^2*F(x)^4-12*C^2*F(x)^5-60*C*F(x)^2+60+12*C*F(x)^3)*(1-F(x)+C*F(x)^
3)/(9*C-15*F(x)*C+15*C^2*F(x)^3+2-4*C*F(x)^2+2*C^2*F(x)^4)^2 =
1/3*(-3*x^2+2+3*x^3)*(16-72*x^2+1998*x^4+240*x-360*x^3-540*x^5-2889*x^
6+2025*x^7)/x^2/(4+30*x-12*x^2-45*x^3+36*x^4)^2,
1/4*(4*C^3*F(x)^7-4*F(x)+135*C+60*C^3*F(x)^6+315*C^2*F(x)^3-315*F(x)*C
-60*C^2*F(x)^4-12*C^2*F(x)^5-60*C*F(x)^2+60+12*C*F(x)^3)*(9*C-15*F(x)*
C+15*C^2*F(x)^3+2-4*C*F(x)^2+2*C^2*F(x)^4)/C^2/(1-F(x)+C*F(x)^3)^4 =
3/4*(16-72*x^2+1998*x^4+240*x-360*x^3-540*x^5-2889*x^6+2025*x^7)*x*(4+
30*x-12*x^2-45*x^3+36*x^4)/(-3*x^2+2+3*x^3)^4];

sys9C15FxC+15C2Fx3+24CFx2+2C2Fx434C31Fx+CFx35=9x336x445x312x2+30x+4343x33x2+25&comma;C4C3Fx74Fx+135C+60C3Fx6+315C2Fx3315FxC60C2Fx412C2Fx560CFx2+60+12CFx31Fx+CFx39C15FxC+15C2Fx3+24CFx2+2C2Fx42=3x33x2+22025x72889x6540x5+1998x4360x372x2+240x+163x236x445x312x2+30x+42&comma;4C3Fx74Fx+135C+60C3Fx6+315C2Fx3315FxC60C2Fx412C2Fx560CFx2+60+12CFx39C15FxC+15C2Fx3+24CFx2+2C2Fx44C21Fx+CFx34=32025x72889x6540x5+1998x4360x372x2+240x+16x36x445x312x2+30x+443x33x2+24

(43)
  

Each of these equations is of the form (J o F)(x) = H(x) with {J[i], H[i]} known. We want to find C such that a solution F(x), F' <> 0, exists, including computing F. In this system, the first equation is rational in x, with degree 15 in the numerator and degree 15 in the denominator, the second rational equation has degrees 10 and 10, and the last has degrees 12 and 12. The solution for this problem is:

FunctionDecomposition(sys, F(x), C);

C=23,Fx=1x

(44)
  

The FunctionDecomposition command can quickly solve problems similar to the previous one. For more complex and difficult problems, see FunctionDecomposition.

Singularities

  

A new command, DEtools[singularities], is available to compute the regular and irregular singular points of a homogeneous linear ODE of arbitrary order. Given such an ODE with rational coefficients Ai, x0 is a singular point of the equation if any of the coefficients Ai has an isolated singularity at it.

  

Example

  

The confluent 1F1 hypergeometric linear equation

ODE_1F1 := DEtools[hyperode]( hypergeom([a],[c], x), y(x)) = 0;

ODE_1F1ayx+c+x&DifferentialD;&DifferentialD;xyxx&DifferentialD;2&DifferentialD;x2yx=0

(45)
  

has one regular singularity at zero and one irregular singularity at infinity.

DEtools[singularities]( ODE_1F1 );

regular=0,irregular=

(46)

The ODE for the Integral and the Derivative of an Unknown

  

Given a nth order linear ODE for yx, the ode_int_y and ode_y1 commands respectively compute the nth order linear ODE satisfied by yx&DifferentialD;x and &DifferentialD;&DifferentialD;xyx.

  

Examples

  

To use simplified input and enhanced display, use DEtools[diff_table] and PDEtools[declare].

with(DEtools, diff_table, ode_int_y, ode_y1);

diff_table&comma;ode_int_y&comma;ode_y1

(47)

Y := diff_table( y(x) ):   # Y[] = y(x)

PDEtools[declare](y(x), c(x), prime=x);

yxwill now be displayed asy

cxwill now be displayed asc

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

(48)
  

Now, if y satisfies

c[0](x)*Y[] + c[1](x)*Y[x] + c[2](x)*Y[x,x] + Y[x,x,x,x] = 0;

c0xyx&plus;c1xdiffyx&comma;x&plus;c2xdiffdiffyx&comma;x&comma;x&plus;diffdiffdiffdiffyx&comma;x&comma;x&comma;x&comma;x&equals;0

(49)
  

then the derivative of y satisfies

DEtools[ode_y1]( (49) ) = 0;

diffdiffdiffdiffyx&comma;x&comma;x&comma;x&comma;xdiffc0x&comma;xdiffdiffdiffyx&comma;x&comma;x&comma;xc0x&plus;c2xdiffdiffyx&comma;x&comma;xdiffc0x&comma;xc2xc1xc0xdiffc2x&comma;xc0xdiffyx&comma;xc0xdiffc0x&comma;xc1xc0x2diffc1x&comma;xc0xyxc0x&equals;0

(50)
  

and so, the integral of the function y in the previous equation satisfies the other ODE (the starting point).

DEtools[ode_int_y]( (50), y(x) ) = 0;

c0xyx&plus;c1xdiffyx&comma;x&plus;c2xdiffdiffyx&comma;x&comma;x&plus;diffdiffdiffdiffyx&comma;x&comma;x&comma;x&comma;x&equals;0

(51)

New Routines for Definite Integration

  

A new command, DEtools[Zeilberger], is available. This is the differential analog of Zeilberger's definite summation algorithm. For a given bivariate hyperexponential function Fx&comma;y, it computes a Z-pair L,G, that is, a linear differential operator L with polynomial coefficients with respect to the first variable x and a hyperexponential function Gx&comma;y satisfying:

                 d

 (L o F)(x, y) = -- G(x, y)

                 dy

  

For more information, see DEtools[Zeilberger].

  

To move to the corresponding section of this page, click Summary, Exact Solutions, Numeric Solutions, DEtools, PDEtools, or diffalg.

PDEtools

  

A new TWSolutions command computes Traveling Wave Solutions (TWS) for autonomous nonlinear partial differential equations systems (PDEs). A TWS is an exact, closed form solution of the form

f[i](tau) = Sum(A[i,k]*tau^k, k=0..n[i]);

fiτ=k=0niAi,kτk

(52)
  

where fi are the unknowns, the ni are finite, the Ai,k are constants with respect to the independent variables xj of the system, and (this implementation uses the hyperbolic tangent)

tau = tanh(Sum(C[k]*x[k], k=0..j));

τ=tanhk=0jCkxk

(53)
  

where the Ck are constants with respect to the xj.

  

Example

  

Use the new diff_table command to reduce redundant typing when entering differential equations.

U := DEtools[diff_table]( u(x,t) ):

  

Consider the Korteweg - de Vries (KdV) Burger's equation that occurs in various physical systems.

KdV := { U[t] + U[]*U[x] - p*U[x,x] + q*U[x,x,x] = 0 };

pdiffdiffux&comma;t&comma;x&comma;x&plus;qdiffdiffdiffux&comma;t&comma;x&comma;x&comma;x&plus;ux&comma;tdiffux&comma;t&comma;x&plus;diffux&comma;t&comma;t&equals;0

(54)
  

Let's consider this problem taking p&comma;q as parameters, so splitting into cases with respect to them; five TWS result.

{PDEtools[TWSolutions]( KdV, parameters = {p,q} )};

p=0&comma;q=q&comma;ux&comma;t=12tanh_C2x+_C3t+_C12q_C22+8_C23q_C3_C2&comma;p=p&comma;q=0&comma;ux&comma;t=2tanh_C2x+_C3t+_C1p_C2_C3_C2&comma;p=p&comma;q=q&comma;ux&comma;t=_C4&comma;p=p&comma;q=q&comma;ux&comma;t=3tanh_C3tpx10q+_C12p225q+6tanh_C3tpx10q+_C1p225q+250_C3q2+3p325qp&comma;p=p&comma;q=q&comma;ux&comma;t=3tanh_C3t+px10q+_C12p225q6tanh_C3t+px10q+_C1p225q+250_C3q2+3p325qp

(55)
  

To move to the corresponding section of this page, click Summary, Exact Solutions, Numeric Solutions, DEtools, PDEtools, or diffalg.

The diffalg Package

  

By setting _Env_diffalg_charpres_methodregchar, the final decomposition is processed using algebraic triangular instead of Groebner basis techniques. Note: This is useful also when triangularizing polynomial systems, not necessarily differential ones.

  

Example

  

A system consisting of two polynomials in five variables u1&comma;u2&comma;u3&comma;u4&comma;u5:

PDEtools[declare]( (u1,u2,u3,u4,u5)(x), quiet );

_Env_diffalg_charpres_method := 'regchar';

_Env_diffalg_charpres_methodregchar

(56)

R := diffalg[differential_ring](derivations = [x],  ranking = [[u1,u2,u3,u4,u5]], notation=diff);

RODE_ring

(57)

p1 := (u2(x)*u3(x)+u4(x)+u2(x))*u1(x)^2+(u2(x)*u3(x)+3)*u1(x)+1;

u2xu3x&plus;u4x&plus;u2xu1x2&plus;u2xu3x&plus;3u1x&plus;1

(58)

p2 := (1+u4(x)+u5(x))*u3(x)^2+u3(x)*(u5(x)^2+u4(x)+2)+u5(x)+2;

1&plus;u4x&plus;u5xu3x2&plus;u3xu5x2&plus;u4x&plus;2&plus;u5x&plus;2

(59)

ans := diffalg[Rosenfeld_Groebner]([p1,p2],R);

anscharacterizable

(60)
  

To see the contents of each characteristic decomposition computed, enter: diffalgequationsansi and diffalginequationsansi; where i is a number between 1 and the number of decompositions computed, 22.

  

To move to the corresponding section of this page, click Summary, Exact Solutions, Numeric Solutions, DEtools, PDEtools, or diffalg.

See Also

Index of New Maple 9.5 Features