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

Online Help

All Products    Maple    MapleSim


Enhancements to Symbolic Capabilities in Maple 7

  

Maple 7 includes a number of enhancements to its symbolic capabilities.

 

Ordinary and Partial Differential Equations

New Behavior for the D Operator

Special Functions

Assuming

Assume

simplify

Vectors and Matrices

Integration

Miscellaneous

Ordinary and Partial Differential Equations

  

Remarkable improvements and additions have been made in the sector of "Exact Solutions for Differential Equations", keeping Maple's dsolve and pdsolve commands as state-of-the-art computational tools.

PDEs

• 

The Maple PDE solver, pdsolve, can now systematically tackle and in many cases successfully solve coupled systems of Partial Differential Equations.

  

- There are no restrictions (but for the computer resources) to the number of equations, unknown functions, or independent variables present in the system.

  

- The PDE system may also include inequations, additional Ordinary Differential Equations, and algebraic constraints involving the unknowns and the independent variables.

  

- The new routines are prepared to tackle PDE systems of type linear, and polynomially nonlinear including nonpolynomial coefficients. The latter are systematically uncoupled using techniques for polynomial systems, by means of a differential extension approach (see PDEtools[dpolyform]).

  

In previous releases, Maple became famous for its high performance in finding "Exact Solutions for Differential Equations". The new ability to find exact solutions to PDE systems as the ones described makes Maple 7 unique among all Computer Algebra Systems. For some examples of the type of problems which can now be tackled, see the Examples section of pdsolve,system.

ODEs

  

Nonlinear ODEs

  

Summary: A new implementation of symmetry methods, for systematically determining, when they exist, point symmetries for Ordinary Differential Equations, was added to Maple's dsolve. For nonlinear problems, this turns the already sophisticated Maple's ODE solver into the most advanced one among those available in computer algebra systems.

• 

A new full implementation of symmetry methods using a formal approach was prepared and incorporated into Maple's dsolve. The ODE point symmetries are computed by formally uncoupling and solving the underlying linear Partial Differential Equation system. These symmetries are then used to integrate the ODE using standard methods.

  

The Maple implementation of this systematic approach works with polynomially nonlinear as well as with nonpolynomial ODEs, and also in the presence of arbitrary parameters or functions. The new symmetry routines are in use by default in dsolve and can also be invoked directly by using the appropriate optional arguments (see dsolve,Lie and DEtools[symgen]). Examples:

infolevel[symgen] := 2:      # turn ON userinfo for symmetries

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)

diff(y(x),x,x) = -3*diff(y(x),x)^2/y(x)-2*diff(y(x),x)/x+1/(x^6*diff(y(x),x)*y(x)^6);

y''=3y'2y2y'x+1x6y'y6

(2)
  

A 3-dimensional symmetry group is found and used to build an implicit solution as follows:

dsolve((2), Lie, way=formal, implicit);

   -> Computing symmetries using: way = formal

0,1y3,x2,0,x,3y8

   <- successful computation of symmetries.

(3)
  

An example from Kamke's book, parametrized by an arbitrary function fx, where only the new symmetry routines succeed in solving the problem:

diff(y(x),x,x) = (3*diff(y(x),x)^2*f(x) - 3*y(x)*diff(y(x),x)*diff(f(x),x)
+ y(x)^2*diff(f(x),x,x) - 6*y(x)^5)/(f(x)*y(x));

y''=3y'2fx3yy'f '+y2f ''6y5fxy

(4)

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

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 5
   -> Computing symmetries using: way = formal

1fx&comma;yf 'fx2,fx&DifferentialD;xfx&comma;y2fx2+3f 'fx&DifferentialD;x3fx2

   <- successful computation of symmetries.

y=fx3fx&DifferentialD;x22c__3fx&DifferentialD;x+c__3213,y=1I3fx6fx&DifferentialD;x22c__3fx&DifferentialD;x+c__3213,y=I31fx6fx&DifferentialD;x22c__3fx&DifferentialD;x+c__3213,fx&DifferentialD;xyc__12108fxc__1y2fx2+12yfx+c__118c__1y2fx2+12yfx+2fx3yc__1y2fx2+12yfxc__2=0,fx&DifferentialD;x+yc__12108fxc__1y2fx2+12yfxc__118c__1y2fx2+12yfx2fx3yc__1y2fx2+12yfxc__2=0

(5)
• 

