Items tagged with performance


The purpose of this post is to review how well-designed Maple 2017 GUI is for a Microsoft surface pro 4 tablet touch screen with windows 10 pro (64-bit) and to determine the performance of Maple 2017 on my tablet which has a m3 CPU with a 0.9 GHZ base frequency and 4 GB RAM.

First, my experience is that 4 GB of RAM is far from enough. Under heavy load I have had problems before on other software with 4 GB of RAM. 68 % of my RAM and 41% of the CPU is already gone by simply running Maple and my web browser at the same time before I have even instructed Maple to do any calculations.


I think a tablet with at least 8 GB of RAM would be preferred. If you only want to use Maple as an expensive calculator then you would most likely not even need 4 GB of RAM. I find that the surface pro 4 to be overpriced for the hardware it provides. I think eve windows 10 tablet with up to 16 GB of RAM and with a much cheaper price looks much more promising than the Microsoft surface pro 4. When I use the surface pro 4 with word 2016 and the reference manager zotero word plugin I sometime notice a trailing line when I sweep up or down in a document with a lot of references which I suspect is because of the low amount of RAM. When I played with Maple 2017 on my surface pro I noticed the same trailing line which again indicates to me that there is not enough RAM. However, I am not certain that low RAM is the cause of such problem.  

Secondly, I managed to increase the size of the Maple icons under the File, Edit etc. menu so now they have a perfect size for a touch screen tablet. Very cool!


However, as you can see words in the text menu File, Edit etc. are way too small for a touch screen tablet. There is a lot of room to the right so the words could easily be increased in size. I am also a missing a menu item called maplet where you can attach your own maplets for easy access. It appears that Maple 2017 GUI has not been designed with a touch screen tablet in mind. I wish the words in the text menu File, Edit etc. would have increased when I increased the size of the icons. The text and icons in the sidebar are also way too small for a touch screen tablet. The name of the open tabs is also to small and x that you tap on to close the worksheet is also to small. It is almost impossible to close a worksheet because the x is so small. 

I thinks there are ways in windows 10 to increase the text size in the menus but I have only been able to increase the text size and icon size for all software at the same time. Since, Maple is more or less the only software that I have where the menu text is too small this is not an optimal solution.   

The table of content for Maple help files also has too small text as seen in the below picture. However, the biggest problem is not the small words it is the row spacing of the table of content. Some of the words appear almost to be on top of each other. I think the row spacing need to be increased. The text within the help files itself displays beautifully and is in the perfect size.   


Another problem is that when you swipe up or down on the touch screen you dont go up or down in the maple document. You just highlight text as seen in the picture below. This needs to be fixed. Highlighting should be done by a long tap on the screen as in word 2017 on a touch screen devices.



The norm today might be to use Maple on a desktop computer or on a laptop but I am convinced that in the future touch screen tablet will become more and more powerful making them an excellent computers to run Maple on because they are so light and portable. I think Maplesoft must have this in mind when they design the GUI.

Now to test the performance of Maple 2017 on my tablet I decided to generate 1 000 000 random number and see how long it takes. Since I dont have a benchmark it becomes very hard to comment on how fast maple 2017 is on my tablet but I am hoping that someone can run the same code on their machine and comment on this post so we can get a benchmark.        


Maple 2017 claims that running such code took about 50 seconds on my tablet however when I timed it with a stop watch it only took around 30 seconds hence I am a bit confused as to where the 20 seconds difference comes from?  


I wrote some procedures in an older version of Maple to sort through a matrix and find repeated elements, and then set the matrix elements equal to one another. As an example, consider the matrix:

