Items tagged with memory

Can somebody of Maple users execute the following command

restart; pdsolve({diff(w(x, y, z), x)+diff(w(x, y, z), y, y)+2*(diff(v(x, y, z), x)-(diff(u(x, y, z), y))-2*w(x, y, z)) = diff(w(x, y, z), z, z), 3*(diff(u(x, y, z), x, x))+2*(diff(u(x, y, z), y, y))+2*(diff(v(x, y, z), x, y))+2*(diff(w(x, y, z), y)) = diff(u(x, y, z), z, z), 3*(diff(v(x, y, z), y, y))+2*(diff(v(x, y, z), x, x))+2*(diff(u(x, y, z), x, y))-2*(diff(w(x, y, z), x)) = diff(v(x, y, z), z, z)}, {u(x, y, z), v(x, y, z), w(x, y, z)})

restart; pdsolve({diff(w(x, y, z), x)+diff(w(x, y, z), y, y)+2*(diff(v(x, y, z), x)-(diff(u(x, y, z), y))-2*w(x, y, z)) = diff(w(x, y, z), z, z), 3*(diff(u(x, y, z), x, x))+2*(diff(u(x, y, z), y, y))+2*(diff(v(x, y, z), x, y))+2*(diff(w(x, y, z), y)) = diff(u(x, y, z), z, z), 3*(diff(v(x, y, z), y, y))+2*(diff(v(x, y, z), x, x))+2*(diff(u(x, y, z), x, y))-2*(diff(w(x, y, z), x)) = diff(v(x, y, z), z, z)}, {u(x, y, z), v(x, y, z), w(x, y, z)})

Error, (in simplify/normal) Maple was unable to allocate enough memory to complete this computation.  Please see ?alloc




in Maple 2016.1.1 on a powerful comp and report the obtained result as an answer to the question?
 That would be very kind of her/him. Thanks in advance. 


i have already release memory with gc() in the most inner for loop ]

,but it still use up my memory

once it printed two lines each time, actually it can release memory

but why it still use up memory

read "D:\\hello.m":
for ii from 1 to 2040 do
for jj from 1 to 2040 do
for kk from 1 to 2040 do
if ii < jj and jj < kk then
if mm[ii] <> mm[jj] and mm[jj] <> mm[kk] then
sol := dsolve([mm[ii],mm[jj],mm[kk]],[a(t),b(t),c(t)]);
end if:
end if:


i can only think

use c# to generate code with file write, nested for loop every 1000 records 

is it the only way to do?


int counter = 0;
for (int i=1; i<=2040; ++i)
for (int j = 1;j <= 2040; ++j)
for (int k = 1; k <= 2040; ++k)
if(counter % 1000 == 0)
Console.Write(i.ToString() + ","+j.ToString() + ","+k.ToString());
counter = counter + 1;


I run into a problem that really suprised me. I have a program that solves a system of differential equations with different initial conditions. I wrote a cycle that goes through initial conditions, solves differential equations and saves the picture (displaying dynamic behaviour of the system) in the given directory. All seemed fine and working until I once checked one of the pictures by running the program on the only one initial condition. It turned out that the picture program gave me this time is not the one that program gave me earlier (while running through cycle). So I panicked and started checking other pictures and it turned out that some of them are right and some of them are not, remarkably, with no particular pattern.

I reckon that I somehow need to manage the memory, clear it after every iteration. (I'm not absolutely sure that problem is here but I just don't have another explanation why this thing could happen.)

While debugging something unrelated to Maple, I noticed in Windows task manager that the process

C:\Program Files\Maple 2016\jre\bin

had a Memory(Private Working Set) of 2,251,088K - roughly 10x the memory footprint of any other running process.

Is this normal?

Not a real issue for me (machine has 16G ram) - but it just *looks* wrong

In case it matters I'm running Maple 2016.1 on Win7, 64bit

if i install maple 2015 in amazon cloud, activate with my license

and i do not use amazon after several trial, 

will the license be used and can not activate in future if i use amazon cloud again in future?

any command or configure needed when using large amount memory such as 100GB memory?

Hi guys,

I have written a program in Maple 2016 (Windows 7) made of two parts :

  1. An initialization step where a formal system of algebraic equations (some non linear) is built
    Let S(U, P) this system, where U denotes a set of unknowns and P a set of parameters (see step 2 below)
  2. An iterative step where this system is solved with respect to U for different values of parameters P
    This loop has to be executed N times for values P1, ..., Pn, ... of P

I observe that the size of the memory (bottom right of the Maple window) inflates as the value of n increases.

