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

Online Help

All Products    Maple    MapleSim

New and Enhanced Packages in Maple 14

Maple 14 contains the following new packages and enhancements to existing packages.

New Packages


CUDA package


DifferentialAlgebra package

Enhanced Packages


DEtools package


DynamicSystems package


Groebner package


IntegerRelations package


LinearAlgebra package


PDEtools package


RegularChains package


RootFinding package


StringTools package


Threads[Task] package

















We have added GPU support for accelerating LinearAlgebra Matrix multiplication using NVIDIA's CUDA technology.  The new CUDA package can be used to enable GPU acceleration. See Efficiency Improvements in Maple 14 for more details and an example.



The new DifferentialAlgebra package supersedes the previous Maple diffalg with an improved set of commands and interface easier to use, for simplifying and manipulating systems of polynomial differential equations (ODE, PDE, DAE, PDAE), also running all the core computations directly in C, faster.


The main functionality of the package is provided by the RosenfeldGroebner command, which permits triangularizing a differential equation system so that it can be solved eliminating one variable at a time, simplifying the system with respect to its integrability conditions, or determining its singular cases.


Commands are also provided to tackle related problems, like BelongsTo for deciding membership to a differential ideal, ReducedForm for reducing a system of partial differential equations with respect to another one and PowerSeriesSolution for computing formal power series solutions for differential equation systems. Other commands for analyzing mathematical properties of differential systems or do algebraic manipulation and related programming are listed in DifferentialAlgebra.


The new features in DifferentialAlgebra allow for a faster and more thorough analysis of DE systems. Among the novelties:


there is flexibility to tackle systems where the dependent variables (functions) have different dependency or no dependency at all;


the systems can include variables and functions that are arbitrary;


it is possible to optionally compute only the general case, or additionally only the essential singular cases, or all of them (default behavior);


simplification of polynomial differential systems can now be performed over nontrivial differential fields (related to the new handling of arbitrary functions);


the package includes a very recent algorithm for the fast recomputation of an equivalent differential equation system (represented by its ideal) after changing the ranking ordering for the dependent and/or independent variables;


As for the redesigned interface, aiming at making computations easier, faster and more flexible


different mathematical notations can be used making easier to enter a problem as well as to read the solution returned in compact notation. It is not necessary to indicate what is the notation being used in the input and you can optionally specify the notation desired in the output;


it is not required anymore to specify the basefield of a computation. Instead, the basefield is consistently derived from the input automatically, on the fly;


you can change or add to the dependent, independent and arbitrary variables and functions specified in the differentia ring, as well as changing their ranking, without having to redefine the differential ring;


you can specify algebraic relations between the arbitrary variables and functions of a PDE system by passing them directly to RosenfeldGroebner in a natural way, as in relations = {..equations..}.

Parametric differential systems




Consider this nonlinear ODE in ux that also depends on a parameter p

ODE := (p-1)*diff(u(x),x)-u(x)^2;



The following differential ring permits to manipulate ODE" as if p' is also a dependent variable (with no dependency, all its derivatives are zero), thus realizing the concept of a parameterized ODE.

ring := DifferentialRing(derivations = [x], blocks = [u,p]);



Analyze the problem now and determine its singular case, finding it is related to the critical value p=1

ideal := RosenfeldGroebner(ODE, ring);



Here are the two cases:

Equations(ideal, solved);



Regard now p as arbitrary, so do not discuss cases in terms of its values

ideal := RosenfeldGroebner(ODE, ring, arbitrary = p);



Equations(ideal, solved);



Power series solutions

Consider the heat equation, here entered directly in (simpler) jet notation, where subscripts indicate derivations

PDE := [u[t, t]-u[x]];



This is a problem in one dependent variable u(t, x); set the differential ring

ring := DifferentialRing(derivations = [t, x], blocks = [u]);



Compute the ideal for PDE

ideal := RosenfeldGroebner(PDE, ring);



The series solution for initial values depending on two arbitrary functions, u(0, x) = f(x) and D[1](u)(0, x) = g(x) also entered in jet notation.

PowerSeriesSolution(ideal, 2, [u = f(x), u[t] = g(x)]);



Normal Forms

Consider the following PDE system

sys := [diff(g(x,y),x) = 2*g(x,y)^2+2, diff(g(x,y),y)^2 = -1/4*(-g(x,y)^4-2*g(x,y)^2-1)/y];



So this is a problem with one unknown gx,y, set the differential ring

ring := DifferentialAlgebra[DifferentialRing](derivations = [x,y], blocks = [g]):

Compute now the ideal but only the general case, disregarding singular cases

ideal := RosenfeldGroebner(sys, ring, singsol = none);



Check the equations representing this general case in the ideal computed

eqs := Equations(ideal[1], solved);



Here is one of its solutions (see pdetest)