For second order nonlinear ODEs, a new algorithm was developed, to compute symmetries, and from there the ODE solution, when symmetries of the form 0&comma;Gx&comma;0&comma;Gx&comma;y&comma;Fx&comma;0&comma;Fx&comma;yGx&comma;Fx&comma;Gx, exist. In these lists, ξ&comma;η represent the infinitesimals of the symmetry generator f&rarr;xixf&plus;etayf. Instead of solving a PDE system, as for instance done in the formal approach, for symmetries of these forms, their computation can be performed without solving any auxiliary differential equations. Example (G is an arbitrary function of its argument):

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

y''=x2y'2+&ExponentialE;yx2xGy'&ExponentialE;yx1xx2+y'x2

(6)

dsolve((6));

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 5
   -> Computing symmetries using: way = patterns

0&comma;&ExponentialE;y,&ExponentialE;1x&comma;0

   <- successful computation of symmetries.

y=ln1c__2+RootOfx&ExponentialE;1x+Ei11x+` `_Z1G_f&DifferentialD;_f+c__1&ExponentialE;1x&DifferentialD;x

(7)
• 

For first order nonlinear ODEs, a new algorithm was developed, to compute symmetries, and from there the ODE solution, when symmetries of the form Fx&comma;Pxy+Qx exist. The algorithm follows the presentation in "First order ODEs, Symmetries and Linear Transformations", {Seventh Rhine Workshop on Computer Algebra, Austria, 2000} (see dsolve, references). This algorithm is of remarkable generality and enables dsolve in Maple 7 to solve a variety of new ODE families. Examples, one from Kamke's book:

x*diff(y(x),x)+a*y(x)-f(x)*g(x^a*y(x)) = 0;

xy'+ayfxgxay=0

(8)

dsolve((8));

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 4
   -> Computing symmetries using: way = 5
   -> Computing symmetries using: way = patterns

x1afx&comma;xaayfx

   <- successful computation of symmetries.

y=RootOffxxa1&DifferentialD;x+` `_Z1g_a&DifferentialD;_a+c__1xa

(9)

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

y'=LambertWx&ExponentialE;&ExponentialE;xy1+LambertWx&ExponentialE;x1x&ExponentialE;xy

(10)

dsolve((10));

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 4
   -> Computing symmetries using: way = 5
   -> Computing symmetries using: way = patterns

x1+LambertWxLambertWx&comma;1+LambertWxyx+&ExponentialE;xLambertWx

   <- successful computation of symmetries.

y=lnxLambertWxc__1x&ExponentialE;x

(11)

infolevel[symgen] := 0:      # turn OFF userinfo on symmetries

  

Linear ODEs

  

Summary: All the linear ODE routines were revised and various new solving approaches were added, leading to solutions to ODE families not solvable in previous Maple releases. The impact of these changes is quite significant -- the changes affect linear ODEs both with rational and nonrational coefficients.

  

A complete re-organization of the userinfo solving information was performed, so that it is now possible to accurately follow the solving path by issuing

infolevel[dsolve] := 3:

• 

There have been radical improvements in the determination of solutions, for second and higher order linear ODEs, in terms of special functions, when they could be obtained as particular cases of the generalized hypergeometric MeijerG function. Consider the following second and fifth order linear ODEs from Kamke's book:

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

(12)

dsolve((12));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Trying a Liouvillian solution using Kovacic's algorithm
<- No Liouvillian solutions exists
-> Trying a solution in terms of special functions:
   -> Bessel
   -> elliptic
   -> Legendre
   -> Kummer
      -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
   -> hypergeometric
      -> heuristic approach
      -> hyper3: Equivalence to 2F1, 1F1 or 0F1 under 'a power @ Moebius'
      <- hyper3 successful: received ODE is equivalent to the 2F1 ODE
   <- hypergeometric successful
<- special function solution successful

y=c__1xvhypergeom12&comma;v&comma;12v&comma;x2+c__2xv+1hypergeom12&comma;v+1&comma;32+v&comma;x2

(13)

x^10*diff(y(x),x$5)-a*y(x) = 0;