Matrix(4, 4, {(1, 1) = 31774769/38880000, (1, 2) = -90858559/233280000, (1, 3) = -76547233/69984000, (1, 4) = -119275567/139968000, (2, 1) = -90858559/233280000, (2, 2) = 1506841/6480000, (2, 3) = 442249/720000, (2, 4) = 85514221/116640000, (3, 1) = -76547233/69984000, (3, 2) = 442249/720000, (3, 3) = 592249771/349920000, (3, 4) = 121562339/87480000, (4, 1) = -119275567/139968000, (4, 2) = 85514221/116640000, (4, 3) = 121562339/87480000, (4, 4) = 170546323/87480000}, datatype = anything, storage = rectangular, order = Fortran_order, shape = [])
Due to its symmetric nature the upper triangular matrix is just the same as the lower triangular. i.e. the elements are equal: (2,1)=(1,2), (3,1)=(1,3) etc...

I have attached a minimal working example Maple script, which processes an input matrix, finds repeats and sets the elements equal to one another (e.g. [1,2]=[2,1], literally printing this) and saves the output to a file using a specific format for processing by another program. The matrix in the file is numeric but the actual matrices contain a lot of algebraic terms and can get quite large. This is where my procedures struggle as they take a very, very long time to process larger algebraic matrices to group the repeats. Is there a more Maple friendly way of going about this problem rather than these "archaic" procedures?

Here is the script:

Thank you in advance


I am trying to evaluate the following function J(n,phi) which can be used to find out a*b(-A*J(3,Pi/6)+B*J(6,Pi/6)) but it takes too much of time whereas mathematica takes much less time for the same. The maple file is attached. Hope my problem get solve. Thank you


r := 2.8749; a := 0.7747; b := 0.3812; A := 17.4; B := 29000; R := 5.4813; Z := 2;

J := proc (n, phi) options operator, arrow; 8*Pi^(3/2)*r*R*(sum((2*r*R)^(2*i)*pochhammer((1/2)*n, i)*pochhammer((1/2)*n+1/2, i)*(sum((-1)^j*cos(phi)^(2*j)*(sum((2*r*cos(phi))^(2.*l)*pochhammer(n+2*i, 2*l)*hypergeom([2*j+2*l+1, .5], [2*j+2*l+1.5], -1)*(.5*Beta(l+.5, n+2*i+l-.5)-sin(arctan(-Z/sqrt(R^2+r^2)))^(2*l+1)*hypergeom([-n-2*i-l+1.5, l+.5], [l+1.5], sin(arctan(-Z/sqrt(R^2+r^2)))^2)/(2*l+1))/(factorial(2*l)*pochhammer(2*j+2*l+1, .5)*(R^2+r^2)^(n+2*i+l-.5)), l = 0 .. 100))/(factorial(i-j)*factorial(j)), j = 0 .. i))/factorial(i), i = 0 .. 100)) end proc;

evalf(a*b*(-A*J(3, (1/6)*Pi)+B*J(6, (1/6)*Pi)));

When using maximize on a relatively complicated function (see attached Maple file and PDF), it runs extremely slow. No return after 3 minutes.

My hardward: i7 2.3G, 8G DDR3 MEM, 500G SSD.

Maybe someone is interested to try the Maple code if your workstation is more powerful? :)


 Question:- can the procedure given below called "epi" be speeded up by compiling/ using evhf.If so how? My paple code is at the bottom.

First some background information.

Recently I ran into a difference in usage of a couple of elliptical functions between Maple and Mathematica.  This first case concerned EllipticalPi. The author of the blog kindly wrote  a Maple procedure to produce the same results as Mathematica’s  usage of ElllipticalPi.

I tested the basic integral that produces the EllipticPi    Ell := int(1/(1-nu*JacobiSN(t, k)^2), t)  answer      Ell := EllipticPi(JacobiSN(t, k), nu, k). They do not produce the same outcome. Plots are in the document .  They agree in one quarter only.

 I then ran into a difference in usage of  EllipticF. This time I was able to get to same outcome myself using Maple’s help.

“It is worth noting the difference between the Legendre normal form of the Incomplete Elliptic integral of the first kind (see A&S 17.2.7), in Maple represented by EllipticF(z,k) but for the splitting of the square root in the denominator of the integrand (see definition lines above), and the normal trigonometric form of this elliptic integral (see A&S 17.2.6), in Maple represented by the InverseJacobiAM function

That worked fine.