sol := tan(2*x-y^(1/2));



pdetest(g(x,y) = sol, eqs);



Thus, these two following expressions expr1 and expr2 

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



expr2 := - diff(g(x, y), x, y)/diff(g(x, y), y)^2;



are actually equivalent, modulo the differential ideal presented by ideal. That is, these two expressions are equal when evaluated at g(x, y) = sol, and, more generally, when evaluated at any solution of the differential ideal:

simplify(subs(g(x,y) = sol, expr1 - expr2));



The equivalence between expr1 and expr2 fact can be derived by computing their normal forms and checking that they are syntactically equal

NF[1] := NormalForm(expr1, ideal);



NF[2] := NormalForm(expr2, ideal);



NF[1] - NF[2];




DEtools[particularsol] using integrating factors

particularsol can now compute particular solutions for an nth order ODE from any incomplete set (less than n) integrating factors admitted by ODE. This is of use when the ODE cannot be solved in general but a particular solution may be sufficient. For example, the general solution of this second order nonlinear ODE

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



is not known. In Maple 13, two particular solutions depending on no arbitrary constants can be computed for it exploring its symmetries. One integrating factor for this ode can however also be computed, and from it in Maple 14 a new particular solution depending on 1 arbitrary constant _C1 is computable, the third one in this sequence of solutions;

particular_sol := DEtools[particularsol](ode);



To illustrate the use of this new particular solution, consider the initial value problem that consists on solving this ode subject to the initial values

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



The standard approach of computing first the general solution of ode is here of no use because that solution is not known. Having computed the one parameter (_C1) solution with particularsol, you can try to adjust it to match these initial conditions in different ways. For instance, using DEtools[IVPsol], introduced in Maple 13 for these purposes, you can pass directly the particular solution you want to be used and the initial values, in this example solving the ODE and initial value problem entirely, as in

DEtools[IVPsol]([iv], particular_sol[2]);



Alternatively you can pass this particular solution to dsolve so that it tackles the problem departing from this given solution 

dsolve([ode, iv], solution = particular_sol[2]);



Note that this approach is also automatically explored by dsolve in Maple 14 even if you do not request it (though in that case the computation will take significantly longer because a general solution is first attempted with no success)

sol := dsolve([ode, iv]);



DEtools[firint] and complete sets of first integrals for linear ODEs

The DEtools[firint] command can now compute a complete set of first integrals for linear ODEs, that is as many as the differential order and all independent from each other. A textbook example:

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

gxwill now be displayed asg

yxwill now be displayed asy

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


ode := diff(y(x), x,x) = ((diff(g[1](x), x,x))*g[2](x)-g[1](x)*(diff(g[2](x), x,x)))*(diff(y(x), x))/(g[2](x)*(diff(g[1](x), x))-g[1](x)*(diff(g[2](x), x)))+((diff(g[1](x), x))*(diff(g[2](x), x,x))-(diff(g[1](x), x,x))*(diff(g[2](x), x)))*y(x)/(g[2](x)*(diff(g[1](x), x))-g[1](x)*(diff(g[2](x), x)))+((diff(g[0](x), x,x))*(-g[2](x)*(diff(g[1](x), x))+g[1](x)*(diff(g[2](x), x)))+((diff(g[1](x), x))*g[0](x)-g[1](x)*(diff(g[0](x), x)))*(diff(g[2](x), x,x))-((diff(g[2](x), x))*g[0](x)-g[2](x)*(diff(g[0](x), x)))*(diff(g[1](x), x,x)))/(-g[2](x)*(diff(g[1](x), x))+g[1](x)*(diff(g[2](x), x)));



This ode is the most general 2nd order non-homogeneous linear ODE having for solution basis g1 and g2, for the homogeneous part, and g0 as particular solution of the whole non-homogeneous equation, so the basis of solutions is represented in Maple by

basis_sol := [[g[1](x), g[2](x)], g[0](x)];



To verify that basis_sol is a complete basis for the solutions of ode, construct with it the general solution then test it using odetest

sol := y(x) = _C1*g[1](x) + _C1*g[2](x) + g[0](x);



odetest(sol, ode);



Compute now a complete set of first integrals for ode

first_integrals := DEtools[firint](ode, y(x), basis = basis_sol);



Verify this result

map(DEtools[firtest], [first_integrals], ode, y(x));






A new command, NyquistPlot, was added to the DynamicSystems package. It plots the Nyquist plot of a linear system.


A new command, StepProperties, was added to this package. It calculates the properties of a step response.


Two new commands, EquilibriumPoint and Linearize, were added to this package.  EquilibriumPoint finds a local equilibrium point for a nonlinear system of DAEs.  Linearize allows a set of nonlinear differential equations to be linearized and converted to a state-space form. These commands are useful in control system design, as you can analyze trim conditions, linearize at a trim (equilibrium) point, and then work with the resulting state-space representation of the linear model.