x10y'''''ay=0

(14)

dsolve((14));

Methods for high order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 5; missing the dependent variable
trying a solution in terms of MeijerG functions
<- MeijerG function solution successful

y=c__1hypergeom&comma;65&comma;75&comma;85&comma;95&comma;a3125x5+c__2xhypergeom&comma;45&comma;65&comma;75&comma;85&comma;a3125x5+c__3x2hypergeom&comma;35&comma;45&comma;65&comma;75&comma;a3125x5+c__4x3hypergeom&comma;25&comma;35&comma;45&comma;65&comma;a3125x5+c__5x4hypergeom&comma;15&comma;25&comma;35&comma;45&comma;a3125x5

(15)
• 

The Maple implementation of Kovacic's algorithm was entirely rewritten. The new implementation is much faster and can reliably tell whether a given second order linear ODE, with rational coefficients, admits Liouvillian solutions. The algorithm also works in the presence of symbolic parameters in the coefficient field. Also new, dsolve will now attempt to return a Liouvillian solution first. Example:

x^2*diff(y(x),x,x)+a*diff(y(x),x)-(b^2*x^2+a*b)*y(x) = 0;

(16)

dsolve((16));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Trying a Liouvillian solution using Kovacic's algorithm
   A Liouvillian solution exists
   Reducible group (found an exponential solution)
   Group is reducible, not completely reducible
   Solution has integrals. Trying a special function solution free of integrals...
   -> Trying a solution in terms of special functions:
      -> Bessel
      -> elliptic
      -> Legendre
      -> Kummer
         -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
      -> hypergeometric
         -> heuristic approach
         -> hyper3: Equivalence to 2F1, 1F1 or 0F1 under 'a power @ Moebius'
            -> trying extended approach, based on solving the ODE satisfied by the "derivative" of y(x)
               -> ODE succesfully computed; trying to solve: diff(diff(y(x),x),x) = -a*(b*x^2+a+2*x)/(b*x^2+a)/x^2*diff(y(x),x)+y(x)*b/x^2*(b^2*x^4+2*a*b*x^2+a^2+2*a*x)/(b*x^2+a)
            <- extended approach, failed in solving the ODE for the "derivative" of y(x)
      -> Mathieu
         -> Equivalence to the rational form of Mathieu ODE under 'a power @ Moebius'
            -> trying extended approach, based on solving the ODE satisfied by the "derivative" of y(x)
               -> ODE succesfully computed; trying to solve: diff(diff(y(x),x),x) = -a*(b*x^2+a+2*x)/(b*x^2+a)/x^2*diff(y(x),x)+y(x)*b/x^2*(b^2*x^4+2*a*b*x^2+a^2+2*a*x)/(b*x^2+a)
            <- extended approach, failed in solving the ODE for the "derivative" of y(x)
      -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
      <- Heun successful: received ODE is equivalent to the "HeunD" ODE, case "c = 0"
   <- Kovacic's algorithm successful

(17)
• 

In connection, a new mechanism was added to dsolve so that when a Liouvillian solution is too complicated, using the information on the underlying Galois group, dsolve reformulates the problem attempting a simpler form using special functions. Example:

1/576*(128*x^2-101*x+108)*y(x)/(x^2*(x-1)^2)+diff(y(x),x,x)=0;

(18)

dsolve((18));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Trying a Liouvillian solution using Kovacic's algorithm
   A Liouvillian solution exists
   Octahedral Galois group S4_SL2
   Basis solution with radicals (size = 108):
[x^(1/4)*(-1+x)^(5/12)*hypergeom([-1/24, 5/24],[2/3],-1/(-1+x)), x^(1/...
   -> attempting a simpler form using special functions
      (the Liouvillian form can be obtained using DEtools[kovacicsols])
   <- returning simpler solution using special functions (size = 47)
<- Kovacic's algorithm successful

y=c__1x141+xLegendreP16&comma;14&comma;x+c__2x141+xLegendreQ16&comma;14&comma;x

(19)
  

From the information displayed, in this example, the simplification obtained by means of this mechanism resulted in a solution forty times more compact.

• 

New methods have been added for higher order ODEs based on factoring Linear Differential Operators in various ways (see DEtools[DFactor] and DEtools[DFactorLCLM]). Example:

x^2*diff(y(x),x,x,x)-2*(n+1)*x*diff(y(x),x,x)+(a*x^2+6*n)*diff(y(x),x)-2*a*x*y(x)=0;

(20)

dsolve((20));

Methods for third order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 3; missing the dependent variable
Equation is the LCLM of -2*x/(x^2+2*(2*n-1)/a)*y(x)+diff(y(x),x), a*y(x)-2*n/x*diff(y(x),x)+diff(diff(y(x),x),x)
trying differential order: 1; missing the dependent variable
checking if the LODE is of Euler type
-> Attemtping a differential factorization
   trying exponential solutions
   checking if the LODE is of Euler type
   1, exponential solutions found
   exponential solutions successful
<- differential factorization successful
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful
<- solving the LCLM ode successful

(21)
  

The following is an example where this new differential factorization combines with the new methods for finding hypergeometric solutions.

diff(y(x),x,x,x) = (-8784+26985*x-17850*x^3-21235*x^2)*diff(y(x),x)/(-5565*x-11025*x^4+12390*x^2+4200*x^3)+(-11025*x^4-29800*x+34675*x^2+22050*x^3+8904)*diff(y(x),x,x)/(-5565*x-11025*x^4+12390*x^2+4200*x^3)+(-2750*x*y(x)-120*y(x)-1050*x^2*y(x))/(-5565*x-11025*x^4+12390*x^2+4200*x^3);

(22)

dsolve((22));

Methods for third order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 3; missing the dependent variable
Equation is the LCLM of -y(x)+diff(y(x),x), 2/21/(-1+x)/x*y(x)+1/105*(170*x-63)/(-1+x)/x*diff(y(x),x)+diff(diff(y(x),x),x)
trying differential order: 1; missing the dependent variable
trying linear constant coefficient
checking if the LODE has constant coefficients
<- constant coefficients successful
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      -> elliptic
      -> Legendre
      -> Kummer
         -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
      -> hypergeometric
         -> heuristic approach
         <- heuristic approach successful
      <- hypergeometric successful
   <- special function solution successful
<- solving the LCLM ode successful

y=c__1&ExponentialE;x+c__2hypergeom27&comma;13&comma;35&comma;x+c__3x25hypergeom2435&comma;1115&comma;75&comma;x

(23)
  

Maple can now detect rational fourth order linear ODEs whose solutions are obtained by multiplying solutions of two second order equations (see DEtools[symmetric_product]). Example:

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

4yx2+y'xy''y'''x+y''''=0

(24)

dsolve((24));

Methods for high order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 4; missing the dependent variable
Equation is the symmetric product of diff(diff(y(x),x),x)+(-1/4-x)*y(x) and diff(diff(y(x),x),x)+(-1/4+x)*y(x)
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful

y=c__1AiryAi14+xAiryAi14x+c__2AiryAi14+xAiryBi14x+c__3AiryBi14+xAiryAi14x+c__4AiryBi14+xAiryBi14x

(25)
• 

Various alternative approaches have been added for second order nonrational linear ODEs containing arbitrary parameters or functions, leading to solutions not achieved in previous Maple releases. Example:

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

y''xny'+xn1n2x2ny=0

(26)

dsolve((26));

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

y=&ExponentialE;xn+1n1&ExponentialE;xn1xn2&DifferentialD;xc__1+c__2&ExponentialE;xn1xn

(27)
• 

A new method for determining transformations mapping a nonrational linear ODE into a rational one was incorporated in Maple's dsolve. This method has noticeable impact in the ability for dsolve to tackle nonrational linear ODEs. Example:

x^2*diff(y(x),x,x)+y(x)/ln(x) = 0;

y''x2+ylnx=0

(28)

dsolve((28));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> trying a solution of the form r0(x) * Y + r1(x) * Y' where Y = exp(int(r(x), dx)) * 2F1([a1, a2], [b1], f)
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
      <- BRANCH 1 successful. Symmetry is:, [0, z]
   <- linear_1 successful
   Change of variables used:
      [x = exp(t)]
   Linear ODE actually solved:
      u(t)-t*diff(u(t),t)+t*diff(diff(u(t),t),t) = 0
<- change of variables successful

y=c__1lnx+c__2Ei1lnxlnx+x

(29)
  

A more difficult example (number 32 from Kamke's book) where this technique is combined with methods for finding special function solutions new in Maple 7 is the following:

diff(y(x),x,x) + (1/2*diff(g(x),x,x,x)/diff(g(x),x) -
3/4*diff(g(x),x,x)^2/(diff(g(x),x)^2) + (1/4-v^2)*diff(g(x),x)^2/g(x)+diff(g(x),x)^2)*y(x) = 0;

y''+g'''2g'3g''24g'2+14v2g'2gx+g'2y=0

