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 10 : Differential Equations

Updates to Differential Equation (DE) Solvers in Maple 10

 

Summary

Ordinary Differential Equations (ODEs) - The dsolve Command and Exact Solutions

Partial Differential Equations (PDEs) - The pdsolve Command and Exact Solutions

The Differential Equation Packages: PDEtools and DEtools

Summary

  

Maple remains the state of the art in computer algebra and differential equations.

  

Maple 10 supports important new special functions in the mathematical language. Correspondingly, the differential equation theme is the exploration of these sophisticated functions to represent solutions to many formerly unsolvable families of linear and nonlinear differential equations. Original computational algorithms were developed by the Maplesoft research team in what is the most important development in the area of ordinary differential equations (ODEs) in the last four Maple releases.

  

For partial differential equations (PDEs), in Maple 9.5 core functionality for computing Traveling Wave Solutions (TWS) for PDE nonlinear, autonomous systems, was added. For Maple 10, the TWS libraries have been significantly extended, exploring differential polynomial forms, so that different types of TWS for PDE systems can be computed using various mathematical functions for a base.

The dsolve and pdsolve Commands: Exact Solutions

• 

New solving algorithms for Abel type ODEs that can be mapped into second order linear hypergeometric type equations - see references.

• 

Added algorithm for solving a general class of ODEs that can be mapped into Abel type.

• 

New solving algorithms for Riccati type ODEs whose solution can be expressed using hypergeometric functions - see references.

• 

New solving algorithms for computing Heun function solutions for second order linear ODEs - see references.

• 

Improved algorithms for computing doubly periodic solutions for second order linear ODEs - see references.

• 

Added algorithms for computing Liouvillian solutions (imprimitive case) for third order linear ODEs.

• 

Added conversions for ODEs: to Abel and using MobiusX, MobiusY, or MobiusR, and enhanced the interface for the previously existing conversions.

• 

Enhanced odetest so that it can now test series solutions for linear and nonlinear ODEs.

• 

New solving algorithms in pdsolve for computing different types of Traveling Wave Solutions for PDEs and PDE systems.

The Differential Equation Packages: DEtools and PDEtools

• 

Nine new commands were added to DEtools: Homomorphisms, to compute homomorphisms between the solution spaces of two linear differential operators; particularsol, to compute particular solutions to linear equations in cases where the general solution cannot be found; and seven other commands for handling differential rational normal forms and hyperexponential functions.

• 

Large extensions of the algorithms that compute exact Traveling Wave Solutions for autonomous PDE systems.

• 

Large number of new differential polynomial extensions were added to PDEtools[dpolyform], regarding all kinds of inverse functions (arbitrary order), as well as cases of definite integrals admitting such a representation.

Ordinary Differential Equations (ODEs) - The dsolve Command and Exact Solutions

Nonlinear Differential Equations

Abel equations: New methods for solving the AIR class

  

In 2004, it was shown that basically all known solvable Abel equations belong to the Abel AIR class and that all their solutions can be expressed in terms of hypergeometric functions (see dsolve/references). There are six different cases. All of them can be solved using Maple 10.

  

Examples

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

yxwill now be displayed asy

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

(1)
  

The 6th subclass, which is the simplest, admits solutions in terms of 0F1 (0-parameter) hypergeometric functions, Airy type; an example of this class is:

diff(y(x),x) = (a[1]*a[4]-a[3]*a[2])*(a[7]*y(x)+a[8])^3/((a[2]^2*a[7]+2*x*a[7]*a[2]*a[1]+x^2*a[7]*a[1]^2+a[5]*(a[3]*x+a[4])^2)*y(x)+a[8]*(x*a[1]+a[2])^2)/a[5]/a[8];

(2)

dsolve((2));

(3)
  

An example of the 4th subclass, hence admitting 0F1 (1-parameter) hypergeometric solutions of Bessel type:

diff(y(x),x) = -(c*b-a*d)*y(x)^2*r/(r*((-a+c^2)*x+c*d-b)*(x*a+b)*y(x)-s*(x*c+d)^2);

(4)

dsolve((4));

(5)
  

The 5th and 3rd AIR subclasses, respectively depending on 1 and 2 parameters, admit solutions in terms of 1F1 hypergeometric confluent functions. N-parameter (N > 1) Abel classes could not be solved by the Maple dsolve command in previous releases except for some particular cases. The 3rd AIR 2-parameter subclass is as general as the 1F1, second order linear equation, class. An example:

diff(y(x),x) = (-b*c+a*d)*y(x)/((x*c+d)*(x*a+b)*y(x)+((a-b*c)*x+b-d*b)*((a-c^2)*x+b-d*c));

(6)

dsolve((6));

(7)
  

The 2nd and 1st Abel AIR subclasses, respectively depending on 2 and 3 parameters, are rather difficult computational problems, and admit solutions in terms of 2F1 hypergeometric functions, which in the general case are complicated. Using new identities these solutions can be expressed in simpler forms in terms of the (new in Maple 10) confluent Heun functions. An example of the 1st AIR subclass:

diff(y(x),x) = (a*d-b*c)*(y(x)-1)*y(x)/(a*(x*c+d)*(a*x+b)*y(x)+((a-b*c)*x+b-b*d)*((a-c^2)*x+b-c*d));

(8)
  

A solution in terms of HeunC confluent functions:

dsolve((8));