There is no mention in the help for usage implementation of EllipticPi as opposed to different usages as there is with EllipticF. I do not know if there is a way in Maple of achieving the same enactment as Mathematica in this case, without the Procedure I  was  given.



Elliptic Pi in Mathematica and Maple

Posted on 2017/02/202017/02/23 by arkajad

We use EllipticPi when we write exact solutions of rotation of a free asymmetric top. While solving Euler’s equations for angular velocity or angular momentum in the body frame we need Jacobi elliptic functions \cn,\sn,\dn,solving the differential equation for the attitude matrix involves EllipticPi function. As I have explained it in Taming the T-handle continued we need the integral

(1)   \begin{equation*}\psi(t)=c_1 t+c_2\int_0^t \frac{1}{1+c_3\,\sn^2(Bs,m)}\,ds.\end{equation*}

In Mathematica this is easily implemented as

(2)   \begin{equation*}\psi(t)=c_1 t+\frac{c_2}{B}\,\Pi(-c_3;\am(Bt,m)|m).\end{equation*}

However, as pointed out by Rowan in a comment to Taming the T-handle continued , the same formula does not work with Maple.

While the documentations of both Mathematica and Maple contain links to Abramowitz and Stegun Handbook of Mathematical Functions, they use different definitions. Here is what concerns us, from p. 590 of the 10th printing:

What we need is 17.2.16, while Maple is using 17.2.14. To convert we need to set x=\sn u,but such a conversion is possible only in the domain where \sncan be inverted. We can do it easily for sufficiently small values of u,but not necessarily for values that contain several quarter-periods.

The following Maple procedure does the job:

epi := proc (t::float, nu::float, k::float) local t2, n, dt, ep0, res; ep0 := EllipticPi(nu, k); t2 := EllipticK(k); n := floor(t/t2); dt := t-t2*n; if type(n, even) then res := Re(n*ep0+EllipticPi(JacobiSN(dt, k), nu, k)) else res := Re((1+n)*ep0-EllipticPi(JacobiSN(t2-dt, k), nu, k)) end if end proc

HAs an example here is the Maple plot for nu=-3, k=0.9:
plot(('epi')(t, -3.0, .9), t = -20 .. 20)

And here is the corresponding Mathematica plot:

The function epi(t,nu, k) defined above for Maple gives now the same result as EllipticPi(nu,JacobiAM(t,k^2),k^2) in Mathematica.

epi := proc (t, nu, k) local t2, n, dt, ep0, res; ep0 := EllipticPi(nu, k); t2 := EllipticK(k); n := floor(t/t2); dt := t-t2*n; if type(n, even) then res := Re(n*ep0+EllipticPi(JacobiSN(dt, k), nu, k)) else res := Re((1+n)*ep0-EllipticPi(JacobiSN(t2-dt, k), nu, k)) end if end proc;

Ell := int(1/(1-nu*JacobiSN(t, k)^2), t);
            Ell := EllipticPi(JacobiSN(t, k), nu, k)
k := .9;
                            k := 0.9
nu := -3;
                            nu := -3
plot([epi(t, nu, k), Ell], t = -8 .. 20);


This is what I did:

It seems like it's working. But is there a way to make the time spit out time smaller than seconds? And to automatically generate how much time it took rather than me looking at it and saying "well 43 seconds minus 41 seconds is 2 seconds"? I suspect there might be.


z0:= a0^2/(4*lambda);  









I use maple 12 on my dual core laptop and i plan to buy maple 2016 and an 8 core system to get advandage of multiple processors. 

Does maple 2016 functions get advandage of multiprocessor systems or it will be the same as having one processor?

I have recently acquired Maple 2016 and wanted to see how its numerical integration compared to previous version (in this instance, 2015 and 18). This integration is a tougher problem than the usual "textbook" case using a well behaved function. The integrand presented in the worksheet below is a small example but it can get much larger.

I am calculating a triple integral numerically from a function read in from a file which contains Laguerre polynomials. Some simplifications are done first and then that is fed into the integration. In the example script below the input has been put into the program to make it simpler.

