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..}.

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]);

$\left[\left[x^2\,1\right]\,\left[1\,x\,y\right]\right]$

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);

$\mathrm{\alpha }≔\sqrt{2}+{\left(\mathrm{-1}\right)}^{\raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{$3$}\right.}$

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

$\mathrm{powers}≔\left[1.\,1.914213562+0.8660254037\mathrm{I}\,2.914213562+3.315515146\mathrm{I}\,2.707106782+8.870387035\mathrm{I}\,\mathrm{-2.500000000}+19.32423841\mathrm{I}\right]$

u := IntegerRelations[PSLQ](powers);

$u≔\left[7\,2\,\mathrm{-1}\,\mathrm{-2}\,1\right]$

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

$\mathrm{minpoly}≔x^4-2x^3-x^2+2x+7$

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

$0$

unassign('u');

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);

$\left[\begin{array}{ccccc}\mathrm{-35.}& 7.& 95.& 2.& \mathrm{-3.}\\ 73.& 44.& 0.& 25.& 37.\\ 22.& \mathrm{-60.}& 26.& 7.& 18.\\ 68.& \mathrm{-74.}& \mathrm{-15.}& \mathrm{-53.}& \mathrm{-40.}\\ \mathrm{-35.}& \mathrm{-55.}& \mathrm{-36.}& \mathrm{-63.}& 91.\end{array}\right]$

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] );

$\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right],\left[\begin{array}{ccc}1.& 0.& 0.\\ 4.& 1.& 0.\\ 7.& 2.& 1.\end{array}\right],\left[\begin{array}{ccc}1& 2& 3\\ 0& \mathrm{-3}& \mathrm{-6}\\ 0& 0& 0\end{array}\right]$

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] );

$\left[\begin{array}{ccc}1.& 0.& 0.\\ 0.& 1.& 0.\\ 0.& 0.& 1.\end{array}\right],\left[\begin{array}{ccc}1& 0& 0\\ 4& 1& 0\\ 7& 2& 1\end{array}\right],\left[\begin{array}{ccc}1.& 2.& 3.\\ 0.& \mathrm{-3.}& \mathrm{-6.}\\ 0.& 0.& 0.\end{array}\right]$

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.

Examples

with(PDEtools):

A non-differential equation

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

${\mathrm{eq}}_1≔a{x}^2+bx+c$

Solve(eq[1], x);

$x=\frac{-b+\sqrt{-4ac+b^2}}{2a},x=-\frac{b+\sqrt{-4ac+b^2}}{2a}$

An ODE problem and its series solution

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

${\mathrm{eq}}_2≔\mathrm{y\text{'}}=y$

Solve(eq[2], series);

$y=y\left(0\right)+y\left(0\right)x+\frac{1}{2}y\left(0\right)x^2+\frac{1}{6}y\left(0\right)x^3+\frac{1}{24}y\left(0\right)x^4+\frac{1}{120}y\left(0\right)x^5+O\left(x^6\right)$

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)];

${\mathrm{eq}}_3≔\left[c{u}_x+u_t=-\mathrm{\lambda }u\left(x\&comma;t\right)\&comma;u\left(x\&comma;0\right)=\mathrm{\phi }\left(x\right)\right]$

Solve(eq[3]);

$\left\{u\left(x\&comma;t\right)=\mathrm{\phi }\left(-tc+x\right){\&ExponentialE;}^{-\mathrm{\lambda }t}\right\}$

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)];

${\mathrm{eq}}_4≔\left[u_t=-u_x\&comma;u\left(x\&comma;0\right)=\sin \left(2\mathrm{\pi }x\right)\&comma;u\left(0\&comma;t\right)=-\sin \left(2\mathrm{\pi }t\right)\right]$

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

${\mathrm{sol}}_4:=\mathbf{module}\left(\right)\mathbf{export}\mathrm{plot}\&comma;\mathrm{plot3d}\&comma;\mathrm{animate}\&comma;\mathrm{value}\&comma;\mathrm{settings}\&semi;...\mathbf{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];

${\mathrm{eq}}_5≔\left[kac\left(a+b\right){\&ExponentialE;}^{kdt}-2a{\&ExponentialE;}^{kt}k+Q\left(-c+a\right)x\&comma;a\ne 0\right]$

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

$\left\{a=a\&comma;b=-\frac{a^2-2}{a}\&comma;c=a\&comma;d=1\right\}$

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;

${\mathrm{eq}}_6≔f_x{g}_x+f_y{g}_y+g\left(x\&comma;y\right)\left(f_{x,x}+f_{y,y}\right)=\mathrm{-1}$

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

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