(9)
  

Verify the solution.

odetest((9), (8));

0

(10)
  

You can also use the new solving routines with the dsolve command: dsolve(ode, y(x), [Abel_AIR]).

  

These new Abel AIR routines positively impact the ability of Maple to solve differential equations of other types too. The symmetry reduction process for many second and higher order nonlinear equations maps the problem into an Abel equation which is now solvable. Large families of first order linear and inverse linear equations, formerly solved using RootOfs of uncomputed integrals, as well as formerly unsolvable first order nonlinear Riccati families, can now be solved in terms of special functions through the new AIR code. In addition, second order linear equations of the Heun type can be solved in Maple 10. Because most differential equations are solved by mapping them into first order linear, nonlinear Riccati, or second order linear equations, these developments in the Abel sector provide new solutions for differential equation families of all types. Some examples illustrating this situation are in the following sections.

A note on solutions with special functions versus solutions involving simpler functions

  

When using special functions to represent ODE solutions, a difficult mathematical problem is to determine whether the special function admits a representation in terms of simpler functions. For example, you may prefer to see the solution in terms of 2F1 hypergeometric functions instead of HeunC, and prefer a solution in terms of exponentials or sin instead of Kummer or Bessel functions.

  

To address this problem, the new Abel AIR routines have two mechanisms.

• 

When the solution can be written in terms of simpler Liouvillian or hypergeometric functions, the routines automatically detect that, before computing any solution, and return the simpler representation.

• 

By assigning the environment variable _Env_dsolve_Abel_AIR_use_simpler_functions to false or true, you can request to never or always (try to) compute a solution in terms of simpler functions.

  

The reason for providing the environment variable mechanism is twofold. Through it, you can make the routines return a simpler solution, when it exists, but its existence is difficult to determine a priori, or you can make them return the special function solution form, even when a solution in terms of simpler functions is known to the routines. This is useful for investigating the special cases of the more advanced functions entering alternative forms of the solution.

  

Examples

  

This is an example of the 1st Abel AIR subclass, where a 2F1 (3 parameter) representation of the solution is simpler than the one involving HeunC functions.

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

odey'=yy11+bax+a+12ac+11yaxx+1+ac

(11)

sol := dsolve(ode);

solc__1+yc+1ac+1ya+c+x12+chypergeombc+1,ac+1,2c,y+hypergeombc+2,ac+2,3c,yyy1bc+1ac+1abyy1hypergeomb+1,a+1,c+1,y+hypergeoma,b,c,yay1+xc=0

(12)
  

To see the representation of this solution in terms of HeunC functions, assign the environment variable _Env_dsolve_Abel_AIR_use_simpler_functions := false. To see a HeunG representation, use (new in Maple 10) convert(sol, HeunG).

  

The next example admits a solution that can be expressed in terms of elementary functions, entirely dispensing with the use of special functions.

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

odey'=y22yx+x1x+1

(13)

dsolve(ode);

y=2RootOfⅇ_Z_Zx+c__1_Zx+ⅇ_Z_Z2ⅇ_Zxc__1_Z+2c__1x

(14)
  

To see a 1F1, Kummer special function representation of the solution, assign false to the environment variable.

_Env_dsolve_Abel_AIR_use_simpler_functions := false;

_Env_dsolve_Abel_AIR_use_simpler_functionsfalse

(15)

dsolve(ode);

c__1+x+1KummerM1,3,2yx1+KummerM2,3,2y1xx+1KummerU1,3,2y+KummerU2,3,2yx1=0

(16)
  

Reset the environment variable.

_Env_dsolve_Abel_AIR_use_simpler_functions := '_Env_dsolve_Abel_AIR_use_simpler_functions':

New solutions for families mappable into Abel equations

  

New routines for mapping some relevant nonlinear first order families into Abel equations were added. These routines automatically take advantage of the old and new Abel ODE solving libraries. These mappings and the transformations used to perform them are also visible using the new Maple 10 convert/ODEs routines.

  

Example

PDEtools[declare](g(x), quiet):

diff(y(x),x) = 2*y(x)*((1/2*diff(g(x),x)*g(x)+(x+1)*g(x)+x^2-mu)*y(x)^(2*nu-1)+y(x)^nu*(1/2*diff(g(x),x)+1+x))/(nu-1)/(y(x)+g(x)*y(x)^nu);

y'=2yg'g2+x+1g+x2μy2ν1+yνg'2+1+xν1y+gyν

(17)

dsolve((17), y(x));

(18)
  

Verify the solution.

odetest((18), (17), y(x));

0

(19)
  

You can also use this solving approach with the dsolve command: dsolve(ode, y(x), [equivalent_to_Abel]).

Riccati equations: New solutions in terms of hypergeometric 2F1, 1F1 and 0F1 functions

  

Similar to the Abel AIR problem, families of Riccati equations admit solutions in terms of hypergeometric functions; for these families, the new algorithms also provide solutions by mapping the equation into one of the six canonical solvable forms, depending on 0 (0F1 type), 1 (0F1 and 1F1 types), 2 (1F1 and 2F1 types), or 3 (2F1 type) parameters.

  

Examples

  

A Riccati equation of the 6th class, admitting Airy type solutions:

diff(y(x),x) = (a^2+x*c^2)/(a*d-c*b)*y(x)^2+2*(a*b+d*c*x)/(a*d-c*b)*y(x)+(b^2+x*d^2)/(a*d-c*b);