So far it appears Maple 18 is faster than 2015 (in this case anyway) and 2016 does not appear to like the syntax I am using even though it runs fine on 18 and 2015 (it does not like the simplify(expr1,LaguerreL) or sqrt parts).

Looking at the stats of the calculation runs:

Maple 18:

memory used=0.52MiB, alloc change=0 bytes, cpu time=20.33s, real time=20.49s, gc time=0ns

answer = 0.160262735437965

Maple 2015:

memory used=350.84KiB, alloc change=0 bytes, cpu time=28.77s, real time=29.24s, gc time=0ns

answer = 0.160262735437309

What is interesting is that Maple 18 is allocating more memory in order to solve the problem compared to 2015. Does anyone have any ideas why this is occuring? Also has there been a syntax change from 2015 -> 2016 which I have not been aware of. Is there a different way to write the script to run in 2016?

Here is the worksheet:

Thank you in advance

- Yeti

Plz help me! How to accelerate the calculation speed the following the program?

with(PDEtools); declare((u, W)(x, t)); KN := 10;
AFP := proc (C1, C2, C3, C4, H, KN, N) local ADM1, n, lambda, F, i, A0, A, U, W, u, L, R, NL, w, PDE1, IC1, d, Eq1, Eq2, Eq3, LI, trL, tr1, trN, Apr, AprK, trSol, Sol, AD; declare((u, W)(x, t)); ADM1 := proc (n) options operator, arrow; convert(subs(lambda = 0, value((Diff(F(Sum(lambda^i*U[i], i = 0 .. n)), `$`(lambda, n)))/factorial(n))), diff) end proc; A0[0] := F(U[0]); for n to KN do A0[n] := ADM1(n) end do; for n from 0 to KN do A[n] := convert(C1*(diff(subs({seq(U[i] = W[i](x, t), i = 0 .. KN)}, expand(subs(F(U[0]) = U[0]*exp(U[0]), A0[n]))), x)), diff)+convert(C2*subs({seq(U[i] = Diff(W[i](x, t), x), i = 0 .. KN)}, expand(subs(F(U[0]) = U[0]^2, A0[n]))), diff) end do; L := proc (w) options operator, arrow; diff(w(x, t), t) end proc; R := proc (w) options operator, arrow; C3*(diff(w(x, t), x)) end proc; NL := proc (w) options operator, arrow; C1*(diff(w(x, t)*exp(w(x, t)), t))-C2*(diff(w(x, t), x))^2 end proc; PDE1 := proc (w) options operator, arrow; L(w)-R(w) = -NL(w) end proc; IC1 := u(x, 0) = sum(2*(int(sin((d+1/2)*Pi*x/H), x = 0 .. H))*exp(-C4*(d+1/2)^2*Pi^2*t/H^2)*sin((d+1/2)*Pi*x/H)/H, d = 0 .. N); LI := proc (w) options operator, arrow; Int(w(x, t), t = 0 .. t) end proc; tr1 := u-rhs(IC1); Eq1 := LI(lhs(PDE1(u))) = LI(rhs(PDE1(u))); Eq2 := simplify(subs(lhs(Eq1) = tr1, Eq1)); trL := u = add(u[j](x, t), j = 0 .. KN); trN := LI(NL(u)) = Int(Sum(A[i], i = 0 .. KN), t = 0 .. t); Eq3 := subs(trL, lhs(Eq2)) = subs(trN, rhs(Eq2)); Apr[0] := u[0](x, t) = rhs(IC1); AprK := u[k+1](x, t) = -(Int(AD[k], t = 0 .. t)); for i from 0 to KN do Apr[i+1] := value(subs({seq(Apr[m], m = 0 .. i)}, subs({seq(W[m] = u[m], m = 0 .. i)}, subs(k = i, AD[i] = A[i], AprK)))) end do; trSol := {seq(Apr[i], i = 0 .. KN)}; value(subs(trSol, trL)) end proc;



