Have you considered generating images in Maple, rather than plots, and then exporting them as image files?

Even if you decide to use plots rather than images, then why polygons instead of point-plots, if you have on the order of 10^5 or 10^6 individual items to render together?

acer

@Scot Gould ... your point is what, then?

@DSkoog That's nice.

It might be nicer still if Export[interactive] could get the ability to process extra arguments, such as plotoptions or say height only (or if it would pick them up from plotsetup()).

I notice that the maplet plotdevice won't pick up the height or width that have been specified using plotoptions, and use them to fill in either of the Dimentions textfields. Eg,

plotsetup(maplet,plotoptions="height=200");

Also, the Export[interactive] command reinstates the prior plotdevice, but it wipes out the prior plotoptions value in doing so (even if it is cancelled without actual export). It could be made gentler, so as to reinstate more prior plotsetup conditions (as my code does I hope). Currently I see it do this instead,

plotsetup(jpeg,plotoptions="height=200");
Warning, plotoutput file set to `plot.jpg`

plotsetup();
       preplot = [], postplot = [], plotdevice = jpeg, 

         plotoutput = plot.jpg, plotoptions = height=200

Export[interactive](plot(sin(x),x=0..2*Pi));
Warning, plotoutput file set to `plot.jpg`

plotsetup();
        preplot = [], postplot = [], plotdevice = jpeg, 

          plotoutput = plot.jpg, plotoptions = 

While Export[interactive] seems to provide all the interactive aspects that the OP mentioned, it might still be nice to have also some maplet variant which closes down immediately after export, and perhaps which did not itself render the plot visually.

The GUI will run out of memory or blow the java heap before it can display all of your 200,000 plots.

But this looks like 2D Math input, inside a paragraph in a Document (as opposed to being in an execution group or a Worksheet, say). If that's right then you won't see any results displayed for that as a collapsed Document Block, from either print or printf, until the entire outer loop completes. And then it'll try to render them all, in one shot.

How many of these do you really want to be able to view at any one time? One? Ten? I suggest you figure that out and then we could suggest other methodologies such as using Embedded Components, smaller sequence of plots as displayed as animation(s), using Explore, etc.

acer

@jbuddenh Sorry, I meant to say Shift-Enter, not Ctl-Enter. I'm in a Friday afternoon fog.

@taro No his original problem was with creation of an operator, to pick up the right instance of x. And as you too showed unapply provides the desired functionality for that aspect.

Assignment to f(x) is not key to resolving this, and is an unnecessary complication that muddies the issues. It also gets in the way of `f` also being made an operator.

restart;                                                                       

sol:=dsolve({f(0) = 12, diff(f(x), x) = 2*x+6});                               
                                                               2
                                                sol := f(x) = x  + 6 x + 12

rhs(sol);  # reasonable                                                        
                                                        2
                                                       x  + 6 x + 12

eval(f(x), sol); # reasonable                                                  
                                                        2
                                                       x  + 6 x + 12

assign(sol): f(x); # unreasonably unnecessary assignment to remember table of f
                                                        2
                                                       x  + 6 x + 12

@Doug Meade In the 64bit Linux version of each of Maple 17.00, 2015.2, and 2016.0 I am seeing,

seq( int( abs( cos(n*x) ), x=0..Pi ), n=1..24 );

                2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2

Nasser Abbasi's website contains his 3rd party runs of suites of examples of symbolic integration and symbolic differential equation solving, and may be of general interest to members of this community.

He has assembled results and compared performance of various recent versions of Maple and Mathematica, including timing and memory use as well as general pass-fail results. Source code is provided for the various problems.

For differential equations I find Nasser's results interesting in several respects. One such aspect is that he provides at least two full two comparison sets, one with Maple 18.02 and Mathematica 10.0.2, and another with Maple 2015.2 and Mathematica 10.3.1. Another is that he provides both mean and total computation times and leaf-counts (size). And another aspect I find useful is that he provides individual problem results, as well as source code. The 1940 different examples are taken from Kamke's book, Differential Gleichungen, 3rd ed., and the tables and examples listed on Nasser's site make it clear that this is a significantly broad collection of problems in multiple classes. I find it remarkable that not only does Maple outperform Mathematica on the pass-fail success rate (92% vs 76%) and compactness (size) of results but Maple is reported as doing it much faster on average with a mean CPU time of 0.5 sec for Maple 2015.2 vs 28.3 sec for Mathematica 10.3.1.

For integration Nasser has used several collections of problems. One the one hand his results comparing Maple 2015.1 and Mathematica 10.1 show only pass-fail numbers rather than the optimal/non-optimal/fail numbers that Albert Rich has shown (for older versions). But here too Nasser has assembled mean and total values for both computation time and leaf-count (size). According to these sites Maple's combine optimal/non-optimal pass rate has increased slightly from 85.1% in Maple 18 (A.Rich) to a total pass rate of 88.3% in Maple 2015.2 (Nasser). The Mathematica total pass rate was reported by both at approximately 97%. The average size of the Maple results (Nasser) is much larger than those of Mathematica, while Maple computes them much faster. This all indicates to me that Maple can afford to use some additonal computation time to work harder (change-of-variables attempts, say) to find solutions as well as to simplify results (w.r.t size, at if not via combine).

