Items tagged with efficiency

Dear All,

The following code calculates the Rotation_number for given set of parameters. I would like to plot the value of Rotation_number against R for R from 500 to 1000. Since there are many variables for each iteration, I would like to know if there is a way to create a for loop for the following code while automatically clear variables except for Rotation_number to speed it up? 



with(plots): with(DEtools): with(plottools):with(LinearAlgebra):
t_start:=2500: t_end:=5000:

b:=-3: c:=3: v1:=1: f:=-4: v2:=2.0: omega:=1: epsilon:=evalf(1/R): R:=100: k:=0.25:



solA:=dsolve({sys, u1(0)=0.6, u2(0)=0.6, z(0)=0.1},
              numeric, method=rkf45, maxfun=10^7,
              events=[[[u1(t)=0, u2(t)>0], halt]]):

for k from 2 do
    if rhs(w[1])<t_end
    then evs(k,1..4):=Array(map(rhs, w));
    else break;



for i from 1 do
if tt>=t_start then break; end if;
end do:

R:=M[i..,3]: Z:=M[i..,4]:



Zshift:=Z-~r_center: Rshift:=R-~z_center:




for i from 1 to m do

if del_alpha[i]<0
then del_alpha[i]:=del_alpha[i]+1;
else del_alpha[i]:=del_alpha[i];





Thank you!

Very kind wishes,

Wang Zhe

I've read the spec online for LinearSolve but it's not clear on the function of inplace on nonsquare matrices. For example, consider the following:


This last line outputs <2;0>, which is also the value stored in B after the operation, whereas [2] would be the desired result. In the case of A being a row vector an error is encountered due to lack of storage. Does what happened above generalise for any matrix with more rows than columns: storing the result in B, but adding zeroes to the bottom unused parts of B, due to B being larger than the solution?

Also, does anyone have any advice on an efficient method for solving A.x=b, in the case where b is a vector, and A is a large but tall (varying size, but often 5x as many rows as columns, e.g. 10000x2000) integer matrix, where most of the entries in any particular column are zero (more than 90%)? I've found the option method='modular' helps quite a lot, but not enough, any ideas for quick fixes?

Greetings to all. I am writing to present a Maple computation that is somewhat of a programming challenge. A recent Post at Math.Stackexchange.Com asked to compute the number of inequivalent colorings of the vertices and edges of a regular hexagon with two colors available for the vertices and three colors for the edges (vertex colors different from edge colors) under the simultaneous action of the dihedral group D6 on the vertices and edges. This is a standard application of Burnside's Lemma and can be computed very straightforwardly using a negligible amount of computing resources. Important: this is the accepted method, it is documented at the MSE link and it works quite well. The answer is that there are 4183 unique configurations.

My purpose in this message is to propose the following task: write a program in your favorite programming language to verify this number by enumerating all possible configurations, computing the orbits of each, and tracking the orbits to eventually arrive at, we hope, the answer, 4183 as stated. This being MaplePrimes the programming language in question is Maple, of course. I implemented the enumeration method and it can be found in the attachments to this message. The algorithm takes about two minutes on the machine that I used and peak memory allocation is about 70 MB. This made for a frustrating debug cycle as it needed a two minute wait to see the result of the changes made to the source code. I therefore decided to use Perl instead of Maple. Imagine my surprise when the very same algorithm (consult attachment) implemented in Perl had a running time on the same machine of about three seconds, used a hash table of about 1.6MB and had resident memory footprint of 6MB. (In fact the hash table can be reduced to half size by simplifying the keys which makes them a bit more difficult to read during debugging.) Let me state it like this: Perl vs. Maple resulted in a speed gain of a factor of forty and a memory savings of 90 percent.

Now how to profit from this experience. A question naturally appears at this point: can we optimize the Maple code so as to bring it into the range of the parameters of the Perl? Here we permit all sorts of optimizations that may occur to the Maple coder other than using Burnside where the motivation is that for many of us including myself there always remain additional Maple programming techniques to learn and acquire. I hope this makes for an enjoyable exercise and I am looking forward to seeing a Maple implementation that can compete with the Perl. This is not code golf but conciseness is a plus.



Happy computing!

Best regards, Marko Riedel

PS: I suspect working with hash tables rather than sets may be a start.


I have a list


I want to be able to tell what position the element [3,5] is in the list

I'm using


is there anything faster

maybe instead of storing as a list, I can use rtables or something?

thankyou for your time


I have coded up a vector that is of my interest. The code runs witout any problem and gives me exactly what I want.

All I want to know, is that if there are more efficient way to do so?

Any tricks, or better use of a particular function that I wasn't aware?

The only tiny bit of unsatisfactory is that, the (1-w) term is at the first term of the addition, is that possible to move it to the last term? Which is more conventional to read.





Hi Maple Prime-ers!

I have a question about efficiency.  I have a set of algebraic equations with some polynomials, that I would like to solve at different points.  I've tried using a for-loop and a map-loop.  Here is a example:


n:=10000;  #Number of solving points
eq1:={b = ''a^2'', c = b^3/2, d = c^(1/2)*4 + b^2}; #Equation to solve

a := convert([seq(i,i=1..n)],Vector);  #timesteps

ans := Vector[column](n)