I am solving large systems of linear equations (mod 2) which are of this form ,
systems:= {0 = f[[1, 4]]-f[[1, 3]], 0 = f[[1, 5]]-f[[1, 3]], 0 = f[[1, 5]]-f[[1, 4]], 0 = f[[1, 6]]-f[[1, 3]], 0 = f[[1, 6]]-f[[1, 4]], 0 = f[[1, 6]]-f[[1, 5]], 0 = f[[1, 7]]-f[[1, 3]], 0 = f[[1, 7]]-f[[1, 4]], 0 = f[[1, 7]]-f[[1, 5]], 0 = f[[1, 7]]-f[[1, 6]], 0 = f[[2, 4]]-f[[1, 3]], 0 = f[[2, 5]]-f[[1, 3]], 0 = f[[2, 5]]-f[[1, 4]], 0 = f[[2, 6]]-f[[1, 3]], 0 = f[[2, 6]]-f[[1, 4]], 0 = f[[2, 6]]-f[[1, 5]], 0 = f[[2, 6]]-f[[2, 4]], 0 = f[[2, 6]]-f[[2, 5]], 0 = f[[2, 7]]-f[[1, 3]], 0 = f[[2, 7]]-f[[1, 4]], 0 = f[[2, 7]]-f[[1, 5]], 0 = f[[2, 7]]-f[[1, 6]], 0 = f[[2, 7]]-f[[2, 4]], 0 = f[[2, 7]]-f[[2, 5]], 0 = f[[3, 1]]-f[[1, 4]], 0 = f[[3, 1]]-f[[1, 5]], 0 = f[[3, 1]]-f[[1, 6]], 0 = f[[3, 1]]-f[[2, 7]], 0 = f[[3, 5]]-f[[1, 4]], 0 = f[[3, 5]]-f[[1, 5]], 0 = f[[3, 5]]-f[[2, 4]], 0 = f[[3, 5]]-f[[2, 5]], 0 = f[[3, 6]]-f[[1, 3]], 0 = f[[3, 6]]-f[[1, 4]], 0 = f[[3, 6]]-f[[1, 5]], 0 = f[[3, 6]]-f[[1, 6]], 0 = f[[3, 6]]-f[[2, 4]], 0 = f[[3, 6]]-f[[2, 5]], 0 = f[[3, 6]]-f[[2, 6]], 0 = f[[3, 7]]-f[[1, 4]], 0 = f[[3, 7]]-f[[1, 5]], 0 = f[[3, 7]]-f[[1, 6]], 0 = f[[3, 7]]-f[[1, 7]], 0 = f[[3, 7]]-f[[2, 4]], 0 = f[[3, 7]]-f[[2, 5]], 0 = f[[3, 7]]-f[[2, 6]], 0 = f[[3, 7]]-f[[2, 7]], 0 = f[[3, 7]]-f[[3, 6]], 0 = f[[4, 1]]-f[[1, 5]], 0 = f[[4, 1]]-f[[1, 7]], 0 = f[[4, 1]]-f[[2, 7]], 0 = f[[4, 1]]-f[[3, 5]], 0 = f[[4, 1]]-f[[3, 7]], 0 = f[[4, 2]]-f[[2, 6]], 0 = f[[4, 2]]-f[[2, 7]], 0 = f[[4, 6]]-f[[1, 5]], 0 = f[[4, 6]]-f[[1, 6]], 0 = f[[4, 6]]-f[[2, 5]], 0 = f[[4, 6]]-f[[2, 6]], 0 = f[[4, 6]]-f[[3, 5]], 0 = f[[4, 6]]-f[[3, 6]], 0 = f[[4, 7]]-f[[1, 5]], 0 = f[[4, 7]]-f[[1, 6]], 0 = f[[4, 7]]-f[[1, 7]], 0 = f[[4, 7]]-f[[2, 5]], 0 = f[[4, 7]]-f[[2, 6]], 0 = f[[4, 7]]-f[[2, 7]], 0 = f[[4, 7]]-f[[3, 5]], 0 = f[[4, 7]]-f[[3, 6]], 0 = f[[4, 7]]-f[[4, 6]], 0 = f[[5, 1]]-f[[2, 6]], 0 = f[[5, 1]]-f[[2, 7]], 0 = f[[5, 1]]-f[[3, 6]], 0 = f[[5, 1]]-f[[4, 6]], 0 = f[[5, 2]]-f[[2, 7]], 0 = f[[5, 2]]-f[[3, 5]], 0 = f[[5, 2]]-f[[3, 6]], 0 = f[[5, 2]]-f[[3, 7]], 0 = f[[5, 2]]-f[[4, 6]], 0 = f[[5, 2]]-f[[4, 7]], 0 = f[[5, 3]]-f[[4, 7]], 0 = f[[5, 7]]-f[[1, 6]], 0 = f[[5, 7]]-f[[1, 7]], 0 = f[[5, 7]]-f[[2, 6]], 0 = f[[5, 7]]-f[[2, 7]], 0 = f[[5, 7]]-f[[3, 6]], 0 = f[[5, 7]]-f[[3, 7]], 0 = f[[5, 7]]-f[[4, 6]], 0 = f[[5, 7]]-f[[4, 7]], 0 = f[[6, 1]]-f[[1, 7]], 0 = f[[6, 1]]-f[[3, 6]], 0 = f[[6, 1]]-f[[4, 7]], 0 = f[[6, 1]]-f[[5, 7]], 0 = f[[6, 2]]-f[[3, 7]], 0 = f[[6, 2]]-f[[4, 7]], 0 = f[[6, 3]]-f[[4, 6]], 0 = f[[6, 3]]-f[[5, 7]], 0 = f[[6, 4]]-f[[5, 7]], 0 = f[[7, 2]]-f[[3, 7]], 0 = f[[7, 2]]-f[[5, 7]], 1 = f[[3, 1]]-f[[1, 7]], 1 = f[[3, 1]]-f[[2, 4]], 1 = f[[3, 1]]-f[[2, 5]], 1 = f[[3, 1]]-f[[2, 6]], 1 = f[[3, 1]]-f[[3, 6]], 1 = f[[4, 1]]-f[[1, 6]], 1 = f[[4, 1]]-f[[2, 5]], 1 = f[[4, 1]]-f[[2, 6]], 1 = f[[4, 1]]-f[[3, 6]], 1 = f[[4, 2]]-f[[3, 5]], 1 = f[[4, 2]]-f[[3, 6]], 1 = f[[4, 2]]-f[[3, 7]], 1 = f[[5, 1]]-f[[1, 6]], 1 = f[[5, 1]]-f[[1, 7]], 1 = f[[5, 1]]-f[[3, 5]], 1 = f[[5, 1]]-f[[3, 7]], 1 = f[[5, 1]]-f[[4, 7]], 1 = f[[5, 2]]-f[[2, 6]], 1 = f[[5, 3]]-f[[4, 6]], 1 = f[[6, 1]]-f[[2, 7]], 1 = f[[6, 1]]-f[[3, 7]], 1 = f[[6, 1]]-f[[4, 6]], 1 = f[[6, 2]]-f[[3, 6]], 1 = f[[6, 2]]-f[[4, 6]], 1 = f[[6, 2]]-f[[5, 7]], 1 = f[[6, 3]]-f[[3, 7]], 1 = f[[6, 3]]-f[[4, 7]], 1 = f[[6, 4]]-f[[4, 7]], 1 = f[[7, 1]]-f[[3, 7]], 1 = f[[7, 1]]-f[[4, 7]], 1 = f[[7, 1]]-f[[5, 7]], 1 = f[[7, 2]]-f[[4, 7]], 1 = f[[7, 3]]-f[[5, 7]], 1 = f[[7, 4]]-f[[5, 7]]};