I was able to isolate in the loop corresponding to step 2, the procedure MyProc I wrote which is responsible of this memory inflation.
Now I would like to manage this inflation (typically the memory size grows up to 3 GiB for n about one thousand) because of its very negative effects on the computational time (probably Maple does spend a lot of time in swapping operations).

Suspecting the remember process to be the source of this problem, I tried simple tricks such as

  • systematically write   > quantity := 'quantity';   for fome intermediate quantities
  • use forget  : for example MyProc contains a call to fsolve and,  after "local" declarations, I inserted  the command  forget(fsolve)   
  • in the the loop over n,  I even inserted the command forget(Myproc).

None of these tricks was to some extent efficient to contain the memory inflation.

I suppose it is a very common situation that people who use to develop code are familiar with. So maybe some of you could provide my some advices or move me towards "strategies" or "methodologies" to prevent this situation ?
My purpose here is not to ask you to solve my problem, but rather to ask youy to give me hints to be able to manage such kind of situations by myself.

Maybe this question is unorthodox and doesn't have its place here ?
It that case please let me know.

Thanks In Advance

PS : it would be very difficult for me to provide you the code : if it is a necessary condition for you to help me, just forget it, I will understand

This is somehow an old problem which came back and I decided to post it. So, I have some code which runs in Grid framework locally. Each node saves data directly to hard disk and there is no need to return anything at the end to the node of ID 0. Nevertheless, I noticed that memory usage on one instance of the mserver is very huge.  Moreover, this instance is all the time in S state, namely sleeping. Below you can see dump from top. I deny this is caused by some particular procedures called in my code since in this case I should rather observe more uniform memory usage. I am not sure if for this moment I could share some code with you which demonstrate this behavior. I will try to write some toy example because my productive code cannot be posted here.


49.1 17:00.19 mserver
0.1 12:43.70 mserver
0.1 12:32.15 mserver
0.1 13:54.02 mserver
0.1 14:45.45 mserver
0.1 12:35.22 mserver
0.1 13:50.77 mserver
0.1 14:14.85 mserver
0.1 8:58.82 mserver
0.1 12:58.48 mserver
0.1 8:51.00 mserver
0.1 10:35.92 mserver
0.1 12:58.13 mserver
0.1 9:34.39 mserver
0.1 10:10.13 mserver
0.1 12:07.77 mserver
0.0 8:21.17 mserver
0.0 11:41.42 mserver
0.0 5:07.27 mserver
0.0 8:31.88 mserver
0.0 6:30.12 mserver

Hej Mapleprimes,

I am making Maple sweat over a simple problem


right click and solve for variable x. 

So far Maple has been working for 10 minutes at allocatet 2 GB 

memory.  And no answer yet. 

Is there a short way to solve this faster?


Kind regards 

Per Kirkegaard

I am faced by the problem where I used Grid:-Seq()---locally---to do some long time computation and I am faced by the exhaustion of memory problem. I think the problem itself is related to the memory management in maple.

So the problematic function is

# Procedure: ComputeEventsCTypeGrid
#   Compute events such that three quadrics intersects in a point.
# Parameters:
#   Q          - a set of quadrics
# Output:
#   Indexes of quadrics which intersect in a point.
#  - Memory
#  - Cleanups
ComputeEventsCTypeGrid := proc( Q )
  local s, cType, i, j, k, rootNb, univ, sys;
  s := proc (i, j, k)
    sys := [ Q[i], Q[j], Q[k] ];
    univ := PolynomialIdeals[UnivariatePolynomial]( indets( sys )[1], sys );
    if not type( univ, constant ) then
      rootNb := nops(select(proc(x)op(x)[2]>0;end proc,RootFinding:-Isolate( univ, [ op( indets(univ ) ) ] )) ):
      if rootNb > 0 then
        return [ univ, rootNb, sys ];
      end if:
    end if:
  end proc;
  cType := [Grid:-Seq(seq(seq(s(i,j,k),k=j+1..nops(Q)),j=i+1..nops(Q)),i=1..nops(Q))];
  return cType;
end proc:

A dump from top after calling ComputeEventsCTypeGrid for some data(total amount of memory on this machine is 251G + 48G swap)