(20)

dsolve((20));

y=AiryAi1,xc__1d+AiryBi1,xdbAiryAixc__1+AiryBixAiryAixc__1+AiryBixaAiryAi1,xc__1cAiryBi1,xc

(21)
  

An example of the 3rd class, admitting 1F1 (2-parameter) solutions, expressible using Kummer functions:

diff(y(x),x) = (a^2-c*(s+r-x)*a+r*c^2*s)/(a*d-c*b)/x*y(x)^2+((2*b+(-s-r+x)*d)*a+2*c*((1/2*x-1/2*r-1/2*s)*b+r*s*d))/(a*d-c*b)/x*y(x)+(b^2-(s+r-x)*d*b+r*d^2*s)/(a*d-c*b)/x;

(22)

dsolve((22), y(x));

y=KummerMr+1,1+sr,xdrKummerUr+1,1+sr,xc__1drsbKummerUr,1+sr,xc__1+KummerMr,1+sr,xKummerUr,1+sr,xc__1+KummerMr,1+sr,xa+KummerUr+1,1+sr,xc__1crsKummerMr+1,1+sr,xcr

(23)
  

An example of the 2nd class, admitting 2F1 (2-parameter) solutions, expressible in simpler terms using HeunC confluent functions new in Maple 10:

diff(y(x),x) = (a^2+r*x*c^2-a*s*c)/(a*d-c*b)/(x-1)/x*y(x)^2+(2*r*x*c*d+(2*b-s*d)*a-b*s*c)/(a*d-c*b)/(x-1)/x*y(x)+(-b*s*d+r*x*d^2+b^2)/(a*d-c*b)/(x-1)/x;

(24)

dsolve((24), y(x));

(25)

Linear Differential Equations

Heun type equations: New methods for computing solutions in terms of the five Heun functions

  

In Maple 10, the five Heun functions were introduced. The solutions to the corresponding five second order linear differential equations cannot be expressed with previously existing functions of the mathematical language. The Heun functions include, among others, the Lame, Spheroidal wave, Mathieu, hypergeometric 2F1, 1F1, and 0F1 functions as particular cases, and are also connected to elliptic functions. As a benchmark, basically all the second order linear equations of Kamke's book have their solution expressible in terms of Heun functions.

  

Taking this into account, new routines for solving the five Heun equations were implemented in dsolve, as well as for solving the whole classes of equations one can derive from these five by changing variables

         k

      a x  + b

 x -> --------,   y(x) -> P(x) y(x)

         k

      c x  + d

  

where a,b,c,d,k are any constants and P can be any function of x. Due to the generality and rich structure of Heun functions, their use for solving second order linear equations made a large number of formerly unsolvable equations solvable, making this pioneering Maple step one of the relevant milestones in the developments in this area.

  

Examples

  

Lame's equation in one of its algebraic forms: this is the first time its solution can be expressed in a computer algebra system.

diff(y(x),x,x) + 1/2*(1/x+1/(x-1)+1/(x-a))*diff(y(x),x) + 1/4*(a*h-nu*(nu+1)*x)/x/(x-1)/(x-a)*y(x) = 0;

y''+1x+1x1+1xay'2+ahνν+1xy4xx1xa=0

(26)

dsolve((26));

y=c__1HeunGa,ah4,ν2,ν2+12,12,12,x+c__2xHeunGa,14+h+1a4,1+ν2,ν2+12,32,12,x

(27)
  

The spheroidal wave function equation: the solution is expressible in terms of HeunC.

diff(y(x),x,x) = 2*(b+1)*x/(1-x^2)*diff(y(x),x) + (4*q*x^2-c)/(1-x^2)*y(x);

(28)

dsolve((28));

y=c__1HeunC0,12,b,q,14b4c4,x2+c__2xHeunC0,12,b,q,14b4c4,x2

(29)
  

The Mathieu equation is a particular case of Heun's equations - this is a rational form of it and the standard Mathieu function solution.

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

odey''=xy'x2+1+4x22qayx2+1

(30)

dsolve(ode);

y=c__1MathieuCa,q,arccosx+c__2MathieuSa,q,arccosx

(31)
  

This equation is also solvable in terms of Heun functions.

dsolve(ode,[Heun]);

y=c__1HeunC0,12,12,q,38a4q2,x2+c__2HeunC0,12,12,q,38a4q2,x2x

(32)
  

The Gauss 2F1 hypergeometric equation and its standard hypergeom 2F1 solution:

ode := diff(y(x),x,x) + (c/x + (a+1+b-c)/(x-1))*diff(y(x),x) - (b*a/x-b*a/(x-1))*y(x);

odey''+cx+1+a+bcx1y'baxbax1y

(33)

dsolve(ode);

y=c__1hypergeoma,b,c,x+c__2xc+1hypergeombc+1,ac+1,2c,x

(34)
  

The hypergeom 2F1 function is a particular case of HeunG and also of HeunC so the solution to Gauss' equation can also be expressed as:

dsolve(ode,[HeunG]);

y=c__1HeunG1,ab,a,b,c,0,x+c__2xc+1HeunG1,bc+1ac+1,bc+1,ac+1,2c,0,x

(35)

dsolve(ode,[HeunC]);