A new command, SystemConnect, was added to this package. This allows different DynamicSystems objects to be interconnected.


A new option adaptive was added to the following commands: BodePlot, FrequencyResponse, MagnitudePlot, NyquistPlot, and PhasePlot. This option allows the specification of the frequency points to be spaced adaptively, which results in a better looking plots.



Use the Groebner[Support] command to inspect the monomials in the polynomial in the Groebner basis.

Groebner[Support]([x^2+23*2+12, y-x/2-1/3]);





The IntegerRelations[PSLQ] command has been extended to work over the complex numbers. For example, this can be used to find the minimal polynomial of a complex algebraic number:

alpha := sqrt(2)+(-1)^(1/3);



powers := map(evalf, [seq(expand(alpha^i), i=0..4)]);



u := IntegerRelations[PSLQ](powers);



minpoly := PolynomialTools[FromCoefficientList](u,x);



radnormal(eval(minpoly, x=alpha));






Improved method for providing output options to LinearAlgebra commands. Most commands in the LinearAlgebra package return one or more Matrices or Vectors.  Until now, the mechanism for passing options to the corresponding Matrix or Vector constructor has been through the inclusion of an outputoptions=[...] option.  This was safe and effective, but somewhat unwieldy. As of this release, these constructor options can be included directly in the LinearAlgebra command itself.  For example,

LinearAlgebra[RandomMatrix](5, datatype=float);



The older form, using the outputoptions=[...] option, continues to be valid, and, in particular, continues to be necessary in the case of LinearAlgebra commands which return more than one object. For example,

LinearAlgebra[LUDecomposition]( <1,2,3;4,5,6;7,8,9>, output=['P','L','U'], outputoptions['L']=[datatype=float] );



If a constructor option appears both in the command calling sequence directly and as an outputoptions suboption, the latter takes precedence, regardless of the order in which the options appear.  This allows you to specify options which are to apply to all output objects and then override specific constructor options for selected output objects.

LinearAlgebra[LUDecomposition]( <1,2,3;4,5,6;7,8,9>, output=['P','L','U'], datatype=float, outputoptions['L']=[datatype=integer] );,100410721,−3.−


New commands CARE and DARE have been added to the LinearAlgebra package. These provide functionality to numerically solve real-valued, implicit linear systems known respectively as Continuous and Discrete Algebraic Riccati Equations. These equations feature prominently in the area of Optimal Control, such as in computational implementations of Linear-Quadratic Regulators.



Two new commands were added to PDEtools.


Solve is an unified command to compute exact, series or numerical solutions, possibly independent of indicated variables, for systems of algebraic or differential equations, possibly including inequations, initial values or boundary conditions. In this sense Solve provides the functionality of solve, fsolve, dsolve, pdsolve and more, through a single command that understands which command is to be called according to your input. Second, Solve has the ability to compute these solutions independent of specified variables, generalizing the functionality provided by solve[identity] to exact, series or numerical solutions, to systems of non-polynomial algebraic and/or differential equations, and allowing for an arbitrary number of identity variables. This unification together with its new solving capability make concretely simpler the interactive study of the solutions of an algebraic or differential equation system.


InvariantEquation to compute the invariant equation that admits a given symmetry group


Four new PDEtools:-Library commands were added to the library of tools to manipulate PDE systems and facilitate programming with them. These are: JetNumbersToJetVariables, JetVariablesToJetNumbers, NormalizeBoundaryConditions and ToSameVariables.





A non-differential equation

eq[1] := a*x^2 + b*x + c;



Solve(eq[1], x);



An ODE problem and its series solution

eq[2] := diff(y(x),x) = y(x);



Solve(eq[2], series);



A PDE problem with boundary conditions

eq[3] := [diff(u(x, t), t)+c*(diff(u(x, t), x)) = -lambda*u(x, t), u(x, 0) = phi(x)];






Numerical solution for a PDE with boundary conditions

eq[4] := [diff(u(x,t),t) = -diff(u(x,t),x), u(x,0) = sin(2*Pi*x), u(0,t) = -sin(2*Pi*t)];



sol[4] := PDEtools:-Solve(eq[4], numeric, time=t, range=0..1);

sol4:=moduleexportplot&comma;plot3d&comma;animate&comma;value&comma;settings&semi;...end module


sol[4]:-plot(t=0, numpoints=50);


In the examples above the advantage with regards to calling solve, dsolve or pdsolve is in using a single command and having a unified format for the input and output. Solve however also provides additional functionality: it can compute solutions independent of indicated variables. The system being solved using independentof can also contain inequations

eq[5] := [k*a*c*(a+b)*exp(k*d*t)-2*a*exp(k*t)*k+Q*(-c+a)*x, a <> 0];