(30)

dsolve((30), y(x));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> trying a solution of the form r0(x) * Y + r1(x) * Y' where Y = exp(int(r(x), dx)) * 2F1([a1, a2], [b1], f)
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      -> elliptic
      -> Legendre
      -> Whittaker
         -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
         <- hyper3 successful: received ODE is equivalent to the 1F1 ODE
      <- Whittaker successful
   <- special function solution successful
<- change of variables successful

y=c__1WhittakerMIv22I8&comma;12&comma;2Igxg'+c__2WhittakerWIv22I8&comma;12&comma;2Igxg'

(31)
• 

In Maple 7, dsolve explores the possibility of mapping the solving of one ODE type into the solving of another ODE type, and takes advantage of this when possible. For example, the following linear ODE, depending on an arbitrary function parameter fx, is now solved by using routines for Riccati type ODEs:

diff(y(x),x,x)-(f(x)^2+diff(f(x),x))*y(x) = 0;

y''fx2+f 'y=0

(32)

dsolve((32), y(x));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> trying a solution of the form r0(x) * Y + r1(x) * Y' where Y = exp(int(r(x), dx)) * 2F1([a1, a2], [b1], f)
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
   -> trying a solution of the form r0(x) * Y + r1(x) * Y' where Y = exp(int(r(x), dx)) * 2F1([a1, a2], [b1], f)
   -> Tackling the "Normal Form" of the given linear ODE:
      trying a symmetry of the form [xi=0, eta=F(x)]
   -> Tackling the linear ODE using alternative approaches:
      trying 2nd order exact linear
      trying symmetries linear in x and y(x)
      trying to convert to a linear ODE with constant coefficients
         testing BRANCH 1 ->
