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
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.
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));
ⅆⅆxy⁡x=−y⁡xy⁡x+x⁢−x+a−1
dsolve((1), y(x));
c__1+x⁢BesselJ⁡a−1,2⁢−y⁡x−BesselJ⁡a,2⁢−y⁡x⁢−y⁡xx⁢BesselY⁡a−1,2⁢−y⁡x−BesselY⁡a,2⁢−y⁡x⁢−y⁡x=0
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.
The Riccati first order ODE family:
PDEtools[declare]((y,F,G)(x), prime=x);
y⁡x⁢will now be displayed as⁢y
F⁡x⁢will now be displayed as⁢F
G⁡x⁢will now be displayed as⁢G
derivatives with respect to⁢x⁢of functions of one variable will now be displayed with '
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);
y'=G⁢y2−F'+2⁢G⁢F2⁢yF+2⁢F⁢F'+G⁢F3F
Independent of the values of the functions F,G, a solution is now always computable as:
dsolve((4), y(x));
y=∫GFⅆx⁢F2+c__1⁢F2−1F⁢∫GFⅆx+c__1
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);
ode≔y''=−2⁢ⅇx⁢G2−G+G'⁢y'G−G⁢2⁢ⅇx+G⁢ⅇ2⁢x⁢y
sol := dsolve((6), y(x));
sol≔y=ⅇ∫−∫G⁢ⅇ−xⅆx⁢ⅇ6⁢x+c__1⁢ⅇ6⁢x−ⅇ4⁢x⁢G⁢ⅇ−5⁢x∫G⁢ⅇ−xⅆx+c__1ⅆx⁢c__2
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.
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;
ode≔2⁢x⁢x−1⁢y''+2⁢x−1⁢y'+μ⁢x+ν⁢y=0
dsolve(ode);
y=c__1⁢MathieuC⁡−μ−2⁢ν,μ2,arccos⁡x+c__2⁢MathieuS⁡−μ−2⁢ν,μ2,arccos⁡x
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.
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);
ode≔y''=−x2+1⁢y'x⁢x−1⁢x+1+yx−1⁢x+1
dsolve(ode); # New output free of uncomputed integrals
New Methods for Initial Value ODE Problems
Computing solutions for initial value ODE problems in more difficult cases:
ode := diff(y(x),x) = 1/(x-y(x)); # Abel type ODE
ode≔y'=1x−y
sol := dsolve({ode, y(0) = 1}); # correct branch for LambertW
sol≔y=−LambertW⁡−1,−2⁢ⅇ−2+x−1+x
simplify( eval(sol, x = 0) ); # verifying initial condition
y⁡0=1
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
New Methods for Piecewise ODEs
ode := diff(diff(y(x),x),x) + piecewise(x < 1/2, 1, 1/2 <= x, 0) * y(x) = 0;
ode≔y''+1x<12012≤x⁢y=0
initial_values := y(0)=1, D(y)(0)=1;
initial_values≔y⁡0=1,D⁡y⁡0=1
dsolve( {ode, initial_values} );
y=sin⁡x+cos⁡xx<12cos⁡12⁢x+3⁢sin⁡122+cos⁡122−sin⁡12⁢x12≤x
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.
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;
ode≔y'⁢y''''−y''⁢y'''+y'3⁢y'''=0
The general solution to this equation is not known. Attempting its computation using dsolve⁡ode, 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 );
ans≔y=_C5⁢x2+_C4⁢x+_C3
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
An ODE problem with initial conditions
ode := [diff(y(x),x)=sin(x-y(x)), y(0) = 8];
ode≔y'=sin⁡x−y,y⁡0=8
sol := dsolve(ode); # new solution in Maple 9.5
sol≔y=x−2⁢arctan⁡tan⁡4⁢x−2⁢tan⁡4+xtan⁡4⁢x+x+2+2⁢π
odetest( sol, ode ); # verifies 'sol' solves the ode and satisfies y(0) = 8
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 f⁡x,y,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 ];
sys≔x⁢∂2∂x2f⁡x,y,z+y+1⁢∂2∂x∂yf⁡x,y,z+z⁢∂2∂x∂zf⁡x,y,z=0,x⁢∂2∂x∂yf⁡x,y,z+y+1⁢∂2∂y2f⁡x,y,z+z⁢∂2∂y∂zf⁡x,y,z=0,x⁢∂2∂x∂zf⁡x,y,z+y+1⁢∂2∂y∂zf⁡x,y,z+z⁢∂2∂z2f⁡x,y,z=0
The general solution involving two arbitrary functions of one and two arguments respectively is:
pdsolve(sys);
f⁡x,y,z=f__5⁡zx⁢x+c__1+f__4⁡zx,y+1x⁢x
The new technique is equivalent to computing differential invariants for the problem.
A nonlinear PDE depending on two parameters p,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;
pde≔−p⁢∂2∂x2u⁡x,t+q⁢∂3∂x3u⁡x,t+u⁡x,t⁢∂∂xu⁡x,t+∂∂tu⁡x,t=0
pdsolve(pde);
u⁡x,t=−3⁢p2⁢tanh⁡c__3⁢t−p⁢x10⁢q+c__1225⁢q+6⁢p2⁢tanh⁡c__3⁢t−p⁢x10⁢q+c__125⁢q+250⁢c__3⁢q2+3⁢p325⁢q⁢p
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 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.
Basic pendulum:
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};
psys≔x⁡t2+y⁡t2=1,ⅆ2ⅆt2x⁡t=−2⁢λ⁡t⁢x⁡t,ⅆ2ⅆt2y⁡t=−2⁢λ⁡t⁢y⁡t−9.8,x⁡0=0,y⁡0=−1,D⁡x⁡0=0.1,D⁡y⁡0=0
psol := dsolve(psys, numeric);
psol≔procx_rkf45_dae...end proc
psol(1);
t=1.,λ⁡t=4.90499905723651,x⁡t=0.000360891517794992,ⅆⅆtx⁡t=−0.0999937504894365,y⁡t=−0.999999934755133,ⅆⅆty⁡t=−0.0000360794101890703
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))};
dsys≔3⁢cos⁡β⁡t⁢ⅆⅆtβ⁡t210+3⁢sin⁡β⁡t⁢ⅆ2ⅆt2β⁡t10+ⅆ2ⅆt2s⁡t,−2⁢cos⁡θ⁡t⁢ⅆⅆtθ⁡t225−2⁢sin⁡θ⁡t⁢ⅆ2ⅆt2θ⁡t25−3⁢cos⁡η⁡t⁢ⅆⅆtη⁡t2⁢sin⁡β⁡t10−3⁢sin⁡η⁡t⁢ⅆ2ⅆt2η⁡t⁢sin⁡β⁡t10−3⁢sin⁡η⁡t⁢ⅆⅆtη⁡t⁢cos⁡β⁡t⁢ⅆⅆtβ⁡t5−3⁢cos⁡η⁡t⁢sin⁡β⁡t⁢ⅆⅆtβ⁡t210+3⁢cos⁡η⁡t⁢cos⁡β⁡t⁢ⅆ2ⅆt2β⁡t10,2⁢sin⁡θ⁡t⁢ⅆⅆtθ⁡t225−2⁢cos⁡θ⁡t⁢ⅆ2ⅆt2θ⁡t25+3⁢sin⁡η⁡t⁢ⅆⅆtη⁡t2⁢sin⁡β⁡t10−3⁢cos⁡η⁡t⁢ⅆ2ⅆt2η⁡t⁢sin⁡β⁡t10−3⁢cos⁡η⁡t⁢ⅆⅆtη⁡t⁢cos⁡β⁡t⁢ⅆⅆtβ⁡t5+3⁢sin⁡η⁡t⁢sin⁡β⁡t⁢ⅆⅆtβ⁡t210−3⁢sin⁡η⁡t⁢cos⁡β⁡t⁢ⅆ2ⅆt2β⁡t10,4⁢−61⁢sin⁡η⁡t⁢sin⁡θ⁡t4000+9⁢sin⁡η⁡t⁢sin⁡θ⁡t⁢cos⁡β⁡t2800−61⁢cos⁡θ⁡t⁢cos⁡η⁡t4000+9⁢cos⁡θ⁡t⁢cos⁡η⁡t⁢cos⁡β⁡t2800⁢ⅆ2ⅆt2η⁡t15⁢sin⁡β⁡t−4⁢217⁢sin⁡θ⁡t⁢cos⁡η⁡t20000−9⁢sin⁡θ⁡t⁢cos⁡η⁡t⁢cos⁡β⁡t2400−217⁢sin⁡η⁡t⁢cos⁡θ⁡t20000+9⁢sin⁡η⁡t⁢cos⁡θ⁡t⁢cos⁡β⁡t2400⁢ⅆ2ⅆt2β⁡t15⁢cos⁡β⁡t−9⁢sin⁡θ⁡t⁢cos⁡η⁡t−sin⁡η⁡t⁢cos⁡θ⁡t⁢sin⁡β⁡t⁢ⅆ2ⅆt2s⁡t50⁢cos⁡β⁡t+73⁢ⅆ2ⅆt2θ⁡t250000−3⁢sin⁡β⁡t⁢ⅆⅆtβ⁡t2⁢sin⁡θ⁡t⁢cos⁡η⁡t500−3⁢sin⁡β⁡t⁢ⅆⅆtη⁡t2⁢sin⁡θ⁡t⁢cos⁡η⁡t1000+3⁢sin⁡η⁡t⁢sin⁡β⁡t⁢ⅆⅆtη⁡t2⁢cos⁡θ⁡t1000+3⁢sin⁡β⁡t⁢ⅆⅆtβ⁡t2⁢sin⁡η⁡t⁢cos⁡θ⁡t500−30411⁢sin⁡θ⁡t125000−3⁢sin⁡η⁡t⁢cos⁡β⁡t⁢ⅆⅆtβ⁡t⁢ⅆⅆtη⁡t⁢sin⁡θ⁡t500−3⁢cos⁡β⁡t⁢ⅆⅆtβ⁡t⁢ⅆⅆtη⁡t⁢cos⁡θ⁡t⁢cos⁡η⁡t500
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=−arccos⁡23,η⁡0=arcsin⁡55,s⁡0=15,θ⁡0=0,D⁡β⁡0=12⁢525,D⁡η⁡0=−4825,D⁡s⁡0=625,D⁡θ⁡0=−6
dsn1 := dsolve(dsys union ics,numeric);
dsn1≔procx_rkf45...end proc
tt := time(): dsn1(5); time1 := time()-tt;
t=5.,β⁡t=−0.440221710798128,ⅆⅆtβ⁡t=3.61399010468775,η⁡t=0.159001441307917,ⅆⅆtη⁡t=0.623236064171025,s⁡t=0.271397346853229,ⅆⅆts⁡t=0.462019863044553,θ⁡t=−51.7583332394113,ⅆⅆtθ⁡t=−12.3007185229252
time1≔1.158
dsn2 := dsolve(dsys union ics,numeric,optimize=true);
dsn2≔procx_rkf45...end proc
tt := time(): dsn2(5); time2 := time()-tt;
t=5.,β⁡t=−0.440221710801189,ⅆⅆtβ⁡t=3.61399010466022,η⁡t=0.159001441306971,ⅆⅆtη⁡t=0.623236064075927,s⁡t=0.271397346852838,ⅆⅆts⁡t=0.462019863044033,θ⁡t=−51.7583332394012,ⅆⅆtθ⁡t=−12.3007185228025
time2≔0.170
`Speed increase factor`=time1/time2;
Speed increase factor=6.811764706
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.
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.
Let U and V be the "differentiation tables" of u⁡x,y,t and v⁡x,y,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 u⁡x,y,t or v⁡x,y,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];
e1≔u⁡x,y,t⁢∂2∂x∂yu⁡x,y,t+∂∂xu⁡x,y,t⁢∂∂yu⁡x,y,t+∂2∂t∂yu⁡x,y,t+∂2∂x2v⁡x,y,t
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.
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≔ⅆⅆxy1⁡x−y2⁡x,ⅆⅆxy2⁡x−y3⁡x−y4⁡x,ⅆⅆxy3⁡x−y5⁡x=0,ⅆⅆxy4⁡x−2⁢y1⁡x−2⁢x⁢y2⁡x−y5⁡x=0,ⅆⅆxy5⁡x−x2⁢y1⁡x−2⁢x⁢y3⁡x−y6⁡x=0,ⅆⅆxy6⁡x−x2⁢y2⁡x+2⁢y3⁡x=0
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)]
y1⁡x=_C3⁢x+_C2,y2⁡x=_C3,y3⁡x=−_C3⁢x2−_C2⁢x+_C1,y4⁡x=_C3⁢x2+_C2⁢x−_C1,y5⁡x=−2⁢_C3⁢x−_C2,y6⁡x=_C3⁢x3+_C2⁢x2−2⁢_C1⁢x−2⁢_C3
A nonlinear ODE of seventh order depending on three parameters a,b,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;
ODE≔−a⁢t2+a⁢u⁡t−315⁢a3⁢c⁢t6+259080⁢a5⁢t4−525⁢a3⁢c⁢t4−259080⁢a5⁢t2+13185⁢a3⁢c⁢t2+34544⁢a5−4335⁢a3⁢c+2159⁢b⁢t+1⁢t−12159⁢ⅆⅆtu⁡t−5⁢a3⁢t+14⁢t−14⁢105⁢t2⁢c+17272⁢a2−35⁢c⁢t⁢ⅆ4ⅆt4u⁡t4318−a3⁢t+15⁢t−15⁢315⁢t2⁢c+17272⁢a2−35⁢c⁢ⅆ5ⅆt5u⁡t17272−15⁢a3⁢63⁢t4⁢c+34544⁢a2⁢t2−70⁢t2⁢c−17272⁢a2+879⁢c⁢t⁢t+12⁢t−12⁢ⅆ2ⅆt2u⁡t2159−5⁢a3⁢315⁢t4⁢c+103632⁢a2⁢t2−210⁢t2⁢c−17272⁢a2+879⁢c⁢t+13⁢t−13⁢ⅆ3ⅆt3u⁡t4318−21⁢c⁢a3⁢t2−16⁢t⁢ⅆ6ⅆt6u⁡t17272−c⁢a3⁢t2−17⁢ⅆ7ⅆt7u⁡t34544=0
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,b,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,b=b,c=c,u⁡t=_C3,a=a,b=−109525⁢a5−_C3⁢a,c=−2159⁢a225,u⁡t=83165⁢a4⁢t6−332645⁢a4⁢t4+8316⁢a4⁢t2+_C3,a=0,b=0,c=c,u⁡t=_C9⁢t6+_C8⁢t5+_C7⁢t4+_C6⁢t3+_C5⁢t2+_C4⁢t+_C3
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.
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];
sys≔9⁢C−15⁢F⁡x⁢C+15⁢C2⁢F⁡x3+2−4⁢C⁢F⁡x2+2⁢C2⁢F⁡x434⁢C3⁢1−F⁡x+C⁢F⁡x35=9⁢x3⁢36⁢x4−45⁢x3−12⁢x2+30⁢x+434⁢3⁢x3−3⁢x2+25,C⁢4⁢C3⁢F⁡x7−4⁢F⁡x+135⁢C+60⁢C3⁢F⁡x6+315⁢C2⁢F⁡x3−315⁢F⁡x⁢C−60⁢C2⁢F⁡x4−12⁢C2⁢F⁡x5−60⁢C⁢F⁡x2+60+12⁢C⁢F⁡x3⁢1−F⁡x+C⁢F⁡x39⁢C−15⁢F⁡x⁢C+15⁢C2⁢F⁡x3+2−4⁢C⁢F⁡x2+2⁢C2⁢F⁡x42=3⁢x3−3⁢x2+2⁢2025⁢x7−2889⁢x6−540⁢x5+1998⁢x4−360⁢x3−72⁢x2+240⁢x+163⁢x2⁢36⁢x4−45⁢x3−12⁢x2+30⁢x+42,4⁢C3⁢F⁡x7−4⁢F⁡x+135⁢C+60⁢C3⁢F⁡x6+315⁢C2⁢F⁡x3−315⁢F⁡x⁢C−60⁢C2⁢F⁡x4−12⁢C2⁢F⁡x5−60⁢C⁢F⁡x2+60+12⁢C⁢F⁡x3⁢9⁢C−15⁢F⁡x⁢C+15⁢C2⁢F⁡x3+2−4⁢C⁢F⁡x2+2⁢C2⁢F⁡x44⁢C2⁢1−F⁡x+C⁢F⁡x34=3⁢2025⁢x7−2889⁢x6−540⁢x5+1998⁢x4−360⁢x3−72⁢x2+240⁢x+16⁢x⁢36⁢x4−45⁢x3−12⁢x2+30⁢x+44⁢3⁢x3−3⁢x2+24
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,F⁡x=1x
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.
The confluent 1F1 hypergeometric linear equation
ODE_1F1 := DEtools[hyperode]( hypergeom([a],[c], x), y(x)) = 0;
ODE_1F1≔a⁢y⁡x+−c+x⁢ⅆⅆxy⁡x−x⁢ⅆ2ⅆx2y⁡x=0
has one regular singularity at zero and one irregular singularity at infinity.
DEtools[singularities]( ODE_1F1 );
regular=0,irregular=∞
The ODE for the Integral and the Derivative of an Unknown
Given a nth order linear ODE for y⁡x, the ode_int_y and ode_y1 commands respectively compute the nth order linear ODE satisfied by ∫y⁡xⅆx and ⅆⅆxy⁡x.
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,ode_int_y,ode_y1
Y := diff_table( y(x) ): # Y[] = y(x)
PDEtools[declare](y(x), c(x), prime=x);
c⁡x⁢will now be displayed as⁢c
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;
c0⁢y+c1⁢y'+c2⁢y''+y''''=0
then the derivative of y satisfies
DEtools[ode_y1]( (49) ) = 0;
y''''−c0 '⁢y'''c0+c2⁢y''+c2 '⁢c0−c0 '⁢c2+c1⁢c0⁢y'c0−c0 '⁢c1−c02−c1 '⁢c0⁢yc0=0
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;
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 F⁡x,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 G⁡x,y satisfying:
d
(L o F)(x, y) = -- G(x, y)
dy
For more information, see DEtools[Zeilberger].
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=0ni⁡Ai,k⁢τk
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));
τ=tanh⁡∑k=0j⁡Ck⁢xk
where the Ck are constants with respect to the xj.
Use the new diff_table command to reduce redundant typing when entering differential equations.
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 };
KdV≔−p⁢ux,x+q⁢ux,x,x+u⁡x,t⁢ux+ut=0
Let's consider this problem taking p,q as parameters, so splitting into cases with respect to them; five TWS result.
{PDEtools[TWSolutions]( KdV, parameters = {p,q} )};
p=0,q=q,u⁡x,t=−12⁢tanh⁡_C2⁢x+_C3⁢t+_C12⁢q⁢_C22+8⁢_C23⁢q−_C3_C2,p=p,q=0,u⁡x,t=−2⁢tanh⁡_C2⁢x+_C3⁢t+_C1⁢p⁢_C2−_C3_C2,p=p,q=q,u⁡x,t=_C4,p=p,q=q,u⁡x,t=−3⁢tanh⁡_C3⁢t−p⁢x10⁢q+_C12⁢p225⁢q+6⁢tanh⁡_C3⁢t−p⁢x10⁢q+_C1⁢p225⁢q+250⁢_C3⁢q2+3⁢p325⁢q⁢p,p=p,q=q,u⁡x,t=−3⁢tanh⁡_C3⁢t+p⁢x10⁢q+_C12⁢p225⁢q−6⁢tanh⁡_C3⁢t+p⁢x10⁢q+_C1⁢p225⁢q+−250⁢_C3⁢q2+3⁢p325⁢q⁢p
The diffalg Package
By setting _Env_diffalg_charpres_method≔regchar, 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.
A system consisting of two polynomials in five variables u1,u2,u3,u4,u5:
PDEtools[declare]( (u1,u2,u3,u4,u5)(x), quiet );
_Env_diffalg_charpres_method := 'regchar';
_Env_diffalg_charpres_method≔regchar
R := diffalg[differential_ring](derivations = [x], ranking = [[u1,u2,u3,u4,u5]], notation=diff);
R≔ODE_ring
p1 := (u2(x)*u3(x)+u4(x)+u2(x))*u1(x)^2+(u2(x)*u3(x)+3)*u1(x)+1;
p1≔u2⁢u3+u4+u2⁢u12+u2⁢u3+3⁢u1+1
p2 := (1+u4(x)+u5(x))*u3(x)^2+u3(x)*(u5(x)^2+u4(x)+2)+u5(x)+2;
p2≔1+u4+u5⁢u32+u3⁢u52+u4+2+u5+2
ans := diffalg[Rosenfeld_Groebner]([p1,p2],R);
ans≔characterizable
To see the contents of each characteristic decomposition computed, enter: diffalgequations⁡ansi and diffalginequations⁡ansi; where i is a number between 1 and the number of decompositions computed, 22.
See Also
Index of New Maple 9.5 Features
Download Help Document