y=c__1x1aHeunC0,ab,c1,0,a+b1c2ab+12,1x1+c__2x1bHeunC0,a+b,c1,0,a+b1c2ab+12,1x1

(36)
  

A large number of relationships between mathematical functions are visible through their connection with Heun functions; this is important for the representation of solutions in applied mathematics problems.

  

The Heun solution routines are also sensitive to assumptions and explore automorphisms of the Heun equations to rewrite the solution free of integrals when possible.

  

You can use the new algorithms for Heun function solutions with the dsolve command: dsolve(ode, y(x), [Heun]) (optionally HeunG, HeunC, HeunB, HeunD, or HeunT instead of Heun).

Improved solutions for linear equations with periodic functions in their coefficients

  

Enhancements were made for computing solutions for linear equations in the presence of periodic functions, typically those of elliptic type like JacobiSN or WeierstrassP. These improvements also combine with the new ability to compute Heun function solutions to obtain a representation for the solution of important classic ODE problems.

  

Examples

  

This is Kamke's second order linear example 2.27, the Jacobi form of Lame's equation.

diff(y(x),x,x)-(n*(n+1)*k^2*JacobiSN(x,k)^2+B)*y(x) = 0;

y''nn+1k2JacobiSNx,k2+By=0

(37)
  

The new routines for the computation of elliptic function solutions combine with those for computing Heun function solutions to obtain:

dsolve((37));

(38)
  

An equation of third order involving WeierstrassP functions

diff(y(x),x,x,x)-(8*WeierstrassP(x,g2,g3)+a)*diff(y(x),x)-4*WeierstrassPPrime(x,g2,g3)*y(x) = 0;

y'''8WeierstrassPx,g2,g3+ay'4WeierstrassPPrimex,g2,g3y=0

(39)
  

Do not compute the integrals. In the uncomputed form, you can see the structure of the solution.

dsolve((39), useInt);

(40)
  

You can also use the algorithms for solving linear equations in the presence of periodic functions in the coefficients with the dsolve command: dsolve(ode, y(x), [with_periodic_functions]). See also DEtools[dperiodic_sols].

Third order equations: New solutions in terms of Liouvillian functions

  

Kovacic's algorithm includes a complete prescription for computing Liouvillian solutions for second order linear ODEs with rational coefficients. The extension of that algorithm for third order linear equations was developed by Singer and Ulmer years ago, but an efficient computational implementation of it is still difficult at present. In this release, a step towards implementing this algorithm has been given, with the development of routines handling the imprimitive case.

  

Example

diff(y(x),x,x,x) + 1/6*(26*x-9)/x/(x-1)*diff(y(x),x,x) + 1/27*1/x*(76*x-55)/(x-1)^2*diff(y(x),x) + 28/729*1/x/(x-1)^2*y(x) = 0;

y'''+26x9y''6xx1+76x55y'27xx12+28y729xx12=0

(41)

dsolve((41));

y=c__1ⅇRootOf4+2916x35832x2+2916x_Z3+972x2972x_Z2+108x27_Z,index=1ⅆx+c__2ⅇRootOf4+2916x35832x2+2916x_Z3+972x2972x_Z2+108x27_Z,index=2ⅆx+c__3ⅇRootOf4+2916x35832x2+2916x_Z3+972x2972x_Z2+108x27_Z,index=3ⅆx

(42)
  

To compute these integrals, use value; to directly obtain the solution with the integrals computed, use the useint option of dsolve.

Miscellaneous

New conversions for ODEs: To Abel and using MobiusX, MobiusY, or MobiusR

  

The routines for mapping ODE problems into other ones are a sort of powertoys for differential equations, written by our research group while developing new algorithms and made available to Maple users as convert/ODEs routines. The package, growing with each release, has been reorganized in a modular way, now uniformingly providing functionality through new optional arguments. Frequently used mappings were added; these are:

• 

MobiusX and MobiusY, to respectively perform Mobius transformations of the independent and dependent variables in arbitrary ODEs;

• 

MobiusR, to perform, on second order linear ODEs, the composition of three transformations: To Riccati -> MobiusY -> to second order linear, resulting in a single non-local transformation with valuable properties;

• 

Abel, to map certain families of first order nonlinear equations into Abel type equations.

  

Examples

• 

MobiusX transformations on a second order linear ODE with constant coefficients:

ode := diff(y(x),x,x) = c[1]*diff(y(x),x)+c[0]*y(x);

odey''=c1y'+c0y

(43)
  

Use ut as a new dependent variable.

convert(ode, MobiusX, [a[0],a[1],b[0],b[1]], u(t));

(44)
  

In this output, you see the resulting ODE in ut and the Mobius transformation used. The arguments after MobiusX are all optional - see convert/ODEs.

  

Among useful optional new functionality, there is an option to specify a simplifier to be used instead of the default one. For example, this specifies a MobiusX transformation of the form x=t1t+1 and requests the output be in partial fraction decomposition form.

convert(ode, MobiusX, [1,-1,1,1], u(t), parfrac);

ut,t=2c1t+122t+1ut+4c0utt+14,x=t1t+1,y=ut

(45)
  

When you know the output cannot be simplified or want to get it faster with no simplification, you can use the optional argument simplifier=NONE.

• 

MobiusY transformations of the dependent variable - in this example y - transform a second order linear equation into a nonlinear equation, while keeping the corresponding first order Riccati equation in the same class. This is the Riccati equation associated with ode.

  