I have been using msolve as follows; msolve(systems,2);  which returns NULL if there is no solution. This however takes a lot of my computer memory and also take a lot of time since the equations are very many.  I decided to try LinearSolve, but it doesn't give me any solutions even for the ones that I know that the solutions exist. My code was writen as follows:

systems:=as above..

vars := [f[[1, 3]], f[[1, 4]], f[[1, 5]], f[[1, 6]], f[[1, 7]], f[[2, 4]], f[[2, 5]], f[[2, 6]], f[[2, 7]], f[[3, 1]], f[[3, 5]], f[[3, 6]], f[[3, 7]], f[[4, 1]], f[[4, 2]], f[[4, 6]], f[[4, 7]], f[[5, 1]], f[[5, 2]], f[[5, 3]], f[[5, 7]], f[[6, 1]], f[[6, 2]], f[[6, 3]], f[[6, 4]], f[[7, 1]], f[[7, 2]], f[[7, 3]], f[[7, 4]]];

LinearSolve(A,b) mod 2;
what I'm I doing wrong? How can I make this fast and in such a way that the solution is computed without taking too much memory?

I also understand that LinearSolve returns the following when there is no solution, "Error, (in LinearAlgebra:-LinearSolve) inconsistent system
", in my case, if there is no solution, I don't want that error to be printed, but I want some variable (call it x) to be printed if a solution is found.

