Efficiency - Maple Help

Efficiency Improvements in Maple 10

 A number of efficiency improvements have been applied to make Maple 10 faster and use less memory.

GNU Multiple Precision (GMP) Library

 • The internal interface between Maple and GMP has been improved.  Maple now uses GMP integers to represent all non-immediate integers.  This allows significant optimization within Maple.  Operations on large integers are much faster than in previous release of Maple.  This speed up has also affected floating-point operations, which are much faster at high Digits settings.

Groebner

 For commutative polynomials, the Groebner[Basis] command implements new algorithms for Groebner basis computation that are faster, in most cases, than the existing algorithms. You can control which algorithm is used with the method option. By default, the command makes a reasonable guess at the most efficient method available. For more information, see Groebner[Basis] and Groebner/Basis_details.
 Example
 The option method="skew" selects an algorithm from Maple 9.5.
 > with(Groebner):
 > Cyclic5:=[    x+y+z+t+u,    x*y+y*z+z*t+t*u+u*x,    x*y*z+y*z*t+z*t*u+t*u*x+u*x*y,    x*y*z*t+y*z*t*u+z*t*u*x+t*u*x*y+u*x*y*z,    x*y*z*t*u-1 ]:
 > time(Basis(Cyclic5, plex(x,y,z,t,u), method="skew"));
 ${24.879}$ (1)
 Without specifying a method, Maple uses the new engine for commutative polynomials. (The variable x is renamed to override the caching mechanism.)
 > time(Basis(eval(Cyclic5,x=X), plex(X,y,z,t,u)));
 ${1.170}$ (2)

Matrix Subselection

 • Subselection of regular shaped rtables is now faster in Maple. The code below now requires .279s, compared to 1.939s in Maple 9.5 on the same machine.
 Example
 > repmat := proc(a,m,n)     a[[seq(1..-1,i=1..m)],[seq(1..-1,i=1..n)]]; end proc:
 > A:=Matrix([[1,2,3],[4,5,6],[7,8,9]],datatype=integer[4]):
 > time(repmat(A,1000,1000));
 ${0.154}$ (3)

LinearAlgebra[MatrixExponential]

 • Computation of the Matrix exponential for real and complex floating-point data is significantly faster. In Maple 9.5.1, the example below requires 14.3 seconds and allocates 4652204 bytes more memory, run under Linux on a 2.4GHz Celeron(R). In Maple 10, this call to MatrixExponential requires 0.06 seconds and allocates only 458668 more bytes of memory.
 Example
 > M := Matrix(50,50,(i,j)->sin(i/30.)*cos(j/20.),datatype=float):
 > st := time():
 > sol := LinearAlgebra[MatrixExponential](M):
 > timeinc := time()-st;
 ${\mathrm{timeinc}}{≔}{0.076}$ (4)

RootFinding[Analytic]

 Special code has been added to RootFinding[Analytic] to detect multiple roots, leading to a significant speedup in the presence of multiple roots.
 Example
 > RootFinding:-Analytic(sinh(z-1)*(z-1)*sin(z-1),z,-3-I..3+I*2,'digits'=32);
 ${1.0000000000000000000000000000000}{,}{1.0000000000000000000000000000000}{,}{1.0000000000000000000000000000000}{,}{-2.1415926535897932384626433832791}$ (5)

Restart

 • On restart, the Maple kernel releases the memory it has allocated.  After a restart, the amount of memory used by the kernel should be similar to the amount of memory used when the kernel first starts.