The Physics package of Maple 16, including 17 new commands and new General Relativity functionality, brings with it the largest number of developments since its introduction in Maple 11, underscoring Maple's goal of having a state-of-the-art environment for algebraic computations in Physics.

For more information see what is new in Physics in Maple 16.

DifferentialGeometry for Maple 16, with 28 new commands, contains important new functionality for working with abstractly defined differential forms, Lie algebras and general relativity.

For more information see what is new in DifferentialGeometry in Maple 16.

For both Ordinary and Partial Differential Equations, a theme in Maple 16 is a thorough revision of the existing symmetry algorithms and their extension to automatically handle problems involving anticommutative variables. This extension includes the dsolve and pdsolve commands, all the commands of the PDEtools[Library] and many of the symmetry commands in PDEtools, making all this DE functionality naturally available for the first time for working on problems in Physics that involve anticommutative variables.

For more information see what is new in Differential Equations in Maple 16.

The VectorCalculus[Hessian] command now takes a determinant option, which requests that the determinant of the Hessian matrix of the input function be returned, as well as the Hessian matrix itself.

with(VectorCalculus):

H, det := Hessian( cos(x*y), [x,y], determinant);

$H,\det ≔\left[\begin{array}{cc}-y^2\cos \left(xy\right)& -\sin \left(xy\right)-yx\cos \left(xy\right)\\ -\sin \left(xy\right)-yx\cos \left(xy\right)& -x^2\cos \left(xy\right)\end{array}\right],-2\cos \left(xy\right)\sin \left(xy\right)xy-{\sin \left(xy\right)}^2$

The new RegularChains package features not only in efficiency improvements and new algorithms, it also features new and existing commands computing over the reals and solving semi-algebraic systems.

The variable order of a polynomial system may have a large impact on performance of triangular decomposition.  The new command SuggestVariableOrder provides an optimal order that can be used in any solvers of the RegularChains library.

The new SquarefreeFactorization command computes the squarefree factorization of a polynomial modulo a regular chain.

with(RegularChains):

with(ChainTools):

R := PolynomialRing([x, y]):

p := (x+y)*(x+2*y)^2*(x+3*y)^3:

rc := Chain([y^2+1], Empty(R), R):

p := SparsePseudoRemainder(p, rc, R):

SquarefreeFactorization(p, x, rc, R);

$\left[\left[\left[\left[x+y\,1\right]\,\left[x+2y\,2\right]\,\left[x+3y\,3\right]\right]\,\mathrm{rc}\right]\right]$

The RealTriangularize command has two new options: method and relaxation. The method option specifies the decomposition algorithm to be used.  The relaxation option specifies if the new relaxation technique is used.  When relaxation=explicit is specified, the number of components in the output is usually reduced because non-strict constraints in inequalities are not allowed.

R := PolynomialRing([x, a, b]):

sys := [x^5*a+x*b-a = 0, x-b > 0]:

numelems(RealTriangularize(sys, R, output = list));

$13$

numelems(RealTriangularize(sys, R, output = list, relaxation = explicit));

$7$

numelems(RealTriangularize(sys, R, output = list, method = incremental));

$13$

The new RealComprehensiveTriangularize command computes a comprehensive triangular decomposition over the reals of a parametric semi-algebraic system.

The new LinearSolve command is a linear semi-algebraic system solver implementing a variant of the Fourier-Motzkins elimination algorithm.

with(SemiAlgebraicSetTools):

R := PolynomialRing([z, y, x]):

F := [z+y+x = 0, 0 <= x+y-z, x-y-z < 0]:

T := LinearSolve(F, R);

$T≔\left[x<0\&comma;-x\le y\&comma;z=-x-y\right]$

The CylindricalAlgebraicDecompose command now takes a list of regular semi-algebraic systems as input.  In addition, its output option, which controls the output format, accepts cadcell and rootof. The Display command has been updated to handle these new output formats.

The following commands in ConstructibleSetTools accept semi-algebraic systems as inputs: Complement, Difference, Intersection, IsContained, IsEmpty, Projection and RemoveRedundantComponents.

The SolveTools[SemiAlgebraic] command computes the solutions of a polynomial system consisting of a combination of equations, inequations and inequalities.

with(SolveTools):

SemiAlgebraic({x^2+x-1=0, x+y^2<0});

$\left[\left[x=-\frac{\sqrt{5}}{2}-\frac{1}{2}\&comma;-\frac{\sqrt{2+2\sqrt{5}}}{2}<y\&comma;y<\frac{\sqrt{2+2\sqrt{5}}}{2}\right]\right]$

The Groebner[IsBasis] command provides a convenient way to determine if a basis is a Groebner basis for a given monomial ordering.