## Try solving in a for-next loop
t1 := time():
for q from 1 to n do
ans(q):=solve(subs({'a' = a(q)},eq1)):
t2 := time() - t1;

## try solving in a map loop
t1s := time():
ans_s := map(q->solve(subs({'a' = a(q)},eq1)),a);
t2s := time() - t1s;

On my computer (2.2Ghz, 2 cores), these both take 115s to solve.  Using Map over For-Next did not speed up computational speed.  

The problem I wish to tackle has 12 equations, invovles 5th order polynomials, and n ~= 300000.  Solving this set of equations takes 2-3 hours.

Anyone know a more efficient method?  Thanks for reading :D



     So I'm trying to animate a ball moving around in a moving circle. I can do a sequence of points, and a sequence of static circles which works okay but I'd like a continuous animation. Here is the points where the ball hits the circle (x,y) position and the times (t).  and the animation of the circle


x1 := [.9, -0.6953537244e-1, .5084436548, .5084436548, -.5253004431, -.4186356935,
     -.8180728424, -.8180728424,...

I'm having problems using the complexplot command in Maple 16 with over 1 million points. I really want to plot the points - I don't want an approximation. I noticed some strange things with the list/table carrying my complex points. If I ask for individual values, like T[20], it won't give the correct value, but if I ask for a range, like T[1..20], it will display the correct values.

I get an error when trying to use complexplot saying either invalid range, if I don't...

I have a vector containing data which is m*n long (ie from 1...(m*n)) and I want to convert it to a matrix of m columns and n rows.

What's the quickest and most efficient way in Maple to do this?

Suppose that you wish to animate the whole view of a plot. By whole view, I mean that it includes the axes and is not just a rotation of a plotted object such as a surface.

One simple way to do this is to call plots:-animate (or plots:-display on a list of plots supplied in a list, with its `insequence=true` option). The option `orientation` would contain the parameter that governs the animation (or generates the sequence).

But that entails recreating the same plot each time. The plot data might not even change. The key thing that changes is the ORIENTATION() descriptor within each 3d plot object in the reulting data structure. So this is inefficient in two key ways, in the worst case scenario.

1) It may even compute the plot's numeric results, as many times as there are frames in the resulting animation.

2) It stores as many instances of the grid of computed numeric data as there are frames.

We'd like to do better, if possible, reducing down to a single computation of the data, and a single instance of storage of a grid of data.

To keep this understandable, I'll consider the simple case of plotting a single 3d surface. More complicated cases can be handled with revisions to the techniques.

Avoiding problem 1) can be done in more than one way. Instead of plotting an expression, a procedure could be plotted, where that procedure has `option remember` so that it automatically stores computed results an immediately returns precomputed stored result when the arguments (x and y values) have been used already.

Another way to avoid problem 1) is to generate the unrotated plot once, and then to use plottools:-rotate to generate the other grids without necessitating recomputation of the surface. But this rotates only objects in the plot, and does alter the view of the axes.

But both 1) and 2) can be solved together by simply re-using the grid of computed data from an initial plot3d call, and then constructing each frame's plot data structure component "manually". The only thing that has to change, in each, is the ORIENTATION(...) subobject.

At 300 frames, the difference in the following example (Intel i7, Windows 7 Pro 64bit, Maple 15.01) is a 10-fold speedup and a seven-fold reduction is memory allocation, for the creation of the animation structure. I'm not inlining all the plots into this post, as they all look the same.





                                1.217, 25685408





                                0.125, 3538296

By creating the entire animation data structure manually, we can get a further factor of 3 improvement in speed and a further factor of 3 reduction in memory allocation.






                                0.046, 1179432                            

Unfortunately, control over the orientation is missing from Plot Components, otherwise such an "animation" could be programmed into a Button. That might be a nice functionality improvement, although it wouldn't be very nice unless accompanied by a way to export all a Plot Component's views to GIF (or mpeg!).

The above example produces animations each of 300 frames. Here's a 60-frame version:

Recently posted onto Wolfram's Blog is a set of 10 tips for how to write fast Mathematica code.  It is a very amusing read -- go read it now, because below I am going to make some comments on it, assuming that you have read it.


  1. Use floating-point numbers if you can, and use them early.
    Basically: if you're using Mathematica as a...

I have a program that makes very simple operations (such as concatenations or comparisons of binary strings) but it is intended to produce many data.

Maple seems to be in trouble when the number of data grows: whith my (quite old) computer, it begins to be very unefficient when trepassing a thershold  about 5*104 items.

Are there some tricks I do not know?

Inside a procedure, local variables are evaluated only one level. Of what good is this, one might ask?

Well, for one thing it allows you to do checks or manipulations of an unevaluated function call without having that function call be evaluated over again. I mean, for function calls to routines which don't happen to remember earlier results.

This is a revision of an Answer

I'd like to numerically compute integrals of the forms:

int(exp(-t)/((-3+2*exp(-(1/10)*t))*(-3+2*exp(-(9/10)*t))), t = 0 .. infinity); evalf(%)

where there are much more terms in the denominator, e.g.,

Int(e^(-t)/(product(-3+2*exp(-.1*(1-.1)^i*t), i = 0 .. A)), t = 0 .. infinity); evalf(%)

for some positive integer A. Even when I have three terms it takes so long... So how do I compute such integrals numerically with maple; what's the efficient...

1 2 3 Page 1 of 3