$\left\{f\left(x\&comma;y\right)=\mathrm{f\_\_1}\left(y\right)\&comma;g\left(x\&comma;y\right)=\frac{-y+\mathrm{c\_\_1}}{{\mathrm{f\_\_1}}_y}\right\}$

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

$\left\{f\left(x\&comma;y\right)=\mathrm{f\_\_1}\left(x\right)\&comma;g\left(x\&comma;y\right)=\frac{-x+\mathrm{c\_\_1}}{\mathrm{\_F1\text{'}}}\right\}$

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];

$S≔\left[x\&comma;1\&comma;u\right]$

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

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

$\mathrm{*\; Partial\; match\; of\; \text{'}name\text{'}\; against\; keyword\; \text{'}arbitraryfunctionname\text{'}}$

$\mathrm{PDE}≔\mathrm{\Lambda }\left(-\ln \left(x\right)+t\&comma;\frac{u\left(x\&comma;t\right)}{x}\&comma;u_x\&comma;\frac{u_t}{x}\right)$

The third order PDE invariant under $S$ is

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

$\mathrm{PDE}≔\mathrm{f\_\_1}\left(-\ln \left(x\right)+t\&comma;\frac{u\left(x\&comma;t\right)}{x}\&comma;u_x\&comma;\frac{u_t}{x}\&comma;u_{t,x}\&comma;u_{x,x}x\&comma;\frac{u_{t,t}}{x}\&comma;u_{t,t,x}\&comma;u_{x,x,x}{x}^2\&comma;u_{t,x,x}x\&comma;\frac{u_{t,t,t}}{x}\right)$

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

SymmetryTest(S, PDE);

$\left\{0\right\}$

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 $u\left(x\&comma;t\right),v\left(x\&comma;t\right)$

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]];

$G≔\left[\left[{\mathrm{\_\&xi;}}_x=0\&comma;{\mathrm{\_\&xi;}}_t=1\&comma;{\mathrm{\_\&eta;}}_u=0\&comma;{\mathrm{\_\&eta;}}_v=0\right]\&comma;\left[{\mathrm{\_\&xi;}}_x=0\&comma;{\mathrm{\_\&xi;}}_t=0\&comma;{\mathrm{\_\&eta;}}_u=1\&comma;{\mathrm{\_\&eta;}}_v=0\right]\&comma;\left[{\mathrm{\_\&xi;}}_x=1\&comma;{\mathrm{\_\&xi;}}_t=0\&comma;{\mathrm{\_\&eta;}}_u=2t\&comma;{\mathrm{\_\&eta;}}_v=0\right]\&comma;\left[{\mathrm{\_\&xi;}}_x=t\&comma;{\mathrm{\_\&xi;}}_t=0\&comma;{\mathrm{\_\&eta;}}_u=t^2+x\&comma;{\mathrm{\_\&eta;}}_v=0\right]\&comma;\left[{\mathrm{\_\&xi;}}_x=\frac{x}{2}+\frac{3t^2}{2}\&comma;{\mathrm{\_\&xi;}}_t=t\&comma;{\mathrm{\_\&eta;}}_u=t^3+3tx\&comma;{\mathrm{\_\&eta;}}_v=-v\right]\right]$

The related 1st order invariant PDE family is:

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

$\mathrm{PDE}≔\mathrm{\Lambda }\left(\frac{v_x}{{v\left(x\&comma;t\right)}^{\raisebox{1ex}{$3$}\!\left/ \!\raisebox{-1ex}{$2$}\right.}}\&comma;\frac{u_x^2-4x+2u_t}{v\left(x\&comma;t\right)}\&comma;\frac{u_x{v}_x+v_t}{{v\left(x\&comma;t\right)}^2}\right)$

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

$\left[\left\{0\right\}\&comma;\left\{0\right\}\&comma;\left\{0\right\}\&comma;\left\{0\right\}\&comma;\left\{0\right\}\right]$

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.

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.

Examples:

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

with(RootFinding):

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

$\mathrm{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]);

$\mathrm{false}$

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

$\mathrm{true}$

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

$\left[\left[x=\mathrm{-0.7071067812}\&comma;y=\mathrm{-0.7071067812}\right]\&comma;\left[x=0.7071067812\&comma;y=0.7071067812\right]\right]$

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

$\mathrm{true}$

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

$\left[\left[x=\mathrm{-0.2588190451}\&comma;y=\mathrm{-0.9659258263}\right]\&comma;\left[x=\mathrm{-0.9659258263}\&comma;y=\mathrm{-0.2588190451}\right]\&comma;\left[x=0.9659258263\&comma;y=0.2588190451\right]\&comma;\left[x=0.2588190451\&comma;y=0.9659258263\right]\right]$

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 $g\ne 0$), 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.