with(Groebner):

F:=[d^5-e^5, c^5-d^5, b^5-c^5, a^4*b+b^4*c+c^4*d+d^4*e+a*e^4,a^5-b^5]:

G:=Basis(F, tdeg(a,b,c,d,e)):

IsBasis(G, tdeg(a,b,c,d,e));

$\mathrm{true}$

IsBasis(G, plex(a,b,c,d,e));

$\mathrm{false}$

The Statistics package contains several enhancements, including new functionality for discrete distributions with noninteger values, custom discrete distributions, efficient maximum likelihood parameter estimation, better handling of Matrix data sets, variable-width histograms, and a new command ScatterPlot3D for lowess smoothing. See What's New, Statistics for more detailed descriptions of these changes.

Many commands in the Student subpackages are now accessible through command completion.

The Student[Calculus1][VolumeOfRevolution] command has a new output option: region.  This new output option allows users to visualize the slice that is rotated to create the solid.  In addition, the new showregion option allows users to embed the slice in the solid.

with(Student):

with(Calculus1):

VolumeOfRevolution(x^2+1, x=0..3, output=region);

VolumeOfRevolution(x^2+1, x=0..3, output=plot, showregion=true);

The default captions in plots generated by visualization routines can be disabled by setting caption option to an empty string.

VolumeOfRevolution(x^2+1, x=0..3, output=plot, caption="");

The Add, Mul, Seq and Map routines from the Threads package have been updated to make them better at exploiting parallelism, especially when given a small number of inputs.  In addition, users can now specify the maximum number of elements to be executed in a single task.  This allows users to tune the execution of the routine to match the input.  For example, a small number of long running computations may benefit from a maximum task size of 1.  However a large number of very fast computations will benefit from a large task size.

The Magma package includes several new commands: IsCrossedSet, IsSimple, IsDiassociative, IsPowerAssociative, IsQuasitrivial, IsomorphicCopy, and IsomorphismClassRepresentatives.

with( Magma ):

L := select(IsCrossedSet,Enumerate(3,quandle,output=list));

$L≔\left[\left[\begin{array}{ccc}1& 1& 1\\ 2& 2& 2\\ 3& 3& 3\end{array}\right]\&comma;\left[\begin{array}{ccc}1& 3& 2\\ 3& 2& 1\\ 2& 1& 3\end{array}\right]\right]$

select( IsSimple, L );

$\left[\left[\begin{array}{ccc}1& 3& 2\\ 3& 2& 1\\ 2& 1& 3\end{array}\right]\right]$

The ListTools package contains the new command, Classify. This is an efficient way to group list elements according to a given property.

with(ListTools);

$\left[\mathrm{BinaryPlace}\&comma;\mathrm{BinarySearch}\&comma;\mathrm{Categorize}\&comma;\mathrm{Classify}\&comma;\mathrm{Collect}\&comma;\mathrm{Deal}\&comma;\mathrm{DotProduct}\&comma;\mathrm{Enumerate}\&comma;\mathrm{FindMaximalElement}\&comma;\mathrm{FindMinimalElement}\&comma;\mathrm{FindRepetitions}\&comma;\mathrm{Flatten}\&comma;\mathrm{FlattenOnce}\&comma;\mathrm{Group}\&comma;\mathrm{Interleave}\&comma;\mathrm{InversePermutation}\&comma;\mathrm{Join}\&comma;\mathrm{JoinSequence}\&comma;\mathrm{LengthSplit}\&comma;\mathrm{MakeUnique}\&comma;\mathrm{Occurrences}\&comma;\mathrm{Pad}\&comma;\mathrm{PartialSums}\&comma;\mathrm{Reverse}\&comma;\mathrm{Rotate}\&comma;\mathrm{Search}\&comma;\mathrm{SearchAll}\&comma;\mathrm{SelectFirst}\&comma;\mathrm{SelectLast}\&comma;\mathrm{Slice}\&comma;\mathrm{Sorted}\&comma;\mathrm{Split}\&comma;\mathrm{Transpose}\&comma;\mathrm{Unpermute}\right]$

types := Classify(whattype, ["Hello", 1, 2., Pi, x, x+y, exp, "world!"]):

eval(types);

$table\left(\left[\mathrm{string}=\left\{''Hello''\&comma;''world!''\right\}\&comma;\mathrm{symbol}=\left\{\mathrm{\pi }\&comma;x\right\}\&comma;\mathrm{integer}=\left\{1\right\}\&comma;\mathrm{procedure}=\left\{\exp \right\}\&comma;\mathrm{float}=\left\{2.\right\}\&comma;\mathrm{`+`}=\left\{x+y\right\}\right]\right)$