Nasser recently wrote that he would try to find time to repeat these comparisons using Maple 2016. Full results using Mathematica 10.4.x would be interesting.

acer

@PsiSquared You only need a single call to randomize(), outside of the loop, after restart.

If you call dice() multiple times (I did it twice) you will get different random runs in the same session (with no restart). This will happen regardless of whether you call randomize(), so there is no need for it inside the procedure dice.

The purpose of the randomize() call is to change the initial random seed. The effect is that after restart the sequence of random runs differ from the full session before.

You can see the effect by commenting out the call to randomize() and then restarting and re-executing the whole sheet (using the menubar's !!! icon, say). Without the call to randomize() then the whole sequence of runs will be the same from session to session, though they differ individually amongst themselves.

I don't understand you comment about obtaining count+xxxx as returned result, as long as you have the earlier line inside dice to initialize count to 0. See the following:

Download randloop11.mw

@Mac Dude I was asking whether you are seeing the buggy behaviour which you reported against Maple 2015 as being fixed in Maple 2016 (if you have it).

I am seeing the following in Maple 2016.0.

Mac Dude, is it ok for you in Maple 2016.0 on your OS X?

restart;
UseHardwareFloats:=true:
fr = 1.64*10^6*E[k]^2*exp(-8.5/E[k]):
solve(fr = 1.64*10^6*E[k]^2*exp(-8.5/E[k]),E[k]);

                     4.250000000             4.250000000     
               -----------------------, ---------------------
                       /  5442.655602\          /5442.655602\
               LambertW|- -----------|  LambertW|-----------|
                       |      (1/2)  |          |    (1/2)  |
                       \    fr       /          \  fr       /

restart:
UseHardwareFloats:=true:
evalf(LambertW(3));

                             1.04990889496403983

restart;
UseHardwareFloats:=true:
evalf( BesselY(0, 2/3*x) );

                         BesselY(0., 0.6666666667 x)

kernelopts(version);
          Maple 2016.0, X86 64 LINUX, Feb 16 2016, Build ID 1113130

acer

@Kitonum If I may, I'll add another example if only to illustrate that it can be tricky (esp. for the new user) to come up with a satisfactory test to use if only sieving (all) results with select, say.

solve( x^3+3*x^2-1, useassumptions ) assuming real, positive;

                                                  1/2 1/3
                                        (-4 + 4 I 3   )              2
                                        ------------------ + ------------------ - 1
                                                2                       1/2 1/3
                                                             (-4 + 4 I 3   )

That result seems ok. Which is why this approach is useful to know about.

Establising that solution as being purely real (exactly) may be a challenge for some users. So for some examples it can be a challenge to find a strong enough predicate to use with select or selectremove. if trying to extract the purely real  and positive solutions from just this:

S:=solve( x^3+3*x^2-1 );

By "challenge" I mean that one can go astray.

restart:
K:=solve( x^3+3*x^2-1, useassumptions ) assuming real, positive:

simplify(combine(rationalize(K))): is(%,real);

                                                           false

simplify(convert(simplify(combine(rationalize(K))),expln)): is(%,real);

                                                            true

simplify(evalc(evala(simplify(convert(simplify(combine(rationalize(K))),expln)))));

                                               2 Pi             Pi         4 Pi
                                           cos(----) - 1 + cos(----) - cos(----)
                                                9               9           9

kernelopts(version);

                                 Maple 2015.2, X86 64 LINUX, Dec 20 2015, Build ID 1097895

# Sure we might happen to obtain the following, more simply. What's key is that
# it *could* be harder. And we can go wrong. And Maple can go wrong.

simplify(evalc(K));

                                                            2 Pi
                                                      2 cos(----) - 1
                                                             9

Note: Maple 2016.0 might return FAIL instead of those `false` and `true` results. But the key thing to keep in mind is that we can always construct even more difficult and challenging examples.

We know that there is an inherent risk when using floating-point approximations as part of the sieving selection, due to round-off error and the possibility of misinterpreting small imaginary components (as either being mere artefact, or not).

For any stated approach we could find examples that present difficulties. So it is useful to be aware of the methods suggest by both Kitonum and Doug.

@Majmaj Apart from not handling distribution across sums, the rough prototype overload I showed would also need special handling to map over rtables (Vector,Matrix, Array) and other data-structures.

If you want exact handling of floats then perhaps you'd be better off using the convert command to first turn the floats into exact rationals. That might be done up front, on initial expressions containing subexpressions of type float, via the subsindets command. Just an idea.

@Honigmelone You may use applyrule across the elements of a Vector (or Matrix or Array) with the map2 command.

So, as an alternative to converting to and from list, and using your code above,

map2(applyrule,[rule,rule2],f_symbol);

What would you hope to see as the results for the following examples?

a:=.123456789:

1.0 * a;
1.00 * a;

0.10 * a;
0.100 * a;

acer