33.007g 0.031t   3676 S   0.0 12.5   2606:20
31.137g 0.029t   3436 S   0.0 11.7   2274:34
8645756 4.984g   2840 S   0.0  2.0  32:06.40
28.798g 0.026t   1968 S   0.0 10.7   1821:16
26.650g 0.024t   1968 S   0.0  9.8   1520:54
25.346g 0.023t   1968 S   0.0  9.2   1236:44
23.296g 0.021t   1968 S   0.0  8.4   1004:52
20.498g 0.018t   1968 S   0.0  7.4 790:30.81
16.799g 0.014t   1968 S   0.0  5.9 625:28.12
15.011g 0.013t   1968 S   0.0  5.2 469:36.27
7678444 4.149g   1968 S   0.0  1.6 104:34.22
6734804 623904   1968 S   0.0  0.2  73:13.13
4327420 132516   1968 S   0.0  0.1  24:11.51
3420712 111336   1968 S   0.0  0.0  11:26.16
13.671g 0.011t   1964 S   0.0  4.6 380:15.13
11.771g 9.831g   1964 S   0.0  3.9 274:25.59
9936056 7.769g   1964 S   0.0  3.1 201:13.94
8805512 3.394g   1964 S   0.0  1.3 148:09.53
5077056 1.500g   1964 S   0.0  0.6  42:19.29
2384784  82040   1832 S   0.0  0.0   3:56.57

Size of output data calculated with

> length(sprintf("%m", eval(cType)));

> 326260610

Also, I called gc() at the end of the computations but memory allocated by instances of mserver were not released. Does it mean gc() should be called from each instance separately? My final point is that I have to run some other calculations for different and bigger dataset (It will probably take 2 days to finish -- Q has around 700 polynomials of degree 2) and for this moment I cannot do this because I've gotten an error about not enough amount of memory.

Here is a simple program that displays the issue.

yint:=proc(i,a,b) local y,yi; y:=x^i; yi:=int(y,x=a..b); return yi; end:


for i from 1 to n do inty:=yint(i,a,b); od:

Running the program gives the following memory usage.

n            memory
10^4      70M
10^5      138M
10^6      562M

Why is the memory increasing so much? Are internal variables to yint stored between calls?

How can I avoid the memory increase with such a loop?


Dear all,

I am using Maple to perform numerical integrations. When the final index in the loop is set to 5, the computation is fast and the results are quickly delivered. When I set a number higher than that, even 6, the program gets really slow and often crashes.

I herewith attach the script I use to generate the results. I guess that there should be a problem of memory management and I tried to use gc() as suggested in some forms but without success. I would appreciate it if someone here could explain the reason behind the problem.

Thank you,

restart; Ts := 1.; sigma := 1.; C := 1.; B := 2./(1+C); with(inttrans); beta := B*Ts*omega; assume(Tb > 0); assume(u >= 0); FzzS := -(3/2)*u^3*((2*u+I*beta)*(exp(2*sigma*u)+sigma^2*exp(2*u))-4*sigma*u*((1+sigma)*u-1))/((2*u+I*beta)^2*exp((2*(1+sigma))*u)-4*u^2*((1+sigma)*u-1)^2); InvFzzS := simplify(invfourier(FzzS, omega, t)); logTimeMin := -2; logTimeMax := -1; NumSteps := 6; logTimeStep := evalf(1.0*(logTimeMax-logTimeMin)/NumSteps); curdirectory(); A := matrix(NumSteps, 2); T1 := Array(1 .. NumSteps); AF := Array(1 .. NumSteps); for i to NumSteps do logTime := evalf(i*logTimeStep+logTimeMin); curTime := evalf(10^logTime); A[i, 1] := curTime; A[i, 2] := evalf(Int(eval(InvFzzS, t = curTime), u = 0 .. infinity, epsilon = 10^(-5))); T1[i] := A[i, 1]; AF[i] := A[i, 2] end do






Can anyone confirm what units of memory are used for this option?

Will Maple 2015 automatically use virtual memory if the size of this option exceeds the RAM memory and how can this be confirmed?

Thank you.


Why the command


coeff(sum(x^i,i=0..999)^500,x,2) prints


Error, unable to compute coeff??


I believe, that memory/cpu issues are not a relevant answer here.



coeff(sum(x^i,i=0..998)^500,x,2) gives the correct result.


coeff(sum(x^i,i=0..998)^500,x,200) is ok.

How do I compute coeffs of longer sums?Or why this limitation is imposed by Maple Server?

Hi all,

I have been trying to figure out why when I run my 'code' maple keeps building up memory. I am currently writing X number of inequalities and plotting the results. I begin the script with the  'restart' command to clear the memory of any previous runs. But this does nothing to the memory allocated. I check with my 'task manager' window.

I've been scouring the internet for similar issues and basically is this a software problem? how can this be avoided?

'restart' does clear the variables but doesn't seem to make the freed up memory accessible.

- pJ


When I run a maple program which take a long time (in command line), I have this kind of message every second:

"memory used=43867.3MB, alloc=147.3MB, time=856.28"

Does there exist any way to avoid this display ?

Thanks in advance.

1 2 3 4 5 6 Page 1 of 6