Keep y as a dependent variable and take _F1x=1.

eval(convert(ode, Riccati, keep), _F1(x)=1);

y'=y2+c1yc0,_ax=ⅇyⅆxc__1

(46)
  

This is a MobiusY transformation, y=fu+gru+s, where all of f,g,r,s,u,y are functions of x, resulting in another Riccati equation.

PDEtools[declare]( (f,g,r,s,u)(x), quiet);

convert((46)[1], MobiusY, [f,g,r,s](x), u(x));

u'=frc1r2c0f 'r+r'f+f2u2fsrg+f 'sg'r+r'g+s'f+c1s+2gf2src0+rgc1ufsrg+s2c0+sgc1g's+s'g+g2fsrg,y=fu+gru+s

(47)

DEtools[odeadvisor]((47)[1], u(x), [Riccati]);

_Riccati

(48)
  

In fact, MobiusY transformations define the Riccati class of equations, so through these transformations any Riccati equation can be obtained from any other one.

• 

MobiusR transformations are non-local transformations (contain an integral with derivatives of the dependent variable in the integrand), have the ability of generating the whole second order linear ODE from any given one, and, for particular cases of the transformation parameters, result in equations with remarkable properties. Consider an arbitrary second order linear ODE:

ode := diff(y(x),x,x)= c[1](x)*diff(y(x),x)+c[0](x)*y(x);

odey''=c1xy'+c0xy

(49)
  

Applying the particular case of MobiusR where the four functions f,g,r,s entering the intermediate MobiusY are equal to 0,1,1,0, you obtain the following, using u as the new variable.

ode_u := convert(ode, MobiusR, [0,1,1,0], y(x),u(x));

ode_uu''=c1xc0x+c0 'u'c0x+uc0x,y=ⅇuc0xu'ⅆx

(50)
  

Applying to this result the same MobiusR, you reobtain the original equation.

convert(ode_u[1], MobiusR, [0,1,1,0], u(x),y(x));

y''=c1xy'+c0xy,u=ⅇc0xyy'ⅆx

(51)
  

In other words, this particular case of MobiusR transformations has itself for an inverse. Another important property: Depending on the equation, this transformation adds a so-called false singularity (the singularity actually exists, the exponents differ by an integer, but the power series solution does not require a logarithmic term); for details, see convert/ODEs.

New odetesting series solutions to ODEs

  

Keeping with the developments of DE testing tools, in this release, odetest is able to test ODE series solutions.

  

Examples

ode := [diff(y(x),x,x)+diff(y(x),x)^2=0, y(a)=0, D(y)(a)=1];

odey''+y'2=0,ya=0,Dya=1

(52)

sol := dsolve( ode, y(x), type='series');

soly=xa12xa2+13xa314xa4+15xa5+Oxa6

(53)
  

'series' specifies the type of test.

odetest(sol, ode, series);

0,0,0

(54)

Partial Differential Equations (PDEs) - The pdsolve Command and Exact Solutions

  

The developments in the ODE area have had an impact on the ability of Maple to solve PDEs using pdsolve. In addition, in this release, pdsolve can compute new (different kinds) of Traveling Wave Solutions for nonlinear autonomous PDE systems.

  

Examples

  

A PDE satisfying the Painleve test, but not having the Painleve property:

restart;

  

To set up enhanced math display:

PDEtools[declare](u(x,t));

ux,twill now be displayed asu

(55)
  

To use simplified math input:

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

pde := U[t]^2 = 2*U[]*U[x]^2-(1+U[]^2)*U[x,x];

pdeut2=2uux2u2+1ux,x

(56)
  

In this example, all terms are nonlinear but the equation is still autonomous, depending on x,t only through u. The new routines perceive that this PDE admits no standard TWS and so search for a combination of tanh and ln TWS leading to:

sol := pdsolve(pde);

solu=tan_C12ln_C22c__3_C1x+_C2t+c__3+c__4_C12_C22

(57)

pdetest(sol, pde);

0

(58)
  

To see that this PDE does not have the Painleve property, perform the change of variables τ=_C1x+_C2t and compute the singularities of the solution: it has critical points (not poles) which are movable (depend on the integration constants).

  

Using optional arguments, it is possible to indicate the type of function desired in the series expansion entering the TWS (see PDEtools[TWSolutions]). For example, for this PDE:

pde := U[t] + U[]*U[x] + U[x,x] + 1/q*U[x,x,x] + U[x,x,x,x] + q*(U[x]^2 + U[]*U[x,x]) = 0;

pdeut+uux+ux,x+ux,x,xq+ux,x,x,x+quux,x+ux2=0

(59)
  

by default, pdsolve computes the standard tanh TWS, but different types of TWS, in terms of other mathematical functions, can be obtained using the HINT option; these are alternative solutions in terms of JacobiSN and sec.

pdsolve(pde, HINT = TWS(JacobiSN));

(60)

pdsolve(pde, HINT = TWS(sec));

u=12_C22sec_C2tq+_C2x+_C12q+4_C221q

(61)
  

These different TWS solutions can be requested in terms of exp, ln, the trigonometric functions sin, cos, tan, their multiplicative inverses and the hyperbolic versions of them, JacobiSN, JacobiCN, JacobiDN, JacobiNS, JacobiNC, JacobiND, InverseJacobiNS, InverseJacobiNC, and InverseJacobiND, as well as WeierstrassP.