<- unable to find a useful change of variables
-> Tackling the linear ODE using alternative approaches:
   trying 2nd order exact linear
   trying symmetries linear in x and y(x)
   trying to convert to a linear ODE with constant coefficients
      testing BRANCH 1 ->
   trying to convert to an ODE of Bessel type
   -> trying reduction of order to Riccati
      trying Riccati sub-methods:
         trying Riccati_symmetries
         <- Riccati particular solution successful
      <- reduction of order to Riccati successful
   <- reduction of order to Riccati successful

y=&ExponentialE;2fx&DifferentialD;x&DifferentialD;x+c__1&ExponentialE;fx&DifferentialD;xc__2

(33)
• 

The algorithms for computing particular solutions to nonhomogeneous linear ODEs were rewritten and new algorithms added. Among the new features, Maple's dsolve can now compute d'Alembertian particular solutions free of integrals with which much simpler general solutions to nonhomogeneous ODEs are returned.  Example:

diff(y(x),x,x) - y(x)*x = (4*x^3+1)*ln(x)/(x*sqrt(x));

(34)

dsolve((34));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
trying high order exact linear fully integrable
trying differential order: 2; linear nonhomogeneous with symmetry [0,1]
trying a double symmetry of the form [xi=0, eta=F(x)]
-> Try solving first the homogeneous part of the ODE
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful
   -> Determining now a particular solution to the non-homogeneous ODE
      building a particular solution using variation of parameters
      particular solution has integrals (!)
      -> trying a d'Alembertian particular solution free of integrals
      <- d'Alembertian particular solution free of integrals successful
<- solving first the homogeneous part of the ODE successful

y=AiryAixc__2+AiryBixc__14xlnx

(35)
• 

Much simpler algorithms for mapping linear ODEs into ones having constant coefficients were incorporated in dsolve in Maple 7. For instance, for this third order ODE, example number 21 of Kamke's book, the solution is now the following:

diff(y(x),x,x,x)+3*a*x*diff(y(x),x,x)+3*a^2*x^2*diff(y(x),x)+a^3*x^3*y(x);