Any help is appreciated.



I would like to thank everyone who takes their time to respond to posts on this page. I have another question.

I have about 11 trillion lists that are of the form A shown below. The lists ofcourse have more elements than A (about 50 elements). What I want is to compute this value I call f, and the moment this value is found to be 1, we stop, and if all the values of f are 0, then we print(A). Here is my code, which has a problem and doesn't give me the result I want. How do I modify this so that if any value of f=1, then we stop, elif no 1 is found, we print just one value for A and not for every 0 produced?

A := [[1, 2], [1, 7], [5, 6], [1, 6], [1, 9], [6, 5], [9, 1], [2, 1], [7, 1], [6, 1], [5, 6]]; n := 9;
for i to n do for j to n do for k to nops(A) do if [i, j] = A[k] then a := Search([i, j], A); b := Search([j, i], A); if a < b then f := `mod`(b-a, 2); if f = 1 then break else print(A) end if end if end if end do end do end do;

Presently what I am doing is to Append all values of f into an Array and check that 1 is not an element of that Array. This is however very inconvenient since my lists are huge, and they are many, and we do not have to cpompute all the values of f once we come across a 1. Other than this, is there a way I can make my program run faster? Any suggestions are welcomed.



 Hi everybody,

Until recently I was using Maple 2015.0 on this PC :

Windows XP
2 dual core proc Intel(R) Xeon(R) CPU E3-1225 V2 ; 3.19 GHz
64 bytes,
16 Go RAM

For two days now I am using Maple 2015.0 on this one

Windows 7
4 dual core proc Intel(R) Xeon(R) CPU 5-2637 V3 ; 3.50 GHz
64 bytes,
64 Go RAM

Comparisons of the running times for exactly the same code, consisting in 10000 independent Monte Carlo  simulations distributed over all the nodes (resp 4 and 8) give :

Windows XP :  504 sec  (with a variation of the order of  +/- 3s for different replicates)

Windows 7   :  343 sec  (with a variation of the order of  +/- 3s for different replicates)

The expected running time should be 504 * (3.2/3.5) * (4/8) = 230 s
(or 504 * (4/8) = 252 s if you neglect the acceleration due to the clock rate)
The realized running time (343 s) is thus at least  40% larger than the expected one.

Does anybody has already observed this kind of performance loss during XP -> 7 migration ?
Are there some comparisons of cpu times between Windows XP and 7 ?

Thank you all for sharing your own experience.

postscript : a NOTIONALexample of how the computations are distributed is given below

NbOfRuns := 10000:

# Data is a Matix(NbOfRuns, NbOfCols, …) constructed elsewhere

NbOfNodes := Grid:-NumNodes():
NbOfRunsPerNode := NbOfRuns / NbOfNodes:
for k from 0 to NbOfNodes do
   FirstData := 1 + k * NbOfRunsPerNode:
   LastData := (k+1) * NbOfRunsPerNode:
   Grid:-Run(k+1, MyCode, [Data[FirstData..LastData, ..], …])
end do:

Dear friends