The Differential Equation Packages: PDEtools and DEtools

PDEtools

Traveling Wave Solutions for PDE systems

  

Leading the implementation of Traveling Wave Solutions (TWS) in computer algebra systems for Maple 9.5, for this release these libraries were extended to compute:

• 

TWS expanding the solutions in powers of different functions (your choice of function, possibly the identity)

• 

TWS as compositions of functions exploring differential polynomial extensions

• 

Only the system of ordinary differential equations  equivalent to the given autonomous PDE system

  

Examples

  

Korteweg-deVries PDE:

with(PDEtools, TWSolutions);

TWSolutions

(62)

KdV := U[t] = U[x,x,x] - 6*U[]*U[x];

KdVut=6uux+ux,x,x

(63)
  

Introduce tau as the usual linear combination of x,t, but convert the PDE problem into an ODE not using any particular function transformation, just the identity, then return this resulting ODE and the transformation used to obtain it.

TWSolutions(KdV, function = identity, output = ODE);

_C13uτ,τ,τ+6uτ_C1+_C2uτ,τ=_C1x+_C2t+c__3,uτ=u

(64)
  

This type of manipulation is useful for performing further analysis. You can see that the ODE is a total derivative; integrating it, we obtain a type 1 Painleve equation, as the Ablowitz-Ramani-Segur (ARS) conjecture suggests.

op([1,1],(64));

_C13uτ,τ,τ+6uτ_C1+_C2uτ

(65)
  

This is an exact equation (see DEtools[firint]). A first integral is:

DEtools[firint]( (65) );

3_C1uτ2+_C2uτ_C13+uτ,τ+c__3=0

(66)
  

This is the Painleve type 1 equation according to the ARS conjecture.

isolate((66), diff(u(tau),tau,tau));

uτ,τ=3_C1uτ2+_C2uτ_C13c__3

(67)
• 

The efficiency of the Traveling Wave Solutions libraries was also enhanced.

  

The following is a nonlinear PDE system example in five unknowns, containing four PDEs, extracted from Landau and Lifshitz's "Fluid Mechanics" book. To obtain enhanced display and simplify the input:

PDEtools[declare]((u,w,Tau)(x,z,t),p(x,z),Ts(z));

ux,z,twill now be displayed asu

wx,z,twill now be displayed asw

Τx,z,twill now be displayed asΤ

px,zwill now be displayed asp

Tszwill now be displayed asTs

(68)

with(DEtools,diff_table);

diff_table

(69)

U := diff_table(u(x,z,t)):  W := diff_table(w(x,z,t)):

P := diff_table(p(x,z)):  T := diff_table(Tau(x,z,t)):

  

The PDE system is:

e1 := U[x]+W[z] = 0;

e1ux+wz=0

(70)

e2 := U[t] + U[]*U[x] + W[]*U[z] = -P[x] + sigma*(U[x,x]+U[z,z]);

e2uux+uzw+ut=px+σux,x+uz,z

(71)

e3 := W[t]+U[]*W[x]+W[]*W[z] = -P[z]+sigma*(W[x,x]+W[z,z])+sigma*rho*(T[]-Ts(z));

e3uwx+wwz+wt=pz+σwx,x+wz,z+σρΤTs

(72)

e4 := T[t]+U[]*T[x]+W[]*T[z] = T[x,x]+T[z,z];

e4Τxu+Τzw+Τt=Τx,x+Τz,z

(73)

sys := [e1,e2,e3,e4]:

  

This system represents a 2-D (coordinates x,z) fluid layer, open to air, subjected to a vertical temperature gradient (Nabla of Tx,z,t) and embedded in a gravitational field. The constants sigma and rho are related to the viscosity, thermal diffusivity, the gravitational constant, and the coefficient of thermal expansion. A set of traveling wave solutions can be computed for this system in 2 seconds (typical PC 2 GigaHertz, 2004). The nonsingular case after removing redundant constant solutions:

TWSolutions( sys, singsol = false, remove_redundant );

(74)
  

For p = constant, this system also admits solutions in terms of the WeierstrassP elliptic function - to see this solution add the optional argument function = WeierstrassP to the calling sequence above.

Differential Polynomial forms for inverse functions and definite integrals

  

In previous releases, Maple started exploring a computationally powerful idea: that of using Differential Polynomial Forms (DPFs) for representing non-polynomial mathematical objects, like mathematical functions, their composition, and more. For this release, the existing DPF representations were polished, allowing you, when possible, the choice of lower order (nonlinear) or higher order (linear) DPFs; many new DPFs were implemented, including those for the new special functions; some cases of indefinite integrals which can be represented in DPF were added; and a new library for computing DPFs for compositions constructed with the @ or @@ operators, so including inverse functions of any order, has been added.

  

Examples

• 

New functions are handled:

with(PDEtools, dpolyform);

dpolyform

(75)

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

y(x) = HeunT(alpha,beta,gamma,x);

y=HeunTα,β,γ,x

(76)

dpolyform((76), no_Fn);

y''=3x2+γy'+β+3xαywherey0

(77)
  

Other new functions handled are: the other four Heun functions, the Wrightomega function, and the thirteen Jacobi functions and corresponding InverseJacobi functions.

• 

Higher or lower order representations can now both be computed:

y(x) = sin(x);

y=sinx

(78)
  

Linear second order representation:

dpolyform((78), no_Fn);

y''=ywherey2+y'20,y'0

(79)
  

Nonlinear first order representation:

dpolyform((78), no_Fn, lower_order);

y'2=y2+1wherey0

(80)
  

The lower order option is available for most trigonometric, inverse trigonometric, and related hyperbolic functions, as well as for WeierstrassP and other elliptic functions.

• 

DPFs for inverse functions. Consider the inverse of the dawson function.

y(x) = `@@`(dawson,-1)(x);

y=dawson−1x

(81)
  

This is an Abel equation of the 2nd kind which happens to admit symmetries separable by product.

dpolyform((81),no_Fn);

y'=12yx1wherey0

(82)

DEtools[odeadvisor](op([1,1],(82)));

_1st_order,_with_symmetry_[F(x)*G(y),0],_Abel,2nd type,class C

(83)
• 

The computation of DPFs for definite integrals is possible when the dependence on the variables is through the integration limits.

eq := y(x) = Int(exp(a),a = f(x)+1/2 .. x-1/2);

eqy=fx+12x12ⅇaⅆa

(84)

DE := dpolyform(eq,no_Fn);

DEf '''=f ''y''y'+f '2f 'y''y'y'''+3f 'y'3y''f 'y'f ''y''y'+f '3+f 'y''+y'f '3y'f '2y''y'wherey''y'0,f '2f '+f ''0,y'f '2+f ''y'y''f '0

(85)
  

Verify the result.

odetest(eq,DE);

0

(86)
  

From DE, you can compute fx in terms of y (up to the value of some constants) without computing the integral. For that purpose, solve the DE.

dsolve(DE,f(x));

fx=lnⅇxc__5c__6+2c__6y+c__3

(87)

DEtools

  

Nine new commands, some based on original algorithms, are available in DEtools in this release: DEtools[particularsol], DEtools[Homomorphisms], and a subpackage of seven commands for computing with Differential Rational Normal Forms.

• 

DEtools[particularsol] is able, for certain types of linear nonhomogeneous ODEs, to find a particular solution for it without computing its general solution.

  

Example

  

A second order nonhomogeneous linear ODE for which the homogeneous part is out of the scope of dsolve:

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

yxwill now be displayed asy

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

(88)

NH_ODE := 133601600831056948930009536*x^3+920184312063950707048658496*x^2+(-4242610768571010035328624653+3711155578640470803611376*x^4-369364944765014363775910745*x^3-4028299868602335386591950537*x^2-7123173270557941102013850561*x)*y(x)+(158668797683584879758300854-361937570512208809606272361*x^4-743569265631618257116222299*x^3+253413657274110944226342787*x^2+698563894241740551690579371*x)*diff(y(x),x)+(-3195084416888717732807842-8089797769268184221773945*x+14158747037070037877844107*x^2+8089797769268184221773945*x^3-10963662620181320145036265*x^4)*diff(y(x),`$`(x,2));

NH_ODE133601600831056948930009536x3+920184312063950707048658496x2+3711155578640470803611376x4369364944765014363775910745x34028299868602335386591950537x27123173270557941102013850561x4242610768571010035328624653y+361937570512208809606272361x4743569265631618257116222299x3+253413657274110944226342787x2+698563894241740551690579371x+158668797683584879758300854y'+10963662620181320145036265x4+8089797769268184221773945x3+14158747037070037877844107x28089797769268184221773945x3195084416888717732807842y''

(89)
  

This is a particular solution for it. The general solution is not known.

p_sol := DEtools[particularsol]( NH_ODE );

p_soly=4x49x4+35x3+49x2+21x+6x212x15

(90)
  

Verify the result.

odetest( p_sol, NH_ODE );

0

(91)
• 

DEtools[Homomorphisms] provides advanced functionality: it computes a basis of all the homomorphisms between the solution spaces of two linear differential operators, thus representing a sophisticated research tool in the area of linear differential equations.

  

Example

  

Let L1 and L2 be any two linear differential operators, for example:

_Envdiffopdomain := [Dx,x]:

L1 := Dx^3;   L2 := Dx^2;

L1Dx3

L2Dx2

(92)
  

Compute a basis of the homomorphisms between the two solutions spaces VL1 and VL2, from the former to the latter. The differential operator elements of this basis have the property: the "multiplication" of L2 by any of them results in an operator exactly right-dividing L1.

  

The dimension of all such maps is order(L1)*order(L2). In this example, that is 3*2 = 6. Because the output is a basis of these maps, this output contains 6 elements.

B := DEtools[Homomorphisms](L1, L2);

BDx,xDx2,Dx2,xDx2Dx,x2Dx22xDx+2,x3Dx22x2Dx+2x

(93)
  

To verify this result, compute the product of L2 with each of these homomorphisms, and then the right division between this product and L1. In this way, we can verify that the remainder (second operand in the output of DEtools[rightdivision]) is zero. That is, the division is exact.

seq( DEtools[rightdivision]( DEtools[mult](L2, b), L1 )[2], b = B );

0,0,0,0,0,0

(94)

A new subpackage for computing with Differential Rational Normal Forms and HyperExponential functions

  

This new subpackage consists of the other seven new commands in DEtools: AreSimilar, Gosper, IsHyperexponential, MultiplicativeDecomposition, PolynomialNormalForm, RationalCanonicalForm, and ReduceHyperexp.

  

