If your procedure sumESQtotal is not written to return unevaluated for nonnumeric inputs then you could try it instead as,

  Minimize( 'sumESQtotal'(A,B) );

with unevaluation quotes. Otherwise Maple will evaluate sumESQtotal at unassigned names A and B.

acer

You could try this: Select with the mouse pointer everything you want converted, then use the right-click context-menu action 2-D Math -> Convert To -> 1-D Math Input.

Another way to do the same thing: from the main menubar choose Edit->Select All (keystrokes Ctrl-a). and then from the menubar Format->Convert To->1D Math Input (keystrokes Alt-r v i)

The above doesn't change document blocks to pairs of execution groups, or insert "> " prompts, and so on. So it doesn't really reformat a Document as a Worksheet.

Maybe I should think about what it would take to write a procedure which does such a conversion, nicely!?

acer

Yes, that's right. A call to the print statement prints.

That allows a way to force a print even when a for-do loop is full color terminated (say, to suppress an avalanche of other results). It is very deliberate and useful behaviour.

It would terrible if issuing the restart statement cleared all output from a worksheet.

The easiest way to clear a whole block of previous output in one fell swoop is to make it all the result of a single function call.

Suppose that your have a procedure such as `f` below.

f:=proc()
     readline();
     print(plot(sin));
     printf("hey!\n");
     print("more");
     return "foo";
end proc:

Now, in a new Document Block or Execution Group issue the command,

  f();

The readline call pops up a dialogue, fine. Click ok, and a few various things are printed to the output of the block/group. Now place the cursor on that same call to f() and hit Enter/Return once again. The very first thing that will happen, even before the popup reappears, is that all the old output of that block/section will vanish. Hence I suggest that your "program" be implemented with an entry point which is a procedure or appliable module.

acer

You haven't shared the worksheet/document with us, but it sounds as if there are some fundamental misunderstandings -- perhaps on both sides here.

Quite often people prepare worksheets/documents with many executable paragraphs (document blocks) or execution groups. It is on purpose that re-executing just one of these will not wipe output of all the others. Some results are very time-consuming to compute, and it would be a much weaker GUI that would always require all output be tied together. I don't see the GUI being at fault in what you've described. It sounds to me more as if you're not using the GUI in the most suitable way for your own task.

It also sounds to me as if you might have spread the various inputs and outputs of your game across several or even many blocks/groups. That doesn't seem like a good idea to me, and if that is the case then I suspect you might be best off doing it otherwise.

My surmise could be wrong, but then you haven't really described the way in which your sheet is currently doing output.

How about making a run of the application (game) cover just one or two blocks/groups? Is the code for the game within procedures? If so, then why not have the procedure print carefully only what must be printed (because function call "output" done within an execution group is in fact replaced in one shot)? Why use multiple readline calls instead of maplets or embedded components which could be easily re-used for both input and output (and be easily cleared)?

acer

These two versions contain as much as I see in the file you uploaded originally (which abruptly ended in the middle of a deep subsection.)

I attach two variants, the second where I just closed up all the outstanding subsections, and the other the same except I expanded all sections before saving. And I also attached a zip file containing both.

FHPBedited.mw

FHPBexpandededited.mw

FHPBedited.zip

Your uploaded worksheet appears to have been last saved with Maple 13.02, so I used that to save the one with all-sections-expanded.

acer

Another mechanism for this is map2 (or map[2]).

L1 := [25,5,1,10,4,20];
                         L1 := [25, 5, 1, 10, 4, 20]

L2 := evalf( map( log10, L1 ) );
    L2 := [1.397940008, 0.6989700041, 0., 1., 0.6020599914, 1.301029996]

L2 := map( log10@evalf, L1 );
    L2 := [1.397940009, 0.6989700043, 0., 1., 0.6020599913, 1.301029996]

map2( `^`, 10, L2 );
        [25.00000002, 5.000000000, 1., 10., 4.000000000, 20.00000002]

map2( round@`^`, 10, L2 );
                            [25, 5, 1, 10, 4, 20]

You haven't said anything about precision/accuracy/efficiency needs, so it's not possible to be definitive about what would be best for you. But avoiding custom procs, using kernel builtins, leveraging evalhf, etc, etc, are aspects that might possibly matter to you.

acer

The keysrokes Alt-v l (lowercase l) collapse all sections and subsections, also available from the menubar choice

View->Collapse All Sections.

I don't know of any way to collapse just the outermost sections.

acer

Using Maple 18.02 in Windows 7 64bit, the closet I could get was to use densityplot instead of listdensityplot (so the "grid" lines appear thinner in the GUI, since the latter produces a bunch of polygons...).

restart:

export_plot_options:=font=[TIMES, roman, 30],
                     axis=[thickness=4, location=origin],
                     size=[850,850]:

P:=plots:-densityplot(exp(-(x^2+y^2)*(1/100)),
                      x = -10.0 .. 10.0, y = -10.0 .. 10.0,
                      export_plot_options,
                      grid=[21,21], scaling=constrained):

subsop([1,1]=0..21.5, subsop([1,2]=0..21.5, P));

[edited] I posted the above in the early morning. I now realize that the obscure double subsop step could be replaced by a single call to plots:-translate. Ie,

restart:
export_plot_options:=font=[TIMES, roman, 30],
                     axis=[thickness=4, location=origin],
                     size=[850,850]:
P:=plots:-densityplot(exp(-(x^2+y^2)*(1/100)),
                      x = -10.0 .. 10.0, y = -10.0 .. 10.0,
                      export_plot_options,
                      grid=[21,21], scaling=constrained):
plottools:-translate(P, 10.5, 10.5);

Having done that, I now reazlie that the originally posted example can be handled the same way, using location=origin and a translation. Ie,

restart:
export_plot_options:=font=[TIMES, roman, 30], axis=[thickness=4, location=origin], size=[850,850]:
points := [seq([seq(exp(-(x^2+y^2)*(1/100)), x = -10.0 .. 10.0)], y = -10.0 .. 10.0)]:
P:=plots:-listdensityplot(points, export_plot_options):
plottools:-translate(P, -0.5, -0.5);

Of course, if you don't like the ranges 0..21 then you could adjust to taste. I'm not really sure whether you wanted axes' ranges from -10..10, or 0..21, or 0..21.5, etc.  Or you might ecen want go with densitplot and no translation, as it produces a nicer looking (to me) plot with less obtrusive gridding, and contains an efficient float[8] rtable rather than many list data polygons.

What about using 0.5 .. 2.0 instead of 1..nB as the third argument to surfdata?

If that isn't what you're after then I'm having trouble understanding.

It might also be that you can use a combination of a modified 3rd (or 2nd) argument to surfdata combined with custom tickmarks (possibly using an alternate syntax to what Tom L showed, where the list contains equations of the form value=targetvalue...). I think we just need to understand what you're after.

acer

The step option (increment or decement) is described on the help page for seq.

seq(i,i=5..1,-1);

                         5, 4, 3, 2, 1

Note that 5.-1.2 is parsed as 5. - 1.2 which is a subtraction of two floats, giving 3.8. Your second example is asking for the sequence of operands of the float expression 3.8 (where "operands" means what the op command returns, and where the operands of a float relate to how Maple stores it as mantissa and radix-10 exponent).

5.-1.2;

                                     3.8

5. - 1.2;

                                     3.8

op(0,3.8);

                                    Float

op(3.8);

                                   38, -1

Float(38, -1);

                                     3.8

seq(i, i in Float(38, -1));

                                   38, -1

seq(i, i=Float(38, -1));

                                   38, -1

seq(i, i=3.8);

                                   38, -1

acer

Try adding the file as "maple.ini" to the location that is returned after issuing the Maple command,

  kernelopts(homedir);

Make sure that you're not inadvertantly saving the file as "maple.ini.txt".

Also, it's probably a better idea to just issue the command and not always load the `plots` package. Ie,

  plots:-setcolors("Spring"):

acer

coeff(convert(ggg,polynom),t,-1);

The point is not so much to get something of type polynom as much as it is to remove the `O` term.

acer

The command,

Typesetting:-Settings(functionassign=false):

will cause subsequent occurences of that bit of 2D Math input syntax to be parsed as a remember table assignments. You could put that inside the Startup Code Region of your Document/Worksheet. This is better than leaving it as a popup query since you may wish to pass your document along to someone else unfamiliar with your intention.

Or switch to using 1D Maple Notation input mode in execution groups, where the syntax in question is unambiguous and always parsed as a remember table assignment. See Preben's response for a way to do that session-wide or even cross-session.

You could then still create operators using the superior, unambiguous syntax which works in both 1D Maple Notation and and 2D Math input modes,

BG := (i,j) -> stuff

acer

The runtime redistributables of some MKL v11.x exist in Maple 18.01 for 64 bit Linux and OSX. I have obtained some performance results for the cited Matrix float[8] Rank test using Maple 18.02 that are pretty much identical to those of Mathematica 9 and 10, on those two platforms. I tried up until about size 2500x2500. (See also this post and comment.)

The version of MKL used in Maple 18.x on 32 and 64bit Windows appears to be some v10.x, which series dates from about 2008-2009. And on the 64bit Windows platform (which is what Nasser used in the first link you've cited) there is still a discrepancy. A quoted timing of 0.35 sec for computing all the singular values of a 1000x1000 float[8] Matrix is pretty fast, but not as fast as the quoted timing for Mathematica as 0.16 sec.

The author of the pages in the first link you gave posted in the Wolfram Community forum a while back. He encountered new out-of-memory problems when running his test at larger sizes in Mathematica 10. He apparently resolved that by setting a preference to disable the new multi-undo feature.

acer

One way is to use a customized system. Eg, compare the before and after.

restart:

Unit(m^2*kg/(s^4*A));

simplify( Unit(m^2*kg) / Unit(s^4*A) );

simplify( 1/Unit(s) );

with(Units):
AddSystem( MySI, GetSystem(SI), volt/microsecond, hertz );
UseSystem( MySI );

Unit(m^2*kg/(s^4*A));

simplify( Unit(m^2*kg) / Unit(s^4*A) );

simplify( 1/Unit(s) );

This should also work with Units[Standard] functionality, combine(..,units), etc.

Note that other poswers of these dimensions are not necessarily affected. To get 1/second^2 to come out as Hz^2 you'd need to also include hertz^2 in the additional arguments, when defining the new system. Etc.

Another way is to just compute with some stock system like SI, and then convert final results. Eg,

restart:
convert( 55*Unit(mm^2*g/(ms^4*A)), units, volt/microsecond );

acer