y'''+3axy''+3a2x2y'+a3x3y

(36)

dsolve((36));

Methods for third order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
<- successful conversion to a linear ODE with constant coefficients

y=&ExponentialE;ax22c__1+c__2&ExponentialE;3ax+c__3&ExponentialE;3ax

(37)
• 

All the methods used for tackling second order linear ODEs are now available directly at user level by giving optional extra arguments to Maple's dsolve. These methods can be tried separately, in sequence, or in any desired order. A list of the methods available can be seen via:

`dsolve/methods`[2, "linear_homogeneous all methods"];

quadrature&comma;const_coeffs&comma;Euler&comma;linear_1&comma;linear/missing_y&comma;Kovacic&comma;special_functions&comma;to_const_coeffs&comma;exact_linear&comma;sym_1&comma;Mathieu&comma;MeijerG&comma;Heun&comma;HeunG&comma;HeunC&comma;HeunB&comma;HeunD&comma;HeunT&comma;mu_xy&comma;equivalent_to_Bessel&comma;to_Riccati&comma;Bessel&comma;elliptic&comma;Legendre&comma;Whittaker&comma;Kummer&comma;cylindrical&comma;hypergeometric&comma;hypergeom1&comma;hypergeom2&comma;Riemann&comma;RNF&comma;hypergeometricsols&comma;rationalize_lode&comma;with_periodic_functions

(38)
  

One can now tackle a linear ODE using different choices of methods and then choose, among the different solutions returned, the one most convenient for the problem under consideration.

• 

The ability to solve linear ODEs using different solving methods also represents a new and powerful tool for studying Liouvillian, special functions, and the relations between them. For example

ode := diff(y(x),`$`(x,2)) = -y(x)-2*x*diff(y(x),x);

odey''=y2xy'

(39)

sol_h := dsolve(ode,[hypergeometric]);

Classification methods on request
Methods to be used are: [hypergeometric]
----------------------------
* Tackling ODE using method: hypergeometric
--- Trying classification methods ---
trying a solution in terms of hypergeometric functions
   -> heuristic approach
   <- heuristic approach successful
<- hypergeometric solution successful

sol_hy=c__1KummerM14&comma;12&comma;x2+c__2KummerU14&comma;12&comma;x2

(40)

sol_B := dsolve(ode,[Bessel]);

Classification methods on request
Methods to be used are: [Bessel]
----------------------------
* Tackling ODE using method: Bessel
--- Trying classification methods ---
  -> searching for a solution in terms of Bessel functions
  <- solution in terms of Bessel functions successful

sol_By=c__1&ExponentialE;x22xBesselI14&comma;x22+c__2&ExponentialE;x22xBesselK14&comma;x22

(41)
  

From the output above, any of the two hypergeometric functions entering sol_h is equal to the linear combination of the Bessel functions entering sol_B, for some particular values of c__1, c__2. To determine the exact relation, one could equate the expressions, expand in series, and solve for the coefficients c__1,c__2. For example, the following hypergeometric function

h1 := eval( rhs(sol_h), {_C1=1,_C2=0} );

h1KummerM14&comma;12&comma;x2

(42)
  

can be expressed in terms of Bessel functions as follows:

e1 := h1-rhs(sol_B)=0;

e1KummerM14&comma;12&comma;x2c__1&ExponentialE;x22xBesselI14&comma;x22c__2&ExponentialE;x22xBesselK14&comma;x22=0

(43)

series(lhs(e1),x,2);          # expand in series

1c__2πΓ34+2c__1Γ34π+c__2Γ342x+Ox2

(44)

coeffs(convert((44),polynom),x);  # coefficients of x

1c__2πΓ34,2c__1Γ34π+c__2Γ342

(45)

_C_values := solve({(45)},{_C1,_C2});  # compute _C

_C_valuesc__1=Γ3422&comma;c__2=Γ34π

(46)

eval(e1,_C_values);

KummerM14&comma;12&comma;x2Γ342&ExponentialE;x22xBesselI14&comma;x222Γ34&ExponentialE;x22xBesselK14&comma;x22π=0

(47)
  

Now, the hypergeometric function can be isolated, resulting in the desired identity:

isolate((47),h1);

KummerM14&comma;12&comma;x2=Γ342&ExponentialE;x22xBesselI14&comma;x222+Γ34&ExponentialE;x22xBesselK14&comma;x22π

(48)
  

In the same way, it is now possible to use dsolve to investigate the relationship between hypergeometric and Liouvillian functions, whenever that relationship exists. For an example, see dpolyform.

New Behavior for the D Operator

• 

Expressions of the form D1fx are now automatically simplified to the ``canonical'' form Dfx.

• 

It is now an error to call a derivative with respect to the kth variable of a function with fewer than k arguments, when k is a literal positive integer.

D[1](f)(x);

Dfx

(49)

D[2](f)(x);

Error, (in evalapply) too few variables for the derivative with respect to the 2nd variable

D[a,b,c](f)(x);

Da,b,cfx

(50)

D[a,b,c](f)(x,y);

Da,b,cfx&comma;y

(51)

D[a,4,c](f)(x,y);

Error, (in evalapply) too few variables for the derivative with respect to the 4th variable

Special Functions

Converting to StandardFunctions

  

convert/StandardFunctions knows more about the MeijerG, ModifiedMeijerG and the 2F1 form of hypergeometric functions.

assume(n,nonnegint);

convert(hypergeom([-n,-n],[1/2-2*n],z),StandardFunctions);

−1n~2n~!24zn~LegendreP2n~&comma;z1z4n~!

(52)

n := 'n':

Converting to MeijerG and ModifiedMeijerG

  

convert/MeijerG (or convert/ModifiedMeijerG) now converts most mathematical expressions in terms of elementary and special functions to their equivalent MeijerG (or ModifiedMeijerG) representation via convertexpr&comma;MeijerG&comma;z where expr is to be viewed as a function of z (or equivalently, to ModifiedMeijerG form via convertexpr&comma;ModifiedMeijerG&comma;z).

Assuming

• 

The new Maple command, assuming, receives an expression (to its left) and a sequence of assumptions (to its right), and evaluates the expression under the given assumptions. The output of assuming is the same as one would receive by first calling assume, entering the assumptions on names, then entering (and so evaluating) an expression depending on those names, and finally removing all the assumptions on the names involved. The advantage of assuming is that it shortcuts this process to one step and permits experiments concerning the value of a given expression under different assumptions in an easy way.

sqrt(x^2) assuming x > 0;

x

(53)

e1 := ln(-a[i]/x)-ln(a[i])+ln(-x);

e1lnaixlnai+lnx

(54)

simplify(e1) assuming a[i]::positive;

ln1x+lnx

(55)

simplify(e1) assuming x::negative;

0

(56)

simplify(e1) assuming posint;  # equivalent to all names being 'posint'

2Iπ

(57)

e2 := Int(exp(-u*x)*x^(1/3),x=0..infinity);

e20&ExponentialE;uxx13&DifferentialD;x

(58)

value(e2) assuming u >= 0;

2π39Γ23u43

(59)

value(e2) assuming u < 0;

(60)
  

For more examples of this useful facility see assuming.

Assume

• 

The assume facility is now able to work with indexed names.

assume(a[1]>0);

assume(a[2]>=0);

is(a[1]>0);

true

(61)

is(a[2]>0);

false

(62)

is(a[1]+a[2]>0);

true

(63)
• 

Assume now knows more about some linear properties and expressions involving powers.

assume(n,even);

is(n^2,even);

true

(64)

is(n^4/8,even);

true

(65)

assume(m>0);

is(2^m>m);

true

(66)
• 

Assume now accepts arguments in obj::prop notation.

assume(n::even);

is(n::integer);

true

(67)

simplify

  

The efficiency improvements to Maple's simplify command include two new routines, for simplifying constant expressions and simplifying the size of an expression. Examples:

(-1)^(6/7)-(-1)^(1/7)+(-1)^(4/7)+(-1)^(2/7)-(-1)^(3/7)-171/2-(-1)^(5/7);

−167−117+−147+−127−1371712−157

(68)

simplify( (68), constant );

1732

(69)
  

The new routine is called automatically, so that the simplification will happen even if the extra argument constant is not given.

184-1200/7*cos(3/7*Pi)^2*cos(1/7*Pi)+128/7*cos(3/7*Pi)^6-
4/7*cos(3/7*Pi)*(120*cos(3/7*Pi)*cos(1/7*Pi)-192*cos(3/7*Pi)^5)-1200/7*cos(2/7*Pi)^2*cos(3/7*Pi)+128/7*cos(2/7*Pi)^6+4/7*cos(2/7*Pi)*(-120*cos(3/7*Pi)*cos(2/7*Pi)+192*cos(2/7*Pi)^5)+1200/7*cos(2/7*Pi)*cos(1/7*Pi)^2+128/7*cos(1/7*Pi)^6-4/7*cos(1/7*Pi)*(-120*cos(1/7*Pi)*cos(2/7*Pi)-192*cos(1/7*Pi)^5);

1841200cos3π72cosπ77+128cos3π7674cos3π7120cos3π7cosπ7192cos3π7571200cos2π72cos3π77+128cos2π767+4cos2π7120cos3π7cos2π7+192cos2π757+1200cos2π7cosπ727+128cosπ7674cosπ7120cosπ7cos2π7192cosπ757

(70)

simplify( (70) );

350

(71)

1/4*exp(-1/4*x^2)*2^(1/4)*x^(3/2)+1/8*exp(1/4*x^2)*2^(3/4)*sqrt(x)*sqrt(Pi)*erf(1/2*sqrt(2)*x)+1/8*exp(1/4*x^2)*2^(3/4)*x^(5/2)*sqrt(Pi)*erf(1/2*sqrt(2)*x);

&ExponentialE;x24214x324+&ExponentialE;x24234xπerf2x28+&ExponentialE;x24234x52πerf2x28

(72)

simplify( (72), size );

214erf2x22πx2+1&ExponentialE;x24+2&ExponentialE;x24xx8

(73)
  

The simplification of the size of an expression is not used by Maple's simplify by default and is performed only when given the extra argument size.

  

The simplification of the size of an expression is also available in the context-sensitive menu by right-clicking an expression and choosing Simplifications and then Size.

Vectors and Matrices

  

 

  

The Vector Constructor Function

  

The Vector function has been extended to accept an initializer which is a list, some or all of whose elements are also lists, in a more natural way.  In such cases, the inner lists are ``flattened'', i.e., they are treated as expression sequences rather than lists.  This flattening is carried out only one level; it is not recursive.

Vector([[10.0],[11.0],[12.1]]);

10.011.012.1

(74)
  

 

  

convert/Vector

• 

The convert/Vector command now accepts an optional ``row'' or ``column'' orientation specifier.

convert( [1,2,3], Vector[row] );

123

(75)
• 

The convert/Vector command has been extended to convert Matrices, matrices, 2-D Arrays, and 2-D arrays.  Given such input, the resulting Vector is constructed by concatenating either the rows or columns of the input object. Concatenation of rows is obtained via convertM&comma;Vectorrow, where M is, for example, a Matrix.  Concatenation of columns is obtained via convert(M,Vector) or convertM&comma;Vectorcolumn.

M := <<1,2,3>|<4,5,6>>;

M142536

(76)

convert( M, Vector);

123456

(77)

Integration

• 

int now includes a decision procedure to integrate elliptic functions expressed as rational functions in WeierstrassP and WeierstrassPPrime.

alias(P(x) = WeierstrassP(x,g2,g3),Pp(x) = WeierstrassPPrime(x,g2,g3)):

Int( Pp(x)/(Pp(x) + P(x)^2), x);

WeierstrassPPrimex&comma;g2&comma;g3WeierstrassPPrimex&comma;g2&comma;g3+WeierstrassPx&comma;g2&comma;g32&DifferentialD;x

(78)

value((78));

_R=RootOf_Z44_Z3+g2_Z+g3_R2lnWeierstrassPx&comma;g2&comma;g3_R4_R312_R2+g2+_&alpha;=RootOf_Z44_Z3+g2_Z+g34_&alpha;3+_&alpha;g2+g3lnWeierstrassSigmaxRootOfWeierstrassP_Z&comma;g2&comma;g3+_&alpha;&comma;g2&comma;g3WeierstrassSigmax+RootOfWeierstrassP_Z&comma;g2&comma;g3+_&alpha;&comma;g2&comma;g3+2xWeierstrassZetaRootOfWeierstrassP_Z&comma;g2&comma;g3+_&alpha;&comma;g2&comma;g34_&alpha;312_&alpha;2+g24_&alpha;3_&alpha;g2g3

(79)

alias(P(x)=P(x),Pp(x)=Pp(x)):

Miscellaneous

subsindets

• 

Often, one seeks to transform all subexpressions of a given expression that are of a given type by some well defined transformation. A new command subsindets has been introduced to promote the efficient implementation of this common pattern of expression manipulation.

expr := sin( x * ( x + 1 ) + ( x + 1 ) * ( x + 2 ) );

exprsinxx+1+x+1x+2

(80)

subsindets( expr, '`*`', expand );

sin2x2+4x+2

(81)

expand( expr );

16sinx2cosx2cos2cosx416sinx2cosx2cos2cosx2+2sinx2cosx2cos216sinx2cosx2sin2sinxcosx3+8sinx2cosx2sin2sinxcosx+16cosx22cos2sinxcosx38cosx22cos2sinxcosx+16cosx22sin2cosx416cosx22sin2cosx2+2cosx22sin28cos2sinxcosx3+4cos2sinxcosx8sin2cosx4+8sin2cosx2sin2

(82)

Primfield

• 

There is now an implementation of Primfield (computation of a primitive description of an algebraic extension) for finite fields Fp. See Primfield for details.

Subfield

• 

Compute the subfields of an algebraic field extension that is given by one root of an irreducible polynomial. See Subfields for details.

Logical Quantifier functions

  

Logical assertions involving the universal and existential quantifiers of predicate calculus may be represented by the new top-level functions forall and exists.

forall( x, x > 0 );

x&comma;0<x

(83)
  

These functions do not attempt to evaluate truth values of given assertions, rather, they act as placeholders to represent assertions for interpretation by other applications.  Except for some basic canonicalization and error-checking, they are inert.

convert/decimal

  

The functionality of convert/decimal has been expanded to be able to convert any base from 2 to 36 to decimal. The first argument may be either any integer or floating-point number, or a string representing one of these two.

convert("10001101", decimal, binary);

141

(84)

convert("1A.C", decimal, hex);

26.75000000

(85)

convert("Maple.7", decimal, 36);

3.745128219×107

(86)