It seems that Maple takes a long time to evaluate the square roots of numbers.

See the simple code below.

st := time();

for i to 1000 do for j to 1000 do

a[i, j] := evalf(abs(i-j+1)^0.3-abs(i-j)^0.3):

end: end:


I run it, then after a few seconds I run it again and again  to see the consuming time: once the running time is 77 seconds, then is 57 seconds, again is 73 seconds ...

Two questions:

1- Why the time is so differnt?

2- Why a simple code is being done at about a minute? Based on the number of operations, I think it should be done at less than a second. It just involves finding two million real third roots each of them less than 100 operations (if Newton method for finding roots is applied it probably needs less than 20 operations). I was thinking that a computer may do one billion operations per second. 

Since I need to report my numerical results in a scientific paper, it is important for me to know what's going on.

It is worthy of noting that I use Maple 18 on a Lenovo Laptop with Corei3 1.90 GHz with 64 bit operating system and 4 Gb RAM.

In advance, I appreciate for helping me to reveal the secrets.

Thank you all


I thought I would share some code for computing sparse matrix products in Maple.  For floating point matrices this is done quickly, but for algebraic datatypes there is a performance problem with the builtin routines, as noted in

Download spm.txt

The code is fairly straightforward in that it uses op(1,A) to extract the dimensions and op(2,A) to extract the non-zero elements of a Matrix or Vector, and then loops over those elements.  I included a sparse map function for cases where you want to map a function (like expand) over non-zero elements only.

# sparse matrix vector product
spmv := proc(A::Matrix,V::Vector)
local m,n,Ae,Ve,Vi,R,e;
n, m := op(1,A);
if op(1,V) <> m then error "incompatible dimensions"; end if;
Ae := op(2,A);
Ve := op(2,V);
Vi := map2(op,1,Ve);
R := Vector(n, storage=sparse);
for e in Ae do
n, m := op(1,e);
if member(m, Vi) then R[n] := R[n] + A[n,m]*V[m]; end if;
end do;
return R;
end proc:
# sparse matrix product
spmm := proc(A::Matrix, B::Matrix)
local m,n,Ae,Be,Bi,R,l,e,i;
n, m := op(1,A);
i, l := op(1,B);
if i <> m then error "incompatible dimensions"; end if;
Ae := op(2,A);
Be := op(2,B);
R := Matrix(n,l,storage=sparse);
for i from 1 to l do
Bi, Be := selectremove(type, Be, (anything,i)=anything);
Bi := map2(op,[1,1],Bi);
for e in Ae do
n, m := op(1,e);
if member(m, Bi) then R[n,i] := R[n,i] + A[n,m]*B[m,i]; end if;
end do;
end do;
return R;
end proc:
# sparse map
smap := proc(f, A::{Matrix,Vector})
local B, Ae, e;
if A::Vector then
B := Vector(op(1,A),storage=sparse):
B := Matrix(op(1,A),storage=sparse):
end if;
Ae := op(2,A);
for e in Ae do
B[op(1,e)] := f(op(2,e),args[3..nargs]);
end do;
return B;
end proc:

As for how it performs, here is a demo inspired by the original post.

n := 674;
k := 6;
A := Matrix(n,n,storage=sparse):
for i to n do
  for j to k do
    A[i,irem(rand(),n)+1] := randpoly(x):
  end do:
end do:
V := Vector(n):
for i to k do
  V[irem(rand(),n)+1] := randpoly(x):
end do:
C := CodeTools:-Usage( spmv(A,V) ):  # 7ms, 25x faster
CodeTools:-Usage( A.V ):  # 174 ms
B := Matrix(n,n,storage=sparse):
for i to n do
  for j to k do
    B[i,irem(rand(),n)+1] := randpoly(x):
  end do:
end do:
C := CodeTools:-Usage( spmm(A,B) ):  # 2.74 sec, 50x faster
CodeTools:-Usage( A.B ):  # 2.44 min
# expand and collect like terms
C := CodeTools:-Usage( smap(expand, C) ):
1 2 3 4 5 Page 1 of 5