Solve(eq[5], {a, b, c, d}, independentof = {t, x});



Solutions that are independent of the specified variables can be computed as well for differential equations or systems of them;

eq[6] := diff(f(x,y),x)*diff(g(x,y),x) + diff(f(x,y),y)*diff(g(x,y),y) + g(x,y)*(diff(f(x,y), x,x) + diff(f(x,y), y,y)) = -1;



Here are solutions for this PDE that are independent of x and independent of y

Solve(eq[6], independentof = x);



Solve(eq[6], independentof = y);



The new InvariantEquations command computes equations that are invariant under given symmetries. Consider the list of infinitesimals of this 1-dimensional symmetry group

S := [x, 1, u];



The 1st order partial differential equation invariant under the symmetry transformation underlying these infinitesimals is

PDE := InvariantEquation(S, u(x, t), name = Lambda);

* Partial match of 'name' against keyword 'arbitraryfunctionname'



The third order PDE invariant under S is

PDE := InvariantEquation(S, u(x, t), order = 3);



When the arbitraryfunctionname is not indicated, as in this input above, the name used is of the form _Fn with n integer. The invariance of this PDE can be verified in various ways, the simplest of which is perhaps to use SymmetryTest, that verifies that S is a symmetry of PDE

SymmetryTest(S, PDE);



With InvariantEquations you can also compute the equation invariant under n-dimensional symmetry groups; consider for instance the following list of 5 symmetries of a problem that involves two dependent variables ux&comma;t,vx&comma;t

G := [[_xi[x] = 0, _xi[t] = 1, _eta[u] = 0, _eta[v] = 0], [_xi[x] = 0, _xi[t] = 0, _eta[u] = 1, _eta[v] = 0], [_xi[x] = 1, _xi[t] = 0, _eta[u] = 2*t, _eta[v] = 0], [_xi[x] = t, _xi[t] = 0, _eta[u] = t^2+x, _eta[v] = 0], [_xi[x] = 1/2*x+3/2*t^2, _xi[t] = t, _eta[u] = t^3+3*t*x, _eta[v] = -v]];



The related 1st order invariant PDE family is:

PDE := InvariantEquation(G, [u, v](x, t), arbitraryfunctionname = Lambda);



map(SymmetryTest, G, PDE, [u, v](x, t));




RegularChains package in Maple 14 provides the following new commands:


Intersect solves polynomial systems incrementally.


RealTriangularize computes triangular decompositions of the real roots of polynomial systems.


CylindricalAlgebraicDecompose computes an F-invariant cylindrical algebraic decomposition of a set of polynomials F.


SubresultantChain creates a data structure which encodes the subresultant chain of two polynomials regarded as univariate polynomials. Different representations of the subresultant chain are supported: by values, over monomial basis, or via Bezout matrices.

It also provides the following improvements to some existing commands:


RegularGcd provides a new calling sequence for faster GCD computations modulo regular chains.


ComprehensiveTriangularize provides a new option, piecewise, for displaying readable output.


RealRootIsolate provides an alternative algorithm, Discoverer. It also isolates the real roots of any semi-algebraic system with finitely many complex solutions.


Triangularize implements a new and faster algorithm, in particular for systems with infinitely many solutions.


New and faster algorithms are available for RegularGcd and Regularize.



The RootFinding package has three new commands:


Given a point that does not lie on a given real manifold, EnclosingBox computes a box around the point that does not intersect the manifold.


The HasRealRoots command determines whether a given set of polynomial equations is solvable over the real numbers.


The WitnessPoints command can find a point on every connected component of a real manifold, or it can find a point on every connected component of the complement of a real manifold.




Compute and display a box inside the unit circle that contains the origin:


circle := x^2+y^2-1;



EnclosingBox(circle, [x=0, y=0], 'output'='plot');


Determine whether a circle and a hyperbola intersect:

HasRealRoots([circle, x*y-1]);



HasRealRoots([circle, 2*x*y-1]);



Isolate([circle, 2*x*y-1], [x,y]);



HasRealRoots([circle, 4*x*y-1]);



Isolate([circle, 4*x*y-1], [x,y]);



The RootFinding[Parametric] subpackage has been enhanced:


The commands DiscriminantVariety and CellDecomposition can now handle systems with more equations than variables.


The command CellDecomposition has been extended to accept inequations (of the form g0), and it has a new option output.



The StringTools package contains the new command IsEodermdrome.


The StringTools package also contains two new commands for data compression, Compress and Uncompress.  These apply zlib compression and expansion of sets of data including strings and byte arrays.



A new function has been added to the Task Programming Model.  The Return function allows a Task to stop the execution of the Task Model and return a particular value from Start.

See Also

Index of New Maple 14 Features

Updates to Differential Equation (DE) Solvers in Maple 14