The DEtools[IsHyperexponential] command checks whether a univariate function is hyperexponential, that is, its logarithmic derivative is a rational function of the dependent variable. If so, it optionally returns the logarithmic derivative.

  

Example

with(DEtools, AreSimilar, Gosper, IsHyperexponential, MultiplicativeDecomposition, PolynomialNormalForm, RationalCanonicalForm, ReduceHyperexp);

AreSimilar,Gosper,IsHyperexponential,MultiplicativeDecomposition,PolynomialNormalForm,RationalCanonicalForm,ReduceHyperexp

(95)

H := exp(x^2)*x^(1/2)/(x+1);

Hⅇx2xx+1

(96)

IsHyperexponential(H, x);

true

(97)
  

The DEtools[AreSimilar] command checks whether two univariate hyperexponential functions differ by a multiplicative factor that is a rational function in the dependent variable.

  

Example

H1 := -(24*x^3+143*x^2+292*x+216)/(x-1)/(x+2)^3*exp(Int(-15/(x+4)^2,x));

H124x3+143x2+292x+216ⅇ15x+42ⅆxx1x+23

(98)

H2 := (x^3+17*x^2+88*x-231)/(x-1)*exp(Int((-23-2*x)/(x+4)^2,x));

H2x3+17x2+88x231ⅇ232xx+42ⅆxx1

(99)

AreSimilar(H,H2,x);

false

(100)
  

The DEtools[Gosper] command implements the continuous analog of Gosper's algorithm for hypergeometric summation. It determines whether a univariate hyperexponential function has an indefinite integral that is again hyperexponential, and if so, computes it.

  

Example

T := (-21*x^2+116*x-94)/(-73-35*x^4-14*x^3-9*x^2-51*x)*exp(-91/(-86+5*x))-(-68-7*x^3+58*x^2-94*x)/(-73-35*x^4-14*x^3-9*x^2-51*x)^2*exp(-91/(-86+5*x))*(-140*x^3-42*x^2-18*x-51)+455*(-68-7*x^3+58*x^2-94*x)/(-73-35*x^4-14*x^3-9*x^2-51*x)/(-86+5*x)^2*exp(-91/(-86+5*x));

T21x2+116x94ⅇ9186+5x35x414x39x251x737x3+58x294x68ⅇ9186+5x140x342x218x5135x414x39x251x732+4557x3+58x294x68ⅇ9186+5x35x414x39x251x7386+5x2

(101)

Int(T,x) = Gosper(T,x);

21x2+116x94ⅇ9186+5x35x414x39x251x737x3+58x294x68ⅇ9186+5x140x342x218x5135x414x39x251x732+4557x3+58x294x68ⅇ9186+5x35x414x39x251x7386+5x2ⅆx=7x358x2+94x+68ⅇ9186+5x35x4+14x3+9x2+51x+73

(102)
  

The DEtools[MultiplicativeDecomposition] command rewrites a univariate hyperexponential function in a canonical way as a product of a rational function and an exponential function.

  

Example

H := exp(Int(4/(x-2)+4/(x+1)-3/(x+1)^2-9/(x-1)^2-(9*x^2+12)/(x^3+4*x-2)+1/(x^3+4*x-2)^2,x));

Hⅇ4x2+4x+13x+129x129x2+12x3+4x2+1x3+4x22ⅆx

(103)

MultiplicativeDecomposition[1](H,x);

x+14x24ⅇ12x812x7108x648x5239x4+48x350x2+144x47x+12x12x3+4x22ⅆxx3+4x23

(104)

MultiplicativeDecomposition[2](H,x);

x24ⅇ5x916x814x7134x6+39x5331x4+96x3+32x2+16x7x+12x12x3+4x22ⅆx

(105)
  

The DEtools[PolynomialNormalForm] and DEtools[RationalCanonicalForm] commands rewrite a univariate rational function in a canonical way as the sum of a logarithmic derivative plus a rational function without nonzero integer residues at its simple poles. In other words: given a rational function, it computes the blocks entering the first order differential equation satisfied by this function.

  

Example

R := 4/(x-2)+4/(x+1)-3/(x+1)^2-9/(x-1)^2-(9*x^2+12)/(x^3+4*x-2)+1/(x^3+4*x-2)^2;

R4x2+4x+13x+129x129x2+12x3+4x2+1x3+4x22

(106)

A,B,C := PolynomialNormalForm(R,x);

A,B,C5x916x814x7134x6+39x5331x4+96x3+32x2+16x7,x+12x12x3+4x22,x24

(107)
  

Check the result.

normal( R - (A/B + diff(C,x)/C) );

0

(108)
  

The DEtools[ReduceHyperexp] command rewrites a univariate hyperexponential function in a canonical way as the derivative of a hyperexponential function plus a hyperexponential function, such that the latter is minimal in some respect.

  

Example

H := -exp(Int((2*x-7)/(x+4)^2,x))*(x^2+27*x+62)/(x+2)^4/(x+4)^2;

Hⅇ2x7x+42ⅆxx2+27x+62x+24x+42

(109)

H1,H2 := ReduceHyperexp(H,x);

H1,H2x2+8x+16ⅇ15x+42ⅆxx+23,0

(110)

See Also

Index of New Maple 10 Features